mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
50ed54d77a | ||
|
|
d6752e77c8 |
No files matched your search
Generated
+1
-3
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.22"
|
||||
version = "0.2.23"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.22.1",
|
||||
@@ -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",
|
||||
|
||||
+3
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.22"
|
||||
version = "0.2.23"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
@@ -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" }
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
长时间连接后画面冻结的修复。/ Fixes video freezing after long sessions.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **控制端切到后台再恢复后画面冻结、延迟显示 0**(#83,感谢 @AYssu 定位并提供补丁):RTP 序号每 65536 包回绕一次;
|
||||
回绕后如果控制端补要(NACK)回绕前的旧包,webrtc-srtp 0.12.0 会把加密状态退回旧值,之后的新包都用错误的回绕计数加密,
|
||||
控制端全部认证失败,画面停住且不再恢复。现按 RFC 3711 附录 A 估算回绕计数,重传不再让状态倒退。加密算法和报文格式不变。
|
||||
回归测试在原库上失败、修复后通过(AES-CM/HMAC 与 AES-GCM);报告者在 Windows 控制端实测后台放置恢复正常,跨过两次回绕。
|
||||
- SRTP rollover counter no longer rewinds when a pre-wrap packet is retransmitted after the wrap (frozen video, #83).
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.23_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.23-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.23`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -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
|
||||
Vendored
+19
@@ -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).
|
||||
|
||||
Vendored
+100
@@ -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 <[email protected]>"]
|
||||
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"]
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
[package]
|
||||
name = "webrtc-srtp"
|
||||
version = "0.12.0"
|
||||
authors = ["Rain Liu <[email protected]>"]
|
||||
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
|
||||
Vendored
+201
@@ -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.
|
||||
Vendored
+21
@@ -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.
|
||||
Vendored
+14
@@ -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.
|
||||
Vendored
+30
@@ -0,0 +1,30 @@
|
||||
<h1 align="center">
|
||||
<a href="https://webrtc.rs"><img src="./doc/webrtc.rs.png" alt="WebRTC.rs"></a>
|
||||
<br>
|
||||
</h1>
|
||||
<p align="center">
|
||||
<a href="https://github.com/webrtc-rs/srtp/actions">
|
||||
<img src="https://github.com/webrtc-rs/srtp/workflows/cargo/badge.svg">
|
||||
</a>
|
||||
<a href="https://codecov.io/gh/webrtc-rs/srtp">
|
||||
<img src="https://codecov.io/gh/webrtc-rs/srtp/branch/main/graph/badge.svg">
|
||||
</a>
|
||||
<a href="https://deps.rs/repo/github/webrtc-rs/srtp">
|
||||
<img src="https://deps.rs/repo/github/webrtc-rs/srtp/status.svg">
|
||||
</a>
|
||||
<a href="https://crates.io/crates/webrtc-srtp">
|
||||
<img src="https://img.shields.io/crates/v/webrtc-srtp.svg">
|
||||
</a>
|
||||
<a href="https://docs.rs/webrtc-srtp">
|
||||
<img src="https://docs.rs/webrtc-srtp/badge.svg">
|
||||
</a>
|
||||
<a href="https://doc.rust-lang.org/1.6.0/complement-project-faq.html#why-dual-mitasl2-license">
|
||||
<img src="https://img.shields.io/badge/license-MIT%2FApache--2.0-blue" alt="License: MIT/Apache 2.0">
|
||||
</a>
|
||||
<a href="https://discord.gg/4Ju8UHdXMs">
|
||||
<img src="https://img.shields.io/discord/800204819540869120?logo=discord" alt="Discord">
|
||||
</a>
|
||||
</p>
|
||||
<p align="center">
|
||||
A pure Rust implementation of SRTP. Rewrite <a href="https://github.com/pion/srtp/releases/tag/v1.5.2">Pion</a> SRTP in Rust
|
||||
</p>
|
||||
+158
@@ -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);
|
||||
Vendored
+23
@@ -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
|
||||
Vendored
BIN
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
@@ -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<u8>,
|
||||
srtcp_session_salt: Vec<u8>,
|
||||
}
|
||||
|
||||
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<Bytes> {
|
||||
// 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<Bytes> {
|
||||
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<u8> = 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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<CipherAeadAesGcm> {
|
||||
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<u8> {
|
||||
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<u8> {
|
||||
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<u8> {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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<aes::Aes128>;
|
||||
|
||||
pub(crate) struct CipherAesCmHmacSha1 {
|
||||
inner: CipherInner,
|
||||
srtp_session_key: Vec<u8>,
|
||||
srtcp_session_key: Vec<u8>,
|
||||
}
|
||||
|
||||
impl CipherAesCmHmacSha1 {
|
||||
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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))
|
||||
}
|
||||
}
|
||||
@@ -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<Sha1>;
|
||||
|
||||
pub const CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN: usize = 10;
|
||||
|
||||
pub(crate) struct CipherInner {
|
||||
srtp_session_salt: Vec<u8>,
|
||||
srtp_session_auth: HmacSha1,
|
||||
srtcp_session_salt: Vec<u8>,
|
||||
srtcp_session_auth: HmacSha1,
|
||||
}
|
||||
|
||||
impl CipherInner {
|
||||
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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<Self> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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))
|
||||
}
|
||||
}
|
||||
Vendored
+61
@@ -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<Bytes>;
|
||||
|
||||
/// Decrypt RTP payload.
|
||||
fn decrypt_rtp(
|
||||
&mut self,
|
||||
payload: &[u8],
|
||||
header: &rtp::header::Header,
|
||||
roc: u32,
|
||||
) -> Result<Bytes>;
|
||||
|
||||
/// Encrypt RTCP payload.
|
||||
fn encrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes>;
|
||||
|
||||
/// Decrypt RTCP payload.
|
||||
fn decrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes>;
|
||||
}
|
||||
Vendored
+83
@@ -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<u8>,
|
||||
pub local_master_salt: Vec<u8>,
|
||||
pub remote_master_key: Vec<u8>,
|
||||
pub remote_master_salt: Vec<u8>,
|
||||
}
|
||||
|
||||
/// 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<ContextOption>,
|
||||
pub remote_rtp_options: Option<ContextOption>,
|
||||
|
||||
pub local_rtcp_options: Option<ContextOption>,
|
||||
pub remote_rtcp_options: Option<ContextOption>,
|
||||
}
|
||||
|
||||
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(())
|
||||
}
|
||||
}
|
||||
+341
@@ -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);
|
||||
}
|
||||
+177
@@ -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<Box<dyn ReplayDetector + Send + 'static>>,
|
||||
}
|
||||
|
||||
/// Encrypt/Decrypt state for a single SRTCP SSRC
|
||||
#[derive(Default)]
|
||||
pub(crate) struct SrtcpSsrcState {
|
||||
srtcp_index: usize,
|
||||
ssrc: u32,
|
||||
replay_detector: Option<Box<dyn ReplayDetector + Send + 'static>>,
|
||||
}
|
||||
|
||||
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<dyn Cipher + Send>,
|
||||
|
||||
srtp_ssrc_states: HashMap<u32, SrtpSsrcState>,
|
||||
srtcp_ssrc_states: HashMap<u32, SrtcpSsrcState>,
|
||||
|
||||
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<ContextOption>,
|
||||
srtcp_ctx_opt: Option<ContextOption>,
|
||||
) -> Result<Context> {
|
||||
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<dyn Cipher + Send> = 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<u32> {
|
||||
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<usize> {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
use crate::{context::Context, protection_profile::ProtectionProfile};
|
||||
fn packet(seq: u16) -> (Vec<u8>, 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);
|
||||
}
|
||||
}
|
||||
+50
@@ -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<Bytes> {
|
||||
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<Bytes> {
|
||||
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)
|
||||
}
|
||||
}
|
||||
+257
@@ -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<RTCPTestCase> = 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(())
|
||||
}
|
||||
+70
@@ -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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
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<Bytes> {
|
||||
let mut buf = plaintext;
|
||||
let header = rtp::header::Header::unmarshal(&mut buf)?;
|
||||
self.encrypt_rtp_with_header(plaintext, &header)
|
||||
}
|
||||
}
|
||||
+188
@@ -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<RTPTestCase> = 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<Context> {
|
||||
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
|
||||
Vendored
+120
@@ -0,0 +1,120 @@
|
||||
use std::io;
|
||||
|
||||
use thiserror::Error;
|
||||
use tokio::sync::mpsc::error::SendError as MpscSendError;
|
||||
|
||||
pub type Result<T> = std::result::Result<T, Error>;
|
||||
|
||||
#[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<io::Error> for Error {
|
||||
fn from(e: io::Error) -> Self {
|
||||
Error::Io(IoError(e))
|
||||
}
|
||||
}
|
||||
|
||||
// Because Tokio SendError is parameterized, we sadly lose the backtrace.
|
||||
impl<T> From<MpscSendError<T>> for Error {
|
||||
fn from(e: MpscSendError<T>) -> Self {
|
||||
Error::MpscSend(e.to_string())
|
||||
}
|
||||
}
|
||||
+173
@@ -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<Vec<u8>> {
|
||||
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(())
|
||||
}
|
||||
}
|
||||
Vendored
+14
@@ -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;
|
||||
Vendored
+36
@@ -0,0 +1,36 @@
|
||||
use util::replay_detector::*;
|
||||
|
||||
pub type ContextOption = Box<dyn (Fn() -> Box<dyn ReplayDetector + Send + 'static>) + 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<dyn ReplayDetector + Send> {
|
||||
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<dyn ReplayDetector + Send> {
|
||||
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<dyn ReplayDetector + Send> { Box::<NoOpReplayDetector>::default() })
|
||||
}
|
||||
|
||||
/// srtcp_no_replay_protection disables SRTCP replay protection.
|
||||
pub fn srtcp_no_replay_protection() -> ContextOption {
|
||||
Box::new(|| -> Box<dyn ReplayDetector + Send> { Box::<NoOpReplayDetector>::default() })
|
||||
}
|
||||
+37
@@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
+271
@@ -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<Mutex<Context>>,
|
||||
streams_map: Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
|
||||
new_stream_rx: Arc<Mutex<mpsc::Receiver<Arc<Stream>>>>,
|
||||
close_stream_tx: mpsc::Sender<u32>,
|
||||
close_session_tx: mpsc::Sender<()>,
|
||||
pub(crate) udp_tx: Arc<dyn Conn + Send + Sync>,
|
||||
is_rtp: bool,
|
||||
}
|
||||
|
||||
impl Session {
|
||||
pub async fn new(
|
||||
conn: Arc<dyn Conn + Send + Sync>,
|
||||
config: Config,
|
||||
is_rtp: bool,
|
||||
) -> Result<Self> {
|
||||
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<Mutex<HashMap<u32, Arc<Stream>>>>, ssrc: u32) {
|
||||
let mut streams = streams_map.lock().await;
|
||||
streams.remove(&ssrc);
|
||||
}
|
||||
|
||||
async fn incoming(
|
||||
udp_rx: &Arc<dyn Conn + Send + Sync>,
|
||||
buf: &mut [u8],
|
||||
streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
|
||||
close_stream_tx: &mpsc::Sender<u32>,
|
||||
new_stream_tx: &mut mpsc::Sender<Arc<Stream>>,
|
||||
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<Mutex<HashMap<u32, Arc<Stream>>>>,
|
||||
close_stream_tx: mpsc::Sender<u32>,
|
||||
is_rtp: bool,
|
||||
ssrc: u32,
|
||||
) -> (Arc<Stream>, 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<Stream> {
|
||||
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<Arc<Stream>> {
|
||||
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<usize> {
|
||||
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<usize> {
|
||||
let raw = pkt.marshal()?;
|
||||
self.write(&raw, true).await
|
||||
}
|
||||
|
||||
pub async fn write_rtcp(
|
||||
&self,
|
||||
pkt: &(dyn rtcp::packet::Packet + Send + Sync),
|
||||
) -> Result<usize> {
|
||||
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<dyn rtcp::packet::Packet + Send + Sync>]) -> Vec<u32> {
|
||||
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()
|
||||
}
|
||||
+239
@@ -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<Bytes> {
|
||||
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<Stream>) -> Result<u32> {
|
||||
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(())
|
||||
}
|
||||
+308
@@ -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<Bytes> {
|
||||
let decrypted = pkt.marshal()?;
|
||||
let encrypted = context.encrypt_rtp(&decrypted)?;
|
||||
Ok(encrypted)
|
||||
}
|
||||
|
||||
async fn payload_srtp(
|
||||
read_stream: &Arc<Stream>,
|
||||
header_size: usize,
|
||||
expected_payload: &[u8],
|
||||
) -> Result<u16> {
|
||||
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(())
|
||||
}
|
||||
Vendored
+91
@@ -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<u32>,
|
||||
pub(crate) buffer: Buffer,
|
||||
is_rtp: bool,
|
||||
}
|
||||
|
||||
impl Stream {
|
||||
/// Create a new stream
|
||||
pub fn new(ssrc: u32, tx: mpsc::Sender<u32>, 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<usize> {
|
||||
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<rtp::packet::Packet> {
|
||||
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<Vec<Box<dyn rtcp::packet::Packet + Send + Sync>>> {
|
||||
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(())
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user