Compare commits

...
4 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 16ded48a99 Release v0.2.24
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 17:45:03 +08:00
d95053d490 X11: change the desktop resolution for the viewer's choice; survive live resizes (#86)
* Restart X11 capture at the new size when the desktop is resized mid-stream

A RandR resize during a session made x11grab fail with BadMatch on the old
size. read_encoder treated that as an encoder failure and walked the whole
fallback chain (NVENC -> CPU, HEVC -> H.264) with the stale size, then the
stream stopped ("Encoder output ended") and the viewer froze. New connections
already re-probed the geometry (#18); live ones did not.

- When an X11 stream fails and the root size differs, skip the encoder
  fallback and restart capture at the new size with the same settings.
- Absolute pointer mapping follows the refreshed X11 size.
- New connections compare the root size with their capture instead of the
  engine's change flag, which a live stream may already have consumed.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

* Change the X11 desktop resolution when the viewer picks one

The official Windows host changes its display resolution for the viewer's
分辨率 choice; this host only scaled the encoded stream, so a smaller choice
made text smaller and blurrier instead of larger.

On X11 the capture/resolution RPC now switches the primary output's mode with
xrandr (an existing mode of that size, else a CVT reduced-blanking mode at
60 Hz, or 30 Hz above an HDMI 2.0 pixel clock), re-applying it when mutter
resets the mode after the list changes. resolution_type 3 (original) and the
end of the last desktop stream restore the mode in use before the first
change. The stream restarts capture at the new native size and reports it in
the screen sources and CaptureSettingSync. UU_DESKTOP_RESIZE=0 keeps the old
encoder scaling; Wayland is unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 02:44:18 -07:00
VallierDevandClaude Opus 5.5 50ed54d77a Release v0.2.23
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 16:34:37 +08:00
d6752e77c8 Fix SRTP rollover counter rewinding on delayed NACK retransmissions (#83) (#84)
webrtc-srtp 0.12.0 stored every sequence number and used a 100-packet window to
guess the rollover counter. A NACK retransmission of a pre-wrap packet sent after
the wrap (65000 after 85) rewound that state, so the next new packets were
protected with ROC+1 and the viewer failed authentication on all of them: frozen
video after the Windows viewer returned from the background.

Vendor webrtc-srtp 0.12.0 with the RFC 3711 Appendix A half-space estimate and a
high-water index that retransmissions cannot move back. Regression tests fail on
upstream (65000 != 85) and pass with the fix for AES-CM/HMAC and AES-GCM.

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: AYssu <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 01:34:07 -07:00
46 changed files with 4404 additions and 16 deletions

No files matched your search

+1
View File
@@ -116,6 +116,7 @@ viewer does not reconnect them automatically.
| `~/.config/uuremote/config.json` | user_id, device_id, client_id, system_id, machine_guid, token, csrf; optional `sign_key`, `ffmpeg_root`. `$UU_CONFIG` overrides the path | | `~/.config/uuremote/config.json` | user_id, device_id, client_id, system_id, machine_guid, token, csrf; optional `sign_key`, `ffmpeg_root`. `$UU_CONFIG` overrides the path |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent | | `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent |
| `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) | | `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) |
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) | | `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super | | Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) | | `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
Generated
+1 -3
View File
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.22" version = "0.2.24"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"base64 0.22.1", "base64 0.22.1",
@@ -3075,8 +3075,6 @@ dependencies = [
[[package]] [[package]]
name = "webrtc-srtp" name = "webrtc-srtp"
version = "0.12.0" version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "383b0f0f73ee6cce396bdbc4d54ec661861a59eae9fc988914c1a8d82c5ac272"
dependencies = [ dependencies = [
"aead", "aead",
"aes", "aes",
+3 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.22" version = "0.2.24"
edition = "2021" edition = "2021"
default-run = "uuremote-server" default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"] authors = ["uu-remote-linux contributors"]
@@ -64,6 +64,8 @@ sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
cc = "1.0" cc = "1.0"
[patch.crates-io] [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" } webrtc-dtls = { path = "vendor/webrtc-dtls" }
# Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs). # Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs).
webrtc = { path = "vendor/webrtc" } webrtc = { path = "vendor/webrtc" }
+2 -1
View File
@@ -46,7 +46,7 @@
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) | | Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) | | Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync | | Clipboard | Two-way text sync |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; "other resolutions" are scaled by the encoder, the host monitor is left untouched | | Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder |
| Sound | System audio captured from PulseAudio / PipeWire and sent as Opus | | Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete | | File transfer | Upload, download (including folders), create folder, rename, delete |
| Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename | | Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename |
@@ -330,6 +330,7 @@ Common environment variables:
|---|---| |---|---|
| `UU_CONFIG` | Config file path (default `~/.config/uuremote/config.json`) | | `UU_CONFIG` | Config file path (default `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless) | | `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless) |
| `UU_DESKTOP_RESIZE=0` | on X11, keep the desktop resolution and only scale the encoded stream when the viewer picks a resolution |
| `UU_WAYLAND_MULTISCREEN=1` | Enable Hyprland physical monitor switching (off by default) | | `UU_WAYLAND_MULTISCREEN=1` | Enable Hyprland physical monitor switching (off by default) |
| `UU_WAYLAND_OUTPUT` | Initial native Wayland output name, e.g. `HDMI-A-1` | | `UU_WAYLAND_OUTPUT` | Initial native Wayland output name, e.g. `HDMI-A-1` |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) | | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) |
+2 -1
View File
@@ -40,7 +40,7 @@
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) | | Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
| 鼠标指针样式 | 远端指针形状实时同步(X11) | | 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步 | | 剪贴板 | 双向文本同步 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;「其他分辨率」由编码器缩放,不改动主机显示器 | | 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 | | 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 | | 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 |
| 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 | | 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 |
@@ -299,6 +299,7 @@ systemctl --user restart uuremote-native.service
|---|---| |---|---|
| `UU_CONFIG` | 配置文件路径(默认 `~/.config/uuremote/config.json`) | | `UU_CONFIG` | 配置文件路径(默认 `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) | | `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) |
| `UU_DESKTOP_RESIZE=0` | X11 下控制端切换分辨率时不改桌面分辨率,只缩放编码画面 |
| `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) | | `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) |
| `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` | | `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) | | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
+13
View File
@@ -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.**
+17
View File
@@ -0,0 +1,17 @@
X11 下切换分辨率会真正修改桌面分辨率。/ On X11 the viewer's resolution choice now changes the desktop resolution.
### 新增 / Added
- **控制端切换分辨率时真正修改桌面分辨率**,与官方 Windows 被控端一致:以前「其他分辨率」只缩放编码画面,选小分辨率反而让字更小更糊。
现在 X11 下用 xrandr 切换主显示器模式,列表里没有的分辨率会自动添加;选「原始」或断开连接后恢复原分辨率。
已用官方 Mac 控制端在 GNOME(X11)上实测切换与恢复。设置 `UU_DESKTOP_RESIZE=0` 可回到只缩放画面的旧行为;Wayland 不变。
- On X11 the resolution choice switches the display mode via xrandr (adding the mode when missing) and restores it for
"original" or on disconnect, like the official Windows host. `UU_DESKTOP_RESIZE=0` restores encoder scaling.
### 修复 / Fixed
- **连接中桌面分辨率变化后画面中断**:以前会把采集失败当成编码器故障,逐个换编码器后停止推流。现在按新尺寸重新采集,鼠标坐标随之更新。
- A desktop resize during a session no longer stops the stream; capture restarts at the new size and pointer mapping follows.
### 下载 / Download
`uu-remote-linux_0.2.24_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.24-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.24`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+12 -4
View File
@@ -46,14 +46,22 @@ unsafe fn x11_display_name() -> *const libc::c_char { b":0\0".as_ptr().cast() }
/// The X11 root can be resized while the host runs (RandR, xrdp reconnects); the /// The X11 root can be resized while the host runs (RandR, xrdp reconnects); the
/// geometry read at startup then makes x11grab reject every new connection. /// geometry read at startup then makes x11grab reject every new connection.
pub fn x11_resized() -> bool { /// Re-reads the root size; None when the X11 engine is not in use or the query fails.
pub fn x11_size() -> Option<(u32, u32)> {
match unsafe { x11_refresh_geometry() } { match unsafe { x11_refresh_geometry() } {
1 => true, 0 | 1 => x11_last_size(),
0 => false, -1 => None,
code => { log::warn!("X11 geometry query failed with code {code}"); false } code => { log::warn!("X11 geometry query failed with code {code}"); None }
} }
} }
/// The root size from the last refresh, without an X round trip (pointer mapping).
pub fn x11_last_size() -> Option<(u32, u32)> {
let (mut w, mut h): (libc::c_int, libc::c_int) = (0, 0);
if unsafe { x11_get_dimensions(&mut w, &mut h) } != 0 || w <= 0 || h <= 0 { return None; }
Some((w as u32, h as u32))
}
pub struct ScreenCapture { pub struct ScreenCapture {
pub backend: crate::desktop_backend::DesktopBackend, pub backend: crate::desktop_backend::DesktopBackend,
pub init_error: Option<String>, pub init_error: Option<String>,
+15
View File
@@ -141,6 +141,21 @@ pub fn handle_rpc_with_codecs(rpc: &[WireField], settings: &watch::Sender<VideoS
apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_available()) apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_available())
} }
/// The resolution a capture/resolution RPC asks for, parsed like apply_rpc: X11 hosts apply it
/// to the display mode itself (desktop_mode), as the official Windows host changes its resolution.
pub fn requested_resolution(rpc: &[WireField]) -> Option<crate::desktop_mode::Request> {
use crate::desktop_mode::Request;
if let Some(request) = message(rpc, 2) {
let fields = decode_wire(request).ok()?;
if number(&fields, 10) == Some(3) { return Some(Request::Native); }
let (w, h) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6)))?;
Some(Request::Size(u32::try_from(w).ok()?, u32::try_from(h).ok()?))
} else if let Some(request) = message(rpc, 6) {
let fields = decode_wire(request).ok()?;
Some(Request::Size(u32::try_from(number(&fields, 1)?).ok()?, u32::try_from(number(&fields, 2)?).ok()?))
} else { None }
}
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, full_chroma: bool) -> Option<Vec<u8>> { fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, full_chroma: bool) -> Option<Vec<u8>> {
let header = message(rpc, 1).unwrap_or(&[]); let header = message(rpc, 1).unwrap_or(&[]);
let mut next = *settings.borrow(); let mut next = *settings.borrow();
+222
View File
@@ -0,0 +1,222 @@
//! X11 desktop resolution follows the viewer's 分辨率 choice, like the official Windows host:
//! the display mode itself changes (xrandr), not just the encoded size. The mode in use before
//! the first change is restored for 原始/follow-remote and when the last desktop stream ends.
//! Disable with UU_DESKTOP_RESIZE=0 (the viewer choice then scales the encoded stream instead).
use std::process::Command;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Request { Native, Size(u32, u32) }
struct Original { display: String, output: String, mode: String }
static ORIGINAL: Mutex<Option<Original>> = Mutex::new(None);
static STREAMS: AtomicUsize = AtomicUsize::new(0);
/// Upper bound per side (H.264 NVENC/VAAPI limit) and lower bound for a usable desktop.
const MAX_SIDE: u32 = 4096;
const MIN_SIZE: (u32, u32) = (640, 480);
pub fn enabled() -> bool { std::env::var("UU_DESKTOP_RESIZE").map_or(true, |v| v != "0") }
/// Keeps the changed mode while any desktop stream runs; the last one restores it.
pub struct StreamGuard;
impl StreamGuard {
pub fn new() -> Self { STREAMS.fetch_add(1, Ordering::SeqCst); Self }
}
impl Drop for StreamGuard {
fn drop(&mut self) {
if STREAMS.fetch_sub(1, Ordering::SeqCst) == 1 && ORIGINAL.lock().unwrap().is_some() {
// xrandr blocks; never run it on the async runtime thread dropping the stream.
std::thread::spawn(|| {
std::thread::sleep(std::time::Duration::from_secs(2));
if STREAMS.load(Ordering::SeqCst) == 0 { restore(); }
});
}
}
}
/// Applies the viewer's resolution request to the X11 display; returns the desktop size now in
/// use, or None when nothing changed hands (the caller keeps encoder scaling as the fallback).
pub fn apply(display: &str, request: Request) -> Option<(u32, u32)> {
match request {
Request::Native => { restore(); crate::capture::x11_size() },
Request::Size(w, h) => {
let target = fit(w, h)?;
match switch(display, target) {
Ok(()) => crate::capture::x11_size(),
Err(error) => { log::warn!("Desktop resolution change to {}x{} failed: {}", target.0, target.1, error); None },
}
},
}
}
/// Even sides within MIN_SIZE..=MAX_SIDE, keeping the aspect ratio when scaled down.
fn fit(w: u32, h: u32) -> Option<(u32, u32)> {
if w == 0 || h == 0 { return None; }
let scale = (f64::from(MAX_SIDE) / f64::from(w.max(h))).min(1.0);
let (w, h) = ((f64::from(w) * scale).round() as u32, (f64::from(h) * scale).round() as u32);
Some((w.max(MIN_SIZE.0) & !1, h.max(MIN_SIZE.1) & !1))
}
fn switch(display: &str, target: (u32, u32)) -> Result<(), String> {
let state = query(display)?;
if state.current == Some(target) { return Ok(()); }
{
let mut original = ORIGINAL.lock().unwrap();
if original.is_none() {
let mode = state.current_mode.clone().ok_or("current mode unknown")?;
log::info!("Desktop resolution: saving original mode {} on {}", mode, state.output);
*original = Some(Original { display: display.into(), output: state.output.clone(), mode });
}
}
let mode = match state.modes.iter().find(|(_, size)| *size == target) {
Some((name, _)) => name.clone(),
None => {
let (name, timings) = cvt_reduced(target.0, target.1);
// An existing mode of this name (earlier session) makes --newmode fail harmlessly.
let mut args = vec!["--newmode", name.as_str()];
args.extend(timings.iter().map(String::as_str));
let _ = xrandr(display, &args);
xrandr(display, &["--addmode", &state.output, &name])?;
name
},
};
set_mode(display, &state.output, &mode, target)?;
log::info!("Desktop resolution changed to {}x{} ({})", target.0, target.1, mode);
Ok(())
}
/// Restores the mode saved before the first change, if any.
pub fn restore() {
let Some(original) = ORIGINAL.lock().unwrap().take() else { return; };
let size = query(&original.display).ok().and_then(|state| state.modes.into_iter().find(|(name, _)| *name == original.mode).map(|(_, size)| size));
match size.ok_or_else(|| "original mode no longer listed".to_owned())
.and_then(|size| set_mode(&original.display, &original.output, &original.mode, size)) {
Ok(()) => log::info!("Desktop resolution restored to {}", original.mode),
Err(error) => log::warn!("Desktop resolution restore failed: {}", error),
}
let _ = crate::capture::x11_size();
}
/// GNOME/mutter may answer a mode list change by re-applying its preferred mode; set it again.
fn set_mode(display: &str, output: &str, mode: &str, size: (u32, u32)) -> Result<(), String> {
for _ in 0..3 {
xrandr(display, &["--output", output, "--mode", mode])?;
std::thread::sleep(std::time::Duration::from_millis(1500));
if query(display)?.current == Some(size) { return Ok(()); }
}
Err(format!("{output} did not keep {mode}"))
}
fn xrandr(display: &str, args: &[&str]) -> Result<String, String> {
let output = Command::new("xrandr").arg("--display").arg(display).args(args).output()
.map_err(|e| format!("xrandr unavailable: {}", e.kind()))?;
if !output.status.success() { return Err(format!("xrandr {} exited with {}", args.first().unwrap_or(&""), output.status)); }
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
struct State { output: String, current: Option<(u32, u32)>, current_mode: Option<String>, modes: Vec<(String, (u32, u32))> }
fn query(display: &str) -> Result<State, String> { parse(&xrandr(display, &["--query"])?).ok_or_else(|| "no connected output".into()) }
/// The primary connected output (else the first connected one with a mode) and its mode list.
fn parse(text: &str) -> Option<State> {
let mut outputs: Vec<(bool, State)> = Vec::new();
for line in text.lines() {
if let Some(rest) = line.strip_prefix(" ") {
let Some((_, state)) = outputs.last_mut() else { continue; };
let mut parts = rest.split_whitespace();
let Some(name) = parts.next() else { continue; };
let Some(size) = mode_size(name) else { continue; };
if parts.any(|rate| rate.contains('*')) { state.current = Some(size); state.current_mode = Some(name.into()); }
state.modes.push((name.into(), size));
} else if !line.starts_with(' ') {
let mut parts = line.split_whitespace();
let (Some(name), Some("connected")) = (parts.next(), parts.next()) else { outputs.push((false, State { output: String::new(), current: None, current_mode: None, modes: Vec::new() })); continue; };
let primary = line.contains(" connected primary ");
outputs.push((primary, State { output: name.into(), current: None, current_mode: None, modes: Vec::new() }));
}
}
let mut connected: Vec<(bool, State)> = outputs.into_iter().filter(|(_, s)| !s.output.is_empty() && s.current.is_some()).collect();
let index = connected.iter().position(|(primary, _)| *primary).unwrap_or(0);
(index < connected.len()).then(|| connected.swap_remove(index).1)
}
/// "1920x1080", "1920x1080R", "1920x1080_60.00", "1920x1080i" → (1920, 1080).
fn mode_size(name: &str) -> Option<(u32, u32)> {
let (w, rest) = name.split_once('x')?;
let h: String = rest.chars().take_while(char::is_ascii_digit).collect();
Some((w.parse().ok()?, h.parse().ok()?))
}
/// VESA CVT reduced-blanking (v1) timings: 60 Hz, or 30 Hz when 60 Hz exceeds an HDMI 2.0
/// pixel clock (virtual/forced connectors on integrated GPUs reject faster modes).
fn cvt_reduced(w: u32, h: u32) -> (String, Vec<String>) {
const H_BLANK: u32 = 160; const H_SYNC: u32 = 32; const H_FRONT: u32 = 48;
const V_FRONT: u32 = 3; const MIN_V_BACK: u32 = 6; const MIN_VBLANK_US: f64 = 460.0;
let v_sync = match (w * 3 == h * 4, w * 9 == h * 16, w * 10 == h * 16, w * 4 == h * 5, w * 9 == h * 15) {
(true, ..) => 4, (_, true, ..) => 5, (_, _, true, ..) => 6, (_, _, _, true, _) | (.., true) => 7, _ => 10,
};
let timing = |refresh: f64| {
let h_period = (1_000_000.0 / refresh - MIN_VBLANK_US) / f64::from(h);
let vbi = ((MIN_VBLANK_US / h_period) as u32 + 1).max(V_FRONT + v_sync + MIN_V_BACK);
let (total_h, total_v) = (w + H_BLANK, h + vbi);
let clock = (refresh * f64::from(total_h) * f64::from(total_v) / 1_000_000.0 / 0.25).floor() * 0.25;
(clock, total_h, total_v)
};
let (mut refresh, mut t) = (60, timing(60.0));
if t.0 > 590.0 { refresh = 30; t = timing(30.0); }
let (clock, total_h, total_v) = t;
let name = format!("{w}x{h}_{refresh}R");
let timings = [format!("{clock:.2}"), w.to_string(), (w + H_FRONT).to_string(), (w + H_FRONT + H_SYNC).to_string(), total_h.to_string(),
h.to_string(), (h + V_FRONT).to_string(), (h + V_FRONT + v_sync).to_string(), total_v.to_string(), "+hsync".into(), "-vsync".into()];
(name, timings.into())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reduced_blanking_matches_the_cvt_tool() {
// `cvt -r 1920 1080`: 138.50 1920 1968 2000 2080 1080 1083 1088 1111 +hsync -vsync
let (name, t) = cvt_reduced(1920, 1080);
assert_eq!(name, "1920x1080_60R");
assert_eq!(t.join(" "), "138.50 1920 1968 2000 2080 1080 1083 1088 1111 +hsync -vsync");
// `cvt -r 2560 1600`: 268.50 2560 2608 2640 2720 1600 1603 1609 1646
assert_eq!(cvt_reduced(2560, 1600).1.join(" "), "268.50 2560 2608 2640 2720 1600 1603 1609 1646 +hsync -vsync");
// 4K at 60 Hz needs 533 MHz (under the cap); a larger desktop drops to 30 Hz.
assert_eq!(cvt_reduced(3840, 2160).0, "3840x2160_60R");
assert_eq!(cvt_reduced(4096, 2560).0, "4096x2560_30R");
}
#[test]
fn requested_sizes_are_even_and_bounded() {
assert_eq!(fit(1280, 720), Some((1280, 720)));
assert_eq!(fit(4112, 2580), Some((4096, 2570)));
assert_eq!(fit(301, 201), Some((640, 480)));
assert_eq!(fit(0, 1080), None);
}
#[test]
fn parses_primary_output_modes_and_current_mode() {
let text = r"Screen 0: minimum 320 x 200, current 1920 x 1080, maximum 16384 x 16384
DP-1 disconnected (normal left inverted right x axis y axis)
HDMI-1 connected primary 1920x1080+0+0 (normal left inverted right x axis y axis) 0mm x 0mm
1024x768 60.00
3840x2160R 29.98
1920x1080R 59.93*+
HDMI-2 disconnected (normal left inverted right x axis y axis)
";
let state = parse(text).unwrap();
assert_eq!(state.output, "HDMI-1");
assert_eq!(state.current, Some((1920, 1080)));
assert_eq!(state.current_mode.as_deref(), Some("1920x1080R"));
assert_eq!(state.modes.len(), 3);
assert_eq!(state.modes[1], ("3840x2160R".to_owned(), (3840, 2160)));
assert!(parse("Screen 0: minimum 320 x 200\nDP-1 disconnected (normal)\n").is_none());
}
}
+3 -1
View File
@@ -5,6 +5,7 @@ mod engine_plugin;
mod doctor; mod doctor;
mod wol; mod wol;
mod desktop_backend; mod desktop_backend;
mod desktop_mode;
mod desktop_session; mod desktop_session;
mod desktop_power; mod desktop_power;
mod portal; mod portal;
@@ -784,7 +785,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
continue; continue;
} }
let resized=desktop && capture.init_error.is_none() && capture.backend==desktop_backend::DesktopBackend::X11 let resized=desktop && capture.init_error.is_none() && capture.backend==desktop_backend::DesktopBackend::X11
&& tokio::task::spawn_blocking(crate::capture::x11_resized).await.unwrap_or(false); // Compare with this capture, not the engine: a live stream may already have refreshed it.
&& tokio::task::spawn_blocking(crate::capture::x11_size).await.ok().flatten().is_some_and(|size| size!=(capture.width,capture.height));
if resized { log::info!("Desktop geometry changed since startup; reinitializing capture"); } if resized { log::info!("Desktop geometry changed since startup; reinitializing capture"); }
let session_capture=if desktop && portal_desktop.is_none() && (capture.init_error.is_some() || resized) { let session_capture=if desktop && portal_desktop.is_none() && (capture.init_error.is_some() || resized) {
match tokio::task::spawn_blocking(ScreenCapture::new).await { match tokio::task::spawn_blocking(ScreenCapture::new).await {
+20 -3
View File
@@ -510,14 +510,14 @@ async fn read_encoder(
// A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline. // A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline.
#[cfg(feature = "inproc-av")] #[cfg(feature = "inproc-av")]
if let Err(error) = &result { if let Err(error) = &result {
if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) { if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) && x11_resized(&display, portal.is_some(), size).is_none() {
log::warn!("In-process {} stream unavailable; switching to the FFmpeg process pipeline: {}",encoder.name_for(settings.codec),error); log::warn!("In-process {} stream unavailable; switching to the FFmpeg process pipeline: {}",encoder.name_for(settings.codec),error);
result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone()).await; result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone()).await;
} }
} }
match result { match result {
Ok(())=>Ok(()), Ok(())=>Ok(()),
Err(error) if !latest.is_closed()=>{ Err(error) if !latest.is_closed() && x11_resized(&display, portal.is_some(), size).is_none()=>{
log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error); log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error);
read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await
}, },
@@ -525,6 +525,13 @@ async fn read_encoder(
} }
} }
/// A resized X11 root fails every encoder alike (x11grab BadMatch on the old size);
/// returns the new size so the stream restarts capture instead of walking the fallback chain.
fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u32)> {
if portal || display.starts_with("wayland:") || display.starts_with("kms:") { return None; }
crate::capture::x11_size().filter(|current| *current != size)
}
/// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session). /// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session).
#[cfg(feature = "inproc-av")] #[cfg(feature = "inproc-av")]
fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool { fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool {
@@ -915,8 +922,9 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
Ok(()) Ok(())
} }
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>, pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>) -> Result<(), String> { mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>) -> Result<(), String> {
let _desktop_mode = crate::desktop_mode::StreamGuard::new();
loop { loop {
if transport_closed(&pc) { return Ok(()); } if transport_closed(&pc) { return Ok(()); }
if pc.connection_state() == RTCPeerConnectionState::Connected if pc.connection_state() == RTCPeerConnectionState::Connected
@@ -956,6 +964,8 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
let discard = next.codec != current.codec || next.source_generation != current.source_generation || next.source_id != current.source_id || send_interrupted; let discard = next.codec != current.codec || next.source_generation != current.source_generation || next.source_id != current.source_id || send_interrupted;
current = next; current = next;
timeline.fps = u64::from(next.fps); timeline.fps = u64::from(next.fps);
// A viewer resolution choice may have changed the X11 display mode (desktop_mode).
if let Some(resized) = x11_resized(&display, portal_stream, size) { size = resized; }
if discard { if discard {
reader.0.abort(); reader.0.abort();
let _ = (&mut reader.0).await; let _ = (&mut reader.0).await;
@@ -969,6 +979,13 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
tokio::select! { tokio::select! {
result = &mut reader.0 => { result = &mut reader.0 => {
let result = result.map_err(|e| format!("Encoder reader task: {e}"))?; let result = result.map_err(|e| format!("Encoder reader task: {e}"))?;
if let Some(resized) = result.as_ref().err().and_then(|_| x11_resized(&display, portal_stream, size)) {
log::info!("Desktop geometry changed during the stream ({}x{} -> {}x{}); restarting capture", size.0, size.1, resized.0, resized.1);
size = resized;
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone()));
continue;
}
if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) { if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) {
log::warn!("HEVC stream failed ({error}); falling back to negotiated H264"); log::warn!("HEVC stream failed ({error}); falling back to negotiated H264");
applied.send_modify(|value| value.codec = VideoCodec::H264); applied.send_modify(|value| value.codec = VideoCodec::H264);
+20 -2
View File
@@ -560,6 +560,20 @@ impl WebRtcSession {
(21, WireValue::Bytes(rpc)) => Some(*rpc), _ => None, (21, WireValue::Bytes(rpc)) => Some(*rpc), _ => None,
}) else { continue; }; }) else { continue; };
let Ok(rpc_fields) = crate::protocol::decode_wire(rpc) else { continue; }; let Ok(rpc_fields) = crate::protocol::decode_wire(rpc) else { continue; };
// X11: 分辨率 changes the display mode itself, like the official Windows host; the stream
// then carries the new native size instead of a scaled one (desktop_mode).
let resized = if desktop && active_screen.init_error.is_none() && active_screen.portal.is_none()
&& active_screen.backend == crate::desktop_backend::DesktopBackend::X11 && crate::desktop_mode::enabled() {
match crate::capture_setting::requested_resolution(&rpc_fields) {
Some(request) => {
let display = active_screen.display.clone();
tokio::task::spawn_blocking(move || crate::desktop_mode::apply(&display, request)).await.ok().flatten()
.filter(|size| *size != input_size)
},
None => None,
}
} else { None };
let input_size = resized.unwrap_or(input_size);
let before = *settings.borrow(); let before = *settings.borrow();
let output_before = before.output; let output_before = before.output;
let revision = track.revision(); let revision = track.revision();
@@ -571,6 +585,8 @@ impl WebRtcSession {
let mut response=None;owner.with_current(||response=apply());response let mut response=None;owner.with_current(||response=apply());response
} else {apply()}; } else {apply()};
let Some(response)=response else {continue;}; let Some(response)=response else {continue;};
// Restart capture even when the encoded settings are unchanged (native size, no scaling).
if resized.is_some() { settings.send_modify(|s| s.source_generation = s.source_generation.wrapping_add(1)); }
let codec_changed = settings.borrow().codec != before.codec; let codec_changed = settings.borrow().codec != before.codec;
if desktop && codec_changed && !track.wait_for_applied(revision, &settings).await { if desktop && codec_changed && !track.wait_for_applied(revision, &settings).await {
log::warn!("Codec switch did not produce a transmitted frame; success reply withheld"); log::warn!("Codec switch did not produce a transmitted frame; success reply withheld");
@@ -581,7 +597,7 @@ impl WebRtcSession {
let next = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let next = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let _ = response_tx.send(crate::initialization::envelope(next(), timestamp, 22, &response)); let _ = response_tx.send(crate::initialization::envelope(next(), timestamp, 22, &response));
let current = *settings.borrow(); let current = *settings.borrow();
if current.output != output_before { if current.output != output_before || resized.is_some() {
match crate::capture_setting::screen_sources(next(), timestamp, input_size, current.output, "Linux desktop") { match crate::capture_setting::screen_sources(next(), timestamp, input_size, current.output, "Linux desktop") {
Ok(screens) => { let _ = response_tx.send(screens); } Ok(screens) => { let _ = response_tx.send(screens); }
Err(error) => log::warn!("Screen sources update failed: {}", error), Err(error) => log::warn!("Screen sources update failed: {}", error),
@@ -889,6 +905,8 @@ impl WebRtcSession {
Box::pin(async move { Box::pin(async move {
let input_size = crate::wayland::input_size((screen.width, screen.height)); let input_size = crate::wayland::input_size((screen.width, screen.height));
// After a RandR resize the stream restarts capture at the new size; map the pointer to it.
let live_x11 = screen.init_error.is_none() && screen.portal.is_none() && screen.backend == crate::desktop_backend::DesktopBackend::X11;
if let Some(term) = &terminal_worker { if let Some(term) = &terminal_worker {
if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); return; } if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); return; }
} }
@@ -1160,7 +1178,7 @@ impl WebRtcSession {
if let Some(session)=message_input_session.as_ref() {session.with_input(|| { if let Some(session)=message_input_session.as_ref() {session.with_input(|| {
if !crate::wayland::input_ready() {return;} if !crate::wayland::input_ready() {return;}
match &event { match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(input_size)), ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy), ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy), ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed), ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
+11
View File
@@ -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
+19
View File
@@ -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).
+100
View File
@@ -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
View File
@@ -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
+201
View File
@@ -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.
+21
View File
@@ -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.
+14
View File
@@ -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.
+30
View File
@@ -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
View File
@@ -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);
+23
View File
@@ -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
Binary file not shown.

After

Width:  |  Height:  |  Size: 32 KiB

+247
View File
@@ -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))
}
}
+61
View File
@@ -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>;
}
+83
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
+120
View File
@@ -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
View File
@@ -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(())
}
}
+14
View File
@@ -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;
+36
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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(())
}
+91
View File
@@ -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(())
}
}