From d6752e77c800c270ce8c8e91f23d123b80b7c447 Mon Sep 17 00:00:00 2001 From: VallierDev <49166112@qq.com> Date: Thu, 22 Oct 2026 01:34:07 -0700 Subject: [PATCH] Fix SRTP rollover counter rewinding on delayed NACK retransmissions (#83) (#84) webrtc-srtp 0.12.0 stored every sequence number and used a 100-packet window to guess the rollover counter. A NACK retransmission of a pre-wrap packet sent after the wrap (65000 after 85) rewound that state, so the next new packets were protected with ROC+1 and the viewer failed authentication on all of them: frozen video after the Windows viewer returned from the background. Vendor webrtc-srtp 0.12.0 with the RFC 3711 Appendix A half-space estimate and a high-water index that retransmissions cannot move back. Regression tests fail on upstream (65000 != 85) and pass with the fix for AES-CM/HMAC and AES-GCM. Co-authored-by: VallierDev <24893073+VallierDev@users.noreply.github.com> Co-authored-by: AYssu <106810650+AYssu@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 --- Cargo.lock | 2 - Cargo.toml | 2 + vendor/webrtc-srtp/.gitignore | 11 + vendor/webrtc-srtp/CHANGELOG.md | 19 + vendor/webrtc-srtp/Cargo.toml | 100 +++++ vendor/webrtc-srtp/Cargo.toml.orig | 46 +++ vendor/webrtc-srtp/LICENSE-APACHE | 201 +++++++++++ vendor/webrtc-srtp/LICENSE-MIT | 21 ++ vendor/webrtc-srtp/PATCHES.md | 14 + vendor/webrtc-srtp/README.md | 30 ++ vendor/webrtc-srtp/benches/srtp_bench.rs | 158 ++++++++ vendor/webrtc-srtp/codecov.yml | 23 ++ vendor/webrtc-srtp/doc/webrtc.rs.png | Bin 0 -> 33276 bytes .../src/cipher/cipher_aead_aes_gcm.rs | 247 +++++++++++++ .../cipher_aes_cm_hmac_sha1/ctrcipher.rs | 220 +++++++++++ .../src/cipher/cipher_aes_cm_hmac_sha1/mod.rs | 133 +++++++ .../cipher_aes_cm_hmac_sha1/opensslcipher.rs | 261 ++++++++++++++ vendor/webrtc-srtp/src/cipher/mod.rs | 61 ++++ vendor/webrtc-srtp/src/config.rs | 83 +++++ .../webrtc-srtp/src/context/context_test.rs | 341 ++++++++++++++++++ vendor/webrtc-srtp/src/context/mod.rs | 177 +++++++++ .../src/context/rollover_regression_test.rs | 73 ++++ vendor/webrtc-srtp/src/context/srtcp.rs | 50 +++ vendor/webrtc-srtp/src/context/srtcp_test.rs | 257 +++++++++++++ vendor/webrtc-srtp/src/context/srtp.rs | 70 ++++ vendor/webrtc-srtp/src/context/srtp_test.rs | 188 ++++++++++ vendor/webrtc-srtp/src/error.rs | 120 ++++++ vendor/webrtc-srtp/src/key_derivation.rs | 173 +++++++++ vendor/webrtc-srtp/src/lib.rs | 14 + vendor/webrtc-srtp/src/option.rs | 36 ++ vendor/webrtc-srtp/src/protection_profile.rs | 37 ++ vendor/webrtc-srtp/src/session/mod.rs | 271 ++++++++++++++ .../src/session/session_rtcp_test.rs | 239 ++++++++++++ .../src/session/session_rtp_test.rs | 308 ++++++++++++++++ vendor/webrtc-srtp/src/stream.rs | 91 +++++ 35 files changed, 4075 insertions(+), 2 deletions(-) create mode 100644 vendor/webrtc-srtp/.gitignore create mode 100644 vendor/webrtc-srtp/CHANGELOG.md create mode 100644 vendor/webrtc-srtp/Cargo.toml create mode 100644 vendor/webrtc-srtp/Cargo.toml.orig create mode 100644 vendor/webrtc-srtp/LICENSE-APACHE create mode 100644 vendor/webrtc-srtp/LICENSE-MIT create mode 100644 vendor/webrtc-srtp/PATCHES.md create mode 100644 vendor/webrtc-srtp/README.md create mode 100644 vendor/webrtc-srtp/benches/srtp_bench.rs create mode 100644 vendor/webrtc-srtp/codecov.yml create mode 100644 vendor/webrtc-srtp/doc/webrtc.rs.png create mode 100644 vendor/webrtc-srtp/src/cipher/cipher_aead_aes_gcm.rs create mode 100644 vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/ctrcipher.rs create mode 100644 vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/mod.rs create mode 100644 vendor/webrtc-srtp/src/cipher/cipher_aes_cm_hmac_sha1/opensslcipher.rs create mode 100644 vendor/webrtc-srtp/src/cipher/mod.rs create mode 100644 vendor/webrtc-srtp/src/config.rs create mode 100644 vendor/webrtc-srtp/src/context/context_test.rs create mode 100644 vendor/webrtc-srtp/src/context/mod.rs create mode 100644 vendor/webrtc-srtp/src/context/rollover_regression_test.rs create mode 100644 vendor/webrtc-srtp/src/context/srtcp.rs create mode 100644 vendor/webrtc-srtp/src/context/srtcp_test.rs create mode 100644 vendor/webrtc-srtp/src/context/srtp.rs create mode 100644 vendor/webrtc-srtp/src/context/srtp_test.rs create mode 100644 vendor/webrtc-srtp/src/error.rs create mode 100644 vendor/webrtc-srtp/src/key_derivation.rs create mode 100644 vendor/webrtc-srtp/src/lib.rs create mode 100644 vendor/webrtc-srtp/src/option.rs create mode 100644 vendor/webrtc-srtp/src/protection_profile.rs create mode 100644 vendor/webrtc-srtp/src/session/mod.rs create mode 100644 vendor/webrtc-srtp/src/session/session_rtcp_test.rs create mode 100644 vendor/webrtc-srtp/src/session/session_rtp_test.rs create mode 100644 vendor/webrtc-srtp/src/stream.rs 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 0000000000000000000000000000000000000000..7bf0dda2a869e19f110bc581a3d20f9609982824 GIT binary patch literal 33276 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 z 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 G`0_t~Oa}h| literal 0 HcmV?d00001 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(()) + } +}