diff --git a/Cargo.lock b/Cargo.lock index 410fdd4..368baac 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3075,8 +3075,6 @@ dependencies = [ [[package]] name = "webrtc-srtp" version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "383b0f0f73ee6cce396bdbc4d54ec661861a59eae9fc988914c1a8d82c5ac272" dependencies = [ "aead", "aes", diff --git a/Cargo.toml b/Cargo.toml index 6998d61..2fede2a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -64,6 +64,8 @@ sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] } cc = "1.0" [patch.crates-io] +# RTP rollover counter survives delayed NACK retransmissions (vendor/webrtc-srtp/PATCHES.md). +webrtc-srtp = { path = "vendor/webrtc-srtp" } webrtc-dtls = { path = "vendor/webrtc-dtls" } # Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs). webrtc = { path = "vendor/webrtc" } diff --git a/vendor/webrtc-srtp/.gitignore b/vendor/webrtc-srtp/.gitignore new file mode 100644 index 0000000..81561ed --- /dev/null +++ b/vendor/webrtc-srtp/.gitignore @@ -0,0 +1,11 @@ +# Generated by Cargo +# will have compiled files and executables +/target/ +/.idea/ + +# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries +# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html +Cargo.lock + +# These are backup files generated by rustfmt +**/*.rs.bk diff --git a/vendor/webrtc-srtp/CHANGELOG.md b/vendor/webrtc-srtp/CHANGELOG.md new file mode 100644 index 0000000..aec0b98 --- /dev/null +++ b/vendor/webrtc-srtp/CHANGELOG.md @@ -0,0 +1,19 @@ +# webrtc-srtp changelog + +## Unreleased + +## v0.9.1 + +* Increased minimum support rust version to `1.60.0`. +* Increased required `webrtc-util` version to `0.7.0`. + + +## v0.9.0 + +* [#8 update deps + loosen some requirements](https://github.com/webrtc-rs/srtp/pull/8) by [@melekes](https://github.com/melekes). +* Increased min version of `log` dependency to `0.4.16`. [#250 Fix log at ^0.4.16 to make tests compile](https://github.com/webrtc-rs/webrtc/pull/250) by [@k0nserv](https://github.com/k0nserv). + +## Prior to 0.8.9 + +Before 0.8.9 there was no changelog, previous changes are sometimes, but not always, available in the [GitHub Releases](https://github.com/webrtc-rs/srtp/releases). + diff --git a/vendor/webrtc-srtp/Cargo.toml b/vendor/webrtc-srtp/Cargo.toml new file mode 100644 index 0000000..7cafcc1 --- /dev/null +++ b/vendor/webrtc-srtp/Cargo.toml @@ -0,0 +1,100 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +name = "webrtc-srtp" +version = "0.12.0" +authors = ["Rain Liu "] +description = "A pure Rust implementation of SRTP" +homepage = "https://webrtc.rs" +documentation = "https://docs.rs/webrtc-srtp" +readme = "README.md" +license = "MIT OR Apache-2.0" +repository = "https://github.com/webrtc-rs/srtp" + +[[bench]] +name = "srtp_bench" +harness = false + +[dependencies.aead] +version = "0.5" +features = ["std"] + +[dependencies.aes] +version = "0.8" + +[dependencies.aes-gcm] +version = "0.10" +features = ["std"] + +[dependencies.byteorder] +version = "1" + +[dependencies.bytes] +version = "1" + +[dependencies.ctr] +version = "0.9" + +[dependencies.hmac] +version = "0.12" +features = ["std"] + +[dependencies.log] +version = "0.4" + +[dependencies.openssl] +version = "0.10.57" +optional = true + +[dependencies.rtcp] +version = "0.10.1" + +[dependencies.rtp] +version = "0.10.0" + +[dependencies.sha1] +version = "0.10" + +[dependencies.subtle] +version = "2" + +[dependencies.thiserror] +version = "1" + +[dependencies.tokio] +version = "1.32.0" +features = ["full"] + +[dependencies.util] +version = "0.8.1" +features = [ + "conn", + "buffer", + "marshal", +] +default-features = false +package = "webrtc-util" + +[dev-dependencies.criterion] +version = "0.5" +features = ["async_futures"] + +[dev-dependencies.lazy_static] +version = "1" + +[dev-dependencies.tokio-test] +version = "0.4" + +[features] +openssl = ["dep:openssl"] +vendored-openssl = ["openssl/vendored"] diff --git a/vendor/webrtc-srtp/Cargo.toml.orig b/vendor/webrtc-srtp/Cargo.toml.orig new file mode 100644 index 0000000..790296a --- /dev/null +++ b/vendor/webrtc-srtp/Cargo.toml.orig @@ -0,0 +1,46 @@ +[package] +name = "webrtc-srtp" +version = "0.12.0" +authors = ["Rain Liu "] +edition = "2021" +description = "A pure Rust implementation of SRTP" +license = "MIT OR Apache-2.0" +documentation = "https://docs.rs/webrtc-srtp" +homepage = "https://webrtc.rs" +repository = "https://github.com/webrtc-rs/srtp" + +[features] +openssl = ["dep:openssl"] +vendored-openssl = ["openssl/vendored"] + +[dependencies] +util = { version = "0.8.1", path = "../util", package = "webrtc-util", default-features = false, features = [ + "conn", + "buffer", + "marshal", +] } +rtp = { version = "0.10.0", path = "../rtp" } +rtcp = { version = "0.10.1", path = "../rtcp" } + +byteorder = "1" +bytes = "1" +thiserror = "1" +hmac = { version = "0.12", features = ["std"] } +sha1 = "0.10" +ctr = "0.9" +aes = "0.8" +subtle = "2" +tokio = { version = "1.32.0", features = ["full"] } +log = "0.4" +aead = { version = "0.5", features = ["std"] } +aes-gcm = { version = "0.10", features = ["std"] } +openssl = { version = "0.10.57", optional = true } + +[dev-dependencies] +criterion = { version = "0.5", features = ["async_futures"] } +tokio-test = "0.4" +lazy_static = "1" + +[[bench]] +name = "srtp_bench" +harness = false diff --git a/vendor/webrtc-srtp/LICENSE-APACHE b/vendor/webrtc-srtp/LICENSE-APACHE new file mode 100644 index 0000000..16fe87b --- /dev/null +++ b/vendor/webrtc-srtp/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/vendor/webrtc-srtp/LICENSE-MIT b/vendor/webrtc-srtp/LICENSE-MIT new file mode 100644 index 0000000..e11d93b --- /dev/null +++ b/vendor/webrtc-srtp/LICENSE-MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 WebRTC.rs + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/webrtc-srtp/PATCHES.md b/vendor/webrtc-srtp/PATCHES.md new file mode 100644 index 0000000..cce3903 --- /dev/null +++ b/vendor/webrtc-srtp/PATCHES.md @@ -0,0 +1,14 @@ +# Local patch to webrtc-srtp 0.12.0 + +Source: crates.io webrtc-srtp 0.12.0 (MIT / Apache-2.0; upstream licenses retained). + +`SrtpSsrcState` estimates the rollover counter with the half-sequence-space rule from +RFC 3711 Appendix A and only advances to the highest packet index seen. Upstream used a +100-packet window and stored every sequence number, so a NACK retransmission of a +pre-wrap packet sent after the wrap (e.g. 65000 after 85) moved the state back and the +next new packet was protected with ROC+1; the receiver then failed authentication for +every following packet (frozen video, #83). Fix and regression tests contributed by +@AYssu. Cipher code, wire format and SRTCP are unchanged. + +The upstream lifecycle test jumped from 5004 to 65535, outside the half-space window; +bridge packets keep it consecutive and the known-answer vectors are unchanged. diff --git a/vendor/webrtc-srtp/README.md b/vendor/webrtc-srtp/README.md new file mode 100644 index 0000000..c6eb608 --- /dev/null +++ b/vendor/webrtc-srtp/README.md @@ -0,0 +1,30 @@ +

+ WebRTC.rs +
+

+

+ + + + + + + + + + + + + + + + + License: MIT/Apache 2.0 + + + Discord + +

+

+ A pure Rust implementation of SRTP. Rewrite Pion SRTP in Rust +

diff --git a/vendor/webrtc-srtp/benches/srtp_bench.rs b/vendor/webrtc-srtp/benches/srtp_bench.rs new file mode 100644 index 0000000..17f2d44 --- /dev/null +++ b/vendor/webrtc-srtp/benches/srtp_bench.rs @@ -0,0 +1,158 @@ +use bytes::BytesMut; +use criterion::{criterion_group, criterion_main, Criterion}; +use util::Marshal; +use webrtc_srtp::{context::Context, protection_profile::ProtectionProfile}; + +const MASTER_KEY: &[u8] = &[ + 96, 180, 31, 4, 119, 137, 128, 252, 75, 194, 252, 44, 63, 56, 61, 55, +]; +const MASTER_SALT: &[u8] = &[247, 26, 49, 94, 99, 29, 79, 94, 5, 111, 252, 216, 62, 195]; +const RAW_RTCP: &[u8] = &[ + 0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, + 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, +]; + +fn benchmark_encrypt_rtp_aes_128_cm_hmac_sha1(c: &mut Criterion) { + let mut ctx = Context::new( + MASTER_KEY, + MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) + .unwrap(); + + let mut pld = BytesMut::new(); + for i in 0..1200 { + pld.extend_from_slice(&[i as u8]); + } + + c.bench_function("Benchmark RTP encrypt", |b| { + let mut seq = 1; + b.iter_batched( + || { + let pkt = rtp::packet::Packet { + header: rtp::header::Header { + sequence_number: seq, + timestamp: seq.into(), + extension_profile: 48862, + marker: true, + padding: false, + extension: true, + payload_type: 96, + ..Default::default() + }, + payload: pld.clone().into(), + }; + seq += 1; + pkt.marshal().unwrap() + }, + |pkt_raw| { + ctx.encrypt_rtp(&pkt_raw).unwrap(); + }, + criterion::BatchSize::LargeInput, + ); + }); +} + +fn benchmark_decrypt_rtp_aes_128_cm_hmac_sha1(c: &mut Criterion) { + let mut setup_ctx = Context::new( + MASTER_KEY, + MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) + .unwrap(); + + let mut ctx = Context::new( + MASTER_KEY, + MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) + .unwrap(); + + let mut pld = BytesMut::new(); + for i in 0..1200 { + pld.extend_from_slice(&[i as u8]); + } + + c.bench_function("Benchmark RTP decrypt", |b| { + let mut seq = 1; + b.iter_batched( + || { + let pkt = rtp::packet::Packet { + header: rtp::header::Header { + sequence_number: seq, + timestamp: seq.into(), + extension_profile: 48862, + marker: true, + padding: false, + extension: true, + payload_type: 96, + ..Default::default() + }, + payload: pld.clone().into(), + }; + seq += 1; + setup_ctx.encrypt_rtp(&pkt.marshal().unwrap()).unwrap() + }, + |encrypted| ctx.decrypt_rtp(&encrypted).unwrap(), + criterion::BatchSize::LargeInput, + ); + }); +} + +fn benchmark_encrypt_rtcp_aes_128_cm_hmac_sha1(c: &mut Criterion) { + let mut ctx = Context::new( + MASTER_KEY, + MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) + .unwrap(); + + c.bench_function("Benchmark RTCP encrypt", |b| { + b.iter(|| { + ctx.encrypt_rtcp(RAW_RTCP).unwrap(); + }); + }); +} + +fn benchmark_decrypt_rtcp_aes_128_cm_hmac_sha1(c: &mut Criterion) { + let encrypted = Context::new( + MASTER_KEY, + MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) + .unwrap() + .encrypt_rtcp(RAW_RTCP) + .unwrap(); + + let mut ctx = Context::new( + MASTER_KEY, + MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) + .unwrap(); + + c.bench_function("Benchmark RTCP decrypt", |b| { + b.iter(|| ctx.decrypt_rtcp(&encrypted).unwrap()); + }); +} + +criterion_group!( + benches, + benchmark_encrypt_rtp_aes_128_cm_hmac_sha1, + benchmark_decrypt_rtp_aes_128_cm_hmac_sha1, + benchmark_encrypt_rtcp_aes_128_cm_hmac_sha1, + benchmark_decrypt_rtcp_aes_128_cm_hmac_sha1 +); +criterion_main!(benches); diff --git a/vendor/webrtc-srtp/codecov.yml b/vendor/webrtc-srtp/codecov.yml new file mode 100644 index 0000000..2be1b3b --- /dev/null +++ b/vendor/webrtc-srtp/codecov.yml @@ -0,0 +1,23 @@ +codecov: + require_ci_to_pass: yes + max_report_age: off + token: d65de923-7c3d-4836-8d9a-5183b356be4f + +coverage: + precision: 2 + round: down + range: 50..90 + status: + project: + default: + enabled: no + threshold: 0.2 + if_not_found: success + patch: + default: + enabled: no + if_not_found: success + changes: + default: + enabled: no + if_not_found: success diff --git a/vendor/webrtc-srtp/doc/webrtc.rs.png b/vendor/webrtc-srtp/doc/webrtc.rs.png new file mode 100644 index 0000000..7bf0dda Binary files /dev/null and b/vendor/webrtc-srtp/doc/webrtc.rs.png differ diff --git a/vendor/webrtc-srtp/src/cipher/cipher_aead_aes_gcm.rs b/vendor/webrtc-srtp/src/cipher/cipher_aead_aes_gcm.rs new file mode 100644 index 0000000..cc88069 --- /dev/null +++ b/vendor/webrtc-srtp/src/cipher/cipher_aead_aes_gcm.rs @@ -0,0 +1,247 @@ +use aes_gcm::aead::generic_array::GenericArray; +use aes_gcm::aead::{Aead, Payload}; +use aes_gcm::{Aes128Gcm, KeyInit, Nonce}; +use byteorder::{BigEndian, ByteOrder}; +use bytes::{Bytes, BytesMut}; +use util::marshal::*; + +use super::Cipher; +use crate::error::{Error, Result}; +use crate::key_derivation::*; + +pub const CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN: usize = 16; + +const RTCP_ENCRYPTION_FLAG: u8 = 0x80; + +/// AEAD Cipher based on AES. +pub(crate) struct CipherAeadAesGcm { + srtp_cipher: aes_gcm::Aes128Gcm, + srtcp_cipher: aes_gcm::Aes128Gcm, + srtp_session_salt: Vec, + srtcp_session_salt: Vec, +} + +impl Cipher for CipherAeadAesGcm { + fn auth_tag_len(&self) -> usize { + CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN + } + + fn encrypt_rtp( + &mut self, + payload: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result { + // Grow the given buffer to fit the output. + let header_len = header.marshal_size(); + let mut writer = BytesMut::with_capacity(payload.len() + self.auth_tag_len()); + + // Copy header unencrypted. + writer.extend_from_slice(&payload[..header_len]); + + let nonce = self.rtp_initialization_vector(header, roc); + + let encrypted = self.srtp_cipher.encrypt( + Nonce::from_slice(&nonce), + Payload { + msg: &payload[header_len..], + aad: &writer, + }, + )?; + + writer.extend(encrypted); + Ok(writer.freeze()) + } + + fn decrypt_rtp( + &mut self, + ciphertext: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result { + if ciphertext.len() < self.auth_tag_len() { + return Err(Error::ErrFailedToVerifyAuthTag); + } + + let nonce = self.rtp_initialization_vector(header, roc); + let payload_offset = header.marshal_size(); + let decrypted_msg: Vec = self.srtp_cipher.decrypt( + Nonce::from_slice(&nonce), + Payload { + msg: &ciphertext[payload_offset..], + aad: &ciphertext[..payload_offset], + }, + )?; + + let mut writer = BytesMut::with_capacity(payload_offset + decrypted_msg.len()); + writer.extend_from_slice(&ciphertext[..payload_offset]); + writer.extend(decrypted_msg); + + Ok(writer.freeze()) + } + + fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result { + let iv = self.rtcp_initialization_vector(srtcp_index, ssrc); + let aad = self.rtcp_additional_authenticated_data(decrypted, srtcp_index); + + let encrypted_data = self.srtcp_cipher.encrypt( + Nonce::from_slice(&iv), + Payload { + msg: &decrypted[8..], + aad: &aad, + }, + )?; + + let mut writer = BytesMut::with_capacity(encrypted_data.len() + aad.len()); + writer.extend_from_slice(&decrypted[..8]); + writer.extend(encrypted_data); + writer.extend_from_slice(&aad[8..]); + + Ok(writer.freeze()) + } + + fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result { + if encrypted.len() < self.auth_tag_len() + SRTCP_INDEX_SIZE { + return Err(Error::ErrFailedToVerifyAuthTag); + } + + let nonce = self.rtcp_initialization_vector(srtcp_index, ssrc); + let aad = self.rtcp_additional_authenticated_data(encrypted, srtcp_index); + + let decrypted_data = self.srtcp_cipher.decrypt( + Nonce::from_slice(&nonce), + Payload { + msg: &encrypted[8..(encrypted.len() - SRTCP_INDEX_SIZE)], + aad: &aad, + }, + )?; + + let mut writer = BytesMut::with_capacity(8 + decrypted_data.len()); + writer.extend_from_slice(&encrypted[..8]); + writer.extend(decrypted_data); + + Ok(writer.freeze()) + } + + fn get_rtcp_index(&self, input: &[u8]) -> usize { + let pos = input.len() - 4; + let val = BigEndian::read_u32(&input[pos..]); + + (val & !((RTCP_ENCRYPTION_FLAG as u32) << 24)) as usize + } +} + +impl CipherAeadAesGcm { + /// Create a new AEAD instance. + pub(crate) fn new(master_key: &[u8], master_salt: &[u8]) -> Result { + let srtp_session_key = aes_cm_key_derivation( + LABEL_SRTP_ENCRYPTION, + master_key, + master_salt, + 0, + master_key.len(), + )?; + + let srtp_block = GenericArray::from_slice(&srtp_session_key); + + let srtp_cipher = Aes128Gcm::new(srtp_block); + + let srtcp_session_key = aes_cm_key_derivation( + LABEL_SRTCP_ENCRYPTION, + master_key, + master_salt, + 0, + master_key.len(), + )?; + + let srtcp_block = GenericArray::from_slice(&srtcp_session_key); + + let srtcp_cipher = Aes128Gcm::new(srtcp_block); + + let srtp_session_salt = aes_cm_key_derivation( + LABEL_SRTP_SALT, + master_key, + master_salt, + 0, + master_key.len(), + )?; + + let srtcp_session_salt = aes_cm_key_derivation( + LABEL_SRTCP_SALT, + master_key, + master_salt, + 0, + master_key.len(), + )?; + + Ok(CipherAeadAesGcm { + srtp_cipher, + srtcp_cipher, + srtp_session_salt, + srtcp_session_salt, + }) + } + + /// The 12-octet IV used by AES-GCM SRTP is formed by first concatenating + /// 2 octets of zeroes, the 4-octet SSRC, the 4-octet rollover counter + /// (ROC), and the 2-octet sequence number (SEQ). The resulting 12-octet + /// value is then XORed to the 12-octet salt to form the 12-octet IV. + /// + /// https://tools.ietf.org/html/rfc7714#section-8.1 + pub(crate) fn rtp_initialization_vector( + &self, + header: &rtp::header::Header, + roc: u32, + ) -> Vec { + let mut iv = vec![0u8; 12]; + BigEndian::write_u32(&mut iv[2..], header.ssrc); + BigEndian::write_u32(&mut iv[6..], roc); + BigEndian::write_u16(&mut iv[10..], header.sequence_number); + + for (i, v) in iv.iter_mut().enumerate() { + *v ^= self.srtp_session_salt[i]; + } + + iv + } + + /// The 12-octet IV used by AES-GCM SRTCP is formed by first + /// concatenating 2 octets of zeroes, the 4-octet SSRC identifier, + /// 2 octets of zeroes, a single "0" bit, and the 31-bit SRTCP index. + /// The resulting 12-octet value is then XORed to the 12-octet salt to + /// form the 12-octet IV. + /// + /// https://tools.ietf.org/html/rfc7714#section-9.1 + pub(crate) fn rtcp_initialization_vector(&self, srtcp_index: usize, ssrc: u32) -> Vec { + let mut iv = vec![0u8; 12]; + + BigEndian::write_u32(&mut iv[2..], ssrc); + BigEndian::write_u32(&mut iv[8..], srtcp_index as u32); + + for (i, v) in iv.iter_mut().enumerate() { + *v ^= self.srtcp_session_salt[i]; + } + + iv + } + + /// In an SRTCP packet, a 1-bit Encryption flag is prepended to the + /// 31-bit SRTCP index to form a 32-bit value we shall call the + /// "ESRTCP word" + /// + /// https://tools.ietf.org/html/rfc7714#section-17 + pub(crate) fn rtcp_additional_authenticated_data( + &self, + rtcp_packet: &[u8], + srtcp_index: usize, + ) -> Vec { + let mut aad = vec![0u8; 12]; + + aad[..8].copy_from_slice(&rtcp_packet[..8]); + + BigEndian::write_u32(&mut aad[8..], srtcp_index as u32); + + aad[8] |= RTCP_ENCRYPTION_FLAG; + aad + } +} diff --git a/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/ctrcipher.rs b/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/ctrcipher.rs new file mode 100644 index 0000000..d4a8391 --- /dev/null +++ b/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/ctrcipher.rs @@ -0,0 +1,220 @@ +use aes::cipher::generic_array::GenericArray; +use aes::cipher::{KeyIvInit, StreamCipher, StreamCipherSeek}; +use bytes::{BufMut, Bytes}; +use rtcp::header::{HEADER_LENGTH, SSRC_LENGTH}; +use subtle::ConstantTimeEq; +use util::marshal::*; + +use super::{Cipher, CipherInner}; +use crate::error::{Error, Result}; +use crate::key_derivation::*; + +type Aes128Ctr = ctr::Ctr128BE; + +pub(crate) struct CipherAesCmHmacSha1 { + inner: CipherInner, + srtp_session_key: Vec, + srtcp_session_key: Vec, +} + +impl CipherAesCmHmacSha1 { + pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result { + let inner = CipherInner::new(master_key, master_salt)?; + + let srtp_session_key = aes_cm_key_derivation( + LABEL_SRTP_ENCRYPTION, + master_key, + master_salt, + 0, + master_key.len(), + )?; + let srtcp_session_key = aes_cm_key_derivation( + LABEL_SRTCP_ENCRYPTION, + master_key, + master_salt, + 0, + master_key.len(), + )?; + + Ok(CipherAesCmHmacSha1 { + inner, + srtp_session_key, + srtcp_session_key, + }) + } +} + +impl Cipher for CipherAesCmHmacSha1 { + fn auth_tag_len(&self) -> usize { + self.inner.auth_tag_len() + } + + fn get_rtcp_index(&self, input: &[u8]) -> usize { + self.inner.get_rtcp_index(input) + } + + fn encrypt_rtp( + &mut self, + plaintext: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result { + let mut writer = Vec::with_capacity(plaintext.len() + self.auth_tag_len()); + + // Write the plaintext to the destination buffer. + writer.extend_from_slice(plaintext); + + // Encrypt the payload + let counter = generate_counter( + header.sequence_number, + roc, + header.ssrc, + &self.inner.srtp_session_salt, + ); + let key = GenericArray::from_slice(&self.srtp_session_key); + let nonce = GenericArray::from_slice(&counter); + let mut stream = Aes128Ctr::new(key, nonce); + stream.apply_keystream(&mut writer[header.marshal_size()..]); + + // Generate the auth tag. + let auth_tag = &self.inner.generate_srtp_auth_tag(&writer, roc)[..self.auth_tag_len()]; + writer.extend(auth_tag); + + Ok(Bytes::from(writer)) + } + + fn decrypt_rtp( + &mut self, + encrypted: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result { + let encrypted_len = encrypted.len(); + if encrypted_len < self.auth_tag_len() { + return Err(Error::SrtpTooSmall(encrypted_len, self.auth_tag_len())); + } + + let mut writer = Vec::with_capacity(encrypted_len - self.auth_tag_len()); + + // Split the auth tag and the cipher text into two parts. + let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..]; + let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()]; + + // Generate the auth tag we expect to see from the ciphertext. + let expected_tag = + &self.inner.generate_srtp_auth_tag(cipher_text, roc)[..self.auth_tag_len()]; + + // See if the auth tag actually matches. + // We use a constant time comparison to prevent timing attacks. + if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 { + return Err(Error::RtpFailedToVerifyAuthTag); + } + + // Write cipher_text to the destination buffer. + writer.extend_from_slice(cipher_text); + + // Decrypt the ciphertext for the payload. + let counter = generate_counter( + header.sequence_number, + roc, + header.ssrc, + &self.inner.srtp_session_salt, + ); + + let key = GenericArray::from_slice(&self.srtp_session_key); + let nonce = GenericArray::from_slice(&counter); + let mut stream = Aes128Ctr::new(key, nonce); + stream.seek(0); + stream.apply_keystream(&mut writer[header.marshal_size()..]); + + Ok(Bytes::from(writer)) + } + + fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result { + let mut writer = + Vec::with_capacity(decrypted.len() + SRTCP_INDEX_SIZE + self.auth_tag_len()); + + // Write the decrypted to the destination buffer. + writer.extend_from_slice(decrypted); + + // Encrypt everything after header + let counter = generate_counter( + (srtcp_index & 0xFFFF) as u16, + (srtcp_index >> 16) as u32, + ssrc, + &self.inner.srtcp_session_salt, + ); + + let key = GenericArray::from_slice(&self.srtcp_session_key); + let nonce = GenericArray::from_slice(&counter); + let mut stream = Aes128Ctr::new(key, nonce); + + stream.apply_keystream(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]); + + // Add SRTCP index and set Encryption bit + writer.put_u32(srtcp_index as u32 | (1u32 << 31)); + + // Generate the auth tag. + let auth_tag = &self.inner.generate_srtcp_auth_tag(&writer)[..self.auth_tag_len()]; + writer.extend(auth_tag); + + Ok(Bytes::from(writer)) + } + + fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result { + let encrypted_len = encrypted.len(); + if encrypted_len < self.auth_tag_len() + SRTCP_INDEX_SIZE { + return Err(Error::SrtcpTooSmall( + encrypted_len, + self.auth_tag_len() + SRTCP_INDEX_SIZE, + )); + } + + let tail_offset = encrypted_len - (self.auth_tag_len() + SRTCP_INDEX_SIZE); + + let mut writer = Vec::with_capacity(tail_offset); + + writer.extend_from_slice(&encrypted[0..tail_offset]); + + let is_encrypted = encrypted[tail_offset] >> 7; + if is_encrypted == 0 { + return Ok(Bytes::from(writer)); + } + + // Split the auth tag and the cipher text into two parts. + let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..]; + if actual_tag.len() != self.auth_tag_len() { + return Err(Error::RtcpInvalidLengthAuthTag( + actual_tag.len(), + self.auth_tag_len(), + )); + } + + let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()]; + + // Generate the auth tag we expect to see from the ciphertext. + let expected_tag = &self.inner.generate_srtcp_auth_tag(cipher_text)[..self.auth_tag_len()]; + + // See if the auth tag actually matches. + // We use a constant time comparison to prevent timing attacks. + if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 { + return Err(Error::RtcpFailedToVerifyAuthTag); + } + + let counter = generate_counter( + (srtcp_index & 0xFFFF) as u16, + (srtcp_index >> 16) as u32, + ssrc, + &self.inner.srtcp_session_salt, + ); + + let key = GenericArray::from_slice(&self.srtcp_session_key); + let nonce = GenericArray::from_slice(&counter); + let mut stream = Aes128Ctr::new(key, nonce); + + stream.seek(0); + stream.apply_keystream(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]); + + Ok(Bytes::from(writer)) + } +} diff --git a/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/mod.rs b/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/mod.rs new file mode 100644 index 0000000..00bae63 --- /dev/null +++ b/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/mod.rs @@ -0,0 +1,133 @@ +use byteorder::{BigEndian, ByteOrder}; +use hmac::{Hmac, Mac}; +use sha1::Sha1; + +use super::Cipher; +use crate::error::{Error, Result}; +use crate::key_derivation::*; +use crate::protection_profile::*; + +#[cfg(not(feature = "openssl"))] +mod ctrcipher; + +#[cfg(feature = "openssl")] +mod opensslcipher; + +#[cfg(not(feature = "openssl"))] +pub(crate) use ctrcipher::CipherAesCmHmacSha1; + +#[cfg(feature = "openssl")] +pub(crate) use opensslcipher::CipherAesCmHmacSha1; + +type HmacSha1 = Hmac; + +pub const CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN: usize = 10; + +pub(crate) struct CipherInner { + srtp_session_salt: Vec, + srtp_session_auth: HmacSha1, + srtcp_session_salt: Vec, + srtcp_session_auth: HmacSha1, +} + +impl CipherInner { + pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result { + let srtp_session_salt = aes_cm_key_derivation( + LABEL_SRTP_SALT, + master_key, + master_salt, + 0, + master_salt.len(), + )?; + let srtcp_session_salt = aes_cm_key_derivation( + LABEL_SRTCP_SALT, + master_key, + master_salt, + 0, + master_salt.len(), + )?; + + let auth_key_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_key_len(); + + let srtp_session_auth_tag = aes_cm_key_derivation( + LABEL_SRTP_AUTHENTICATION_TAG, + master_key, + master_salt, + 0, + auth_key_len, + )?; + let srtcp_session_auth_tag = aes_cm_key_derivation( + LABEL_SRTCP_AUTHENTICATION_TAG, + master_key, + master_salt, + 0, + auth_key_len, + )?; + + let srtp_session_auth = HmacSha1::new_from_slice(&srtp_session_auth_tag) + .map_err(|e| Error::Other(e.to_string()))?; + let srtcp_session_auth = HmacSha1::new_from_slice(&srtcp_session_auth_tag) + .map_err(|e| Error::Other(e.to_string()))?; + + Ok(Self { + srtp_session_salt, + srtp_session_auth, + srtcp_session_salt, + srtcp_session_auth, + }) + } + + /// https://tools.ietf.org/html/rfc3711#section-4.2 + /// In the case of SRTP, M SHALL consist of the Authenticated + /// Portion of the packet (as specified in Figure 1) concatenated with + /// the roc, M = Authenticated Portion || roc; + /// + /// The pre-defined authentication transform for SRTP is HMAC-SHA1 + /// [RFC2104]. With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL + /// be 0. For SRTP (respectively SRTCP), the HMAC SHALL be applied to + /// the session authentication key and M as specified above, i.e., + /// HMAC(k_a, M). The HMAC output SHALL then be truncated to the n_tag + /// left-most bits. + /// - Authenticated portion of the packet is everything BEFORE MKI + /// - k_a is the session message authentication key + /// - n_tag is the bit-length of the output authentication tag + fn generate_srtp_auth_tag(&self, buf: &[u8], roc: u32) -> [u8; 20] { + let mut signer = self.srtp_session_auth.clone(); + + signer.update(buf); + + // For SRTP only, we need to hash the rollover counter as well. + signer.update(&roc.to_be_bytes()); + + signer.finalize().into_bytes().into() + } + + /// https://tools.ietf.org/html/rfc3711#section-4.2 + /// + /// The pre-defined authentication transform for SRTP is HMAC-SHA1 + /// [RFC2104]. With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL + /// be 0. For SRTP (respectively SRTCP), the HMAC SHALL be applied to + /// the session authentication key and M as specified above, i.e., + /// HMAC(k_a, M). The HMAC output SHALL then be truncated to the n_tag + /// left-most bits. + /// - Authenticated portion of the packet is everything BEFORE MKI + /// - k_a is the session message authentication key + /// - n_tag is the bit-length of the output authentication tag + fn generate_srtcp_auth_tag(&self, buf: &[u8]) -> [u8; 20] { + let mut signer = self.srtcp_session_auth.clone(); + + signer.update(buf); + + signer.finalize().into_bytes().into() + } + + fn auth_tag_len(&self) -> usize { + CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN + } + + fn get_rtcp_index(&self, input: &[u8]) -> usize { + let tail_offset = input.len() - (self.auth_tag_len() + SRTCP_INDEX_SIZE); + (BigEndian::read_u32(&input[tail_offset..tail_offset + SRTCP_INDEX_SIZE]) & !(1 << 31)) + as usize + } +} diff --git a/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/opensslcipher.rs b/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/opensslcipher.rs new file mode 100644 index 0000000..48ce6c7 --- /dev/null +++ b/vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/opensslcipher.rs @@ -0,0 +1,261 @@ +use bytes::{BufMut, Bytes}; +use openssl::cipher_ctx::CipherCtx; +use rtcp::header::{HEADER_LENGTH, SSRC_LENGTH}; +use subtle::ConstantTimeEq; +use util::marshal::*; + +use super::{Cipher, CipherInner}; +use crate::{ + error::{Error, Result}, + key_derivation::*, +}; + +pub(crate) struct CipherAesCmHmacSha1 { + inner: CipherInner, + rtp_ctx: CipherCtx, + rtcp_ctx: CipherCtx, +} + +impl CipherAesCmHmacSha1 { + pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result { + let inner = CipherInner::new(master_key, master_salt)?; + + let srtp_session_key = aes_cm_key_derivation( + LABEL_SRTP_ENCRYPTION, + master_key, + master_salt, + 0, + master_key.len(), + )?; + let srtcp_session_key = aes_cm_key_derivation( + LABEL_SRTCP_ENCRYPTION, + master_key, + master_salt, + 0, + master_key.len(), + )?; + + let t = openssl::cipher::Cipher::aes_128_ctr(); + let mut rtp_ctx = CipherCtx::new().map_err(|e| Error::Other(e.to_string()))?; + rtp_ctx + .encrypt_init(Some(t), Some(&srtp_session_key[..]), None) + .map_err(|e| Error::Other(e.to_string()))?; + + let t = openssl::cipher::Cipher::aes_128_ctr(); + let mut rtcp_ctx = CipherCtx::new().map_err(|e| Error::Other(e.to_string()))?; + rtcp_ctx + .encrypt_init(Some(t), Some(&srtcp_session_key[..]), None) + .map_err(|e| Error::Other(e.to_string()))?; + + Ok(Self { + inner, + rtp_ctx, + rtcp_ctx, + }) + } +} + +impl Cipher for CipherAesCmHmacSha1 { + fn auth_tag_len(&self) -> usize { + self.inner.auth_tag_len() + } + + fn get_rtcp_index(&self, input: &[u8]) -> usize { + self.inner.get_rtcp_index(input) + } + + fn encrypt_rtp( + &mut self, + plaintext: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result { + let header_len = header.marshal_size(); + let mut writer = Vec::with_capacity(plaintext.len() + self.auth_tag_len()); + + // Copy the header unencrypted. + writer.extend_from_slice(&plaintext[..header_len]); + + // Encrypt the payload + let nonce = generate_counter( + header.sequence_number, + roc, + header.ssrc, + &self.inner.srtp_session_salt, + ); + writer.resize(plaintext.len(), 0); + self.rtp_ctx.encrypt_init(None, None, Some(&nonce)).unwrap(); + let count = self + .rtp_ctx + .cipher_update(&plaintext[header_len..], Some(&mut writer[header_len..])) + .unwrap(); + self.rtp_ctx + .cipher_final(&mut writer[header_len + count..]) + .unwrap(); + + // Generate and write the auth tag. + let auth_tag = &self.inner.generate_srtp_auth_tag(&writer, roc)[..self.auth_tag_len()]; + writer.extend_from_slice(auth_tag); + + Ok(Bytes::from(writer)) + } + + fn decrypt_rtp( + &mut self, + encrypted: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result { + let encrypted_len = encrypted.len(); + if encrypted_len < self.auth_tag_len() { + return Err(Error::SrtpTooSmall(encrypted_len, self.auth_tag_len())); + } + let header_len = header.marshal_size(); + + let mut writer = Vec::with_capacity(encrypted_len - self.auth_tag_len()); + + // Split the auth tag and the cipher text into two parts. + let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..]; + let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()]; + + // Generate the auth tag we expect to see from the ciphertext. + let expected_tag = + &self.inner.generate_srtp_auth_tag(cipher_text, roc)[..self.auth_tag_len()]; + + // See if the auth tag actually matches. + // We use a constant time comparison to prevent timing attacks. + if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 { + return Err(Error::RtpFailedToVerifyAuthTag); + } + + // Write cipher_text to the destination buffer. + writer.extend_from_slice(&cipher_text[..header_len]); + + // Decrypt the ciphertext for the payload. + let nonce = generate_counter( + header.sequence_number, + roc, + header.ssrc, + &self.inner.srtp_session_salt, + ); + + writer.resize(encrypted_len - self.auth_tag_len(), 0); + self.rtp_ctx.decrypt_init(None, None, Some(&nonce)).unwrap(); + let count = self + .rtp_ctx + .cipher_update(&cipher_text[header_len..], Some(&mut writer[header_len..])) + .unwrap(); + self.rtp_ctx + .cipher_final(&mut writer[header_len + count..]) + .unwrap(); + + Ok(Bytes::from(writer)) + } + + fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result { + let decrypted_len = decrypted.len(); + + let mut writer = Vec::with_capacity(decrypted_len + SRTCP_INDEX_SIZE + self.auth_tag_len()); + + // Write the decrypted to the destination buffer. + writer.extend_from_slice(&decrypted[..HEADER_LENGTH + SSRC_LENGTH]); + + // Encrypt everything after header + let nonce = generate_counter( + (srtcp_index & 0xFFFF) as u16, + (srtcp_index >> 16) as u32, + ssrc, + &self.inner.srtcp_session_salt, + ); + + writer.resize(decrypted_len, 0); + self.rtcp_ctx + .encrypt_init(None, None, Some(&nonce)) + .unwrap(); + let count = self + .rtcp_ctx + .cipher_update( + &decrypted[HEADER_LENGTH + SSRC_LENGTH..], + Some(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]), + ) + .unwrap(); + self.rtcp_ctx + .cipher_final(&mut writer[HEADER_LENGTH + SSRC_LENGTH + count..]) + .unwrap(); + + // Add SRTCP index and set Encryption bit + writer.put_u32(srtcp_index as u32 | (1u32 << 31)); + + // Generate the auth tag. + let auth_tag = &self.inner.generate_srtcp_auth_tag(&writer)[..self.auth_tag_len()]; + writer.extend(auth_tag); + + Ok(Bytes::from(writer)) + } + + fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result { + let encrypted_len = encrypted.len(); + + if encrypted_len < self.auth_tag_len() + SRTCP_INDEX_SIZE { + return Err(Error::SrtcpTooSmall( + encrypted_len, + self.auth_tag_len() + SRTCP_INDEX_SIZE, + )); + } + + let tail_offset = encrypted_len - (self.auth_tag_len() + SRTCP_INDEX_SIZE); + + let mut writer = Vec::with_capacity(tail_offset); + + writer.extend_from_slice(&encrypted[..HEADER_LENGTH + SSRC_LENGTH]); + + let is_encrypted = encrypted[tail_offset] >> 7; + if is_encrypted == 0 { + return Ok(Bytes::from(writer)); + } + + // Split the auth tag and the cipher text into two parts. + let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..]; + if actual_tag.len() != self.auth_tag_len() { + return Err(Error::RtcpInvalidLengthAuthTag( + actual_tag.len(), + self.auth_tag_len(), + )); + } + + let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()]; + + // Generate the auth tag we expect to see from the ciphertext. + let expected_tag = &self.inner.generate_srtcp_auth_tag(cipher_text)[..self.auth_tag_len()]; + + // See if the auth tag actually matches. + // We use a constant time comparison to prevent timing attacks. + if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 { + return Err(Error::RtcpFailedToVerifyAuthTag); + } + + let nonce = generate_counter( + (srtcp_index & 0xFFFF) as u16, + (srtcp_index >> 16) as u32, + ssrc, + &self.inner.srtcp_session_salt, + ); + + writer.resize(tail_offset, 0); + self.rtcp_ctx + .decrypt_init(None, None, Some(&nonce)) + .unwrap(); + let count = self + .rtcp_ctx + .cipher_update( + &encrypted[HEADER_LENGTH + SSRC_LENGTH..tail_offset], + Some(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]), + ) + .unwrap(); + self.rtcp_ctx + .cipher_final(&mut writer[HEADER_LENGTH + SSRC_LENGTH + count..]) + .unwrap(); + + Ok(Bytes::from(writer)) + } +} diff --git a/vendor/webrtc-srtp/src/cipher/mod.rs b/vendor/webrtc-srtp/src/cipher/mod.rs new file mode 100644 index 0000000..ce3cc19 --- /dev/null +++ b/vendor/webrtc-srtp/src/cipher/mod.rs @@ -0,0 +1,61 @@ +pub mod cipher_aead_aes_gcm; +pub mod cipher_aes_cm_hmac_sha1; + +use bytes::Bytes; + +use crate::error::Result; + +///NOTE: Auth tag and AEAD auth tag are placed at the different position in SRTCP +/// +///In non-AEAD cipher, the authentication tag is placed *after* the ESRTCP word +///(Encrypted-flag and SRTCP index). +/// +///> AES_128_CM_HMAC_SHA1_80 +///> | RTCP Header | Encrypted payload |E| SRTCP Index | Auth tag | +///> ^ |----------| +///> | ^ +///> | authTagLen=10 +///> aeadAuthTagLen=0 +/// +///In AEAD cipher, the AEAD authentication tag is embedded in the ciphertext. +///It is *before* the ESRTCP word (Encrypted-flag and SRTCP index). +/// +///> AEAD_AES_128_GCM +///> | RTCP Header | Encrypted payload | AEAD auth tag |E| SRTCP Index | +///> |---------------| ^ +///> ^ authTagLen=0 +///> aeadAuthTagLen=16 +/// +///See https://tools.ietf.org/html/rfc7714 for the full specifications. + +/// Cipher represents a implementation of one +/// of the SRTP Specific ciphers. +pub(crate) trait Cipher { + /// Get authenticated tag length. + fn auth_tag_len(&self) -> usize; + + /// Retrieved RTCP index. + fn get_rtcp_index(&self, input: &[u8]) -> usize; + + /// Encrypt RTP payload. + fn encrypt_rtp( + &mut self, + payload: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result; + + /// Decrypt RTP payload. + fn decrypt_rtp( + &mut self, + payload: &[u8], + header: &rtp::header::Header, + roc: u32, + ) -> Result; + + /// Encrypt RTCP payload. + fn encrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result; + + /// Decrypt RTCP payload. + fn decrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result; +} diff --git a/vendor/webrtc-srtp/src/config.rs b/vendor/webrtc-srtp/src/config.rs new file mode 100644 index 0000000..d2f771e --- /dev/null +++ b/vendor/webrtc-srtp/src/config.rs @@ -0,0 +1,83 @@ +use util::KeyingMaterialExporter; + +use crate::error::Result; +use crate::option::*; +use crate::protection_profile::*; + +const LABEL_EXTRACTOR_DTLS_SRTP: &str = "EXTRACTOR-dtls_srtp"; + +/// SessionKeys bundles the keys required to setup an SRTP session +#[derive(Default, Debug, Clone)] +pub struct SessionKeys { + pub local_master_key: Vec, + pub local_master_salt: Vec, + pub remote_master_key: Vec, + pub remote_master_salt: Vec, +} + +/// Config is used to configure a session. +/// You can provide either a KeyingMaterialExporter to export keys +/// or directly pass the keys themselves. +/// After a Config is passed to a session it must not be modified. +#[derive(Default)] +pub struct Config { + pub keys: SessionKeys, + pub profile: ProtectionProfile, + //LoggerFactory: logging.LoggerFactory + /// List of local/remote context options. + /// ReplayProtection is enabled on remote context by default. + /// Default replay protection window size is 64. + pub local_rtp_options: Option, + pub remote_rtp_options: Option, + + pub local_rtcp_options: Option, + pub remote_rtcp_options: Option, +} + +impl Config { + /// ExtractSessionKeysFromDTLS allows setting the Config SessionKeys by + /// extracting them from DTLS. This behavior is defined in RFC5764: + /// https://tools.ietf.org/html/rfc5764 + pub async fn extract_session_keys_from_dtls( + &mut self, + exporter: impl KeyingMaterialExporter, + is_client: bool, + ) -> Result<()> { + let key_len = self.profile.key_len(); + let salt_len = self.profile.salt_len(); + + let keying_material = exporter + .export_keying_material( + LABEL_EXTRACTOR_DTLS_SRTP, + &[], + (key_len * 2) + (salt_len * 2), + ) + .await?; + + let mut offset = 0; + let client_write_key = keying_material[offset..offset + key_len].to_vec(); + offset += key_len; + + let server_write_key = keying_material[offset..offset + key_len].to_vec(); + offset += key_len; + + let client_write_salt = keying_material[offset..offset + salt_len].to_vec(); + offset += salt_len; + + let server_write_salt = keying_material[offset..offset + salt_len].to_vec(); + + if is_client { + self.keys.local_master_key = client_write_key; + self.keys.local_master_salt = client_write_salt; + self.keys.remote_master_key = server_write_key; + self.keys.remote_master_salt = server_write_salt; + } else { + self.keys.local_master_key = server_write_key; + self.keys.local_master_salt = server_write_salt; + self.keys.remote_master_key = client_write_key; + self.keys.remote_master_salt = client_write_salt; + } + + Ok(()) + } +} diff --git a/vendor/webrtc-srtp/src/context/context_test.rs b/vendor/webrtc-srtp/src/context/context_test.rs new file mode 100644 index 0000000..a07298c --- /dev/null +++ b/vendor/webrtc-srtp/src/context/context_test.rs @@ -0,0 +1,341 @@ +use bytes::Bytes; +use lazy_static::lazy_static; + +use super::*; +use crate::key_derivation::*; + +const CIPHER_CONTEXT_ALGO: ProtectionProfile = ProtectionProfile::Aes128CmHmacSha1_80; +const DEFAULT_SSRC: u32 = 0; + +#[test] +fn test_context_roc() -> Result<()> { + let key_len = CIPHER_CONTEXT_ALGO.key_len(); + let salt_len = CIPHER_CONTEXT_ALGO.salt_len(); + + let mut c = Context::new( + &vec![0; key_len], + &vec![0; salt_len], + CIPHER_CONTEXT_ALGO, + None, + None, + )?; + + let roc = c.get_roc(123); + assert!(roc.is_none(), "ROC must return None for unused SSRC"); + + c.set_roc(123, 100); + let roc = c.get_roc(123); + if let Some(r) = roc { + assert_eq!(r, 100, "ROC is set to 100, but returned {r}") + } else { + panic!("ROC must return value for used SSRC"); + } + + Ok(()) +} + +#[test] +fn test_context_index() -> Result<()> { + let key_len = CIPHER_CONTEXT_ALGO.key_len(); + let salt_len = CIPHER_CONTEXT_ALGO.salt_len(); + + let mut c = Context::new( + &vec![0; key_len], + &vec![0; salt_len], + CIPHER_CONTEXT_ALGO, + None, + None, + )?; + + let index = c.get_index(123); + assert!(index.is_none(), "Index must return None for unused SSRC"); + + c.set_index(123, 100); + let index = c.get_index(123); + if let Some(i) = index { + assert_eq!(i, 100, "Index is set to 100, but returned {i}"); + } else { + panic!("Index must return true for used SSRC") + } + + Ok(()) +} + +#[test] +fn test_key_len() -> Result<()> { + let key_len = CIPHER_CONTEXT_ALGO.key_len(); + let salt_len = CIPHER_CONTEXT_ALGO.salt_len(); + + let result = Context::new(&[], &vec![0; salt_len], CIPHER_CONTEXT_ALGO, None, None); + assert!(result.is_err(), "CreateContext accepted a 0 length key"); + + let result = Context::new(&vec![0; key_len], &[], CIPHER_CONTEXT_ALGO, None, None); + assert!(result.is_err(), "CreateContext accepted a 0 length salt"); + + let result = Context::new( + &vec![0; key_len], + &vec![0; salt_len], + CIPHER_CONTEXT_ALGO, + None, + None, + ); + assert!( + result.is_ok(), + "CreateContext failed with a valid length key and salt" + ); + + Ok(()) +} + +#[test] +fn test_valid_packet_counter() -> Result<()> { + let master_key = vec![ + 0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28, + 0x89, + ]; + let master_salt = vec![ + 0x62, 0x77, 0x60, 0x38, 0xc0, 0x6d, 0xc9, 0x41, 0x9f, 0x6d, 0xd9, 0x43, 0x3e, 0x7c, + ]; + + let srtp_session_salt = aes_cm_key_derivation( + LABEL_SRTP_SALT, + &master_key, + &master_salt, + 0, + master_salt.len(), + )?; + + let s = SrtpSsrcState { + ssrc: 4160032510, + ..Default::default() + }; + let expected_counter = [ + 0xcf, 0x90, 0x1e, 0xa5, 0xda, 0xd3, 0x2c, 0x15, 0x00, 0xa2, 0x24, 0xae, 0xae, 0xaf, 0x00, + 0x00, + ]; + let counter = generate_counter(32846, s.rollover_counter, s.ssrc, &srtp_session_salt); + assert_eq!( + counter, expected_counter, + "Session Key {counter:?} does not match expected {expected_counter:?}", + ); + + Ok(()) +} + +#[test] +fn test_rollover_count() -> Result<()> { + let mut s = SrtpSsrcState { + ssrc: DEFAULT_SSRC, + ..Default::default() + }; + + // Set initial seqnum + let roc = s.next_rollover_count(65530); + assert_eq!(roc, 0, "Initial rolloverCounter must be 0"); + s.update_rollover_count(65530); + + // Invalid packets never update ROC + s.next_rollover_count(0); + s.next_rollover_count(0x4000); + s.next_rollover_count(0x8000); + s.next_rollover_count(0xFFFF); + s.next_rollover_count(0); + + // We rolled over to 0 + let roc = s.next_rollover_count(0); + assert_eq!(roc, 1, "rolloverCounter was not updated after it crossed 0"); + s.update_rollover_count(0); + + let roc = s.next_rollover_count(65530); + assert_eq!( + roc, 0, + "rolloverCounter was not updated when it rolled back, failed to handle out of order" + ); + s.update_rollover_count(65530); + + let roc = s.next_rollover_count(5); + assert_eq!( + roc, 1, + "rolloverCounter was not updated when it rolled over initial, to handle out of order" + ); + s.update_rollover_count(5); + + s.next_rollover_count(6); + s.update_rollover_count(6); + + s.next_rollover_count(7); + s.update_rollover_count(7); + + let roc = s.next_rollover_count(8); + assert_eq!( + roc, 1, + "rolloverCounter was improperly updated for non-significant packets" + ); + s.update_rollover_count(8); + + // valid packets never update ROC + let roc = s.next_rollover_count(0x4000); + assert_eq!( + roc, 1, + "rolloverCounter was improperly updated for non-significant packets" + ); + s.update_rollover_count(0x4000); + + let roc = s.next_rollover_count(0x8000); + assert_eq!( + roc, 1, + "rolloverCounter was improperly updated for non-significant packets" + ); + s.update_rollover_count(0x8000); + + let roc = s.next_rollover_count(0xFFFF); + assert_eq!( + roc, 1, + "rolloverCounter was improperly updated for non-significant packets" + ); + s.update_rollover_count(0xFFFF); + + let roc = s.next_rollover_count(0); + assert_eq!( + roc, 2, + "rolloverCounter must be incremented after wrapping, got {roc}" + ); + + Ok(()) +} + +lazy_static! { + static ref MASTER_KEY: Bytes = Bytes::from_static(&[ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, + 0x0f, + ]); + static ref MASTER_SALT: Bytes = Bytes::from_static(&[ + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, + ]); + static ref DECRYPTED_RTP_PACKET: Bytes = Bytes::from_static(&[ + 0x80, 0x0f, 0x12, 0x34, 0xde, 0xca, 0xfb, 0xad, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, + 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, + ]); + static ref ENCRYPTED_RTP_PACKET: Bytes = Bytes::from_static(&[ + 0x80, 0x0f, 0x12, 0x34, 0xde, 0xca, 0xfb, 0xad, 0xca, 0xfe, 0xba, 0xbe, 0xc5, 0x00, 0x2e, + 0xde, 0x04, 0xcf, 0xdd, 0x2e, 0xb9, 0x11, 0x59, 0xe0, 0x88, 0x0a, 0xa0, 0x6e, 0xd2, 0x97, + 0x68, 0x26, 0xf7, 0x96, 0xb2, 0x01, 0xdf, 0x31, 0x31, 0xa1, 0x27, 0xe8, 0xa3, 0x92, + ]); + static ref DECRYPTED_RTCP_PACKET: Bytes = Bytes::from_static(&[ + 0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, + 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, + ]); + static ref ENCRYPTED_RTCP_PACKET: Bytes = Bytes::from_static(&[ + 0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xc9, 0x8b, 0x8b, 0x5d, 0xf0, 0x39, 0x2a, + 0x55, 0x85, 0x2b, 0x6c, 0x21, 0xac, 0x8e, 0x70, 0x25, 0xc5, 0x2c, 0x6f, 0xbe, 0xa2, 0xb3, + 0xb4, 0x46, 0xea, 0x31, 0x12, 0x3b, 0xa8, 0x8c, 0xe6, 0x1e, 0x80, 0x00, 0x00, 0x01, + ]); +} + +#[test] +fn test_encrypt_rtp() { + let mut ctx = Context::new( + &MASTER_KEY, + &MASTER_SALT, + ProtectionProfile::AeadAes128Gcm, + None, + None, + ) + .expect("Error creating srtp context"); + + let gotten_encrypted_rtp_packet = ctx + .encrypt_rtp(&DECRYPTED_RTP_PACKET) + .expect("Error encrypting rtp payload"); + + assert_eq!(gotten_encrypted_rtp_packet, *ENCRYPTED_RTP_PACKET) +} + +#[test] +fn test_decrypt_rtp() { + let mut ctx = Context::new( + &MASTER_KEY, + &MASTER_SALT, + ProtectionProfile::AeadAes128Gcm, + None, + None, + ) + .expect("Error creating srtp context"); + + let gotten_decrypted_rtp_packet = ctx + .decrypt_rtp(&ENCRYPTED_RTP_PACKET) + .expect("Error decrypting rtp payload"); + + assert_eq!(gotten_decrypted_rtp_packet, *DECRYPTED_RTP_PACKET) +} + +#[test] +fn test_encrypt_rtcp() { + let mut ctx = Context::new( + &MASTER_KEY, + &MASTER_SALT, + ProtectionProfile::AeadAes128Gcm, + None, + None, + ) + .expect("Error creating srtp context"); + + let gotten_encrypted_rtcp_packet = ctx + .encrypt_rtcp(&DECRYPTED_RTCP_PACKET) + .expect("Error encrypting rtcp payload"); + + assert_eq!(gotten_encrypted_rtcp_packet, *ENCRYPTED_RTCP_PACKET) +} + +#[test] +fn test_decrypt_rtcp() { + let mut ctx = Context::new( + &MASTER_KEY, + &MASTER_SALT, + ProtectionProfile::AeadAes128Gcm, + None, + None, + ) + .expect("Error creating srtp context"); + + let gotten_decrypted_rtcp_packet = ctx + .decrypt_rtcp(&ENCRYPTED_RTCP_PACKET) + .expect("Error decrypting rtcp payload"); + + assert_eq!(gotten_decrypted_rtcp_packet, *DECRYPTED_RTCP_PACKET) +} + +#[test] +fn test_rollover_high_water_mark() { + let mut state = super::SrtpSsrcState::default(); + for seq in [65000, 65535, 85] { + state.update_rollover_count(seq); + } + for seq in [65000, 65530, 84, 0] { + state.update_rollover_count(seq); + assert_eq!(state.rollover_counter, 1); + assert_eq!(state.last_sequence_number, 85); + } + assert_eq!(state.next_rollover_count(86), 1); + state.update_rollover_count(1000); + state.update_rollover_count(32000); + state.update_rollover_count(64000); + assert_eq!(state.next_rollover_count(1000), 2); + state.update_rollover_count(1000); + assert_eq!(state.rollover_counter, 2); + assert_eq!(state.last_sequence_number, 1000); +} + +#[test] +fn test_rollover_initial_zero_and_counter_wrap() { + let mut state = super::SrtpSsrcState::default(); + state.update_rollover_count(0); + assert_eq!(state.next_rollover_count(65535), u32::MAX); + state.update_rollover_count(65535); + assert_eq!(state.rollover_counter, 0); + assert_eq!(state.last_sequence_number, 0); + state.rollover_counter = u32::MAX; + state.last_sequence_number = 65535; + state.update_rollover_count(0); + assert_eq!(state.rollover_counter, 0); + assert_eq!(state.last_sequence_number, 0); +} diff --git a/vendor/webrtc-srtp/src/context/mod.rs b/vendor/webrtc-srtp/src/context/mod.rs new file mode 100644 index 0000000..4695bfe --- /dev/null +++ b/vendor/webrtc-srtp/src/context/mod.rs @@ -0,0 +1,177 @@ +#[cfg(test)] +mod context_test; +#[cfg(test)] +mod rollover_regression_test; +#[cfg(test)] +mod srtcp_test; +#[cfg(test)] +mod srtp_test; + +use std::collections::HashMap; + +use util::replay_detector::*; + +use crate::cipher::cipher_aead_aes_gcm::*; +use crate::cipher::cipher_aes_cm_hmac_sha1::*; +use crate::cipher::*; +use crate::error::{Error, Result}; +use crate::option::*; +use crate::protection_profile::*; + +pub mod srtcp; +pub mod srtp; + +const SEQUENCE_HALF_RANGE: i32 = 1 << 15; + +/// Encrypt/Decrypt state for a single SRTP SSRC +#[derive(Default)] +pub(crate) struct SrtpSsrcState { + ssrc: u32, + rollover_counter: u32, + rollover_has_processed: bool, + last_sequence_number: u16, + replay_detector: Option>, +} + +/// Encrypt/Decrypt state for a single SRTCP SSRC +#[derive(Default)] +pub(crate) struct SrtcpSsrcState { + srtcp_index: usize, + ssrc: u32, + replay_detector: Option>, +} + +impl SrtpSsrcState { + pub fn next_rollover_count(&self, sequence_number: u16) -> u32 { + let roc = self.rollover_counter; + if !self.rollover_has_processed { + return roc; + } + // RFC 3711 Appendix A: estimate the index nearest the highest packet. + let last = i32::from(self.last_sequence_number); + let seq = i32::from(sequence_number); + if last < SEQUENCE_HALF_RANGE { + if seq - last > SEQUENCE_HALF_RANGE { + return roc.wrapping_sub(1); + } + } else if last - SEQUENCE_HALF_RANGE > seq { + return roc.wrapping_add(1); + } + roc + } + + pub fn update_rollover_count(&mut self, sequence_number: u16) { + let roc = self.next_rollover_count(sequence_number); + // Retransmissions must never move the highest authenticated index back. + if !self.rollover_has_processed + || (roc == self.rollover_counter && sequence_number > self.last_sequence_number) + || roc == self.rollover_counter.wrapping_add(1) + { + self.rollover_counter = roc; + self.last_sequence_number = sequence_number; + self.rollover_has_processed = true; + } + } +} + +/// Context represents a SRTP cryptographic context +/// Context can only be used for one-way operations +/// it must either used ONLY for encryption or ONLY for decryption +pub struct Context { + cipher: Box, + + srtp_ssrc_states: HashMap, + srtcp_ssrc_states: HashMap, + + new_srtp_replay_detector: ContextOption, + new_srtcp_replay_detector: ContextOption, +} + +impl Context { + /// CreateContext creates a new SRTP Context + pub fn new( + master_key: &[u8], + master_salt: &[u8], + profile: ProtectionProfile, + srtp_ctx_opt: Option, + srtcp_ctx_opt: Option, + ) -> Result { + let key_len = profile.key_len(); + let salt_len = profile.salt_len(); + + if master_key.len() != key_len { + return Err(Error::SrtpMasterKeyLength(key_len, master_key.len())); + } else if master_salt.len() != salt_len { + return Err(Error::SrtpSaltLength(salt_len, master_salt.len())); + } + + let cipher: Box = match profile { + ProtectionProfile::Aes128CmHmacSha1_80 => { + Box::new(CipherAesCmHmacSha1::new(master_key, master_salt)?) + } + + ProtectionProfile::AeadAes128Gcm => { + Box::new(CipherAeadAesGcm::new(master_key, master_salt)?) + } + }; + + let srtp_ctx_opt = if let Some(ctx_opt) = srtp_ctx_opt { + ctx_opt + } else { + srtp_no_replay_protection() + }; + + let srtcp_ctx_opt = if let Some(ctx_opt) = srtcp_ctx_opt { + ctx_opt + } else { + srtcp_no_replay_protection() + }; + + Ok(Context { + cipher, + srtp_ssrc_states: HashMap::new(), + srtcp_ssrc_states: HashMap::new(), + new_srtp_replay_detector: srtp_ctx_opt, + new_srtcp_replay_detector: srtcp_ctx_opt, + }) + } + + fn get_srtp_ssrc_state(&mut self, ssrc: u32) -> &mut SrtpSsrcState { + let s = SrtpSsrcState { + ssrc, + replay_detector: Some((self.new_srtp_replay_detector)()), + ..Default::default() + }; + + self.srtp_ssrc_states.entry(ssrc).or_insert(s) + } + + fn get_srtcp_ssrc_state(&mut self, ssrc: u32) -> &mut SrtcpSsrcState { + let s = SrtcpSsrcState { + ssrc, + replay_detector: Some((self.new_srtcp_replay_detector)()), + ..Default::default() + }; + self.srtcp_ssrc_states.entry(ssrc).or_insert(s) + } + + /// roc returns SRTP rollover counter value of specified SSRC. + fn get_roc(&self, ssrc: u32) -> Option { + self.srtp_ssrc_states.get(&ssrc).map(|s| s.rollover_counter) + } + + /// set_roc sets SRTP rollover counter value of specified SSRC. + fn set_roc(&mut self, ssrc: u32, roc: u32) { + self.get_srtp_ssrc_state(ssrc).rollover_counter = roc; + } + + /// index returns SRTCP index value of specified SSRC. + fn get_index(&self, ssrc: u32) -> Option { + self.srtcp_ssrc_states.get(&ssrc).map(|s| s.srtcp_index) + } + + /// set_index sets SRTCP index value of specified SSRC. + fn set_index(&mut self, ssrc: u32, index: usize) { + self.get_srtcp_ssrc_state(ssrc).srtcp_index = index; + } +} diff --git a/vendor/webrtc-srtp/src/context/rollover_regression_test.rs b/vendor/webrtc-srtp/src/context/rollover_regression_test.rs new file mode 100644 index 0000000..5719ec5 --- /dev/null +++ b/vendor/webrtc-srtp/src/context/rollover_regression_test.rs @@ -0,0 +1,73 @@ +use crate::{context::Context, protection_profile::ProtectionProfile}; +fn packet(seq: u16) -> (Vec, rtp::header::Header) { + let h = rtp::header::Header { + version: 2, + sequence_number: seq, + ssrc: 1, + ..Default::default() + }; + let mut b = vec![0x80, 96]; + b.extend(seq.to_be_bytes()); + b.extend(0u32.to_be_bytes()); + b.extend(1u32.to_be_bytes()); + b.extend([1, 2, 3, 4]); + (b, h) +} +fn run(profile: ProtectionProfile, retransmits: bool) -> usize { + let mut tx = Context::new( + &vec![0; 16], + &vec![ + 0; + match profile { + ProtectionProfile::Aes128CmHmacSha1_80 => 14, + _ => 12, + } + ], + profile, + None, + None, + ) + .unwrap(); + let mut rx = Context::new( + &vec![0; 16], + &vec![ + 0; + match profile { + ProtectionProfile::Aes128CmHmacSha1_80 => 14, + _ => 12, + } + ], + profile, + None, + None, + ) + .unwrap(); + for seq in (65000u16..=65535).chain(0..=85) { + let (b, h) = packet(seq); + let e = tx.encrypt_rtp_with_header(&b, &h).unwrap(); + rx.decrypt_rtp(&e).unwrap(); + } + if retransmits { + for seq in [65000, 65530] { + let (b, h) = packet(seq); + let _ = tx.encrypt_rtp_with_header(&b, &h).unwrap(); + } + } + let mut failures = 0; + for seq in 86..=1000 { + let (b, h) = packet(seq); + let e = tx.encrypt_rtp_with_header(&b, &h).unwrap(); + failures += usize::from(rx.decrypt_rtp(&e).is_err()); + } + failures +} +#[test] +fn delayed_retransmissions_preserve_authentication() { + for profile in [ + ProtectionProfile::Aes128CmHmacSha1_80, + ProtectionProfile::AeadAes128Gcm, + ] { + assert_eq!(run(profile, false), 0); + assert_eq!(run(profile, true), 0); + } +} diff --git a/vendor/webrtc-srtp/src/context/srtcp.rs b/vendor/webrtc-srtp/src/context/srtcp.rs new file mode 100644 index 0000000..8bc54fd --- /dev/null +++ b/vendor/webrtc-srtp/src/context/srtcp.rs @@ -0,0 +1,50 @@ +use bytes::Bytes; +use util::marshal::*; + +use super::*; +use crate::error::Result; + +impl Context { + /// DecryptRTCP decrypts a RTCP packet with an encrypted payload + pub fn decrypt_rtcp(&mut self, encrypted: &[u8]) -> Result { + let mut buf = encrypted; + rtcp::header::Header::unmarshal(&mut buf)?; + + let index = self.cipher.get_rtcp_index(encrypted); + let ssrc = u32::from_be_bytes([encrypted[4], encrypted[5], encrypted[6], encrypted[7]]); + + if let Some(replay_detector) = &mut self.get_srtcp_ssrc_state(ssrc).replay_detector { + if !replay_detector.check(index as u64) { + return Err(Error::SrtcpSsrcDuplicated(ssrc, index)); + } + } + + let dst = self.cipher.decrypt_rtcp(encrypted, index, ssrc)?; + + if let Some(replay_detector) = &mut self.get_srtcp_ssrc_state(ssrc).replay_detector { + replay_detector.accept(); + } + + Ok(dst) + } + + /// EncryptRTCP marshals and encrypts an RTCP packet, writing to the dst buffer provided. + /// If the dst buffer does not have the capacity to hold `len(plaintext) + 14` bytes, a new one will be allocated and returned. + pub fn encrypt_rtcp(&mut self, decrypted: &[u8]) -> Result { + let mut buf = decrypted; + rtcp::header::Header::unmarshal(&mut buf)?; + + let ssrc = u32::from_be_bytes([decrypted[4], decrypted[5], decrypted[6], decrypted[7]]); + + let index = { + let state = self.get_srtcp_ssrc_state(ssrc); + state.srtcp_index += 1; + if state.srtcp_index > MAX_SRTCP_INDEX { + state.srtcp_index = 0; + } + state.srtcp_index + }; + + self.cipher.encrypt_rtcp(decrypted, index, ssrc) + } +} diff --git a/vendor/webrtc-srtp/src/context/srtcp_test.rs b/vendor/webrtc-srtp/src/context/srtcp_test.rs new file mode 100644 index 0000000..55d7722 --- /dev/null +++ b/vendor/webrtc-srtp/src/context/srtcp_test.rs @@ -0,0 +1,257 @@ +use bytes::{Buf, Bytes, BytesMut}; +use lazy_static::lazy_static; + +use super::*; +use crate::key_derivation::*; + +pub struct RTCPTestCase { + ssrc: u32, + index: usize, + encrypted: Bytes, + decrypted: Bytes, +} + +lazy_static! { + static ref RTCP_TEST_MASTER_KEY: Bytes = Bytes::from_static(&[ + 0xfd, 0xa6, 0x25, 0x95, 0xd7, 0xf6, 0x92, 0x6f, 0x7d, 0x9c, 0x02, 0x4c, 0xc9, 0x20, 0x9f, + 0x34 + ]); + + static ref RTCP_TEST_MASTER_SALT: Bytes = Bytes::from_static(&[ + 0xa9, 0x65, 0x19, 0x85, 0x54, 0x0b, 0x47, 0xbe, 0x2f, 0x27, 0xa8, 0xb8, 0x81, 0x23 + ]); + + static ref RTCP_TEST_CASES: Vec = vec![ + RTCPTestCase { + ssrc: 0x66ef91ff, + index: 0, + encrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0xcd, 0x34, 0xc5, 0x78, 0xb2, 0x8b, + 0xe1, 0x6b, 0xc5, 0x09, 0xd5, 0x77, 0xe4, 0xce, 0x5f, 0x20, 0x80, 0x21, 0xbd, 0x66, + 0x74, 0x65, 0xe9, 0x5f, 0x49, 0xe5, 0xf5, 0xc0, 0x68, 0x4e, 0xe5, 0x6a, 0x78, 0x07, + 0x75, 0x46, 0xed, 0x90, 0xf6, 0xdc, 0x9d, 0xef, 0x3b, 0xdf, 0xf2, 0x79, 0xa9, 0xd8, + 0x80, 0x00, 0x00, 0x01, 0x60, 0xc0, 0xae, 0xb5, 0x6f, 0x40, 0x88, 0x0e, 0x28, 0xba + ]), + decrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0xdf, 0x48, 0x80, 0xdd, 0x61, 0xa6, + 0x2e, 0xd3, 0xd8, 0xbc, 0xde, 0xbe, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x16, 0x04, + 0x81, 0xca, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0x01, 0x10, 0x52, 0x6e, 0x54, 0x35, + 0x43, 0x6d, 0x4a, 0x68, 0x7a, 0x79, 0x65, 0x74, 0x41, 0x78, 0x77, 0x2b, 0x00, 0x00 + ]), + }, + RTCPTestCase{ + ssrc: 0x11111111, + index: 0, + encrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11, + 0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46, + 0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38, + 0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad, + 0x80, 0x00, 0x00, 0x01, 0x34, 0x3c, 0x2e, 0x83, 0x17, 0x13, 0x93, 0x69, 0xcf, 0xc0 + ]), + decrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0xdf, 0x48, 0x80, 0xdd, 0x61, 0xa6, + 0x2e, 0xd3, 0xd8, 0xbc, 0xde, 0xbe, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x16, 0x04, + 0x81, 0xca, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0x01, 0x10, 0x52, 0x6e, 0x54, 0x35, + 0x43, 0x6d, 0x4a, 0x68, 0x7a, 0x79, 0x65, 0x74, 0x41, 0x78, 0x77, 0x2b, 0x00, 0x00 + ]), + }, + RTCPTestCase{ + ssrc: 0x11111111, + index: 0x7ffffffe, // Upper boundary of index + encrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11, + 0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46, + 0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38, + 0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad, + 0xff, 0xff, 0xff, 0xff, 0x5a, 0x99, 0xce, 0xed, 0x9f, 0x2e, 0x4d, 0x9d, 0xfa, 0x97 + ]), + decrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x0, 0x6, 0x11, 0x11, 0x11, 0x11, 0x4, 0x99, 0x47, 0x53, 0xc4, 0x1e, + 0xb9, 0xde, 0x52, 0xa3, 0x1d, 0x77, 0x2f, 0xff, 0xcc, 0x75, 0xbb, 0x6a, 0x29, 0xb8, + 0x1, 0xb7, 0x2e, 0x4b, 0x4e, 0xcb, 0xa4, 0x81, 0x2d, 0x46, 0x4, 0x5e, 0x86, 0x90, + 0x17, 0x4f, 0x4d, 0x78, 0x2f, 0x58, 0xb8, 0x67, 0x91, 0x89, 0xe3, 0x61, 0x1, 0x7d + ]), + }, + RTCPTestCase{ + ssrc: 0x11111111, + index: 0x7fffffff, // Will be wrapped to 0 + encrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11, + 0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46, + 0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38, + 0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad, + 0x80, 0x00, 0x00, 0x00, 0x7d, 0x51, 0xf8, 0x0e, 0x56, 0x40, 0x72, 0x7b, 0x9e, 0x02 + ]), + decrypted: Bytes::from_static(&[ + 0x80, 0xc8, 0x0, 0x6, 0x11, 0x11, 0x11, 0x11, 0xda, 0xb5, 0xe0, 0x56, 0x9a, 0x4a, + 0x74, 0xed, 0x8a, 0x54, 0xc, 0xcf, 0xd5, 0x9, 0xb1, 0x40, 0x1, 0x42, 0xc3, 0x9a, + 0x76, 0x0, 0xa9, 0xd4, 0xf7, 0x29, 0x9e, 0x51, 0xfb, 0x3c, 0xc1, 0x74, 0x72, 0xf9, + 0x52, 0xb1, 0x92, 0x31, 0xca, 0x22, 0xab, 0x3e, 0xc5, 0x5f, 0x83, 0x34, 0xf0, 0x28 + ]), + }, + ]; +} + +#[test] +fn test_rtcp_lifecycle() -> Result<()> { + let mut encrypt_context = Context::new( + &RTCP_TEST_MASTER_KEY, + &RTCP_TEST_MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + )?; + let mut decrypt_context = Context::new( + &RTCP_TEST_MASTER_KEY, + &RTCP_TEST_MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + )?; + + for test_case in &*RTCP_TEST_CASES { + let decrypt_result = decrypt_context.decrypt_rtcp(&test_case.encrypted)?; + assert_eq!( + decrypt_result, test_case.decrypted, + "RTCP failed to decrypt" + ); + + encrypt_context.set_index(test_case.ssrc, test_case.index); + let encrypt_result = encrypt_context.encrypt_rtcp(&test_case.decrypted)?; + assert_eq!( + encrypt_result, test_case.encrypted, + "RTCP failed to encrypt" + ); + } + + Ok(()) +} + +#[test] +fn test_rtcp_invalid_auth_tag() -> Result<()> { + let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len(); + + let mut decrypt_context = Context::new( + &RTCP_TEST_MASTER_KEY, + &RTCP_TEST_MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + )?; + + let decrypt_result = decrypt_context.decrypt_rtcp(&RTCP_TEST_CASES[0].encrypted)?; + assert_eq!( + decrypt_result, RTCP_TEST_CASES[0].decrypted, + "RTCP failed to decrypt" + ); + + // Zero out auth tag + let mut rtcp_packet = BytesMut::new(); + rtcp_packet.extend_from_slice(&RTCP_TEST_CASES[0].encrypted); + let rtcp_packet_len = rtcp_packet.len(); + rtcp_packet[rtcp_packet_len - auth_tag_len..].copy_from_slice(&vec![0; auth_tag_len]); + let rtcp_packet = rtcp_packet.freeze(); + let decrypt_result = decrypt_context.decrypt_rtcp(&rtcp_packet); + assert!( + decrypt_result.is_err(), + "Was able to decrypt RTCP packet with invalid Auth Tag" + ); + + Ok(()) +} + +#[test] +fn test_rtcp_replay_detector_separation() -> Result<()> { + let mut decrypt_context = Context::new( + &RTCP_TEST_MASTER_KEY, + &RTCP_TEST_MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + Some(srtcp_replay_protection(10)), + )?; + + let rtcp_packet1 = RTCP_TEST_CASES[0].encrypted.clone(); + let decrypt_result1 = decrypt_context.decrypt_rtcp(&rtcp_packet1)?; + assert_eq!( + decrypt_result1, RTCP_TEST_CASES[0].decrypted, + "RTCP failed to decrypt" + ); + + let rtcp_packet2 = RTCP_TEST_CASES[1].encrypted.clone(); + let decrypt_result2 = decrypt_context.decrypt_rtcp(&rtcp_packet2)?; + assert_eq!( + decrypt_result2, RTCP_TEST_CASES[1].decrypted, + "RTCP failed to decrypt" + ); + + let result = decrypt_context.decrypt_rtcp(&rtcp_packet1); + assert!( + result.is_err(), + "Was able to decrypt duplicated RTCP packet" + ); + + let result = decrypt_context.decrypt_rtcp(&rtcp_packet2); + assert!( + result.is_err(), + "Was able to decrypt duplicated RTCP packet" + ); + + Ok(()) +} + +fn get_rtcp_index(encrypted: &Bytes, auth_tag_len: usize) -> u32 { + let tail_offset = encrypted.len() - (auth_tag_len + SRTCP_INDEX_SIZE); + let reader = &mut encrypted.slice(tail_offset..tail_offset + SRTCP_INDEX_SIZE); + //^(1 << 31) + reader.get_u32() & 0x7FFFFFFF +} + +#[test] +fn test_encrypt_rtcp_separation() -> Result<()> { + let mut encrypt_context = Context::new( + &RTCP_TEST_MASTER_KEY, + &RTCP_TEST_MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + )?; + + let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len(); + + let mut decrypt_context = Context::new( + &RTCP_TEST_MASTER_KEY, + &RTCP_TEST_MASTER_SALT, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + Some(srtcp_replay_protection(10)), + )?; + + let inputs = vec![ + RTCP_TEST_CASES[0].decrypted.clone(), + RTCP_TEST_CASES[1].decrypted.clone(), + RTCP_TEST_CASES[0].decrypted.clone(), + RTCP_TEST_CASES[1].decrypted.clone(), + ]; + let mut encrypted_rctps = vec![]; + + for input in &inputs { + let encrypted = encrypt_context.encrypt_rtcp(input)?; + encrypted_rctps.push(encrypted); + } + + for (i, expected_index) in [1, 1, 2, 2].iter().enumerate() { + assert_eq!( + *expected_index, + get_rtcp_index(&encrypted_rctps[i], auth_tag_len), + "RTCP index does not match" + ); + } + + for (i, output) in encrypted_rctps.iter().enumerate() { + let decrypted = decrypt_context.decrypt_rtcp(output)?; + assert_eq!(inputs[i], decrypted); + } + + Ok(()) +} diff --git a/vendor/webrtc-srtp/src/context/srtp.rs b/vendor/webrtc-srtp/src/context/srtp.rs new file mode 100644 index 0000000..aaf0d99 --- /dev/null +++ b/vendor/webrtc-srtp/src/context/srtp.rs @@ -0,0 +1,70 @@ +use bytes::Bytes; +use util::marshal::*; + +use super::*; +use crate::error::Result; + +impl Context { + pub fn decrypt_rtp_with_header( + &mut self, + encrypted: &[u8], + header: &rtp::header::Header, + ) -> Result { + let roc = { + let state = self.get_srtp_ssrc_state(header.ssrc); + if let Some(replay_detector) = &mut state.replay_detector { + if !replay_detector.check(header.sequence_number as u64) { + return Err(Error::SrtpSsrcDuplicated( + header.ssrc, + header.sequence_number, + )); + } + } + + state.next_rollover_count(header.sequence_number) + }; + + let dst = self.cipher.decrypt_rtp(encrypted, header, roc)?; + { + let state = self.get_srtp_ssrc_state(header.ssrc); + if let Some(replay_detector) = &mut state.replay_detector { + replay_detector.accept(); + } + state.update_rollover_count(header.sequence_number); + } + + Ok(dst) + } + + /// DecryptRTP decrypts a RTP packet with an encrypted payload + pub fn decrypt_rtp(&mut self, encrypted: &[u8]) -> Result { + let mut buf = encrypted; + let header = rtp::header::Header::unmarshal(&mut buf)?; + self.decrypt_rtp_with_header(encrypted, &header) + } + + pub fn encrypt_rtp_with_header( + &mut self, + payload: &[u8], + header: &rtp::header::Header, + ) -> Result { + let roc = self + .get_srtp_ssrc_state(header.ssrc) + .next_rollover_count(header.sequence_number); + + let dst = self.cipher.encrypt_rtp(payload, header, roc)?; + + self.get_srtp_ssrc_state(header.ssrc) + .update_rollover_count(header.sequence_number); + + Ok(dst) + } + + /// EncryptRTP marshals and encrypts an RTP packet, writing to the dst buffer provided. + /// If the dst buffer does not have the capacity to hold `len(plaintext) + 10` bytes, a new one will be allocated and returned. + pub fn encrypt_rtp(&mut self, plaintext: &[u8]) -> Result { + let mut buf = plaintext; + let header = rtp::header::Header::unmarshal(&mut buf)?; + self.encrypt_rtp_with_header(plaintext, &header) + } +} diff --git a/vendor/webrtc-srtp/src/context/srtp_test.rs b/vendor/webrtc-srtp/src/context/srtp_test.rs new file mode 100644 index 0000000..ecd3440 --- /dev/null +++ b/vendor/webrtc-srtp/src/context/srtp_test.rs @@ -0,0 +1,188 @@ +use bytes::Bytes; +use lazy_static::lazy_static; +use util::marshal::*; + +use super::*; + +struct RTPTestCase { + sequence_number: u16, + encrypted: Bytes, +} + +lazy_static! { + static ref RTP_TEST_CASE_DECRYPTED: Bytes = Bytes::from_static(&[0x00, 0x01, 0x02, 0x03, 0x04, 0x05]); + static ref RTP_TEST_CASES: Vec = vec![ + RTPTestCase { + sequence_number: 5000, + encrypted: Bytes::from_static(&[ + 0x6d, 0xd3, 0x7e, 0xd5, 0x99, 0xb7, 0x2d, 0x28, 0xb1, 0xf3, 0xa1, 0xf0, 0xc, 0xfb, + 0xfd, 0x8 + ]), + }, + RTPTestCase { + sequence_number: 5001, + encrypted: Bytes::from_static(&[ + 0xda, 0x47, 0xb, 0x2a, 0x74, 0x53, 0x65, 0xbd, 0x2f, 0xeb, 0xdc, 0x4b, 0x6d, 0x23, + 0xf3, 0xde + ]), + }, + RTPTestCase { + sequence_number: 5002, + encrypted: Bytes::from_static(&[ + 0x6e, 0xa7, 0x69, 0x8d, 0x24, 0x6d, 0xdc, 0xbf, 0xec, 0x2, 0x1c, 0xd1, 0x60, 0x76, + 0xc1, 0x0e + ]), + }, + RTPTestCase { + sequence_number: 5003, + encrypted: Bytes::from_static(&[ + 0x24, 0x7e, 0x96, 0xc8, 0x7d, 0x33, 0xa2, 0x92, 0x8d, 0x13, 0x8d, 0xe0, 0x76, 0x9f, + 0x08, 0xdc + ]), + }, + RTPTestCase { + sequence_number: 5004, + encrypted: Bytes::from_static(&[ + 0x75, 0x43, 0x28, 0xe4, 0x3a, 0x77, 0x59, 0x9b, 0x2e, 0xdf, 0x7b, 0x12, 0x68, 0x0b, + 0x57, 0x49 + ]), + }, + RTPTestCase{ + sequence_number: 65535, // upper boundary + encrypted: Bytes::from_static(&[ + 0xaf, 0xf7, 0xc2, 0x70, 0x37, 0x20, 0x83, 0x9c, 0x2c, 0x63, 0x85, 0x15, 0x0e, 0x44, + 0xca, 0x36 + ]), + }, + ]; +} + +fn build_test_context() -> Result { + let master_key = Bytes::from_static(&[ + 0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28, + 0x89, + ]); + let master_salt = Bytes::from_static(&[ + 0x62, 0x77, 0x60, 0x38, 0xc0, 0x6d, 0xc9, 0x41, 0x9f, 0x6d, 0xd9, 0x43, 0x3e, 0x7c, + ]); + + Context::new( + &master_key, + &master_salt, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + ) +} + +#[test] +fn test_rtp_invalid_auth() -> Result<()> { + let master_key = Bytes::from_static(&[ + 0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28, + 0x89, + ]); + let invalid_salt = Bytes::from_static(&[ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + ]); + + let mut encrypt_context = build_test_context()?; + let mut invalid_context = Context::new( + &master_key, + &invalid_salt, + ProtectionProfile::Aes128CmHmacSha1_80, + None, + None, + )?; + + for test_case in &*RTP_TEST_CASES { + let pkt = rtp::packet::Packet { + header: rtp::header::Header { + sequence_number: test_case.sequence_number, + ..Default::default() + }, + payload: RTP_TEST_CASE_DECRYPTED.clone(), + }; + + let pkt_raw = pkt.marshal()?; + let out = encrypt_context.encrypt_rtp(&pkt_raw)?; + + let result = invalid_context.decrypt_rtp(&out); + assert!( + result.is_err(), + "Managed to decrypt with incorrect salt for packet with SeqNum: {}", + test_case.sequence_number + ); + } + + Ok(()) +} + +#[test] +fn test_rtp_lifecycle() -> Result<()> { + let mut encrypt_context = build_test_context()?; + let mut decrypt_context = build_test_context()?; + let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len(); + + for test_case in RTP_TEST_CASES.iter() { + // Keep consecutive indices within RFC 3711's half-sequence-space window. + // The known-answer vector at 65535 still uses ROC 0, as before. + if test_case.sequence_number == 65535 { + for sequence_number in [32000, 64000] { + let bridge = rtp::packet::Packet { + header: rtp::header::Header { + sequence_number, + ..Default::default() + }, + payload: RTP_TEST_CASE_DECRYPTED.clone(), + } + .marshal()?; + let encrypted = encrypt_context.encrypt_rtp(&bridge)?; + assert_eq!(decrypt_context.decrypt_rtp(&encrypted)?, bridge); + } + } + let decrypted_pkt = rtp::packet::Packet { + header: rtp::header::Header { + sequence_number: test_case.sequence_number, + ..Default::default() + }, + payload: RTP_TEST_CASE_DECRYPTED.clone(), + }; + + let decrypted_raw = decrypted_pkt.marshal()?; + + let encrypted_pkt = rtp::packet::Packet { + header: rtp::header::Header { + sequence_number: test_case.sequence_number, + ..Default::default() + }, + payload: test_case.encrypted.clone(), + }; + + let encrypted_raw = encrypted_pkt.marshal()?; + let actual_encrypted = encrypt_context.encrypt_rtp(&decrypted_raw)?; + assert_eq!( + actual_encrypted, encrypted_raw, + "RTP packet with SeqNum invalid encryption: {}", + test_case.sequence_number + ); + + let actual_decrypted = decrypt_context.decrypt_rtp(&encrypted_raw)?; + assert_ne!( + encrypted_raw[..encrypted_raw.len() - auth_tag_len].to_vec(), + actual_decrypted, + "DecryptRTP improperly encrypted in place" + ); + + assert_eq!( + actual_decrypted, decrypted_raw, + "RTP packet with SeqNum invalid decryption: {}", + test_case.sequence_number, + ) + } + + Ok(()) +} + +//TODO: BenchmarkEncryptRTP +//TODO: BenchmarkEncryptRTPInPlace +//TODO: BenchmarkDecryptRTP diff --git a/vendor/webrtc-srtp/src/error.rs b/vendor/webrtc-srtp/src/error.rs new file mode 100644 index 0000000..b4f1a03 --- /dev/null +++ b/vendor/webrtc-srtp/src/error.rs @@ -0,0 +1,120 @@ +use std::io; + +use thiserror::Error; +use tokio::sync::mpsc::error::SendError as MpscSendError; + +pub type Result = std::result::Result; + +#[derive(Error, Debug, PartialEq)] +#[non_exhaustive] +pub enum Error { + #[error("duplicated packet")] + ErrDuplicated, + #[error("SRTP master key is not long enough")] + ErrShortSrtpMasterKey, + #[error("SRTP master salt is not long enough")] + ErrShortSrtpMasterSalt, + #[error("no such SRTP Profile")] + ErrNoSuchSrtpProfile, + #[error("indexOverKdr > 0 is not supported yet")] + ErrNonZeroKdrNotSupported, + #[error("exporter called with wrong label")] + ErrExporterWrongLabel, + #[error("no config provided")] + ErrNoConfig, + #[error("no conn provided")] + ErrNoConn, + #[error("failed to verify auth tag")] + ErrFailedToVerifyAuthTag, + #[error("packet is too short to be rtcp packet")] + ErrTooShortRtcp, + #[error("payload differs")] + ErrPayloadDiffers, + #[error("started channel used incorrectly, should only be closed")] + ErrStartedChannelUsedIncorrectly, + #[error("stream has not been inited, unable to close")] + ErrStreamNotInited, + #[error("stream is already closed")] + ErrStreamAlreadyClosed, + #[error("stream is already inited")] + ErrStreamAlreadyInited, + #[error("failed to cast child")] + ErrFailedTypeAssertion, + + #[error("index_over_kdr > 0 is not supported yet")] + UnsupportedIndexOverKdr, + #[error("SRTP Master Key must be len {0}, got {1}")] + SrtpMasterKeyLength(usize, usize), + #[error("SRTP Salt must be len {0}, got {1}")] + SrtpSaltLength(usize, usize), + #[error("SyntaxError: {0}")] + ExtMapParse(String), + #[error("srtp ssrc={0} index={1}: duplicated")] + SrtpSsrcDuplicated(u32, u16), + #[error("srtcp ssrc={0} index={1}: duplicated")] + SrtcpSsrcDuplicated(u32, usize), + #[error("ssrc {0} not exist in srtcp_ssrc_state")] + SsrcMissingFromSrtcp(u32), + #[error("Stream with ssrc {0} exists")] + StreamWithSsrcExists(u32), + #[error("Session RTP/RTCP type must be same as input buffer")] + SessionRtpRtcpTypeMismatch, + #[error("Session EOF")] + SessionEof, + #[error("too short SRTP packet: only {0} bytes, expected > {1} bytes")] + SrtpTooSmall(usize, usize), + #[error("too short SRTCP packet: only {0} bytes, expected > {1} bytes")] + SrtcpTooSmall(usize, usize), + #[error("failed to verify rtp auth tag")] + RtpFailedToVerifyAuthTag, + #[error("too short auth tag: only {0} bytes, expected > {1} bytes")] + RtcpInvalidLengthAuthTag(usize, usize), + #[error("failed to verify rtcp auth tag")] + RtcpFailedToVerifyAuthTag, + #[error("SessionSRTP has been closed")] + SessionSrtpAlreadyClosed, + #[error("this stream is not a RTPStream")] + InvalidRtpStream, + #[error("this stream is not a RTCPStream")] + InvalidRtcpStream, + + #[error("{0}")] + Io(#[source] IoError), + #[error("{0}")] + KeyingMaterial(#[from] util::KeyingMaterialExporterError), + #[error("mpsc send: {0}")] + MpscSend(String), + #[error("{0}")] + Util(#[from] util::Error), + #[error("{0}")] + Rtcp(#[from] rtcp::Error), + #[error("aes gcm: {0}")] + AesGcm(#[from] aes_gcm::Error), + + #[error("{0}")] + Other(String), +} + +#[derive(Debug, Error)] +#[error("io error: {0}")] +pub struct IoError(#[from] pub io::Error); + +// Workaround for wanting PartialEq for io::Error. +impl PartialEq for IoError { + fn eq(&self, other: &Self) -> bool { + self.0.kind() == other.0.kind() + } +} + +impl From for Error { + fn from(e: io::Error) -> Self { + Error::Io(IoError(e)) + } +} + +// Because Tokio SendError is parameterized, we sadly lose the backtrace. +impl From> for Error { + fn from(e: MpscSendError) -> Self { + Error::MpscSend(e.to_string()) + } +} diff --git a/vendor/webrtc-srtp/src/key_derivation.rs b/vendor/webrtc-srtp/src/key_derivation.rs new file mode 100644 index 0000000..3434509 --- /dev/null +++ b/vendor/webrtc-srtp/src/key_derivation.rs @@ -0,0 +1,173 @@ +use aes::cipher::generic_array::GenericArray; +use aes::cipher::BlockEncrypt; +use aes::Aes128; +use aes_gcm::KeyInit; + +use crate::error::{Error, Result}; + +pub const LABEL_SRTP_ENCRYPTION: u8 = 0x00; +pub const LABEL_SRTP_AUTHENTICATION_TAG: u8 = 0x01; +pub const LABEL_SRTP_SALT: u8 = 0x02; +pub const LABEL_SRTCP_ENCRYPTION: u8 = 0x03; +pub const LABEL_SRTCP_AUTHENTICATION_TAG: u8 = 0x04; +pub const LABEL_SRTCP_SALT: u8 = 0x05; + +pub(crate) const SRTCP_INDEX_SIZE: usize = 4; + +pub(crate) fn aes_cm_key_derivation( + label: u8, + master_key: &[u8], + master_salt: &[u8], + index_over_kdr: usize, + out_len: usize, +) -> Result> { + if index_over_kdr != 0 { + // 24-bit "index DIV kdr" must be xored to prf input. + return Err(Error::UnsupportedIndexOverKdr); + } + + // https://tools.ietf.org/html/rfc3711#appendix-B.3 + // The input block for AES-CM is generated by exclusive-oring the master salt with the + // concatenation of the encryption key label 0x00 with (index DIV kdr), + // - index is 'rollover count' and DIV is 'divided by' + + let n_master_key = master_key.len(); + let n_master_salt = master_salt.len(); + + let mut prf_in = vec![0u8; n_master_key]; + prf_in[..n_master_salt].copy_from_slice(master_salt); + + prf_in[7] ^= label; + + //The resulting value is then AES encrypted using the master key to get the cipher key. + let key = GenericArray::from_slice(master_key); + let block = Aes128::new(key); + + let mut out = vec![0u8; ((out_len + n_master_key) / n_master_key) * n_master_key]; + for (i, n) in (0..out_len).step_by(n_master_key).enumerate() { + //BigEndian.PutUint16(prfIn[nMasterKey-2:], i) + prf_in[n_master_key - 2] = ((i >> 8) & 0xFF) as u8; + prf_in[n_master_key - 1] = (i & 0xFF) as u8; + + out[n..n + n_master_key].copy_from_slice(&prf_in); + let out_key = GenericArray::from_mut_slice(&mut out[n..n + n_master_key]); + block.encrypt_block(out_key); + } + + Ok(out[..out_len].to_vec()) +} + +/// Generate IV https://tools.ietf.org/html/rfc3711#section-4.1.1 +/// where the 128-bit integer value IV SHALL be defined by the SSRC, the +/// SRTP packet index i, and the SRTP session salting key k_s, as below. +/// ROC = a 32-bit unsigned rollover counter (roc), which records how many +/// times the 16-bit RTP sequence number has been reset to zero after +/// passing through 65,535 +/// ```nobuild +/// i = 2^16 * roc + SEQ +/// IV = (salt*2 ^ 16) | (ssrc*2 ^ 64) | (i*2 ^ 16) +/// ``` +pub(crate) fn generate_counter( + sequence_number: u16, + rollover_counter: u32, + ssrc: u32, + session_salt: &[u8], +) -> [u8; 16] { + assert!(session_salt.len() <= 16); + + let mut counter = [0; 16]; + + let ssrc_be = ssrc.to_be_bytes(); + let rollover_be = rollover_counter.to_be_bytes(); + let seq_be = ((sequence_number as u32) << 16).to_be_bytes(); + + counter[4..8].copy_from_slice(&ssrc_be); + counter[8..12].copy_from_slice(&rollover_be); + counter[12..16].copy_from_slice(&seq_be); + + for i in 0..session_salt.len() { + counter[i] ^= session_salt[i]; + } + + counter +} + +#[cfg(test)] +mod test { + use super::*; + use crate::protection_profile::*; + + #[test] + fn test_valid_session_keys() -> Result<()> { + // Key Derivation Test Vectors from https://tools.ietf.org/html/rfc3711#appendix-B.3 + let master_key = vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ]; + let master_salt = vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ]; + + let expected_session_key = vec![ + 0xC6, 0x1E, 0x7A, 0x93, 0x74, 0x4F, 0x39, 0xEE, 0x10, 0x73, 0x4A, 0xFE, 0x3F, 0xF7, + 0xA0, 0x87, + ]; + let expected_session_salt = vec![ + 0x30, 0xCB, 0xBC, 0x08, 0x86, 0x3D, 0x8C, 0x85, 0xD4, 0x9D, 0xB3, 0x4A, 0x9A, 0xE1, + ]; + let expected_session_auth_tag = vec![ + 0xCE, 0xBE, 0x32, 0x1F, 0x6F, 0xF7, 0x71, 0x6B, 0x6F, 0xD4, 0xAB, 0x49, 0xAF, 0x25, + 0x6A, 0x15, 0x6D, 0x38, 0xBA, 0xA4, + ]; + + let session_key = aes_cm_key_derivation( + LABEL_SRTP_ENCRYPTION, + &master_key, + &master_salt, + 0, + master_key.len(), + )?; + assert_eq!( + session_key, expected_session_key, + "Session Key:\n{session_key:?} \ndoes not match expected:\n{expected_session_key:?}\nMaster Key:\n{master_key:?}\nMaster Salt:\n{master_salt:?}\n", + ); + + let session_salt = aes_cm_key_derivation( + LABEL_SRTP_SALT, + &master_key, + &master_salt, + 0, + master_salt.len(), + )?; + assert_eq!( + session_salt, expected_session_salt, + "Session Salt {session_salt:?} does not match expected {expected_session_salt:?}" + ); + + let auth_key_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_key_len(); + + let session_auth_tag = aes_cm_key_derivation( + LABEL_SRTP_AUTHENTICATION_TAG, + &master_key, + &master_salt, + 0, + auth_key_len, + )?; + assert_eq!( + session_auth_tag, expected_session_auth_tag, + "Session Auth Tag {session_auth_tag:?} does not match expected {expected_session_auth_tag:?}", + ); + + Ok(()) + } + + // This test asserts that calling aesCmKeyDerivation with a non-zero indexOverKdr fails + // Currently this isn't supported, but the API makes sure we can add this in the future + #[test] + fn test_index_over_kdr() -> Result<()> { + let result = aes_cm_key_derivation(LABEL_SRTP_AUTHENTICATION_TAG, &[], &[], 1, 0); + assert!(result.is_err()); + + Ok(()) + } +} diff --git a/vendor/webrtc-srtp/src/lib.rs b/vendor/webrtc-srtp/src/lib.rs new file mode 100644 index 0000000..044042e --- /dev/null +++ b/vendor/webrtc-srtp/src/lib.rs @@ -0,0 +1,14 @@ +#![warn(rust_2018_idioms)] +#![allow(dead_code)] + +mod cipher; +pub mod config; +pub mod context; +mod error; +mod key_derivation; +pub mod option; +pub mod protection_profile; +pub mod session; +pub mod stream; + +pub use error::Error; diff --git a/vendor/webrtc-srtp/src/option.rs b/vendor/webrtc-srtp/src/option.rs new file mode 100644 index 0000000..d2513a8 --- /dev/null +++ b/vendor/webrtc-srtp/src/option.rs @@ -0,0 +1,36 @@ +use util::replay_detector::*; + +pub type ContextOption = Box Box) + Send + Sync>; + +pub(crate) const MAX_SEQUENCE_NUMBER: u16 = 65535; +pub(crate) const MAX_SRTCP_INDEX: usize = 0x7FFFFFFF; + +/// srtp_replay_protection sets SRTP replay protection window size. +pub fn srtp_replay_protection(window_size: usize) -> ContextOption { + Box::new(move || -> Box { + Box::new(WrappedSlidingWindowDetector::new( + window_size, + MAX_SEQUENCE_NUMBER as u64, + )) + }) +} + +/// Sets SRTCP replay protection window size. +pub fn srtcp_replay_protection(window_size: usize) -> ContextOption { + Box::new(move || -> Box { + Box::new(WrappedSlidingWindowDetector::new( + window_size, + MAX_SRTCP_INDEX as u64, + )) + }) +} + +/// srtp_no_replay_protection disables SRTP replay protection. +pub fn srtp_no_replay_protection() -> ContextOption { + Box::new(|| -> Box { Box::::default() }) +} + +/// srtcp_no_replay_protection disables SRTCP replay protection. +pub fn srtcp_no_replay_protection() -> ContextOption { + Box::new(|| -> Box { Box::::default() }) +} diff --git a/vendor/webrtc-srtp/src/protection_profile.rs b/vendor/webrtc-srtp/src/protection_profile.rs new file mode 100644 index 0000000..0991ea7 --- /dev/null +++ b/vendor/webrtc-srtp/src/protection_profile.rs @@ -0,0 +1,37 @@ +/// ProtectionProfile specifies Cipher and AuthTag details, similar to TLS cipher suite +#[derive(Default, Debug, Clone, Copy)] +#[repr(u8)] +pub enum ProtectionProfile { + #[default] + Aes128CmHmacSha1_80 = 0x0001, + AeadAes128Gcm = 0x0007, +} + +impl ProtectionProfile { + pub(crate) fn key_len(&self) -> usize { + match *self { + ProtectionProfile::Aes128CmHmacSha1_80 | ProtectionProfile::AeadAes128Gcm => 16, + } + } + + pub(crate) fn salt_len(&self) -> usize { + match *self { + ProtectionProfile::Aes128CmHmacSha1_80 => 14, + ProtectionProfile::AeadAes128Gcm => 12, + } + } + + pub(crate) fn auth_tag_len(&self) -> usize { + match *self { + ProtectionProfile::Aes128CmHmacSha1_80 => 10, //CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN, + ProtectionProfile::AeadAes128Gcm => 16, //CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN, + } + } + + pub(crate) fn auth_key_len(&self) -> usize { + match *self { + ProtectionProfile::Aes128CmHmacSha1_80 => 20, + ProtectionProfile::AeadAes128Gcm => 0, + } + } +} diff --git a/vendor/webrtc-srtp/src/session/mod.rs b/vendor/webrtc-srtp/src/session/mod.rs new file mode 100644 index 0000000..efee1be --- /dev/null +++ b/vendor/webrtc-srtp/src/session/mod.rs @@ -0,0 +1,271 @@ +#[cfg(test)] +mod session_rtcp_test; +#[cfg(test)] +mod session_rtp_test; + +use std::collections::{HashMap, HashSet}; +use std::marker::{Send, Sync}; +use std::sync::Arc; + +use bytes::Bytes; +use tokio::sync::{mpsc, Mutex}; +use util::conn::Conn; +use util::marshal::*; + +use crate::config::*; +use crate::context::*; +use crate::error::{Error, Result}; +use crate::option::*; +use crate::stream::*; + +const DEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOW: usize = 64; +const DEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOW: usize = 64; + +/// Session implements io.ReadWriteCloser and provides a bi-directional SRTP session +/// SRTP itself does not have a design like this, but it is common in most applications +/// for local/remote to each have their own keying material. This provides those patterns +/// instead of making everyone re-implement +pub struct Session { + local_context: Arc>, + streams_map: Arc>>>, + new_stream_rx: Arc>>>, + close_stream_tx: mpsc::Sender, + close_session_tx: mpsc::Sender<()>, + pub(crate) udp_tx: Arc, + is_rtp: bool, +} + +impl Session { + pub async fn new( + conn: Arc, + config: Config, + is_rtp: bool, + ) -> Result { + let local_context = Context::new( + &config.keys.local_master_key, + &config.keys.local_master_salt, + config.profile, + config.local_rtp_options, + config.local_rtcp_options, + )?; + + let mut remote_context = Context::new( + &config.keys.remote_master_key, + &config.keys.remote_master_salt, + config.profile, + if config.remote_rtp_options.is_none() { + Some(srtp_replay_protection( + DEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOW, + )) + } else { + config.remote_rtp_options + }, + if config.remote_rtcp_options.is_none() { + Some(srtcp_replay_protection( + DEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOW, + )) + } else { + config.remote_rtcp_options + }, + )?; + + let streams_map = Arc::new(Mutex::new(HashMap::new())); + let (mut new_stream_tx, new_stream_rx) = mpsc::channel(8); + let (close_stream_tx, mut close_stream_rx) = mpsc::channel(8); + let (close_session_tx, mut close_session_rx) = mpsc::channel(8); + let udp_tx = Arc::clone(&conn); + let udp_rx = Arc::clone(&conn); + let cloned_streams_map = Arc::clone(&streams_map); + let cloned_close_stream_tx = close_stream_tx.clone(); + + tokio::spawn(async move { + let mut buf = vec![0u8; 8192]; + + loop { + let incoming_stream = Session::incoming( + &udp_rx, + &mut buf, + &cloned_streams_map, + &cloned_close_stream_tx, + &mut new_stream_tx, + &mut remote_context, + is_rtp, + ); + let close_stream = close_stream_rx.recv(); + let close_session = close_session_rx.recv(); + + tokio::select! { + result = incoming_stream => match result{ + Ok(()) => {}, + Err(err) => log::info!("{}", err), + }, + opt = close_stream => if let Some(ssrc) = opt { + Session::close_stream(&cloned_streams_map, ssrc).await + }, + _ = close_session => break + } + } + }); + + Ok(Session { + local_context: Arc::new(Mutex::new(local_context)), + streams_map, + new_stream_rx: Arc::new(Mutex::new(new_stream_rx)), + close_stream_tx, + close_session_tx, + udp_tx, + is_rtp, + }) + } + + async fn close_stream(streams_map: &Arc>>>, ssrc: u32) { + let mut streams = streams_map.lock().await; + streams.remove(&ssrc); + } + + async fn incoming( + udp_rx: &Arc, + buf: &mut [u8], + streams_map: &Arc>>>, + close_stream_tx: &mpsc::Sender, + new_stream_tx: &mut mpsc::Sender>, + remote_context: &mut Context, + is_rtp: bool, + ) -> Result<()> { + let n = udp_rx.recv(buf).await?; + if n == 0 { + return Err(Error::SessionEof); + } + + let decrypted = if is_rtp { + remote_context.decrypt_rtp(&buf[0..n])? + } else { + remote_context.decrypt_rtcp(&buf[0..n])? + }; + + let mut buf = &decrypted[..]; + let ssrcs = if is_rtp { + vec![rtp::header::Header::unmarshal(&mut buf)?.ssrc] + } else { + let pkts = rtcp::packet::unmarshal(&mut buf)?; + destination_ssrc(&pkts) + }; + + for ssrc in ssrcs { + let (stream, is_new) = + Session::get_or_create_stream(streams_map, close_stream_tx.clone(), is_rtp, ssrc) + .await; + if is_new { + log::trace!( + "srtp session got new {} stream {}", + if is_rtp { "rtp" } else { "rtcp" }, + ssrc + ); + new_stream_tx.send(Arc::clone(&stream)).await?; + } + + match stream.buffer.write(&decrypted).await { + Ok(_) => {} + Err(err) => { + // Silently drop data when the buffer is full. + if util::Error::ErrBufferFull != err { + return Err(err.into()); + } + } + } + } + + Ok(()) + } + + async fn get_or_create_stream( + streams_map: &Arc>>>, + close_stream_tx: mpsc::Sender, + is_rtp: bool, + ssrc: u32, + ) -> (Arc, bool) { + let mut streams = streams_map.lock().await; + + if let Some(stream) = streams.get(&ssrc) { + (Arc::clone(stream), false) + } else { + let stream = Arc::new(Stream::new(ssrc, close_stream_tx, is_rtp)); + streams.insert(ssrc, Arc::clone(&stream)); + (stream, true) + } + } + + /// open on the given SSRC to create a stream, it can be used + /// if you want a certain SSRC, but don't want to wait for Accept + pub async fn open(&self, ssrc: u32) -> Arc { + let (stream, _) = Session::get_or_create_stream( + &self.streams_map, + self.close_stream_tx.clone(), + self.is_rtp, + ssrc, + ) + .await; + + stream + } + + /// accept returns a stream to handle RTCP for a single SSRC + pub async fn accept(&self) -> Result> { + let mut new_stream_rx = self.new_stream_rx.lock().await; + let result = new_stream_rx.recv().await; + if let Some(stream) = result { + Ok(stream) + } else { + Err(Error::SessionSrtpAlreadyClosed) + } + } + + pub async fn close(&self) -> Result<()> { + self.close_session_tx.send(()).await?; + + Ok(()) + } + + pub async fn write(&self, buf: &Bytes, is_rtp: bool) -> Result { + if self.is_rtp != is_rtp { + return Err(Error::SessionRtpRtcpTypeMismatch); + } + + let encrypted = { + let mut local_context = self.local_context.lock().await; + + if is_rtp { + local_context.encrypt_rtp(buf)? + } else { + local_context.encrypt_rtcp(buf)? + } + }; + + Ok(self.udp_tx.send(&encrypted).await?) + } + + pub async fn write_rtp(&self, pkt: &rtp::packet::Packet) -> Result { + let raw = pkt.marshal()?; + self.write(&raw, true).await + } + + pub async fn write_rtcp( + &self, + pkt: &(dyn rtcp::packet::Packet + Send + Sync), + ) -> Result { + let raw = pkt.marshal()?; + self.write(&raw, false).await + } +} + +/// create a list of Destination SSRCs +/// that's a superset of all Destinations in the slice. +fn destination_ssrc(pkts: &[Box]) -> Vec { + let mut ssrc_set = HashSet::new(); + for p in pkts { + for ssrc in p.destination_ssrc() { + ssrc_set.insert(ssrc); + } + } + ssrc_set.into_iter().collect() +} diff --git a/vendor/webrtc-srtp/src/session/session_rtcp_test.rs b/vendor/webrtc-srtp/src/session/session_rtcp_test.rs new file mode 100644 index 0000000..8d880e9 --- /dev/null +++ b/vendor/webrtc-srtp/src/session/session_rtcp_test.rs @@ -0,0 +1,239 @@ +use std::sync::Arc; + +use bytes::{Bytes, BytesMut}; +use rtcp::payload_feedbacks::*; +use tokio::sync::{mpsc, Mutex}; +use util::conn::conn_pipe::*; + +use super::*; +use crate::error::Result; +use crate::protection_profile::*; + +async fn build_session_srtcp_pair() -> Result<(Session, Session)> { + let (ua, ub) = pipe(); + + let ca = Config { + profile: ProtectionProfile::Aes128CmHmacSha1_80, + keys: SessionKeys { + local_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + local_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + remote_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + remote_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + }, + + local_rtp_options: None, + remote_rtp_options: None, + + local_rtcp_options: None, + remote_rtcp_options: None, + }; + + let cb = Config { + profile: ProtectionProfile::Aes128CmHmacSha1_80, + keys: SessionKeys { + local_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + local_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + remote_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + remote_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + }, + + local_rtp_options: None, + remote_rtp_options: None, + + local_rtcp_options: None, + remote_rtcp_options: None, + }; + + let sa = Session::new(Arc::new(ua), ca, false).await?; + let sb = Session::new(Arc::new(ub), cb, false).await?; + + Ok((sa, sb)) +} + +const TEST_SSRC: u32 = 5000; + +#[tokio::test] +async fn test_session_srtcp_accept() -> Result<()> { + let (sa, sb) = build_session_srtcp_pair().await?; + + let rtcp_packet = picture_loss_indication::PictureLossIndication { + media_ssrc: TEST_SSRC, + ..Default::default() + }; + + let test_payload = rtcp_packet.marshal()?; + sa.write_rtcp(&rtcp_packet).await?; + + let read_stream = sb.accept().await?; + let ssrc = read_stream.get_ssrc(); + assert_eq!( + ssrc, TEST_SSRC, + "SSRC mismatch during accept exp({TEST_SSRC}) actual({ssrc})" + ); + + let mut read_buffer = BytesMut::with_capacity(test_payload.len()); + read_buffer.resize(test_payload.len(), 0u8); + read_stream.read(&mut read_buffer).await?; + + assert_eq!( + &test_payload[..], + &read_buffer[..], + "Sent buffer does not match the one received exp({:?}) actual({:?})", + &test_payload[..], + &read_buffer[..] + ); + + sa.close().await?; + sb.close().await?; + + Ok(()) +} + +#[tokio::test] +async fn test_session_srtcp_listen() -> Result<()> { + let (sa, sb) = build_session_srtcp_pair().await?; + + let rtcp_packet = picture_loss_indication::PictureLossIndication { + media_ssrc: TEST_SSRC, + ..Default::default() + }; + + let test_payload = rtcp_packet.marshal()?; + let read_stream = sb.open(TEST_SSRC).await; + + sa.write_rtcp(&rtcp_packet).await?; + + let mut read_buffer = BytesMut::with_capacity(test_payload.len()); + read_buffer.resize(test_payload.len(), 0u8); + read_stream.read(&mut read_buffer).await?; + + assert_eq!( + &test_payload[..], + &read_buffer[..], + "Sent buffer does not match the one received exp({:?}) actual({:?})", + &test_payload[..], + &read_buffer[..] + ); + + sa.close().await?; + sb.close().await?; + + Ok(()) +} + +fn encrypt_srtcp( + context: &mut Context, + pkt: &(dyn rtcp::packet::Packet + Send + Sync), +) -> Result { + let decrypted = pkt.marshal()?; + let encrypted = context.encrypt_rtcp(&decrypted)?; + Ok(encrypted) +} + +const PLI_PACKET_SIZE: usize = 8; + +async fn get_sender_ssrc(read_stream: &Arc) -> Result { + let auth_tag_size = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len(); + + let mut read_buffer = BytesMut::with_capacity(PLI_PACKET_SIZE + auth_tag_size); + read_buffer.resize(PLI_PACKET_SIZE + auth_tag_size, 0u8); + + let pkts = read_stream.read_rtcp(&mut read_buffer).await?; + let mut bytes = &pkts[0].marshal()?[..]; + let pli = picture_loss_indication::PictureLossIndication::unmarshal(&mut bytes)?; + + Ok(pli.sender_ssrc) +} + +#[tokio::test] +async fn test_session_srtcp_replay_protection() -> Result<()> { + let (sa, sb) = build_session_srtcp_pair().await?; + + let read_stream = sb.open(TEST_SSRC).await; + + // Generate test packets + let mut packets = vec![]; + let mut expected_ssrc = vec![]; + { + let mut local_context = sa.local_context.lock().await; + for i in 0..0x10u32 { + expected_ssrc.push(i); + + let packet = picture_loss_indication::PictureLossIndication { + media_ssrc: TEST_SSRC, + sender_ssrc: i, + }; + + let encrypted = encrypt_srtcp(&mut local_context, &packet)?; + + packets.push(encrypted); + } + } + + let (done_tx, mut done_rx) = mpsc::channel::<()>(1); + + let received_ssrc = Arc::new(Mutex::new(vec![])); + let cloned_received_ssrc = Arc::clone(&received_ssrc); + let count = expected_ssrc.len(); + + tokio::spawn(async move { + let mut i = 0; + while i < count { + match get_sender_ssrc(&read_stream).await { + Ok(ssrc) => { + let mut r = cloned_received_ssrc.lock().await; + r.push(ssrc); + + i += 1; + } + Err(_) => break, + } + } + + drop(done_tx); + }); + + // Write with replay attack + for packet in &packets { + sa.udp_tx.send(packet).await?; + + // Immediately replay + sa.udp_tx.send(packet).await?; + } + for packet in &packets { + // Delayed replay + sa.udp_tx.send(packet).await?; + } + + done_rx.recv().await; + + sa.close().await?; + sb.close().await?; + + { + let received_ssrc = received_ssrc.lock().await; + assert_eq!(&expected_ssrc[..], &received_ssrc[..]); + } + + Ok(()) +} diff --git a/vendor/webrtc-srtp/src/session/session_rtp_test.rs b/vendor/webrtc-srtp/src/session/session_rtp_test.rs new file mode 100644 index 0000000..5764d13 --- /dev/null +++ b/vendor/webrtc-srtp/src/session/session_rtp_test.rs @@ -0,0 +1,308 @@ +use std::collections::HashMap; +use std::sync::Arc; + +use bytes::{Bytes, BytesMut}; +use tokio::net::UdpSocket; +use tokio::sync::{mpsc, Mutex}; + +use super::*; +use crate::error::Result; +use crate::protection_profile::*; + +async fn build_session_srtp_pair() -> Result<(Session, Session)> { + let ua = UdpSocket::bind("127.0.0.1:0").await?; + let ub = UdpSocket::bind("127.0.0.1:0").await?; + + ua.connect(ub.local_addr()?).await?; + ub.connect(ua.local_addr()?).await?; + + let ca = Config { + profile: ProtectionProfile::Aes128CmHmacSha1_80, + keys: SessionKeys { + local_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + local_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + remote_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + remote_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + }, + + local_rtp_options: None, + remote_rtp_options: None, + + local_rtcp_options: None, + remote_rtcp_options: None, + }; + + let cb = Config { + profile: ProtectionProfile::Aes128CmHmacSha1_80, + keys: SessionKeys { + local_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + local_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + remote_master_key: vec![ + 0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE, + 0x41, 0x39, + ], + remote_master_salt: vec![ + 0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6, + ], + }, + + local_rtp_options: None, + remote_rtp_options: None, + + local_rtcp_options: None, + remote_rtcp_options: None, + }; + + let sa = Session::new(Arc::new(ua), ca, true).await?; + let sb = Session::new(Arc::new(ub), cb, true).await?; + + Ok((sa, sb)) +} + +const TEST_SSRC: u32 = 5000; +const RTP_HEADER_SIZE: usize = 12; + +#[tokio::test] +async fn test_session_srtp_accept() -> Result<()> { + let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]); + let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len()); + read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8); + let (sa, sb) = build_session_srtp_pair().await?; + + let packet = rtp::packet::Packet { + header: rtp::header::Header { + ssrc: TEST_SSRC, + ..Default::default() + }, + payload: test_payload.clone(), + }; + sa.write_rtp(&packet).await?; + + let read_stream = sb.accept().await?; + let ssrc = read_stream.get_ssrc(); + assert_eq!( + ssrc, TEST_SSRC, + "SSRC mismatch during accept exp({TEST_SSRC}) actual({ssrc})" + ); + + read_stream.read(&mut read_buffer).await?; + + assert_eq!( + &test_payload[..], + &read_buffer[RTP_HEADER_SIZE..], + "Sent buffer does not match the one received exp({:?}) actual({:?})", + &test_payload[..], + &read_buffer[RTP_HEADER_SIZE..] + ); + + sa.close().await?; + sb.close().await?; + + Ok(()) +} + +#[tokio::test] +async fn test_session_srtp_listen() -> Result<()> { + let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]); + let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len()); + read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8); + let (sa, sb) = build_session_srtp_pair().await?; + + let packet = rtp::packet::Packet { + header: rtp::header::Header { + ssrc: TEST_SSRC, + ..Default::default() + }, + payload: test_payload.clone(), + }; + + let read_stream = sb.open(TEST_SSRC).await; + + sa.write_rtp(&packet).await?; + + read_stream.read(&mut read_buffer).await?; + + assert_eq!( + &test_payload[..], + &read_buffer[RTP_HEADER_SIZE..], + "Sent buffer does not match the one received exp({:?}) actual({:?})", + &test_payload[..], + &read_buffer[RTP_HEADER_SIZE..] + ); + + sa.close().await?; + sb.close().await?; + + Ok(()) +} + +#[tokio::test] +async fn test_session_srtp_multi_ssrc() -> Result<()> { + let ssrcs = vec![5000, 5001, 5002]; + let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]); + let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len()); + read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8); + let (sa, sb) = build_session_srtp_pair().await?; + + let mut read_streams = HashMap::new(); + for ssrc in &ssrcs { + let read_stream = sb.open(*ssrc).await; + read_streams.insert(*ssrc, read_stream); + } + + for ssrc in &ssrcs { + let packet = rtp::packet::Packet { + header: rtp::header::Header { + ssrc: *ssrc, + ..Default::default() + }, + payload: test_payload.clone(), + }; + sa.write_rtp(&packet).await?; + + if let Some(read_stream) = read_streams.get_mut(ssrc) { + read_stream.read(&mut read_buffer).await?; + + assert_eq!( + &test_payload[..], + &read_buffer[RTP_HEADER_SIZE..], + "Sent buffer does not match the one received exp({:?}) actual({:?})", + &test_payload[..], + &read_buffer[RTP_HEADER_SIZE..] + ); + } else { + panic!("ssrc {} not found", *ssrc); + } + } + + sa.close().await?; + sb.close().await?; + + Ok(()) +} + +fn encrypt_srtp(context: &mut Context, pkt: &rtp::packet::Packet) -> Result { + let decrypted = pkt.marshal()?; + let encrypted = context.encrypt_rtp(&decrypted)?; + Ok(encrypted) +} + +async fn payload_srtp( + read_stream: &Arc, + header_size: usize, + expected_payload: &[u8], +) -> Result { + let mut read_buffer = BytesMut::with_capacity(header_size + expected_payload.len()); + read_buffer.resize(header_size + expected_payload.len(), 0u8); + + let pkt = read_stream.read_rtp(&mut read_buffer).await?; + + assert_eq!( + expected_payload, + &pkt.payload[..], + "Sent buffer does not match the one received exp({:?}) actual({:?})", + expected_payload, + &pkt.payload[..] + ); + + Ok(pkt.header.sequence_number) +} + +#[tokio::test] +async fn test_session_srtp_replay_protection() -> Result<()> { + let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]); + + let (sa, sb) = build_session_srtp_pair().await?; + + let read_stream = sb.open(TEST_SSRC).await; + + // Generate test packets + let mut packets = vec![]; + let mut expected_sequence_number = vec![]; + { + let mut local_context = sa.local_context.lock().await; + let mut i = 0xFFF0u16; + while i != 0x10 { + expected_sequence_number.push(i); + + let packet = rtp::packet::Packet { + header: rtp::header::Header { + ssrc: TEST_SSRC, + sequence_number: i, + ..Default::default() + }, + payload: test_payload.clone(), + }; + + let encrypted = encrypt_srtp(&mut local_context, &packet)?; + + packets.push(encrypted); + + if i == 0xFFFF { + i = 0; + } else { + i += 1; + } + } + } + + let (done_tx, mut done_rx) = mpsc::channel::<()>(1); + + let received_sequence_number = Arc::new(Mutex::new(vec![])); + let cloned_received_sequence_number = Arc::clone(&received_sequence_number); + let count = expected_sequence_number.len(); + + tokio::spawn(async move { + let mut i = 0; + while i < count { + let seq = payload_srtp(&read_stream, RTP_HEADER_SIZE, &test_payload) + .await + .unwrap(); + let mut r = cloned_received_sequence_number.lock().await; + r.push(seq); + + i += 1; + } + + drop(done_tx); + }); + + // Write with replay attack + for packet in &packets { + sa.udp_tx.send(packet).await?; + + // Immediately replay + sa.udp_tx.send(packet).await?; + } + for packet in &packets { + // Delayed replay + sa.udp_tx.send(packet).await?; + } + + done_rx.recv().await; + + sa.close().await?; + sb.close().await?; + + { + let received_sequence_number = received_sequence_number.lock().await; + assert_eq!(&received_sequence_number[..], &expected_sequence_number[..]); + } + + Ok(()) +} diff --git a/vendor/webrtc-srtp/src/stream.rs b/vendor/webrtc-srtp/src/stream.rs new file mode 100644 index 0000000..735f12c --- /dev/null +++ b/vendor/webrtc-srtp/src/stream.rs @@ -0,0 +1,91 @@ +use tokio::sync::mpsc; +use util::marshal::*; +use util::Buffer; + +use crate::error::{Error, Result}; + +/// Limit the buffer size to 1MB +pub const SRTP_BUFFER_SIZE: usize = 1000 * 1000; + +/// Limit the buffer size to 100KB +pub const SRTCP_BUFFER_SIZE: usize = 100 * 1000; + +/// Stream handles decryption for a single RTP/RTCP SSRC +#[derive(Debug)] +pub struct Stream { + ssrc: u32, + tx: mpsc::Sender, + pub(crate) buffer: Buffer, + is_rtp: bool, +} + +impl Stream { + /// Create a new stream + pub fn new(ssrc: u32, tx: mpsc::Sender, is_rtp: bool) -> Self { + Stream { + ssrc, + tx, + // Create a buffer with a 1MB limit + buffer: Buffer::new( + 0, + if is_rtp { + SRTP_BUFFER_SIZE + } else { + SRTCP_BUFFER_SIZE + }, + ), + is_rtp, + } + } + + /// GetSSRC returns the SSRC we are demuxing for + pub fn get_ssrc(&self) -> u32 { + self.ssrc + } + + /// Check if RTP is a stream. + pub fn is_rtp_stream(&self) -> bool { + self.is_rtp + } + + /// Read reads and decrypts full RTP packet from the nextConn + pub async fn read(&self, buf: &mut [u8]) -> Result { + Ok(self.buffer.read(buf, None).await?) + } + + /// ReadRTP reads and decrypts full RTP packet and its header from the nextConn + pub async fn read_rtp(&self, buf: &mut [u8]) -> Result { + if !self.is_rtp { + return Err(Error::InvalidRtpStream); + } + + let n = self.buffer.read(buf, None).await?; + let mut b = &buf[..n]; + let pkt = rtp::packet::Packet::unmarshal(&mut b)?; + + Ok(pkt) + } + + /// read_rtcp reads and decrypts full RTP packet and its header from the nextConn + pub async fn read_rtcp( + &self, + buf: &mut [u8], + ) -> Result>> { + if self.is_rtp { + return Err(Error::InvalidRtcpStream); + } + + let n = self.buffer.read(buf, None).await?; + let mut b = &buf[..n]; + let pkt = rtcp::packet::unmarshal(&mut b)?; + + Ok(pkt) + } + + /// Close removes the ReadStream from the session and cleans up any associated state + pub async fn close(&self) -> Result<()> { + self.buffer.close().await; + let _ = self.tx.send(self.ssrc).await; + Ok(()) + } +}