mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b6703b19df | ||
|
|
76a225a235 | ||
|
|
da99c1ceb4 | ||
|
|
0fe9b979e5 | ||
|
|
cb4850d296 | ||
|
|
16ded48a99 | ||
|
|
d95053d490 | ||
|
|
50ed54d77a | ||
|
|
d6752e77c8 |
No files matched your search
@@ -116,6 +116,8 @@ 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_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
|
||||||
| `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) |
|
||||||
@@ -130,8 +132,9 @@ viewer does not reconnect them automatically.
|
|||||||
| `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default |
|
| `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default |
|
||||||
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
|
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
|
||||||
|
|
||||||
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. The config is re-read
|
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. `config.json` is parsed once
|
||||||
every 60 s.
|
(`config::file()`); only a `LoginExpired` room answer re-reads it from disk (`config::read_fresh()`) before waiting
|
||||||
|
for a new QR login.
|
||||||
|
|
||||||
## 6. Code map
|
## 6. Code map
|
||||||
|
|
||||||
|
|||||||
Generated
+1
-3
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
|||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "uu-remote-linux"
|
name = "uu-remote-linux"
|
||||||
version = "0.2.22"
|
version = "0.2.26"
|
||||||
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
@@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "uu-remote-linux"
|
name = "uu-remote-linux"
|
||||||
version = "0.2.22"
|
version = "0.2.26"
|
||||||
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" }
|
||||||
|
|||||||
+3
-1
@@ -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,8 @@ 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_NVENC_RGB=0` / `=1` | NVENC encodes BGRA directly (saves CPU). Off by default when a monitor is connected to the NVIDIA card (slower when the desktop is composited on the same GPU); `0` forces off, `1` forces on |
|
||||||
| `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) |
|
||||||
|
|||||||
@@ -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,8 @@ 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_NVENC_RGB=0` / `=1` | NVENC 直接编码 BGRA(省 CPU)。显示器接在 NVIDIA 卡上时默认关闭(同卡合成时直吃反而更慢),`0` 强制关,`1` 强制开 |
|
||||||
| `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) |
|
||||||
|
|||||||
@@ -305,6 +305,32 @@ static void on_status_menu(GtkStatusIcon *i, guint button, guint time, gpointer
|
|||||||
(void)i; (void)button; (void)time; (void)d;
|
(void)i; (void)button; (void)time; (void)d;
|
||||||
gtk_menu_popup_at_pointer(GTK_MENU(tray_menu), NULL);
|
gtk_menu_popup_at_pointer(GTK_MENU(tray_menu), NULL);
|
||||||
}
|
}
|
||||||
|
// Monochrome tray icon that follows light/dark panels: GTK and the GNOME AppIndicator extension
|
||||||
|
// recolor "-symbolic" names, KDE recolors the ColorScheme-Text class. Installed into the user's
|
||||||
|
// hicolor theme (found by every panel's default lookup) and also offered as the icon theme path,
|
||||||
|
// so it needs no package install. KDE tries dash-trimmed names ("uu-remote-linux") in each theme
|
||||||
|
// before the next one, so the name must not trim into the colored app icon (#87).
|
||||||
|
static const char TRAY_ICON_NAME[] = "uuremote-tray-symbolic";
|
||||||
|
static const char TRAY_ICON_SVG[] =
|
||||||
|
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\">"
|
||||||
|
"<style id=\"current-color-scheme\">.ColorScheme-Text{color:#232629}</style>"
|
||||||
|
"<path class=\"ColorScheme-Text\" fill=\"currentColor\" fill-rule=\"evenodd\" d=\"M2.5 2h11A1.5 1.5 0 0 1 15 3.5v7a1.5 1.5 0 0 1-1.5 1.5h-11"
|
||||||
|
"A1.5 1.5 0 0 1 1 10.5v-7A1.5 1.5 0 0 1 2.5 2zm0 1.5v7h11v-7z\"/>"
|
||||||
|
"<path class=\"ColorScheme-Text\" fill=\"currentColor\" d=\"M7.25 12h1.5v1.5H11a.75.75 0 0 1 0 1.5H5a.75.75 0 0 1 0-1.5h2.25z"
|
||||||
|
"M11.5 4.5v4l-1.35-1.35-3.1 3.1-1.2-1.2 3.1-3.1L7.5 4.5z\"/></svg>\n";
|
||||||
|
// Returns the icon theme root holding the icon ($XDG_DATA_HOME/icons), or NULL.
|
||||||
|
static gchar *write_tray_icon(void) {
|
||||||
|
gchar *root = g_build_filename(g_get_user_data_dir(), "icons", NULL);
|
||||||
|
gchar *apps = g_build_filename(root, "hicolor", "scalable", "apps", NULL);
|
||||||
|
gchar *file = g_strconcat(TRAY_ICON_NAME, ".svg", NULL);
|
||||||
|
gchar *path = g_build_filename(apps, file, NULL), *current = NULL;
|
||||||
|
// Rewriting an unchanged file would only make icon caches rescan.
|
||||||
|
int ok = g_file_get_contents(path, ¤t, NULL, NULL) && strcmp(current, TRAY_ICON_SVG) == 0;
|
||||||
|
if (!ok) ok = g_mkdir_with_parents(apps, 0755) == 0 && g_file_set_contents(path, TRAY_ICON_SVG, -1, NULL);
|
||||||
|
g_free(apps); g_free(file); g_free(path); g_free(current);
|
||||||
|
if (!ok) { g_free(root); return NULL; }
|
||||||
|
return root;
|
||||||
|
}
|
||||||
static void build_tray(void) {
|
static void build_tray(void) {
|
||||||
tray_menu = gtk_menu_new();
|
tray_menu = gtk_menu_new();
|
||||||
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口");
|
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口");
|
||||||
@@ -318,7 +344,10 @@ static void build_tray(void) {
|
|||||||
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new());
|
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new());
|
||||||
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), quit);
|
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), quit);
|
||||||
gtk_widget_show_all(tray_menu);
|
gtk_widget_show_all(tray_menu);
|
||||||
const char *icon = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
|
gchar *icon_path = write_tray_icon();
|
||||||
|
if (icon_path) gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), icon_path);
|
||||||
|
const char *fallback = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
|
||||||
|
const char *icon = icon_path ? TRAY_ICON_NAME : fallback;
|
||||||
|
|
||||||
// StatusNotifierItem (GNOME AppIndicator extension, KDE): libayatana-appindicator3 / libappindicator3.
|
// StatusNotifierItem (GNOME AppIndicator extension, KDE): libayatana-appindicator3 / libappindicator3.
|
||||||
const char *libs[] = { "libayatana-appindicator3.so.1", "libappindicator3.so.1" };
|
const char *libs[] = { "libayatana-appindicator3.so.1", "libappindicator3.so.1" };
|
||||||
@@ -329,8 +358,11 @@ static void build_tray(void) {
|
|||||||
void (*set_status)(void *, int) = (void (*)(void *, int))dlsym(h, "app_indicator_set_status");
|
void (*set_status)(void *, int) = (void (*)(void *, int))dlsym(h, "app_indicator_set_status");
|
||||||
void (*set_menu)(void *, GtkMenu *) = (void (*)(void *, GtkMenu *))dlsym(h, "app_indicator_set_menu");
|
void (*set_menu)(void *, GtkMenu *) = (void (*)(void *, GtkMenu *))dlsym(h, "app_indicator_set_menu");
|
||||||
void (*set_title)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_title");
|
void (*set_title)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_title");
|
||||||
|
void (*set_theme_path)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_icon_theme_path");
|
||||||
if (ind_new && set_status && set_menu) {
|
if (ind_new && set_status && set_menu) {
|
||||||
void *ind = ind_new("uu-remote-linux", icon, 0 /* APPLICATION_STATUS */);
|
// Without a theme path the panel cannot find the cached icon; keep the installed one.
|
||||||
|
void *ind = ind_new("uu-remote-linux", set_theme_path ? icon : fallback, 0 /* APPLICATION_STATUS */);
|
||||||
|
if (icon_path && set_theme_path) set_theme_path(ind, icon_path);
|
||||||
if (set_title) set_title(ind, "UU 远程 Linux 主机");
|
if (set_title) set_title(ind, "UU 远程 Linux 主机");
|
||||||
set_menu(ind, GTK_MENU(tray_menu));
|
set_menu(ind, GTK_MENU(tray_menu));
|
||||||
set_status(ind, 1 /* ACTIVE */);
|
set_status(ind, 1 /* ACTIVE */);
|
||||||
|
|||||||
@@ -0,0 +1,13 @@
|
|||||||
|
长时间连接后画面冻结的修复。/ Fixes video freezing after long sessions.
|
||||||
|
|
||||||
|
### 修复 / Fixed
|
||||||
|
- **控制端切到后台再恢复后画面冻结、延迟显示 0**(#83,感谢 @AYssu 定位并提供补丁):RTP 序号每 65536 包回绕一次;
|
||||||
|
回绕后如果控制端补要(NACK)回绕前的旧包,webrtc-srtp 0.12.0 会把加密状态退回旧值,之后的新包都用错误的回绕计数加密,
|
||||||
|
控制端全部认证失败,画面停住且不再恢复。现按 RFC 3711 附录 A 估算回绕计数,重传不再让状态倒退。加密算法和报文格式不变。
|
||||||
|
回归测试在原库上失败、修复后通过(AES-CM/HMAC 与 AES-GCM);报告者在 Windows 控制端实测后台放置恢复正常,跨过两次回绕。
|
||||||
|
- SRTP rollover counter no longer rewinds when a pre-wrap packet is retransmitted after the wrap (frozen video, #83).
|
||||||
|
|
||||||
|
### 下载 / Download
|
||||||
|
`uu-remote-linux_0.2.23_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.23-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.23`(x86_64)。
|
||||||
|
|
||||||
|
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||||
@@ -0,0 +1,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.**
|
||||||
@@ -0,0 +1,12 @@
|
|||||||
|
托盘图标随深色/浅色模式自动变色。/ The tray icon now follows light and dark panels.
|
||||||
|
|
||||||
|
### 修复 / Fixed
|
||||||
|
- **深色模式下托盘图标看不清**(#87):托盘改用内置单色符号图标,GNOME(AppIndicator 扩展)和 KDE 会按面板主题自动着色,
|
||||||
|
tarball 安装也不用另装图标。旧版 AppIndicator 库或缓存目录不可写时沿用原图标。目前只经过 CI 编译,尚未在 KDE / GNOME 面板上实机确认。
|
||||||
|
- The tray uses a built-in monochrome symbolic icon (written to the user cache and offered as the indicator's icon theme
|
||||||
|
path) that GNOME's AppIndicator extension and KDE recolor for the panel theme. Built in CI; not yet checked on a real panel.
|
||||||
|
|
||||||
|
### 下载 / Download
|
||||||
|
`uu-remote-linux_0.2.25_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.25-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.25`(x86_64)。
|
||||||
|
|
||||||
|
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||||
@@ -0,0 +1,16 @@
|
|||||||
|
修复 KDE 托盘图标显示为未知图标;显示器接在 NVIDIA 卡上时默认不再让 NVENC 直接编码 BGRA。/ Fixes the KDE tray icon; NVENC skips direct BGRA input when NVIDIA drives the display.
|
||||||
|
|
||||||
|
### 修复 / Fixed
|
||||||
|
- **KDE 托盘显示成未知(空白页)图标**(#87,v0.2.25 引入):单色托盘图标改名为 `uuremote-tray-symbolic`,写到 `~/.local/share/icons/hicolor`,
|
||||||
|
各家面板的默认图标查找都能找到,仍会随深色/浅色面板着色。已在 Plasma 6.7 / KF6 上用 KIconLoader 按 Plasma 的查找方式验证,Plasma 6.8 面板待报告者确认。
|
||||||
|
v0.2.25 留下的 `~/.cache/uu-remote-linux/icons` 不再使用,可以删除。
|
||||||
|
- **同一张 NVIDIA 卡负责显示时编码变慢**(#16):显示、采集、编码都在同一张 NVIDIA 卡上时,NVENC 直接编码 BGRA 反而比 CPU 转换慢
|
||||||
|
(RTX 5070 4K:探针 82.6 vs 98 fps)。现在只要有显示器接在 NVIDIA 卡上就改用 CPU 转换;核显接显示器的机器不变。`UU_NVENC_RGB=1` 强制直接编码,`=0` 强制 CPU 转换。
|
||||||
|
- The tray icon is installed as `uuremote-tray-symbolic` in the user hicolor theme, so KDE's default lookup finds it
|
||||||
|
(v0.2.25 showed the unknown icon on Plasma 6.8). NVENC no longer takes packed BGRA when a connected monitor hangs off
|
||||||
|
an NVIDIA card (slower when the desktop is composited on the encoding GPU); `UU_NVENC_RGB=1` forces it.
|
||||||
|
|
||||||
|
### 下载 / Download
|
||||||
|
`uu-remote-linux_0.2.26_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.26-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.26`(x86_64)。
|
||||||
|
|
||||||
|
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||||
+12
-4
@@ -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>,
|
||||||
|
|||||||
@@ -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();
|
||||||
|
|||||||
@@ -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
@@ -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 {
|
||||||
|
|||||||
+64
-6
@@ -262,10 +262,29 @@ fn cpu_hevc_options(settings: &VideoSettings, gop: &str) -> Vec<String> {
|
|||||||
|
|
||||||
/// NVENC converts packed RGB on the GPU (BT.601 limited range, tagged bt470bg like the swscale default;
|
/// NVENC converts packed RGB on the GPU (BT.601 limited range, tagged bt470bg like the swscale default;
|
||||||
/// compared on the 3090), so 4:2:0 without scaling skips the CPU BGRA→YUV pass (#16: ~2 cores at 4K).
|
/// compared on the 3090), so 4:2:0 without scaling skips the CPU BGRA→YUV pass (#16: ~2 cores at 4K).
|
||||||
/// `input` is the source pixel format; `UU_NVENC_RGB=0` restores CPU conversion.
|
/// When the desktop is composited on the NVIDIA card itself, the packed-RGB path is slower than CPU
|
||||||
|
/// conversion (#16: RTX 5070 at 4K, 82.6 vs 98 fps), so it stays off unless `UU_NVENC_RGB=1`.
|
||||||
|
/// `input` is the source pixel format; `UU_NVENC_RGB=0` always restores CPU conversion.
|
||||||
fn nvenc_rgb_input(settings: &VideoSettings, encoder: Encoder, input: &'static str) -> Option<&'static str> {
|
fn nvenc_rgb_input(settings: &VideoSettings, encoder: Encoder, input: &'static str) -> Option<&'static str> {
|
||||||
(encoder == Encoder::Nvenc && settings.chroma != crate::capture_setting::CHROMA_444 && settings.output.is_none()
|
let wanted = match std::env::var("UU_NVENC_RGB").as_deref() {
|
||||||
&& std::env::var("UU_NVENC_RGB").as_deref() != Ok("0")).then_some(input)
|
Ok("0") => false,
|
||||||
|
Ok("1") => true,
|
||||||
|
_ => !nvidia_drives_display(std::path::Path::new("/sys/class/drm")),
|
||||||
|
};
|
||||||
|
(encoder == Encoder::Nvenc && settings.chroma != crate::capture_setting::CHROMA_444 && settings.output.is_none() && wanted)
|
||||||
|
.then_some(input)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A connected DRM connector (`cardN-HDMI-A-1/status`) on a card bound to the nvidia driver.
|
||||||
|
/// Only visible with nvidia-drm modeset, which Wayland compositors require.
|
||||||
|
fn nvidia_drives_display(drm: &std::path::Path) -> bool {
|
||||||
|
std::fs::read_dir(drm).into_iter().flatten().flatten().any(|entry| {
|
||||||
|
let name = entry.file_name().to_string_lossy().into_owned();
|
||||||
|
let Some((card, _)) = name.split_once('-') else { return false; };
|
||||||
|
card.starts_with("card")
|
||||||
|
&& std::fs::read_to_string(entry.path().join("status")).is_ok_and(|s| s.trim() == "connected")
|
||||||
|
&& std::fs::read_link(drm.join(card).join("device/driver")).is_ok_and(|p| p.file_name().is_some_and(|n| n == "nvidia"))
|
||||||
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn encoder_options(settings: &VideoSettings, encoder: Encoder, gop: &str, rgb: Option<&'static str>) -> Vec<String> {
|
fn encoder_options(settings: &VideoSettings, encoder: Encoder, gop: &str, rgb: Option<&'static str>) -> Vec<String> {
|
||||||
@@ -510,14 +529,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 +544,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 +941,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 +983,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 +998,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);
|
||||||
@@ -1045,6 +1081,28 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
|||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
|
#[test]
|
||||||
|
fn nvidia_display_is_detected_from_connected_connectors() {
|
||||||
|
use std::os::unix::fs::symlink;
|
||||||
|
let root = std::env::temp_dir().join(format!("uu-drm-test-{}", std::process::id()));
|
||||||
|
let _ = std::fs::remove_dir_all(&root);
|
||||||
|
let card = |n: &str, driver: &str, connector: &str, status: &str| {
|
||||||
|
std::fs::create_dir_all(root.join(format!("drivers/{driver}"))).unwrap();
|
||||||
|
std::fs::create_dir_all(root.join(format!("drm/{n}/device"))).unwrap();
|
||||||
|
let _ = symlink(root.join(format!("drivers/{driver}")), root.join(format!("drm/{n}/device/driver")));
|
||||||
|
std::fs::create_dir_all(root.join(format!("drm/{n}-{connector}"))).unwrap();
|
||||||
|
std::fs::write(root.join(format!("drm/{n}-{connector}/status")), format!("{status}\n")).unwrap();
|
||||||
|
};
|
||||||
|
let drm = root.join("drm");
|
||||||
|
card("card0", "i915", "HDMI-A-1", "connected");
|
||||||
|
card("card1", "nvidia", "DP-1", "disconnected");
|
||||||
|
assert!(!super::nvidia_drives_display(&drm), "iGPU drives the display");
|
||||||
|
card("card1", "nvidia", "DP-2", "connected");
|
||||||
|
assert!(super::nvidia_drives_display(&drm), "NVIDIA drives a display");
|
||||||
|
assert!(!super::nvidia_drives_display(&root.join("missing")));
|
||||||
|
let _ = std::fs::remove_dir_all(&root);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn native_frame_dimensions_are_padded_to_even() {
|
fn native_frame_dimensions_are_padded_to_even() {
|
||||||
// A scaled compositor can report an odd logical desktop (e.g. two stacked 150% monitors →
|
// A scaled compositor can report an odd logical desktop (e.g. two stacked 150% monitors →
|
||||||
|
|||||||
+20
-2
@@ -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),
|
||||||
|
|||||||
@@ -0,0 +1,11 @@
|
|||||||
|
# Generated by Cargo
|
||||||
|
# will have compiled files and executables
|
||||||
|
/target/
|
||||||
|
/.idea/
|
||||||
|
|
||||||
|
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
|
||||||
|
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
|
||||||
|
Cargo.lock
|
||||||
|
|
||||||
|
# These are backup files generated by rustfmt
|
||||||
|
**/*.rs.bk
|
||||||
Vendored
+19
@@ -0,0 +1,19 @@
|
|||||||
|
# webrtc-srtp changelog
|
||||||
|
|
||||||
|
## Unreleased
|
||||||
|
|
||||||
|
## v0.9.1
|
||||||
|
|
||||||
|
* Increased minimum support rust version to `1.60.0`.
|
||||||
|
* Increased required `webrtc-util` version to `0.7.0`.
|
||||||
|
|
||||||
|
|
||||||
|
## v0.9.0
|
||||||
|
|
||||||
|
* [#8 update deps + loosen some requirements](https://github.com/webrtc-rs/srtp/pull/8) by [@melekes](https://github.com/melekes).
|
||||||
|
* Increased min version of `log` dependency to `0.4.16`. [#250 Fix log at ^0.4.16 to make tests compile](https://github.com/webrtc-rs/webrtc/pull/250) by [@k0nserv](https://github.com/k0nserv).
|
||||||
|
|
||||||
|
## Prior to 0.8.9
|
||||||
|
|
||||||
|
Before 0.8.9 there was no changelog, previous changes are sometimes, but not always, available in the [GitHub Releases](https://github.com/webrtc-rs/srtp/releases).
|
||||||
|
|
||||||
Vendored
+100
@@ -0,0 +1,100 @@
|
|||||||
|
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||||
|
#
|
||||||
|
# When uploading crates to the registry Cargo will automatically
|
||||||
|
# "normalize" Cargo.toml files for maximal compatibility
|
||||||
|
# with all versions of Cargo and also rewrite `path` dependencies
|
||||||
|
# to registry (e.g., crates.io) dependencies.
|
||||||
|
#
|
||||||
|
# If you are reading this file be aware that the original Cargo.toml
|
||||||
|
# will likely look very different (and much more reasonable).
|
||||||
|
# See Cargo.toml.orig for the original contents.
|
||||||
|
|
||||||
|
[package]
|
||||||
|
edition = "2021"
|
||||||
|
name = "webrtc-srtp"
|
||||||
|
version = "0.12.0"
|
||||||
|
authors = ["Rain Liu <[email protected]>"]
|
||||||
|
description = "A pure Rust implementation of SRTP"
|
||||||
|
homepage = "https://webrtc.rs"
|
||||||
|
documentation = "https://docs.rs/webrtc-srtp"
|
||||||
|
readme = "README.md"
|
||||||
|
license = "MIT OR Apache-2.0"
|
||||||
|
repository = "https://github.com/webrtc-rs/srtp"
|
||||||
|
|
||||||
|
[[bench]]
|
||||||
|
name = "srtp_bench"
|
||||||
|
harness = false
|
||||||
|
|
||||||
|
[dependencies.aead]
|
||||||
|
version = "0.5"
|
||||||
|
features = ["std"]
|
||||||
|
|
||||||
|
[dependencies.aes]
|
||||||
|
version = "0.8"
|
||||||
|
|
||||||
|
[dependencies.aes-gcm]
|
||||||
|
version = "0.10"
|
||||||
|
features = ["std"]
|
||||||
|
|
||||||
|
[dependencies.byteorder]
|
||||||
|
version = "1"
|
||||||
|
|
||||||
|
[dependencies.bytes]
|
||||||
|
version = "1"
|
||||||
|
|
||||||
|
[dependencies.ctr]
|
||||||
|
version = "0.9"
|
||||||
|
|
||||||
|
[dependencies.hmac]
|
||||||
|
version = "0.12"
|
||||||
|
features = ["std"]
|
||||||
|
|
||||||
|
[dependencies.log]
|
||||||
|
version = "0.4"
|
||||||
|
|
||||||
|
[dependencies.openssl]
|
||||||
|
version = "0.10.57"
|
||||||
|
optional = true
|
||||||
|
|
||||||
|
[dependencies.rtcp]
|
||||||
|
version = "0.10.1"
|
||||||
|
|
||||||
|
[dependencies.rtp]
|
||||||
|
version = "0.10.0"
|
||||||
|
|
||||||
|
[dependencies.sha1]
|
||||||
|
version = "0.10"
|
||||||
|
|
||||||
|
[dependencies.subtle]
|
||||||
|
version = "2"
|
||||||
|
|
||||||
|
[dependencies.thiserror]
|
||||||
|
version = "1"
|
||||||
|
|
||||||
|
[dependencies.tokio]
|
||||||
|
version = "1.32.0"
|
||||||
|
features = ["full"]
|
||||||
|
|
||||||
|
[dependencies.util]
|
||||||
|
version = "0.8.1"
|
||||||
|
features = [
|
||||||
|
"conn",
|
||||||
|
"buffer",
|
||||||
|
"marshal",
|
||||||
|
]
|
||||||
|
default-features = false
|
||||||
|
package = "webrtc-util"
|
||||||
|
|
||||||
|
[dev-dependencies.criterion]
|
||||||
|
version = "0.5"
|
||||||
|
features = ["async_futures"]
|
||||||
|
|
||||||
|
[dev-dependencies.lazy_static]
|
||||||
|
version = "1"
|
||||||
|
|
||||||
|
[dev-dependencies.tokio-test]
|
||||||
|
version = "0.4"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
openssl = ["dep:openssl"]
|
||||||
|
vendored-openssl = ["openssl/vendored"]
|
||||||
+46
@@ -0,0 +1,46 @@
|
|||||||
|
[package]
|
||||||
|
name = "webrtc-srtp"
|
||||||
|
version = "0.12.0"
|
||||||
|
authors = ["Rain Liu <[email protected]>"]
|
||||||
|
edition = "2021"
|
||||||
|
description = "A pure Rust implementation of SRTP"
|
||||||
|
license = "MIT OR Apache-2.0"
|
||||||
|
documentation = "https://docs.rs/webrtc-srtp"
|
||||||
|
homepage = "https://webrtc.rs"
|
||||||
|
repository = "https://github.com/webrtc-rs/srtp"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
openssl = ["dep:openssl"]
|
||||||
|
vendored-openssl = ["openssl/vendored"]
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
util = { version = "0.8.1", path = "../util", package = "webrtc-util", default-features = false, features = [
|
||||||
|
"conn",
|
||||||
|
"buffer",
|
||||||
|
"marshal",
|
||||||
|
] }
|
||||||
|
rtp = { version = "0.10.0", path = "../rtp" }
|
||||||
|
rtcp = { version = "0.10.1", path = "../rtcp" }
|
||||||
|
|
||||||
|
byteorder = "1"
|
||||||
|
bytes = "1"
|
||||||
|
thiserror = "1"
|
||||||
|
hmac = { version = "0.12", features = ["std"] }
|
||||||
|
sha1 = "0.10"
|
||||||
|
ctr = "0.9"
|
||||||
|
aes = "0.8"
|
||||||
|
subtle = "2"
|
||||||
|
tokio = { version = "1.32.0", features = ["full"] }
|
||||||
|
log = "0.4"
|
||||||
|
aead = { version = "0.5", features = ["std"] }
|
||||||
|
aes-gcm = { version = "0.10", features = ["std"] }
|
||||||
|
openssl = { version = "0.10.57", optional = true }
|
||||||
|
|
||||||
|
[dev-dependencies]
|
||||||
|
criterion = { version = "0.5", features = ["async_futures"] }
|
||||||
|
tokio-test = "0.4"
|
||||||
|
lazy_static = "1"
|
||||||
|
|
||||||
|
[[bench]]
|
||||||
|
name = "srtp_bench"
|
||||||
|
harness = false
|
||||||
Vendored
+201
@@ -0,0 +1,201 @@
|
|||||||
|
Apache License
|
||||||
|
Version 2.0, January 2004
|
||||||
|
http://www.apache.org/licenses/
|
||||||
|
|
||||||
|
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||||
|
|
||||||
|
1. Definitions.
|
||||||
|
|
||||||
|
"License" shall mean the terms and conditions for use, reproduction,
|
||||||
|
and distribution as defined by Sections 1 through 9 of this document.
|
||||||
|
|
||||||
|
"Licensor" shall mean the copyright owner or entity authorized by
|
||||||
|
the copyright owner that is granting the License.
|
||||||
|
|
||||||
|
"Legal Entity" shall mean the union of the acting entity and all
|
||||||
|
other entities that control, are controlled by, or are under common
|
||||||
|
control with that entity. For the purposes of this definition,
|
||||||
|
"control" means (i) the power, direct or indirect, to cause the
|
||||||
|
direction or management of such entity, whether by contract or
|
||||||
|
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||||
|
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||||
|
|
||||||
|
"You" (or "Your") shall mean an individual or Legal Entity
|
||||||
|
exercising permissions granted by this License.
|
||||||
|
|
||||||
|
"Source" form shall mean the preferred form for making modifications,
|
||||||
|
including but not limited to software source code, documentation
|
||||||
|
source, and configuration files.
|
||||||
|
|
||||||
|
"Object" form shall mean any form resulting from mechanical
|
||||||
|
transformation or translation of a Source form, including but
|
||||||
|
not limited to compiled object code, generated documentation,
|
||||||
|
and conversions to other media types.
|
||||||
|
|
||||||
|
"Work" shall mean the work of authorship, whether in Source or
|
||||||
|
Object form, made available under the License, as indicated by a
|
||||||
|
copyright notice that is included in or attached to the work
|
||||||
|
(an example is provided in the Appendix below).
|
||||||
|
|
||||||
|
"Derivative Works" shall mean any work, whether in Source or Object
|
||||||
|
form, that is based on (or derived from) the Work and for which the
|
||||||
|
editorial revisions, annotations, elaborations, or other modifications
|
||||||
|
represent, as a whole, an original work of authorship. For the purposes
|
||||||
|
of this License, Derivative Works shall not include works that remain
|
||||||
|
separable from, or merely link (or bind by name) to the interfaces of,
|
||||||
|
the Work and Derivative Works thereof.
|
||||||
|
|
||||||
|
"Contribution" shall mean any work of authorship, including
|
||||||
|
the original version of the Work and any modifications or additions
|
||||||
|
to that Work or Derivative Works thereof, that is intentionally
|
||||||
|
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||||
|
or by an individual or Legal Entity authorized to submit on behalf of
|
||||||
|
the copyright owner. For the purposes of this definition, "submitted"
|
||||||
|
means any form of electronic, verbal, or written communication sent
|
||||||
|
to the Licensor or its representatives, including but not limited to
|
||||||
|
communication on electronic mailing lists, source code control systems,
|
||||||
|
and issue tracking systems that are managed by, or on behalf of, the
|
||||||
|
Licensor for the purpose of discussing and improving the Work, but
|
||||||
|
excluding communication that is conspicuously marked or otherwise
|
||||||
|
designated in writing by the copyright owner as "Not a Contribution."
|
||||||
|
|
||||||
|
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||||
|
on behalf of whom a Contribution has been received by Licensor and
|
||||||
|
subsequently incorporated within the Work.
|
||||||
|
|
||||||
|
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||||
|
this License, each Contributor hereby grants to You a perpetual,
|
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||||
|
copyright license to reproduce, prepare Derivative Works of,
|
||||||
|
publicly display, publicly perform, sublicense, and distribute the
|
||||||
|
Work and such Derivative Works in Source or Object form.
|
||||||
|
|
||||||
|
3. Grant of Patent License. Subject to the terms and conditions of
|
||||||
|
this License, each Contributor hereby grants to You a perpetual,
|
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||||
|
(except as stated in this section) patent license to make, have made,
|
||||||
|
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||||
|
where such license applies only to those patent claims licensable
|
||||||
|
by such Contributor that are necessarily infringed by their
|
||||||
|
Contribution(s) alone or by combination of their Contribution(s)
|
||||||
|
with the Work to which such Contribution(s) was submitted. If You
|
||||||
|
institute patent litigation against any entity (including a
|
||||||
|
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||||
|
or a Contribution incorporated within the Work constitutes direct
|
||||||
|
or contributory patent infringement, then any patent licenses
|
||||||
|
granted to You under this License for that Work shall terminate
|
||||||
|
as of the date such litigation is filed.
|
||||||
|
|
||||||
|
4. Redistribution. You may reproduce and distribute copies of the
|
||||||
|
Work or Derivative Works thereof in any medium, with or without
|
||||||
|
modifications, and in Source or Object form, provided that You
|
||||||
|
meet the following conditions:
|
||||||
|
|
||||||
|
(a) You must give any other recipients of the Work or
|
||||||
|
Derivative Works a copy of this License; and
|
||||||
|
|
||||||
|
(b) You must cause any modified files to carry prominent notices
|
||||||
|
stating that You changed the files; and
|
||||||
|
|
||||||
|
(c) You must retain, in the Source form of any Derivative Works
|
||||||
|
that You distribute, all copyright, patent, trademark, and
|
||||||
|
attribution notices from the Source form of the Work,
|
||||||
|
excluding those notices that do not pertain to any part of
|
||||||
|
the Derivative Works; and
|
||||||
|
|
||||||
|
(d) If the Work includes a "NOTICE" text file as part of its
|
||||||
|
distribution, then any Derivative Works that You distribute must
|
||||||
|
include a readable copy of the attribution notices contained
|
||||||
|
within such NOTICE file, excluding those notices that do not
|
||||||
|
pertain to any part of the Derivative Works, in at least one
|
||||||
|
of the following places: within a NOTICE text file distributed
|
||||||
|
as part of the Derivative Works; within the Source form or
|
||||||
|
documentation, if provided along with the Derivative Works; or,
|
||||||
|
within a display generated by the Derivative Works, if and
|
||||||
|
wherever such third-party notices normally appear. The contents
|
||||||
|
of the NOTICE file are for informational purposes only and
|
||||||
|
do not modify the License. You may add Your own attribution
|
||||||
|
notices within Derivative Works that You distribute, alongside
|
||||||
|
or as an addendum to the NOTICE text from the Work, provided
|
||||||
|
that such additional attribution notices cannot be construed
|
||||||
|
as modifying the License.
|
||||||
|
|
||||||
|
You may add Your own copyright statement to Your modifications and
|
||||||
|
may provide additional or different license terms and conditions
|
||||||
|
for use, reproduction, or distribution of Your modifications, or
|
||||||
|
for any such Derivative Works as a whole, provided Your use,
|
||||||
|
reproduction, and distribution of the Work otherwise complies with
|
||||||
|
the conditions stated in this License.
|
||||||
|
|
||||||
|
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||||
|
any Contribution intentionally submitted for inclusion in the Work
|
||||||
|
by You to the Licensor shall be under the terms and conditions of
|
||||||
|
this License, without any additional terms or conditions.
|
||||||
|
Notwithstanding the above, nothing herein shall supersede or modify
|
||||||
|
the terms of any separate license agreement you may have executed
|
||||||
|
with Licensor regarding such Contributions.
|
||||||
|
|
||||||
|
6. Trademarks. This License does not grant permission to use the trade
|
||||||
|
names, trademarks, service marks, or product names of the Licensor,
|
||||||
|
except as required for reasonable and customary use in describing the
|
||||||
|
origin of the Work and reproducing the content of the NOTICE file.
|
||||||
|
|
||||||
|
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||||
|
agreed to in writing, Licensor provides the Work (and each
|
||||||
|
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||||
|
implied, including, without limitation, any warranties or conditions
|
||||||
|
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||||
|
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||||
|
appropriateness of using or redistributing the Work and assume any
|
||||||
|
risks associated with Your exercise of permissions under this License.
|
||||||
|
|
||||||
|
8. Limitation of Liability. In no event and under no legal theory,
|
||||||
|
whether in tort (including negligence), contract, or otherwise,
|
||||||
|
unless required by applicable law (such as deliberate and grossly
|
||||||
|
negligent acts) or agreed to in writing, shall any Contributor be
|
||||||
|
liable to You for damages, including any direct, indirect, special,
|
||||||
|
incidental, or consequential damages of any character arising as a
|
||||||
|
result of this License or out of the use or inability to use the
|
||||||
|
Work (including but not limited to damages for loss of goodwill,
|
||||||
|
work stoppage, computer failure or malfunction, or any and all
|
||||||
|
other commercial damages or losses), even if such Contributor
|
||||||
|
has been advised of the possibility of such damages.
|
||||||
|
|
||||||
|
9. Accepting Warranty or Additional Liability. While redistributing
|
||||||
|
the Work or Derivative Works thereof, You may choose to offer,
|
||||||
|
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||||
|
or other liability obligations and/or rights consistent with this
|
||||||
|
License. However, in accepting such obligations, You may act only
|
||||||
|
on Your own behalf and on Your sole responsibility, not on behalf
|
||||||
|
of any other Contributor, and only if You agree to indemnify,
|
||||||
|
defend, and hold each Contributor harmless for any liability
|
||||||
|
incurred by, or claims asserted against, such Contributor by reason
|
||||||
|
of your accepting any such warranty or additional liability.
|
||||||
|
|
||||||
|
END OF TERMS AND CONDITIONS
|
||||||
|
|
||||||
|
APPENDIX: How to apply the Apache License to your work.
|
||||||
|
|
||||||
|
To apply the Apache License to your work, attach the following
|
||||||
|
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||||
|
replaced with your own identifying information. (Don't include
|
||||||
|
the brackets!) The text should be enclosed in the appropriate
|
||||||
|
comment syntax for the file format. We also recommend that a
|
||||||
|
file or class name and description of purpose be included on the
|
||||||
|
same "printed page" as the copyright notice for easier
|
||||||
|
identification within third-party archives.
|
||||||
|
|
||||||
|
Copyright [yyyy] [name of copyright owner]
|
||||||
|
|
||||||
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
you may not use this file except in compliance with the License.
|
||||||
|
You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing, software
|
||||||
|
distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
See the License for the specific language governing permissions and
|
||||||
|
limitations under the License.
|
||||||
Vendored
+21
@@ -0,0 +1,21 @@
|
|||||||
|
MIT License
|
||||||
|
|
||||||
|
Copyright (c) 2021 WebRTC.rs
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all
|
||||||
|
copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
SOFTWARE.
|
||||||
Vendored
+14
@@ -0,0 +1,14 @@
|
|||||||
|
# Local patch to webrtc-srtp 0.12.0
|
||||||
|
|
||||||
|
Source: crates.io webrtc-srtp 0.12.0 (MIT / Apache-2.0; upstream licenses retained).
|
||||||
|
|
||||||
|
`SrtpSsrcState` estimates the rollover counter with the half-sequence-space rule from
|
||||||
|
RFC 3711 Appendix A and only advances to the highest packet index seen. Upstream used a
|
||||||
|
100-packet window and stored every sequence number, so a NACK retransmission of a
|
||||||
|
pre-wrap packet sent after the wrap (e.g. 65000 after 85) moved the state back and the
|
||||||
|
next new packet was protected with ROC+1; the receiver then failed authentication for
|
||||||
|
every following packet (frozen video, #83). Fix and regression tests contributed by
|
||||||
|
@AYssu. Cipher code, wire format and SRTCP are unchanged.
|
||||||
|
|
||||||
|
The upstream lifecycle test jumped from 5004 to 65535, outside the half-space window;
|
||||||
|
bridge packets keep it consecutive and the known-answer vectors are unchanged.
|
||||||
Vendored
+30
@@ -0,0 +1,30 @@
|
|||||||
|
<h1 align="center">
|
||||||
|
<a href="https://webrtc.rs"><img src="./doc/webrtc.rs.png" alt="WebRTC.rs"></a>
|
||||||
|
<br>
|
||||||
|
</h1>
|
||||||
|
<p align="center">
|
||||||
|
<a href="https://github.com/webrtc-rs/srtp/actions">
|
||||||
|
<img src="https://github.com/webrtc-rs/srtp/workflows/cargo/badge.svg">
|
||||||
|
</a>
|
||||||
|
<a href="https://codecov.io/gh/webrtc-rs/srtp">
|
||||||
|
<img src="https://codecov.io/gh/webrtc-rs/srtp/branch/main/graph/badge.svg">
|
||||||
|
</a>
|
||||||
|
<a href="https://deps.rs/repo/github/webrtc-rs/srtp">
|
||||||
|
<img src="https://deps.rs/repo/github/webrtc-rs/srtp/status.svg">
|
||||||
|
</a>
|
||||||
|
<a href="https://crates.io/crates/webrtc-srtp">
|
||||||
|
<img src="https://img.shields.io/crates/v/webrtc-srtp.svg">
|
||||||
|
</a>
|
||||||
|
<a href="https://docs.rs/webrtc-srtp">
|
||||||
|
<img src="https://docs.rs/webrtc-srtp/badge.svg">
|
||||||
|
</a>
|
||||||
|
<a href="https://doc.rust-lang.org/1.6.0/complement-project-faq.html#why-dual-mitasl2-license">
|
||||||
|
<img src="https://img.shields.io/badge/license-MIT%2FApache--2.0-blue" alt="License: MIT/Apache 2.0">
|
||||||
|
</a>
|
||||||
|
<a href="https://discord.gg/4Ju8UHdXMs">
|
||||||
|
<img src="https://img.shields.io/discord/800204819540869120?logo=discord" alt="Discord">
|
||||||
|
</a>
|
||||||
|
</p>
|
||||||
|
<p align="center">
|
||||||
|
A pure Rust implementation of SRTP. Rewrite <a href="https://github.com/pion/srtp/releases/tag/v1.5.2">Pion</a> SRTP in Rust
|
||||||
|
</p>
|
||||||
+158
@@ -0,0 +1,158 @@
|
|||||||
|
use bytes::BytesMut;
|
||||||
|
use criterion::{criterion_group, criterion_main, Criterion};
|
||||||
|
use util::Marshal;
|
||||||
|
use webrtc_srtp::{context::Context, protection_profile::ProtectionProfile};
|
||||||
|
|
||||||
|
const MASTER_KEY: &[u8] = &[
|
||||||
|
96, 180, 31, 4, 119, 137, 128, 252, 75, 194, 252, 44, 63, 56, 61, 55,
|
||||||
|
];
|
||||||
|
const MASTER_SALT: &[u8] = &[247, 26, 49, 94, 99, 29, 79, 94, 5, 111, 252, 216, 62, 195];
|
||||||
|
const RAW_RTCP: &[u8] = &[
|
||||||
|
0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
|
||||||
|
0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
|
||||||
|
];
|
||||||
|
|
||||||
|
fn benchmark_encrypt_rtp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
MASTER_KEY,
|
||||||
|
MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let mut pld = BytesMut::new();
|
||||||
|
for i in 0..1200 {
|
||||||
|
pld.extend_from_slice(&[i as u8]);
|
||||||
|
}
|
||||||
|
|
||||||
|
c.bench_function("Benchmark RTP encrypt", |b| {
|
||||||
|
let mut seq = 1;
|
||||||
|
b.iter_batched(
|
||||||
|
|| {
|
||||||
|
let pkt = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
sequence_number: seq,
|
||||||
|
timestamp: seq.into(),
|
||||||
|
extension_profile: 48862,
|
||||||
|
marker: true,
|
||||||
|
padding: false,
|
||||||
|
extension: true,
|
||||||
|
payload_type: 96,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: pld.clone().into(),
|
||||||
|
};
|
||||||
|
seq += 1;
|
||||||
|
pkt.marshal().unwrap()
|
||||||
|
},
|
||||||
|
|pkt_raw| {
|
||||||
|
ctx.encrypt_rtp(&pkt_raw).unwrap();
|
||||||
|
},
|
||||||
|
criterion::BatchSize::LargeInput,
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn benchmark_decrypt_rtp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
|
||||||
|
let mut setup_ctx = Context::new(
|
||||||
|
MASTER_KEY,
|
||||||
|
MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
MASTER_KEY,
|
||||||
|
MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let mut pld = BytesMut::new();
|
||||||
|
for i in 0..1200 {
|
||||||
|
pld.extend_from_slice(&[i as u8]);
|
||||||
|
}
|
||||||
|
|
||||||
|
c.bench_function("Benchmark RTP decrypt", |b| {
|
||||||
|
let mut seq = 1;
|
||||||
|
b.iter_batched(
|
||||||
|
|| {
|
||||||
|
let pkt = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
sequence_number: seq,
|
||||||
|
timestamp: seq.into(),
|
||||||
|
extension_profile: 48862,
|
||||||
|
marker: true,
|
||||||
|
padding: false,
|
||||||
|
extension: true,
|
||||||
|
payload_type: 96,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: pld.clone().into(),
|
||||||
|
};
|
||||||
|
seq += 1;
|
||||||
|
setup_ctx.encrypt_rtp(&pkt.marshal().unwrap()).unwrap()
|
||||||
|
},
|
||||||
|
|encrypted| ctx.decrypt_rtp(&encrypted).unwrap(),
|
||||||
|
criterion::BatchSize::LargeInput,
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn benchmark_encrypt_rtcp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
MASTER_KEY,
|
||||||
|
MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
c.bench_function("Benchmark RTCP encrypt", |b| {
|
||||||
|
b.iter(|| {
|
||||||
|
ctx.encrypt_rtcp(RAW_RTCP).unwrap();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn benchmark_decrypt_rtcp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
|
||||||
|
let encrypted = Context::new(
|
||||||
|
MASTER_KEY,
|
||||||
|
MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap()
|
||||||
|
.encrypt_rtcp(RAW_RTCP)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
MASTER_KEY,
|
||||||
|
MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
c.bench_function("Benchmark RTCP decrypt", |b| {
|
||||||
|
b.iter(|| ctx.decrypt_rtcp(&encrypted).unwrap());
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
criterion_group!(
|
||||||
|
benches,
|
||||||
|
benchmark_encrypt_rtp_aes_128_cm_hmac_sha1,
|
||||||
|
benchmark_decrypt_rtp_aes_128_cm_hmac_sha1,
|
||||||
|
benchmark_encrypt_rtcp_aes_128_cm_hmac_sha1,
|
||||||
|
benchmark_decrypt_rtcp_aes_128_cm_hmac_sha1
|
||||||
|
);
|
||||||
|
criterion_main!(benches);
|
||||||
Vendored
+23
@@ -0,0 +1,23 @@
|
|||||||
|
codecov:
|
||||||
|
require_ci_to_pass: yes
|
||||||
|
max_report_age: off
|
||||||
|
token: d65de923-7c3d-4836-8d9a-5183b356be4f
|
||||||
|
|
||||||
|
coverage:
|
||||||
|
precision: 2
|
||||||
|
round: down
|
||||||
|
range: 50..90
|
||||||
|
status:
|
||||||
|
project:
|
||||||
|
default:
|
||||||
|
enabled: no
|
||||||
|
threshold: 0.2
|
||||||
|
if_not_found: success
|
||||||
|
patch:
|
||||||
|
default:
|
||||||
|
enabled: no
|
||||||
|
if_not_found: success
|
||||||
|
changes:
|
||||||
|
default:
|
||||||
|
enabled: no
|
||||||
|
if_not_found: success
|
||||||
Vendored
BIN
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
@@ -0,0 +1,247 @@
|
|||||||
|
use aes_gcm::aead::generic_array::GenericArray;
|
||||||
|
use aes_gcm::aead::{Aead, Payload};
|
||||||
|
use aes_gcm::{Aes128Gcm, KeyInit, Nonce};
|
||||||
|
use byteorder::{BigEndian, ByteOrder};
|
||||||
|
use bytes::{Bytes, BytesMut};
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use super::Cipher;
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
use crate::key_derivation::*;
|
||||||
|
|
||||||
|
pub const CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN: usize = 16;
|
||||||
|
|
||||||
|
const RTCP_ENCRYPTION_FLAG: u8 = 0x80;
|
||||||
|
|
||||||
|
/// AEAD Cipher based on AES.
|
||||||
|
pub(crate) struct CipherAeadAesGcm {
|
||||||
|
srtp_cipher: aes_gcm::Aes128Gcm,
|
||||||
|
srtcp_cipher: aes_gcm::Aes128Gcm,
|
||||||
|
srtp_session_salt: Vec<u8>,
|
||||||
|
srtcp_session_salt: Vec<u8>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Cipher for CipherAeadAesGcm {
|
||||||
|
fn auth_tag_len(&self) -> usize {
|
||||||
|
CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
payload: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
// Grow the given buffer to fit the output.
|
||||||
|
let header_len = header.marshal_size();
|
||||||
|
let mut writer = BytesMut::with_capacity(payload.len() + self.auth_tag_len());
|
||||||
|
|
||||||
|
// Copy header unencrypted.
|
||||||
|
writer.extend_from_slice(&payload[..header_len]);
|
||||||
|
|
||||||
|
let nonce = self.rtp_initialization_vector(header, roc);
|
||||||
|
|
||||||
|
let encrypted = self.srtp_cipher.encrypt(
|
||||||
|
Nonce::from_slice(&nonce),
|
||||||
|
Payload {
|
||||||
|
msg: &payload[header_len..],
|
||||||
|
aad: &writer,
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
writer.extend(encrypted);
|
||||||
|
Ok(writer.freeze())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
ciphertext: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
if ciphertext.len() < self.auth_tag_len() {
|
||||||
|
return Err(Error::ErrFailedToVerifyAuthTag);
|
||||||
|
}
|
||||||
|
|
||||||
|
let nonce = self.rtp_initialization_vector(header, roc);
|
||||||
|
let payload_offset = header.marshal_size();
|
||||||
|
let decrypted_msg: Vec<u8> = self.srtp_cipher.decrypt(
|
||||||
|
Nonce::from_slice(&nonce),
|
||||||
|
Payload {
|
||||||
|
msg: &ciphertext[payload_offset..],
|
||||||
|
aad: &ciphertext[..payload_offset],
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let mut writer = BytesMut::with_capacity(payload_offset + decrypted_msg.len());
|
||||||
|
writer.extend_from_slice(&ciphertext[..payload_offset]);
|
||||||
|
writer.extend(decrypted_msg);
|
||||||
|
|
||||||
|
Ok(writer.freeze())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
|
||||||
|
let iv = self.rtcp_initialization_vector(srtcp_index, ssrc);
|
||||||
|
let aad = self.rtcp_additional_authenticated_data(decrypted, srtcp_index);
|
||||||
|
|
||||||
|
let encrypted_data = self.srtcp_cipher.encrypt(
|
||||||
|
Nonce::from_slice(&iv),
|
||||||
|
Payload {
|
||||||
|
msg: &decrypted[8..],
|
||||||
|
aad: &aad,
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let mut writer = BytesMut::with_capacity(encrypted_data.len() + aad.len());
|
||||||
|
writer.extend_from_slice(&decrypted[..8]);
|
||||||
|
writer.extend(encrypted_data);
|
||||||
|
writer.extend_from_slice(&aad[8..]);
|
||||||
|
|
||||||
|
Ok(writer.freeze())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
|
||||||
|
if encrypted.len() < self.auth_tag_len() + SRTCP_INDEX_SIZE {
|
||||||
|
return Err(Error::ErrFailedToVerifyAuthTag);
|
||||||
|
}
|
||||||
|
|
||||||
|
let nonce = self.rtcp_initialization_vector(srtcp_index, ssrc);
|
||||||
|
let aad = self.rtcp_additional_authenticated_data(encrypted, srtcp_index);
|
||||||
|
|
||||||
|
let decrypted_data = self.srtcp_cipher.decrypt(
|
||||||
|
Nonce::from_slice(&nonce),
|
||||||
|
Payload {
|
||||||
|
msg: &encrypted[8..(encrypted.len() - SRTCP_INDEX_SIZE)],
|
||||||
|
aad: &aad,
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let mut writer = BytesMut::with_capacity(8 + decrypted_data.len());
|
||||||
|
writer.extend_from_slice(&encrypted[..8]);
|
||||||
|
writer.extend(decrypted_data);
|
||||||
|
|
||||||
|
Ok(writer.freeze())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_rtcp_index(&self, input: &[u8]) -> usize {
|
||||||
|
let pos = input.len() - 4;
|
||||||
|
let val = BigEndian::read_u32(&input[pos..]);
|
||||||
|
|
||||||
|
(val & !((RTCP_ENCRYPTION_FLAG as u32) << 24)) as usize
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CipherAeadAesGcm {
|
||||||
|
/// Create a new AEAD instance.
|
||||||
|
pub(crate) fn new(master_key: &[u8], master_salt: &[u8]) -> Result<CipherAeadAesGcm> {
|
||||||
|
let srtp_session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_ENCRYPTION,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let srtp_block = GenericArray::from_slice(&srtp_session_key);
|
||||||
|
|
||||||
|
let srtp_cipher = Aes128Gcm::new(srtp_block);
|
||||||
|
|
||||||
|
let srtcp_session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTCP_ENCRYPTION,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let srtcp_block = GenericArray::from_slice(&srtcp_session_key);
|
||||||
|
|
||||||
|
let srtcp_cipher = Aes128Gcm::new(srtcp_block);
|
||||||
|
|
||||||
|
let srtp_session_salt = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_SALT,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let srtcp_session_salt = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTCP_SALT,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(CipherAeadAesGcm {
|
||||||
|
srtp_cipher,
|
||||||
|
srtcp_cipher,
|
||||||
|
srtp_session_salt,
|
||||||
|
srtcp_session_salt,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The 12-octet IV used by AES-GCM SRTP is formed by first concatenating
|
||||||
|
/// 2 octets of zeroes, the 4-octet SSRC, the 4-octet rollover counter
|
||||||
|
/// (ROC), and the 2-octet sequence number (SEQ). The resulting 12-octet
|
||||||
|
/// value is then XORed to the 12-octet salt to form the 12-octet IV.
|
||||||
|
///
|
||||||
|
/// https://tools.ietf.org/html/rfc7714#section-8.1
|
||||||
|
pub(crate) fn rtp_initialization_vector(
|
||||||
|
&self,
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Vec<u8> {
|
||||||
|
let mut iv = vec![0u8; 12];
|
||||||
|
BigEndian::write_u32(&mut iv[2..], header.ssrc);
|
||||||
|
BigEndian::write_u32(&mut iv[6..], roc);
|
||||||
|
BigEndian::write_u16(&mut iv[10..], header.sequence_number);
|
||||||
|
|
||||||
|
for (i, v) in iv.iter_mut().enumerate() {
|
||||||
|
*v ^= self.srtp_session_salt[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
iv
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The 12-octet IV used by AES-GCM SRTCP is formed by first
|
||||||
|
/// concatenating 2 octets of zeroes, the 4-octet SSRC identifier,
|
||||||
|
/// 2 octets of zeroes, a single "0" bit, and the 31-bit SRTCP index.
|
||||||
|
/// The resulting 12-octet value is then XORed to the 12-octet salt to
|
||||||
|
/// form the 12-octet IV.
|
||||||
|
///
|
||||||
|
/// https://tools.ietf.org/html/rfc7714#section-9.1
|
||||||
|
pub(crate) fn rtcp_initialization_vector(&self, srtcp_index: usize, ssrc: u32) -> Vec<u8> {
|
||||||
|
let mut iv = vec![0u8; 12];
|
||||||
|
|
||||||
|
BigEndian::write_u32(&mut iv[2..], ssrc);
|
||||||
|
BigEndian::write_u32(&mut iv[8..], srtcp_index as u32);
|
||||||
|
|
||||||
|
for (i, v) in iv.iter_mut().enumerate() {
|
||||||
|
*v ^= self.srtcp_session_salt[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
iv
|
||||||
|
}
|
||||||
|
|
||||||
|
/// In an SRTCP packet, a 1-bit Encryption flag is prepended to the
|
||||||
|
/// 31-bit SRTCP index to form a 32-bit value we shall call the
|
||||||
|
/// "ESRTCP word"
|
||||||
|
///
|
||||||
|
/// https://tools.ietf.org/html/rfc7714#section-17
|
||||||
|
pub(crate) fn rtcp_additional_authenticated_data(
|
||||||
|
&self,
|
||||||
|
rtcp_packet: &[u8],
|
||||||
|
srtcp_index: usize,
|
||||||
|
) -> Vec<u8> {
|
||||||
|
let mut aad = vec![0u8; 12];
|
||||||
|
|
||||||
|
aad[..8].copy_from_slice(&rtcp_packet[..8]);
|
||||||
|
|
||||||
|
BigEndian::write_u32(&mut aad[8..], srtcp_index as u32);
|
||||||
|
|
||||||
|
aad[8] |= RTCP_ENCRYPTION_FLAG;
|
||||||
|
aad
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,220 @@
|
|||||||
|
use aes::cipher::generic_array::GenericArray;
|
||||||
|
use aes::cipher::{KeyIvInit, StreamCipher, StreamCipherSeek};
|
||||||
|
use bytes::{BufMut, Bytes};
|
||||||
|
use rtcp::header::{HEADER_LENGTH, SSRC_LENGTH};
|
||||||
|
use subtle::ConstantTimeEq;
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use super::{Cipher, CipherInner};
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
use crate::key_derivation::*;
|
||||||
|
|
||||||
|
type Aes128Ctr = ctr::Ctr128BE<aes::Aes128>;
|
||||||
|
|
||||||
|
pub(crate) struct CipherAesCmHmacSha1 {
|
||||||
|
inner: CipherInner,
|
||||||
|
srtp_session_key: Vec<u8>,
|
||||||
|
srtcp_session_key: Vec<u8>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CipherAesCmHmacSha1 {
|
||||||
|
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
|
||||||
|
let inner = CipherInner::new(master_key, master_salt)?;
|
||||||
|
|
||||||
|
let srtp_session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_ENCRYPTION,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
let srtcp_session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTCP_ENCRYPTION,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
Ok(CipherAesCmHmacSha1 {
|
||||||
|
inner,
|
||||||
|
srtp_session_key,
|
||||||
|
srtcp_session_key,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Cipher for CipherAesCmHmacSha1 {
|
||||||
|
fn auth_tag_len(&self) -> usize {
|
||||||
|
self.inner.auth_tag_len()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_rtcp_index(&self, input: &[u8]) -> usize {
|
||||||
|
self.inner.get_rtcp_index(input)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
plaintext: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let mut writer = Vec::with_capacity(plaintext.len() + self.auth_tag_len());
|
||||||
|
|
||||||
|
// Write the plaintext to the destination buffer.
|
||||||
|
writer.extend_from_slice(plaintext);
|
||||||
|
|
||||||
|
// Encrypt the payload
|
||||||
|
let counter = generate_counter(
|
||||||
|
header.sequence_number,
|
||||||
|
roc,
|
||||||
|
header.ssrc,
|
||||||
|
&self.inner.srtp_session_salt,
|
||||||
|
);
|
||||||
|
let key = GenericArray::from_slice(&self.srtp_session_key);
|
||||||
|
let nonce = GenericArray::from_slice(&counter);
|
||||||
|
let mut stream = Aes128Ctr::new(key, nonce);
|
||||||
|
stream.apply_keystream(&mut writer[header.marshal_size()..]);
|
||||||
|
|
||||||
|
// Generate the auth tag.
|
||||||
|
let auth_tag = &self.inner.generate_srtp_auth_tag(&writer, roc)[..self.auth_tag_len()];
|
||||||
|
writer.extend(auth_tag);
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
encrypted: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let encrypted_len = encrypted.len();
|
||||||
|
if encrypted_len < self.auth_tag_len() {
|
||||||
|
return Err(Error::SrtpTooSmall(encrypted_len, self.auth_tag_len()));
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut writer = Vec::with_capacity(encrypted_len - self.auth_tag_len());
|
||||||
|
|
||||||
|
// Split the auth tag and the cipher text into two parts.
|
||||||
|
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
|
||||||
|
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
|
||||||
|
|
||||||
|
// Generate the auth tag we expect to see from the ciphertext.
|
||||||
|
let expected_tag =
|
||||||
|
&self.inner.generate_srtp_auth_tag(cipher_text, roc)[..self.auth_tag_len()];
|
||||||
|
|
||||||
|
// See if the auth tag actually matches.
|
||||||
|
// We use a constant time comparison to prevent timing attacks.
|
||||||
|
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
|
||||||
|
return Err(Error::RtpFailedToVerifyAuthTag);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write cipher_text to the destination buffer.
|
||||||
|
writer.extend_from_slice(cipher_text);
|
||||||
|
|
||||||
|
// Decrypt the ciphertext for the payload.
|
||||||
|
let counter = generate_counter(
|
||||||
|
header.sequence_number,
|
||||||
|
roc,
|
||||||
|
header.ssrc,
|
||||||
|
&self.inner.srtp_session_salt,
|
||||||
|
);
|
||||||
|
|
||||||
|
let key = GenericArray::from_slice(&self.srtp_session_key);
|
||||||
|
let nonce = GenericArray::from_slice(&counter);
|
||||||
|
let mut stream = Aes128Ctr::new(key, nonce);
|
||||||
|
stream.seek(0);
|
||||||
|
stream.apply_keystream(&mut writer[header.marshal_size()..]);
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
|
||||||
|
let mut writer =
|
||||||
|
Vec::with_capacity(decrypted.len() + SRTCP_INDEX_SIZE + self.auth_tag_len());
|
||||||
|
|
||||||
|
// Write the decrypted to the destination buffer.
|
||||||
|
writer.extend_from_slice(decrypted);
|
||||||
|
|
||||||
|
// Encrypt everything after header
|
||||||
|
let counter = generate_counter(
|
||||||
|
(srtcp_index & 0xFFFF) as u16,
|
||||||
|
(srtcp_index >> 16) as u32,
|
||||||
|
ssrc,
|
||||||
|
&self.inner.srtcp_session_salt,
|
||||||
|
);
|
||||||
|
|
||||||
|
let key = GenericArray::from_slice(&self.srtcp_session_key);
|
||||||
|
let nonce = GenericArray::from_slice(&counter);
|
||||||
|
let mut stream = Aes128Ctr::new(key, nonce);
|
||||||
|
|
||||||
|
stream.apply_keystream(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]);
|
||||||
|
|
||||||
|
// Add SRTCP index and set Encryption bit
|
||||||
|
writer.put_u32(srtcp_index as u32 | (1u32 << 31));
|
||||||
|
|
||||||
|
// Generate the auth tag.
|
||||||
|
let auth_tag = &self.inner.generate_srtcp_auth_tag(&writer)[..self.auth_tag_len()];
|
||||||
|
writer.extend(auth_tag);
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
|
||||||
|
let encrypted_len = encrypted.len();
|
||||||
|
if encrypted_len < self.auth_tag_len() + SRTCP_INDEX_SIZE {
|
||||||
|
return Err(Error::SrtcpTooSmall(
|
||||||
|
encrypted_len,
|
||||||
|
self.auth_tag_len() + SRTCP_INDEX_SIZE,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
let tail_offset = encrypted_len - (self.auth_tag_len() + SRTCP_INDEX_SIZE);
|
||||||
|
|
||||||
|
let mut writer = Vec::with_capacity(tail_offset);
|
||||||
|
|
||||||
|
writer.extend_from_slice(&encrypted[0..tail_offset]);
|
||||||
|
|
||||||
|
let is_encrypted = encrypted[tail_offset] >> 7;
|
||||||
|
if is_encrypted == 0 {
|
||||||
|
return Ok(Bytes::from(writer));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Split the auth tag and the cipher text into two parts.
|
||||||
|
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
|
||||||
|
if actual_tag.len() != self.auth_tag_len() {
|
||||||
|
return Err(Error::RtcpInvalidLengthAuthTag(
|
||||||
|
actual_tag.len(),
|
||||||
|
self.auth_tag_len(),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
|
||||||
|
|
||||||
|
// Generate the auth tag we expect to see from the ciphertext.
|
||||||
|
let expected_tag = &self.inner.generate_srtcp_auth_tag(cipher_text)[..self.auth_tag_len()];
|
||||||
|
|
||||||
|
// See if the auth tag actually matches.
|
||||||
|
// We use a constant time comparison to prevent timing attacks.
|
||||||
|
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
|
||||||
|
return Err(Error::RtcpFailedToVerifyAuthTag);
|
||||||
|
}
|
||||||
|
|
||||||
|
let counter = generate_counter(
|
||||||
|
(srtcp_index & 0xFFFF) as u16,
|
||||||
|
(srtcp_index >> 16) as u32,
|
||||||
|
ssrc,
|
||||||
|
&self.inner.srtcp_session_salt,
|
||||||
|
);
|
||||||
|
|
||||||
|
let key = GenericArray::from_slice(&self.srtcp_session_key);
|
||||||
|
let nonce = GenericArray::from_slice(&counter);
|
||||||
|
let mut stream = Aes128Ctr::new(key, nonce);
|
||||||
|
|
||||||
|
stream.seek(0);
|
||||||
|
stream.apply_keystream(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]);
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,133 @@
|
|||||||
|
use byteorder::{BigEndian, ByteOrder};
|
||||||
|
use hmac::{Hmac, Mac};
|
||||||
|
use sha1::Sha1;
|
||||||
|
|
||||||
|
use super::Cipher;
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
use crate::key_derivation::*;
|
||||||
|
use crate::protection_profile::*;
|
||||||
|
|
||||||
|
#[cfg(not(feature = "openssl"))]
|
||||||
|
mod ctrcipher;
|
||||||
|
|
||||||
|
#[cfg(feature = "openssl")]
|
||||||
|
mod opensslcipher;
|
||||||
|
|
||||||
|
#[cfg(not(feature = "openssl"))]
|
||||||
|
pub(crate) use ctrcipher::CipherAesCmHmacSha1;
|
||||||
|
|
||||||
|
#[cfg(feature = "openssl")]
|
||||||
|
pub(crate) use opensslcipher::CipherAesCmHmacSha1;
|
||||||
|
|
||||||
|
type HmacSha1 = Hmac<Sha1>;
|
||||||
|
|
||||||
|
pub const CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN: usize = 10;
|
||||||
|
|
||||||
|
pub(crate) struct CipherInner {
|
||||||
|
srtp_session_salt: Vec<u8>,
|
||||||
|
srtp_session_auth: HmacSha1,
|
||||||
|
srtcp_session_salt: Vec<u8>,
|
||||||
|
srtcp_session_auth: HmacSha1,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CipherInner {
|
||||||
|
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
|
||||||
|
let srtp_session_salt = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_SALT,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_salt.len(),
|
||||||
|
)?;
|
||||||
|
let srtcp_session_salt = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTCP_SALT,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_salt.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let auth_key_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_key_len();
|
||||||
|
|
||||||
|
let srtp_session_auth_tag = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_AUTHENTICATION_TAG,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
auth_key_len,
|
||||||
|
)?;
|
||||||
|
let srtcp_session_auth_tag = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTCP_AUTHENTICATION_TAG,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
auth_key_len,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let srtp_session_auth = HmacSha1::new_from_slice(&srtp_session_auth_tag)
|
||||||
|
.map_err(|e| Error::Other(e.to_string()))?;
|
||||||
|
let srtcp_session_auth = HmacSha1::new_from_slice(&srtcp_session_auth_tag)
|
||||||
|
.map_err(|e| Error::Other(e.to_string()))?;
|
||||||
|
|
||||||
|
Ok(Self {
|
||||||
|
srtp_session_salt,
|
||||||
|
srtp_session_auth,
|
||||||
|
srtcp_session_salt,
|
||||||
|
srtcp_session_auth,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// https://tools.ietf.org/html/rfc3711#section-4.2
|
||||||
|
/// In the case of SRTP, M SHALL consist of the Authenticated
|
||||||
|
/// Portion of the packet (as specified in Figure 1) concatenated with
|
||||||
|
/// the roc, M = Authenticated Portion || roc;
|
||||||
|
///
|
||||||
|
/// The pre-defined authentication transform for SRTP is HMAC-SHA1
|
||||||
|
/// [RFC2104]. With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL
|
||||||
|
/// be 0. For SRTP (respectively SRTCP), the HMAC SHALL be applied to
|
||||||
|
/// the session authentication key and M as specified above, i.e.,
|
||||||
|
/// HMAC(k_a, M). The HMAC output SHALL then be truncated to the n_tag
|
||||||
|
/// left-most bits.
|
||||||
|
/// - Authenticated portion of the packet is everything BEFORE MKI
|
||||||
|
/// - k_a is the session message authentication key
|
||||||
|
/// - n_tag is the bit-length of the output authentication tag
|
||||||
|
fn generate_srtp_auth_tag(&self, buf: &[u8], roc: u32) -> [u8; 20] {
|
||||||
|
let mut signer = self.srtp_session_auth.clone();
|
||||||
|
|
||||||
|
signer.update(buf);
|
||||||
|
|
||||||
|
// For SRTP only, we need to hash the rollover counter as well.
|
||||||
|
signer.update(&roc.to_be_bytes());
|
||||||
|
|
||||||
|
signer.finalize().into_bytes().into()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// https://tools.ietf.org/html/rfc3711#section-4.2
|
||||||
|
///
|
||||||
|
/// The pre-defined authentication transform for SRTP is HMAC-SHA1
|
||||||
|
/// [RFC2104]. With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL
|
||||||
|
/// be 0. For SRTP (respectively SRTCP), the HMAC SHALL be applied to
|
||||||
|
/// the session authentication key and M as specified above, i.e.,
|
||||||
|
/// HMAC(k_a, M). The HMAC output SHALL then be truncated to the n_tag
|
||||||
|
/// left-most bits.
|
||||||
|
/// - Authenticated portion of the packet is everything BEFORE MKI
|
||||||
|
/// - k_a is the session message authentication key
|
||||||
|
/// - n_tag is the bit-length of the output authentication tag
|
||||||
|
fn generate_srtcp_auth_tag(&self, buf: &[u8]) -> [u8; 20] {
|
||||||
|
let mut signer = self.srtcp_session_auth.clone();
|
||||||
|
|
||||||
|
signer.update(buf);
|
||||||
|
|
||||||
|
signer.finalize().into_bytes().into()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn auth_tag_len(&self) -> usize {
|
||||||
|
CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_rtcp_index(&self, input: &[u8]) -> usize {
|
||||||
|
let tail_offset = input.len() - (self.auth_tag_len() + SRTCP_INDEX_SIZE);
|
||||||
|
(BigEndian::read_u32(&input[tail_offset..tail_offset + SRTCP_INDEX_SIZE]) & !(1 << 31))
|
||||||
|
as usize
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,261 @@
|
|||||||
|
use bytes::{BufMut, Bytes};
|
||||||
|
use openssl::cipher_ctx::CipherCtx;
|
||||||
|
use rtcp::header::{HEADER_LENGTH, SSRC_LENGTH};
|
||||||
|
use subtle::ConstantTimeEq;
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use super::{Cipher, CipherInner};
|
||||||
|
use crate::{
|
||||||
|
error::{Error, Result},
|
||||||
|
key_derivation::*,
|
||||||
|
};
|
||||||
|
|
||||||
|
pub(crate) struct CipherAesCmHmacSha1 {
|
||||||
|
inner: CipherInner,
|
||||||
|
rtp_ctx: CipherCtx,
|
||||||
|
rtcp_ctx: CipherCtx,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CipherAesCmHmacSha1 {
|
||||||
|
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
|
||||||
|
let inner = CipherInner::new(master_key, master_salt)?;
|
||||||
|
|
||||||
|
let srtp_session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_ENCRYPTION,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
let srtcp_session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTCP_ENCRYPTION,
|
||||||
|
master_key,
|
||||||
|
master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let t = openssl::cipher::Cipher::aes_128_ctr();
|
||||||
|
let mut rtp_ctx = CipherCtx::new().map_err(|e| Error::Other(e.to_string()))?;
|
||||||
|
rtp_ctx
|
||||||
|
.encrypt_init(Some(t), Some(&srtp_session_key[..]), None)
|
||||||
|
.map_err(|e| Error::Other(e.to_string()))?;
|
||||||
|
|
||||||
|
let t = openssl::cipher::Cipher::aes_128_ctr();
|
||||||
|
let mut rtcp_ctx = CipherCtx::new().map_err(|e| Error::Other(e.to_string()))?;
|
||||||
|
rtcp_ctx
|
||||||
|
.encrypt_init(Some(t), Some(&srtcp_session_key[..]), None)
|
||||||
|
.map_err(|e| Error::Other(e.to_string()))?;
|
||||||
|
|
||||||
|
Ok(Self {
|
||||||
|
inner,
|
||||||
|
rtp_ctx,
|
||||||
|
rtcp_ctx,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Cipher for CipherAesCmHmacSha1 {
|
||||||
|
fn auth_tag_len(&self) -> usize {
|
||||||
|
self.inner.auth_tag_len()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_rtcp_index(&self, input: &[u8]) -> usize {
|
||||||
|
self.inner.get_rtcp_index(input)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
plaintext: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let header_len = header.marshal_size();
|
||||||
|
let mut writer = Vec::with_capacity(plaintext.len() + self.auth_tag_len());
|
||||||
|
|
||||||
|
// Copy the header unencrypted.
|
||||||
|
writer.extend_from_slice(&plaintext[..header_len]);
|
||||||
|
|
||||||
|
// Encrypt the payload
|
||||||
|
let nonce = generate_counter(
|
||||||
|
header.sequence_number,
|
||||||
|
roc,
|
||||||
|
header.ssrc,
|
||||||
|
&self.inner.srtp_session_salt,
|
||||||
|
);
|
||||||
|
writer.resize(plaintext.len(), 0);
|
||||||
|
self.rtp_ctx.encrypt_init(None, None, Some(&nonce)).unwrap();
|
||||||
|
let count = self
|
||||||
|
.rtp_ctx
|
||||||
|
.cipher_update(&plaintext[header_len..], Some(&mut writer[header_len..]))
|
||||||
|
.unwrap();
|
||||||
|
self.rtp_ctx
|
||||||
|
.cipher_final(&mut writer[header_len + count..])
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
// Generate and write the auth tag.
|
||||||
|
let auth_tag = &self.inner.generate_srtp_auth_tag(&writer, roc)[..self.auth_tag_len()];
|
||||||
|
writer.extend_from_slice(auth_tag);
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
encrypted: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let encrypted_len = encrypted.len();
|
||||||
|
if encrypted_len < self.auth_tag_len() {
|
||||||
|
return Err(Error::SrtpTooSmall(encrypted_len, self.auth_tag_len()));
|
||||||
|
}
|
||||||
|
let header_len = header.marshal_size();
|
||||||
|
|
||||||
|
let mut writer = Vec::with_capacity(encrypted_len - self.auth_tag_len());
|
||||||
|
|
||||||
|
// Split the auth tag and the cipher text into two parts.
|
||||||
|
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
|
||||||
|
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
|
||||||
|
|
||||||
|
// Generate the auth tag we expect to see from the ciphertext.
|
||||||
|
let expected_tag =
|
||||||
|
&self.inner.generate_srtp_auth_tag(cipher_text, roc)[..self.auth_tag_len()];
|
||||||
|
|
||||||
|
// See if the auth tag actually matches.
|
||||||
|
// We use a constant time comparison to prevent timing attacks.
|
||||||
|
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
|
||||||
|
return Err(Error::RtpFailedToVerifyAuthTag);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write cipher_text to the destination buffer.
|
||||||
|
writer.extend_from_slice(&cipher_text[..header_len]);
|
||||||
|
|
||||||
|
// Decrypt the ciphertext for the payload.
|
||||||
|
let nonce = generate_counter(
|
||||||
|
header.sequence_number,
|
||||||
|
roc,
|
||||||
|
header.ssrc,
|
||||||
|
&self.inner.srtp_session_salt,
|
||||||
|
);
|
||||||
|
|
||||||
|
writer.resize(encrypted_len - self.auth_tag_len(), 0);
|
||||||
|
self.rtp_ctx.decrypt_init(None, None, Some(&nonce)).unwrap();
|
||||||
|
let count = self
|
||||||
|
.rtp_ctx
|
||||||
|
.cipher_update(&cipher_text[header_len..], Some(&mut writer[header_len..]))
|
||||||
|
.unwrap();
|
||||||
|
self.rtp_ctx
|
||||||
|
.cipher_final(&mut writer[header_len + count..])
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
|
||||||
|
let decrypted_len = decrypted.len();
|
||||||
|
|
||||||
|
let mut writer = Vec::with_capacity(decrypted_len + SRTCP_INDEX_SIZE + self.auth_tag_len());
|
||||||
|
|
||||||
|
// Write the decrypted to the destination buffer.
|
||||||
|
writer.extend_from_slice(&decrypted[..HEADER_LENGTH + SSRC_LENGTH]);
|
||||||
|
|
||||||
|
// Encrypt everything after header
|
||||||
|
let nonce = generate_counter(
|
||||||
|
(srtcp_index & 0xFFFF) as u16,
|
||||||
|
(srtcp_index >> 16) as u32,
|
||||||
|
ssrc,
|
||||||
|
&self.inner.srtcp_session_salt,
|
||||||
|
);
|
||||||
|
|
||||||
|
writer.resize(decrypted_len, 0);
|
||||||
|
self.rtcp_ctx
|
||||||
|
.encrypt_init(None, None, Some(&nonce))
|
||||||
|
.unwrap();
|
||||||
|
let count = self
|
||||||
|
.rtcp_ctx
|
||||||
|
.cipher_update(
|
||||||
|
&decrypted[HEADER_LENGTH + SSRC_LENGTH..],
|
||||||
|
Some(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
self.rtcp_ctx
|
||||||
|
.cipher_final(&mut writer[HEADER_LENGTH + SSRC_LENGTH + count..])
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
// Add SRTCP index and set Encryption bit
|
||||||
|
writer.put_u32(srtcp_index as u32 | (1u32 << 31));
|
||||||
|
|
||||||
|
// Generate the auth tag.
|
||||||
|
let auth_tag = &self.inner.generate_srtcp_auth_tag(&writer)[..self.auth_tag_len()];
|
||||||
|
writer.extend(auth_tag);
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
|
||||||
|
let encrypted_len = encrypted.len();
|
||||||
|
|
||||||
|
if encrypted_len < self.auth_tag_len() + SRTCP_INDEX_SIZE {
|
||||||
|
return Err(Error::SrtcpTooSmall(
|
||||||
|
encrypted_len,
|
||||||
|
self.auth_tag_len() + SRTCP_INDEX_SIZE,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
let tail_offset = encrypted_len - (self.auth_tag_len() + SRTCP_INDEX_SIZE);
|
||||||
|
|
||||||
|
let mut writer = Vec::with_capacity(tail_offset);
|
||||||
|
|
||||||
|
writer.extend_from_slice(&encrypted[..HEADER_LENGTH + SSRC_LENGTH]);
|
||||||
|
|
||||||
|
let is_encrypted = encrypted[tail_offset] >> 7;
|
||||||
|
if is_encrypted == 0 {
|
||||||
|
return Ok(Bytes::from(writer));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Split the auth tag and the cipher text into two parts.
|
||||||
|
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
|
||||||
|
if actual_tag.len() != self.auth_tag_len() {
|
||||||
|
return Err(Error::RtcpInvalidLengthAuthTag(
|
||||||
|
actual_tag.len(),
|
||||||
|
self.auth_tag_len(),
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
|
||||||
|
|
||||||
|
// Generate the auth tag we expect to see from the ciphertext.
|
||||||
|
let expected_tag = &self.inner.generate_srtcp_auth_tag(cipher_text)[..self.auth_tag_len()];
|
||||||
|
|
||||||
|
// See if the auth tag actually matches.
|
||||||
|
// We use a constant time comparison to prevent timing attacks.
|
||||||
|
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
|
||||||
|
return Err(Error::RtcpFailedToVerifyAuthTag);
|
||||||
|
}
|
||||||
|
|
||||||
|
let nonce = generate_counter(
|
||||||
|
(srtcp_index & 0xFFFF) as u16,
|
||||||
|
(srtcp_index >> 16) as u32,
|
||||||
|
ssrc,
|
||||||
|
&self.inner.srtcp_session_salt,
|
||||||
|
);
|
||||||
|
|
||||||
|
writer.resize(tail_offset, 0);
|
||||||
|
self.rtcp_ctx
|
||||||
|
.decrypt_init(None, None, Some(&nonce))
|
||||||
|
.unwrap();
|
||||||
|
let count = self
|
||||||
|
.rtcp_ctx
|
||||||
|
.cipher_update(
|
||||||
|
&encrypted[HEADER_LENGTH + SSRC_LENGTH..tail_offset],
|
||||||
|
Some(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
self.rtcp_ctx
|
||||||
|
.cipher_final(&mut writer[HEADER_LENGTH + SSRC_LENGTH + count..])
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
Ok(Bytes::from(writer))
|
||||||
|
}
|
||||||
|
}
|
||||||
Vendored
+61
@@ -0,0 +1,61 @@
|
|||||||
|
pub mod cipher_aead_aes_gcm;
|
||||||
|
pub mod cipher_aes_cm_hmac_sha1;
|
||||||
|
|
||||||
|
use bytes::Bytes;
|
||||||
|
|
||||||
|
use crate::error::Result;
|
||||||
|
|
||||||
|
///NOTE: Auth tag and AEAD auth tag are placed at the different position in SRTCP
|
||||||
|
///
|
||||||
|
///In non-AEAD cipher, the authentication tag is placed *after* the ESRTCP word
|
||||||
|
///(Encrypted-flag and SRTCP index).
|
||||||
|
///
|
||||||
|
///> AES_128_CM_HMAC_SHA1_80
|
||||||
|
///> | RTCP Header | Encrypted payload |E| SRTCP Index | Auth tag |
|
||||||
|
///> ^ |----------|
|
||||||
|
///> | ^
|
||||||
|
///> | authTagLen=10
|
||||||
|
///> aeadAuthTagLen=0
|
||||||
|
///
|
||||||
|
///In AEAD cipher, the AEAD authentication tag is embedded in the ciphertext.
|
||||||
|
///It is *before* the ESRTCP word (Encrypted-flag and SRTCP index).
|
||||||
|
///
|
||||||
|
///> AEAD_AES_128_GCM
|
||||||
|
///> | RTCP Header | Encrypted payload | AEAD auth tag |E| SRTCP Index |
|
||||||
|
///> |---------------| ^
|
||||||
|
///> ^ authTagLen=0
|
||||||
|
///> aeadAuthTagLen=16
|
||||||
|
///
|
||||||
|
///See https://tools.ietf.org/html/rfc7714 for the full specifications.
|
||||||
|
|
||||||
|
/// Cipher represents a implementation of one
|
||||||
|
/// of the SRTP Specific ciphers.
|
||||||
|
pub(crate) trait Cipher {
|
||||||
|
/// Get authenticated tag length.
|
||||||
|
fn auth_tag_len(&self) -> usize;
|
||||||
|
|
||||||
|
/// Retrieved RTCP index.
|
||||||
|
fn get_rtcp_index(&self, input: &[u8]) -> usize;
|
||||||
|
|
||||||
|
/// Encrypt RTP payload.
|
||||||
|
fn encrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
payload: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes>;
|
||||||
|
|
||||||
|
/// Decrypt RTP payload.
|
||||||
|
fn decrypt_rtp(
|
||||||
|
&mut self,
|
||||||
|
payload: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
roc: u32,
|
||||||
|
) -> Result<Bytes>;
|
||||||
|
|
||||||
|
/// Encrypt RTCP payload.
|
||||||
|
fn encrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes>;
|
||||||
|
|
||||||
|
/// Decrypt RTCP payload.
|
||||||
|
fn decrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes>;
|
||||||
|
}
|
||||||
Vendored
+83
@@ -0,0 +1,83 @@
|
|||||||
|
use util::KeyingMaterialExporter;
|
||||||
|
|
||||||
|
use crate::error::Result;
|
||||||
|
use crate::option::*;
|
||||||
|
use crate::protection_profile::*;
|
||||||
|
|
||||||
|
const LABEL_EXTRACTOR_DTLS_SRTP: &str = "EXTRACTOR-dtls_srtp";
|
||||||
|
|
||||||
|
/// SessionKeys bundles the keys required to setup an SRTP session
|
||||||
|
#[derive(Default, Debug, Clone)]
|
||||||
|
pub struct SessionKeys {
|
||||||
|
pub local_master_key: Vec<u8>,
|
||||||
|
pub local_master_salt: Vec<u8>,
|
||||||
|
pub remote_master_key: Vec<u8>,
|
||||||
|
pub remote_master_salt: Vec<u8>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Config is used to configure a session.
|
||||||
|
/// You can provide either a KeyingMaterialExporter to export keys
|
||||||
|
/// or directly pass the keys themselves.
|
||||||
|
/// After a Config is passed to a session it must not be modified.
|
||||||
|
#[derive(Default)]
|
||||||
|
pub struct Config {
|
||||||
|
pub keys: SessionKeys,
|
||||||
|
pub profile: ProtectionProfile,
|
||||||
|
//LoggerFactory: logging.LoggerFactory
|
||||||
|
/// List of local/remote context options.
|
||||||
|
/// ReplayProtection is enabled on remote context by default.
|
||||||
|
/// Default replay protection window size is 64.
|
||||||
|
pub local_rtp_options: Option<ContextOption>,
|
||||||
|
pub remote_rtp_options: Option<ContextOption>,
|
||||||
|
|
||||||
|
pub local_rtcp_options: Option<ContextOption>,
|
||||||
|
pub remote_rtcp_options: Option<ContextOption>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Config {
|
||||||
|
/// ExtractSessionKeysFromDTLS allows setting the Config SessionKeys by
|
||||||
|
/// extracting them from DTLS. This behavior is defined in RFC5764:
|
||||||
|
/// https://tools.ietf.org/html/rfc5764
|
||||||
|
pub async fn extract_session_keys_from_dtls(
|
||||||
|
&mut self,
|
||||||
|
exporter: impl KeyingMaterialExporter,
|
||||||
|
is_client: bool,
|
||||||
|
) -> Result<()> {
|
||||||
|
let key_len = self.profile.key_len();
|
||||||
|
let salt_len = self.profile.salt_len();
|
||||||
|
|
||||||
|
let keying_material = exporter
|
||||||
|
.export_keying_material(
|
||||||
|
LABEL_EXTRACTOR_DTLS_SRTP,
|
||||||
|
&[],
|
||||||
|
(key_len * 2) + (salt_len * 2),
|
||||||
|
)
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
let mut offset = 0;
|
||||||
|
let client_write_key = keying_material[offset..offset + key_len].to_vec();
|
||||||
|
offset += key_len;
|
||||||
|
|
||||||
|
let server_write_key = keying_material[offset..offset + key_len].to_vec();
|
||||||
|
offset += key_len;
|
||||||
|
|
||||||
|
let client_write_salt = keying_material[offset..offset + salt_len].to_vec();
|
||||||
|
offset += salt_len;
|
||||||
|
|
||||||
|
let server_write_salt = keying_material[offset..offset + salt_len].to_vec();
|
||||||
|
|
||||||
|
if is_client {
|
||||||
|
self.keys.local_master_key = client_write_key;
|
||||||
|
self.keys.local_master_salt = client_write_salt;
|
||||||
|
self.keys.remote_master_key = server_write_key;
|
||||||
|
self.keys.remote_master_salt = server_write_salt;
|
||||||
|
} else {
|
||||||
|
self.keys.local_master_key = server_write_key;
|
||||||
|
self.keys.local_master_salt = server_write_salt;
|
||||||
|
self.keys.remote_master_key = client_write_key;
|
||||||
|
self.keys.remote_master_salt = client_write_salt;
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
+341
@@ -0,0 +1,341 @@
|
|||||||
|
use bytes::Bytes;
|
||||||
|
use lazy_static::lazy_static;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::key_derivation::*;
|
||||||
|
|
||||||
|
const CIPHER_CONTEXT_ALGO: ProtectionProfile = ProtectionProfile::Aes128CmHmacSha1_80;
|
||||||
|
const DEFAULT_SSRC: u32 = 0;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_context_roc() -> Result<()> {
|
||||||
|
let key_len = CIPHER_CONTEXT_ALGO.key_len();
|
||||||
|
let salt_len = CIPHER_CONTEXT_ALGO.salt_len();
|
||||||
|
|
||||||
|
let mut c = Context::new(
|
||||||
|
&vec![0; key_len],
|
||||||
|
&vec![0; salt_len],
|
||||||
|
CIPHER_CONTEXT_ALGO,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let roc = c.get_roc(123);
|
||||||
|
assert!(roc.is_none(), "ROC must return None for unused SSRC");
|
||||||
|
|
||||||
|
c.set_roc(123, 100);
|
||||||
|
let roc = c.get_roc(123);
|
||||||
|
if let Some(r) = roc {
|
||||||
|
assert_eq!(r, 100, "ROC is set to 100, but returned {r}")
|
||||||
|
} else {
|
||||||
|
panic!("ROC must return value for used SSRC");
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_context_index() -> Result<()> {
|
||||||
|
let key_len = CIPHER_CONTEXT_ALGO.key_len();
|
||||||
|
let salt_len = CIPHER_CONTEXT_ALGO.salt_len();
|
||||||
|
|
||||||
|
let mut c = Context::new(
|
||||||
|
&vec![0; key_len],
|
||||||
|
&vec![0; salt_len],
|
||||||
|
CIPHER_CONTEXT_ALGO,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let index = c.get_index(123);
|
||||||
|
assert!(index.is_none(), "Index must return None for unused SSRC");
|
||||||
|
|
||||||
|
c.set_index(123, 100);
|
||||||
|
let index = c.get_index(123);
|
||||||
|
if let Some(i) = index {
|
||||||
|
assert_eq!(i, 100, "Index is set to 100, but returned {i}");
|
||||||
|
} else {
|
||||||
|
panic!("Index must return true for used SSRC")
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_key_len() -> Result<()> {
|
||||||
|
let key_len = CIPHER_CONTEXT_ALGO.key_len();
|
||||||
|
let salt_len = CIPHER_CONTEXT_ALGO.salt_len();
|
||||||
|
|
||||||
|
let result = Context::new(&[], &vec![0; salt_len], CIPHER_CONTEXT_ALGO, None, None);
|
||||||
|
assert!(result.is_err(), "CreateContext accepted a 0 length key");
|
||||||
|
|
||||||
|
let result = Context::new(&vec![0; key_len], &[], CIPHER_CONTEXT_ALGO, None, None);
|
||||||
|
assert!(result.is_err(), "CreateContext accepted a 0 length salt");
|
||||||
|
|
||||||
|
let result = Context::new(
|
||||||
|
&vec![0; key_len],
|
||||||
|
&vec![0; salt_len],
|
||||||
|
CIPHER_CONTEXT_ALGO,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
result.is_ok(),
|
||||||
|
"CreateContext failed with a valid length key and salt"
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_valid_packet_counter() -> Result<()> {
|
||||||
|
let master_key = vec![
|
||||||
|
0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28,
|
||||||
|
0x89,
|
||||||
|
];
|
||||||
|
let master_salt = vec![
|
||||||
|
0x62, 0x77, 0x60, 0x38, 0xc0, 0x6d, 0xc9, 0x41, 0x9f, 0x6d, 0xd9, 0x43, 0x3e, 0x7c,
|
||||||
|
];
|
||||||
|
|
||||||
|
let srtp_session_salt = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_SALT,
|
||||||
|
&master_key,
|
||||||
|
&master_salt,
|
||||||
|
0,
|
||||||
|
master_salt.len(),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let s = SrtpSsrcState {
|
||||||
|
ssrc: 4160032510,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
let expected_counter = [
|
||||||
|
0xcf, 0x90, 0x1e, 0xa5, 0xda, 0xd3, 0x2c, 0x15, 0x00, 0xa2, 0x24, 0xae, 0xae, 0xaf, 0x00,
|
||||||
|
0x00,
|
||||||
|
];
|
||||||
|
let counter = generate_counter(32846, s.rollover_counter, s.ssrc, &srtp_session_salt);
|
||||||
|
assert_eq!(
|
||||||
|
counter, expected_counter,
|
||||||
|
"Session Key {counter:?} does not match expected {expected_counter:?}",
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rollover_count() -> Result<()> {
|
||||||
|
let mut s = SrtpSsrcState {
|
||||||
|
ssrc: DEFAULT_SSRC,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
|
||||||
|
// Set initial seqnum
|
||||||
|
let roc = s.next_rollover_count(65530);
|
||||||
|
assert_eq!(roc, 0, "Initial rolloverCounter must be 0");
|
||||||
|
s.update_rollover_count(65530);
|
||||||
|
|
||||||
|
// Invalid packets never update ROC
|
||||||
|
s.next_rollover_count(0);
|
||||||
|
s.next_rollover_count(0x4000);
|
||||||
|
s.next_rollover_count(0x8000);
|
||||||
|
s.next_rollover_count(0xFFFF);
|
||||||
|
s.next_rollover_count(0);
|
||||||
|
|
||||||
|
// We rolled over to 0
|
||||||
|
let roc = s.next_rollover_count(0);
|
||||||
|
assert_eq!(roc, 1, "rolloverCounter was not updated after it crossed 0");
|
||||||
|
s.update_rollover_count(0);
|
||||||
|
|
||||||
|
let roc = s.next_rollover_count(65530);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 0,
|
||||||
|
"rolloverCounter was not updated when it rolled back, failed to handle out of order"
|
||||||
|
);
|
||||||
|
s.update_rollover_count(65530);
|
||||||
|
|
||||||
|
let roc = s.next_rollover_count(5);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 1,
|
||||||
|
"rolloverCounter was not updated when it rolled over initial, to handle out of order"
|
||||||
|
);
|
||||||
|
s.update_rollover_count(5);
|
||||||
|
|
||||||
|
s.next_rollover_count(6);
|
||||||
|
s.update_rollover_count(6);
|
||||||
|
|
||||||
|
s.next_rollover_count(7);
|
||||||
|
s.update_rollover_count(7);
|
||||||
|
|
||||||
|
let roc = s.next_rollover_count(8);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 1,
|
||||||
|
"rolloverCounter was improperly updated for non-significant packets"
|
||||||
|
);
|
||||||
|
s.update_rollover_count(8);
|
||||||
|
|
||||||
|
// valid packets never update ROC
|
||||||
|
let roc = s.next_rollover_count(0x4000);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 1,
|
||||||
|
"rolloverCounter was improperly updated for non-significant packets"
|
||||||
|
);
|
||||||
|
s.update_rollover_count(0x4000);
|
||||||
|
|
||||||
|
let roc = s.next_rollover_count(0x8000);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 1,
|
||||||
|
"rolloverCounter was improperly updated for non-significant packets"
|
||||||
|
);
|
||||||
|
s.update_rollover_count(0x8000);
|
||||||
|
|
||||||
|
let roc = s.next_rollover_count(0xFFFF);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 1,
|
||||||
|
"rolloverCounter was improperly updated for non-significant packets"
|
||||||
|
);
|
||||||
|
s.update_rollover_count(0xFFFF);
|
||||||
|
|
||||||
|
let roc = s.next_rollover_count(0);
|
||||||
|
assert_eq!(
|
||||||
|
roc, 2,
|
||||||
|
"rolloverCounter must be incremented after wrapping, got {roc}"
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
lazy_static! {
|
||||||
|
static ref MASTER_KEY: Bytes = Bytes::from_static(&[
|
||||||
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
|
||||||
|
0x0f,
|
||||||
|
]);
|
||||||
|
static ref MASTER_SALT: Bytes = Bytes::from_static(&[
|
||||||
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab,
|
||||||
|
]);
|
||||||
|
static ref DECRYPTED_RTP_PACKET: Bytes = Bytes::from_static(&[
|
||||||
|
0x80, 0x0f, 0x12, 0x34, 0xde, 0xca, 0xfb, 0xad, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab,
|
||||||
|
0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
|
||||||
|
]);
|
||||||
|
static ref ENCRYPTED_RTP_PACKET: Bytes = Bytes::from_static(&[
|
||||||
|
0x80, 0x0f, 0x12, 0x34, 0xde, 0xca, 0xfb, 0xad, 0xca, 0xfe, 0xba, 0xbe, 0xc5, 0x00, 0x2e,
|
||||||
|
0xde, 0x04, 0xcf, 0xdd, 0x2e, 0xb9, 0x11, 0x59, 0xe0, 0x88, 0x0a, 0xa0, 0x6e, 0xd2, 0x97,
|
||||||
|
0x68, 0x26, 0xf7, 0x96, 0xb2, 0x01, 0xdf, 0x31, 0x31, 0xa1, 0x27, 0xe8, 0xa3, 0x92,
|
||||||
|
]);
|
||||||
|
static ref DECRYPTED_RTCP_PACKET: Bytes = Bytes::from_static(&[
|
||||||
|
0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
|
||||||
|
0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
|
||||||
|
]);
|
||||||
|
static ref ENCRYPTED_RTCP_PACKET: Bytes = Bytes::from_static(&[
|
||||||
|
0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xc9, 0x8b, 0x8b, 0x5d, 0xf0, 0x39, 0x2a,
|
||||||
|
0x55, 0x85, 0x2b, 0x6c, 0x21, 0xac, 0x8e, 0x70, 0x25, 0xc5, 0x2c, 0x6f, 0xbe, 0xa2, 0xb3,
|
||||||
|
0xb4, 0x46, 0xea, 0x31, 0x12, 0x3b, 0xa8, 0x8c, 0xe6, 0x1e, 0x80, 0x00, 0x00, 0x01,
|
||||||
|
]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_encrypt_rtp() {
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
&MASTER_KEY,
|
||||||
|
&MASTER_SALT,
|
||||||
|
ProtectionProfile::AeadAes128Gcm,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.expect("Error creating srtp context");
|
||||||
|
|
||||||
|
let gotten_encrypted_rtp_packet = ctx
|
||||||
|
.encrypt_rtp(&DECRYPTED_RTP_PACKET)
|
||||||
|
.expect("Error encrypting rtp payload");
|
||||||
|
|
||||||
|
assert_eq!(gotten_encrypted_rtp_packet, *ENCRYPTED_RTP_PACKET)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_decrypt_rtp() {
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
&MASTER_KEY,
|
||||||
|
&MASTER_SALT,
|
||||||
|
ProtectionProfile::AeadAes128Gcm,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.expect("Error creating srtp context");
|
||||||
|
|
||||||
|
let gotten_decrypted_rtp_packet = ctx
|
||||||
|
.decrypt_rtp(&ENCRYPTED_RTP_PACKET)
|
||||||
|
.expect("Error decrypting rtp payload");
|
||||||
|
|
||||||
|
assert_eq!(gotten_decrypted_rtp_packet, *DECRYPTED_RTP_PACKET)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_encrypt_rtcp() {
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
&MASTER_KEY,
|
||||||
|
&MASTER_SALT,
|
||||||
|
ProtectionProfile::AeadAes128Gcm,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.expect("Error creating srtp context");
|
||||||
|
|
||||||
|
let gotten_encrypted_rtcp_packet = ctx
|
||||||
|
.encrypt_rtcp(&DECRYPTED_RTCP_PACKET)
|
||||||
|
.expect("Error encrypting rtcp payload");
|
||||||
|
|
||||||
|
assert_eq!(gotten_encrypted_rtcp_packet, *ENCRYPTED_RTCP_PACKET)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_decrypt_rtcp() {
|
||||||
|
let mut ctx = Context::new(
|
||||||
|
&MASTER_KEY,
|
||||||
|
&MASTER_SALT,
|
||||||
|
ProtectionProfile::AeadAes128Gcm,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.expect("Error creating srtp context");
|
||||||
|
|
||||||
|
let gotten_decrypted_rtcp_packet = ctx
|
||||||
|
.decrypt_rtcp(&ENCRYPTED_RTCP_PACKET)
|
||||||
|
.expect("Error decrypting rtcp payload");
|
||||||
|
|
||||||
|
assert_eq!(gotten_decrypted_rtcp_packet, *DECRYPTED_RTCP_PACKET)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rollover_high_water_mark() {
|
||||||
|
let mut state = super::SrtpSsrcState::default();
|
||||||
|
for seq in [65000, 65535, 85] {
|
||||||
|
state.update_rollover_count(seq);
|
||||||
|
}
|
||||||
|
for seq in [65000, 65530, 84, 0] {
|
||||||
|
state.update_rollover_count(seq);
|
||||||
|
assert_eq!(state.rollover_counter, 1);
|
||||||
|
assert_eq!(state.last_sequence_number, 85);
|
||||||
|
}
|
||||||
|
assert_eq!(state.next_rollover_count(86), 1);
|
||||||
|
state.update_rollover_count(1000);
|
||||||
|
state.update_rollover_count(32000);
|
||||||
|
state.update_rollover_count(64000);
|
||||||
|
assert_eq!(state.next_rollover_count(1000), 2);
|
||||||
|
state.update_rollover_count(1000);
|
||||||
|
assert_eq!(state.rollover_counter, 2);
|
||||||
|
assert_eq!(state.last_sequence_number, 1000);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rollover_initial_zero_and_counter_wrap() {
|
||||||
|
let mut state = super::SrtpSsrcState::default();
|
||||||
|
state.update_rollover_count(0);
|
||||||
|
assert_eq!(state.next_rollover_count(65535), u32::MAX);
|
||||||
|
state.update_rollover_count(65535);
|
||||||
|
assert_eq!(state.rollover_counter, 0);
|
||||||
|
assert_eq!(state.last_sequence_number, 0);
|
||||||
|
state.rollover_counter = u32::MAX;
|
||||||
|
state.last_sequence_number = 65535;
|
||||||
|
state.update_rollover_count(0);
|
||||||
|
assert_eq!(state.rollover_counter, 0);
|
||||||
|
assert_eq!(state.last_sequence_number, 0);
|
||||||
|
}
|
||||||
+177
@@ -0,0 +1,177 @@
|
|||||||
|
#[cfg(test)]
|
||||||
|
mod context_test;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod rollover_regression_test;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod srtcp_test;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod srtp_test;
|
||||||
|
|
||||||
|
use std::collections::HashMap;
|
||||||
|
|
||||||
|
use util::replay_detector::*;
|
||||||
|
|
||||||
|
use crate::cipher::cipher_aead_aes_gcm::*;
|
||||||
|
use crate::cipher::cipher_aes_cm_hmac_sha1::*;
|
||||||
|
use crate::cipher::*;
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
use crate::option::*;
|
||||||
|
use crate::protection_profile::*;
|
||||||
|
|
||||||
|
pub mod srtcp;
|
||||||
|
pub mod srtp;
|
||||||
|
|
||||||
|
const SEQUENCE_HALF_RANGE: i32 = 1 << 15;
|
||||||
|
|
||||||
|
/// Encrypt/Decrypt state for a single SRTP SSRC
|
||||||
|
#[derive(Default)]
|
||||||
|
pub(crate) struct SrtpSsrcState {
|
||||||
|
ssrc: u32,
|
||||||
|
rollover_counter: u32,
|
||||||
|
rollover_has_processed: bool,
|
||||||
|
last_sequence_number: u16,
|
||||||
|
replay_detector: Option<Box<dyn ReplayDetector + Send + 'static>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Encrypt/Decrypt state for a single SRTCP SSRC
|
||||||
|
#[derive(Default)]
|
||||||
|
pub(crate) struct SrtcpSsrcState {
|
||||||
|
srtcp_index: usize,
|
||||||
|
ssrc: u32,
|
||||||
|
replay_detector: Option<Box<dyn ReplayDetector + Send + 'static>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SrtpSsrcState {
|
||||||
|
pub fn next_rollover_count(&self, sequence_number: u16) -> u32 {
|
||||||
|
let roc = self.rollover_counter;
|
||||||
|
if !self.rollover_has_processed {
|
||||||
|
return roc;
|
||||||
|
}
|
||||||
|
// RFC 3711 Appendix A: estimate the index nearest the highest packet.
|
||||||
|
let last = i32::from(self.last_sequence_number);
|
||||||
|
let seq = i32::from(sequence_number);
|
||||||
|
if last < SEQUENCE_HALF_RANGE {
|
||||||
|
if seq - last > SEQUENCE_HALF_RANGE {
|
||||||
|
return roc.wrapping_sub(1);
|
||||||
|
}
|
||||||
|
} else if last - SEQUENCE_HALF_RANGE > seq {
|
||||||
|
return roc.wrapping_add(1);
|
||||||
|
}
|
||||||
|
roc
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn update_rollover_count(&mut self, sequence_number: u16) {
|
||||||
|
let roc = self.next_rollover_count(sequence_number);
|
||||||
|
// Retransmissions must never move the highest authenticated index back.
|
||||||
|
if !self.rollover_has_processed
|
||||||
|
|| (roc == self.rollover_counter && sequence_number > self.last_sequence_number)
|
||||||
|
|| roc == self.rollover_counter.wrapping_add(1)
|
||||||
|
{
|
||||||
|
self.rollover_counter = roc;
|
||||||
|
self.last_sequence_number = sequence_number;
|
||||||
|
self.rollover_has_processed = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Context represents a SRTP cryptographic context
|
||||||
|
/// Context can only be used for one-way operations
|
||||||
|
/// it must either used ONLY for encryption or ONLY for decryption
|
||||||
|
pub struct Context {
|
||||||
|
cipher: Box<dyn Cipher + Send>,
|
||||||
|
|
||||||
|
srtp_ssrc_states: HashMap<u32, SrtpSsrcState>,
|
||||||
|
srtcp_ssrc_states: HashMap<u32, SrtcpSsrcState>,
|
||||||
|
|
||||||
|
new_srtp_replay_detector: ContextOption,
|
||||||
|
new_srtcp_replay_detector: ContextOption,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Context {
|
||||||
|
/// CreateContext creates a new SRTP Context
|
||||||
|
pub fn new(
|
||||||
|
master_key: &[u8],
|
||||||
|
master_salt: &[u8],
|
||||||
|
profile: ProtectionProfile,
|
||||||
|
srtp_ctx_opt: Option<ContextOption>,
|
||||||
|
srtcp_ctx_opt: Option<ContextOption>,
|
||||||
|
) -> Result<Context> {
|
||||||
|
let key_len = profile.key_len();
|
||||||
|
let salt_len = profile.salt_len();
|
||||||
|
|
||||||
|
if master_key.len() != key_len {
|
||||||
|
return Err(Error::SrtpMasterKeyLength(key_len, master_key.len()));
|
||||||
|
} else if master_salt.len() != salt_len {
|
||||||
|
return Err(Error::SrtpSaltLength(salt_len, master_salt.len()));
|
||||||
|
}
|
||||||
|
|
||||||
|
let cipher: Box<dyn Cipher + Send> = match profile {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 => {
|
||||||
|
Box::new(CipherAesCmHmacSha1::new(master_key, master_salt)?)
|
||||||
|
}
|
||||||
|
|
||||||
|
ProtectionProfile::AeadAes128Gcm => {
|
||||||
|
Box::new(CipherAeadAesGcm::new(master_key, master_salt)?)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let srtp_ctx_opt = if let Some(ctx_opt) = srtp_ctx_opt {
|
||||||
|
ctx_opt
|
||||||
|
} else {
|
||||||
|
srtp_no_replay_protection()
|
||||||
|
};
|
||||||
|
|
||||||
|
let srtcp_ctx_opt = if let Some(ctx_opt) = srtcp_ctx_opt {
|
||||||
|
ctx_opt
|
||||||
|
} else {
|
||||||
|
srtcp_no_replay_protection()
|
||||||
|
};
|
||||||
|
|
||||||
|
Ok(Context {
|
||||||
|
cipher,
|
||||||
|
srtp_ssrc_states: HashMap::new(),
|
||||||
|
srtcp_ssrc_states: HashMap::new(),
|
||||||
|
new_srtp_replay_detector: srtp_ctx_opt,
|
||||||
|
new_srtcp_replay_detector: srtcp_ctx_opt,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_srtp_ssrc_state(&mut self, ssrc: u32) -> &mut SrtpSsrcState {
|
||||||
|
let s = SrtpSsrcState {
|
||||||
|
ssrc,
|
||||||
|
replay_detector: Some((self.new_srtp_replay_detector)()),
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
|
||||||
|
self.srtp_ssrc_states.entry(ssrc).or_insert(s)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_srtcp_ssrc_state(&mut self, ssrc: u32) -> &mut SrtcpSsrcState {
|
||||||
|
let s = SrtcpSsrcState {
|
||||||
|
ssrc,
|
||||||
|
replay_detector: Some((self.new_srtcp_replay_detector)()),
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
self.srtcp_ssrc_states.entry(ssrc).or_insert(s)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// roc returns SRTP rollover counter value of specified SSRC.
|
||||||
|
fn get_roc(&self, ssrc: u32) -> Option<u32> {
|
||||||
|
self.srtp_ssrc_states.get(&ssrc).map(|s| s.rollover_counter)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// set_roc sets SRTP rollover counter value of specified SSRC.
|
||||||
|
fn set_roc(&mut self, ssrc: u32, roc: u32) {
|
||||||
|
self.get_srtp_ssrc_state(ssrc).rollover_counter = roc;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// index returns SRTCP index value of specified SSRC.
|
||||||
|
fn get_index(&self, ssrc: u32) -> Option<usize> {
|
||||||
|
self.srtcp_ssrc_states.get(&ssrc).map(|s| s.srtcp_index)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// set_index sets SRTCP index value of specified SSRC.
|
||||||
|
fn set_index(&mut self, ssrc: u32, index: usize) {
|
||||||
|
self.get_srtcp_ssrc_state(ssrc).srtcp_index = index;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,73 @@
|
|||||||
|
use crate::{context::Context, protection_profile::ProtectionProfile};
|
||||||
|
fn packet(seq: u16) -> (Vec<u8>, rtp::header::Header) {
|
||||||
|
let h = rtp::header::Header {
|
||||||
|
version: 2,
|
||||||
|
sequence_number: seq,
|
||||||
|
ssrc: 1,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
let mut b = vec![0x80, 96];
|
||||||
|
b.extend(seq.to_be_bytes());
|
||||||
|
b.extend(0u32.to_be_bytes());
|
||||||
|
b.extend(1u32.to_be_bytes());
|
||||||
|
b.extend([1, 2, 3, 4]);
|
||||||
|
(b, h)
|
||||||
|
}
|
||||||
|
fn run(profile: ProtectionProfile, retransmits: bool) -> usize {
|
||||||
|
let mut tx = Context::new(
|
||||||
|
&vec![0; 16],
|
||||||
|
&vec![
|
||||||
|
0;
|
||||||
|
match profile {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 => 14,
|
||||||
|
_ => 12,
|
||||||
|
}
|
||||||
|
],
|
||||||
|
profile,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let mut rx = Context::new(
|
||||||
|
&vec![0; 16],
|
||||||
|
&vec![
|
||||||
|
0;
|
||||||
|
match profile {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 => 14,
|
||||||
|
_ => 12,
|
||||||
|
}
|
||||||
|
],
|
||||||
|
profile,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
for seq in (65000u16..=65535).chain(0..=85) {
|
||||||
|
let (b, h) = packet(seq);
|
||||||
|
let e = tx.encrypt_rtp_with_header(&b, &h).unwrap();
|
||||||
|
rx.decrypt_rtp(&e).unwrap();
|
||||||
|
}
|
||||||
|
if retransmits {
|
||||||
|
for seq in [65000, 65530] {
|
||||||
|
let (b, h) = packet(seq);
|
||||||
|
let _ = tx.encrypt_rtp_with_header(&b, &h).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut failures = 0;
|
||||||
|
for seq in 86..=1000 {
|
||||||
|
let (b, h) = packet(seq);
|
||||||
|
let e = tx.encrypt_rtp_with_header(&b, &h).unwrap();
|
||||||
|
failures += usize::from(rx.decrypt_rtp(&e).is_err());
|
||||||
|
}
|
||||||
|
failures
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn delayed_retransmissions_preserve_authentication() {
|
||||||
|
for profile in [
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
ProtectionProfile::AeadAes128Gcm,
|
||||||
|
] {
|
||||||
|
assert_eq!(run(profile, false), 0);
|
||||||
|
assert_eq!(run(profile, true), 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
+50
@@ -0,0 +1,50 @@
|
|||||||
|
use bytes::Bytes;
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::error::Result;
|
||||||
|
|
||||||
|
impl Context {
|
||||||
|
/// DecryptRTCP decrypts a RTCP packet with an encrypted payload
|
||||||
|
pub fn decrypt_rtcp(&mut self, encrypted: &[u8]) -> Result<Bytes> {
|
||||||
|
let mut buf = encrypted;
|
||||||
|
rtcp::header::Header::unmarshal(&mut buf)?;
|
||||||
|
|
||||||
|
let index = self.cipher.get_rtcp_index(encrypted);
|
||||||
|
let ssrc = u32::from_be_bytes([encrypted[4], encrypted[5], encrypted[6], encrypted[7]]);
|
||||||
|
|
||||||
|
if let Some(replay_detector) = &mut self.get_srtcp_ssrc_state(ssrc).replay_detector {
|
||||||
|
if !replay_detector.check(index as u64) {
|
||||||
|
return Err(Error::SrtcpSsrcDuplicated(ssrc, index));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let dst = self.cipher.decrypt_rtcp(encrypted, index, ssrc)?;
|
||||||
|
|
||||||
|
if let Some(replay_detector) = &mut self.get_srtcp_ssrc_state(ssrc).replay_detector {
|
||||||
|
replay_detector.accept();
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(dst)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// EncryptRTCP marshals and encrypts an RTCP packet, writing to the dst buffer provided.
|
||||||
|
/// If the dst buffer does not have the capacity to hold `len(plaintext) + 14` bytes, a new one will be allocated and returned.
|
||||||
|
pub fn encrypt_rtcp(&mut self, decrypted: &[u8]) -> Result<Bytes> {
|
||||||
|
let mut buf = decrypted;
|
||||||
|
rtcp::header::Header::unmarshal(&mut buf)?;
|
||||||
|
|
||||||
|
let ssrc = u32::from_be_bytes([decrypted[4], decrypted[5], decrypted[6], decrypted[7]]);
|
||||||
|
|
||||||
|
let index = {
|
||||||
|
let state = self.get_srtcp_ssrc_state(ssrc);
|
||||||
|
state.srtcp_index += 1;
|
||||||
|
if state.srtcp_index > MAX_SRTCP_INDEX {
|
||||||
|
state.srtcp_index = 0;
|
||||||
|
}
|
||||||
|
state.srtcp_index
|
||||||
|
};
|
||||||
|
|
||||||
|
self.cipher.encrypt_rtcp(decrypted, index, ssrc)
|
||||||
|
}
|
||||||
|
}
|
||||||
+257
@@ -0,0 +1,257 @@
|
|||||||
|
use bytes::{Buf, Bytes, BytesMut};
|
||||||
|
use lazy_static::lazy_static;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::key_derivation::*;
|
||||||
|
|
||||||
|
pub struct RTCPTestCase {
|
||||||
|
ssrc: u32,
|
||||||
|
index: usize,
|
||||||
|
encrypted: Bytes,
|
||||||
|
decrypted: Bytes,
|
||||||
|
}
|
||||||
|
|
||||||
|
lazy_static! {
|
||||||
|
static ref RTCP_TEST_MASTER_KEY: Bytes = Bytes::from_static(&[
|
||||||
|
0xfd, 0xa6, 0x25, 0x95, 0xd7, 0xf6, 0x92, 0x6f, 0x7d, 0x9c, 0x02, 0x4c, 0xc9, 0x20, 0x9f,
|
||||||
|
0x34
|
||||||
|
]);
|
||||||
|
|
||||||
|
static ref RTCP_TEST_MASTER_SALT: Bytes = Bytes::from_static(&[
|
||||||
|
0xa9, 0x65, 0x19, 0x85, 0x54, 0x0b, 0x47, 0xbe, 0x2f, 0x27, 0xa8, 0xb8, 0x81, 0x23
|
||||||
|
]);
|
||||||
|
|
||||||
|
static ref RTCP_TEST_CASES: Vec<RTCPTestCase> = vec![
|
||||||
|
RTCPTestCase {
|
||||||
|
ssrc: 0x66ef91ff,
|
||||||
|
index: 0,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0xcd, 0x34, 0xc5, 0x78, 0xb2, 0x8b,
|
||||||
|
0xe1, 0x6b, 0xc5, 0x09, 0xd5, 0x77, 0xe4, 0xce, 0x5f, 0x20, 0x80, 0x21, 0xbd, 0x66,
|
||||||
|
0x74, 0x65, 0xe9, 0x5f, 0x49, 0xe5, 0xf5, 0xc0, 0x68, 0x4e, 0xe5, 0x6a, 0x78, 0x07,
|
||||||
|
0x75, 0x46, 0xed, 0x90, 0xf6, 0xdc, 0x9d, 0xef, 0x3b, 0xdf, 0xf2, 0x79, 0xa9, 0xd8,
|
||||||
|
0x80, 0x00, 0x00, 0x01, 0x60, 0xc0, 0xae, 0xb5, 0x6f, 0x40, 0x88, 0x0e, 0x28, 0xba
|
||||||
|
]),
|
||||||
|
decrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0xdf, 0x48, 0x80, 0xdd, 0x61, 0xa6,
|
||||||
|
0x2e, 0xd3, 0xd8, 0xbc, 0xde, 0xbe, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x16, 0x04,
|
||||||
|
0x81, 0xca, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0x01, 0x10, 0x52, 0x6e, 0x54, 0x35,
|
||||||
|
0x43, 0x6d, 0x4a, 0x68, 0x7a, 0x79, 0x65, 0x74, 0x41, 0x78, 0x77, 0x2b, 0x00, 0x00
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTCPTestCase{
|
||||||
|
ssrc: 0x11111111,
|
||||||
|
index: 0,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11,
|
||||||
|
0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46,
|
||||||
|
0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38,
|
||||||
|
0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad,
|
||||||
|
0x80, 0x00, 0x00, 0x01, 0x34, 0x3c, 0x2e, 0x83, 0x17, 0x13, 0x93, 0x69, 0xcf, 0xc0
|
||||||
|
]),
|
||||||
|
decrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0xdf, 0x48, 0x80, 0xdd, 0x61, 0xa6,
|
||||||
|
0x2e, 0xd3, 0xd8, 0xbc, 0xde, 0xbe, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x16, 0x04,
|
||||||
|
0x81, 0xca, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0x01, 0x10, 0x52, 0x6e, 0x54, 0x35,
|
||||||
|
0x43, 0x6d, 0x4a, 0x68, 0x7a, 0x79, 0x65, 0x74, 0x41, 0x78, 0x77, 0x2b, 0x00, 0x00
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTCPTestCase{
|
||||||
|
ssrc: 0x11111111,
|
||||||
|
index: 0x7ffffffe, // Upper boundary of index
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11,
|
||||||
|
0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46,
|
||||||
|
0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38,
|
||||||
|
0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad,
|
||||||
|
0xff, 0xff, 0xff, 0xff, 0x5a, 0x99, 0xce, 0xed, 0x9f, 0x2e, 0x4d, 0x9d, 0xfa, 0x97
|
||||||
|
]),
|
||||||
|
decrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x0, 0x6, 0x11, 0x11, 0x11, 0x11, 0x4, 0x99, 0x47, 0x53, 0xc4, 0x1e,
|
||||||
|
0xb9, 0xde, 0x52, 0xa3, 0x1d, 0x77, 0x2f, 0xff, 0xcc, 0x75, 0xbb, 0x6a, 0x29, 0xb8,
|
||||||
|
0x1, 0xb7, 0x2e, 0x4b, 0x4e, 0xcb, 0xa4, 0x81, 0x2d, 0x46, 0x4, 0x5e, 0x86, 0x90,
|
||||||
|
0x17, 0x4f, 0x4d, 0x78, 0x2f, 0x58, 0xb8, 0x67, 0x91, 0x89, 0xe3, 0x61, 0x1, 0x7d
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTCPTestCase{
|
||||||
|
ssrc: 0x11111111,
|
||||||
|
index: 0x7fffffff, // Will be wrapped to 0
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11,
|
||||||
|
0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46,
|
||||||
|
0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38,
|
||||||
|
0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad,
|
||||||
|
0x80, 0x00, 0x00, 0x00, 0x7d, 0x51, 0xf8, 0x0e, 0x56, 0x40, 0x72, 0x7b, 0x9e, 0x02
|
||||||
|
]),
|
||||||
|
decrypted: Bytes::from_static(&[
|
||||||
|
0x80, 0xc8, 0x0, 0x6, 0x11, 0x11, 0x11, 0x11, 0xda, 0xb5, 0xe0, 0x56, 0x9a, 0x4a,
|
||||||
|
0x74, 0xed, 0x8a, 0x54, 0xc, 0xcf, 0xd5, 0x9, 0xb1, 0x40, 0x1, 0x42, 0xc3, 0x9a,
|
||||||
|
0x76, 0x0, 0xa9, 0xd4, 0xf7, 0x29, 0x9e, 0x51, 0xfb, 0x3c, 0xc1, 0x74, 0x72, 0xf9,
|
||||||
|
0x52, 0xb1, 0x92, 0x31, 0xca, 0x22, 0xab, 0x3e, 0xc5, 0x5f, 0x83, 0x34, 0xf0, 0x28
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
];
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rtcp_lifecycle() -> Result<()> {
|
||||||
|
let mut encrypt_context = Context::new(
|
||||||
|
&RTCP_TEST_MASTER_KEY,
|
||||||
|
&RTCP_TEST_MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
let mut decrypt_context = Context::new(
|
||||||
|
&RTCP_TEST_MASTER_KEY,
|
||||||
|
&RTCP_TEST_MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
for test_case in &*RTCP_TEST_CASES {
|
||||||
|
let decrypt_result = decrypt_context.decrypt_rtcp(&test_case.encrypted)?;
|
||||||
|
assert_eq!(
|
||||||
|
decrypt_result, test_case.decrypted,
|
||||||
|
"RTCP failed to decrypt"
|
||||||
|
);
|
||||||
|
|
||||||
|
encrypt_context.set_index(test_case.ssrc, test_case.index);
|
||||||
|
let encrypt_result = encrypt_context.encrypt_rtcp(&test_case.decrypted)?;
|
||||||
|
assert_eq!(
|
||||||
|
encrypt_result, test_case.encrypted,
|
||||||
|
"RTCP failed to encrypt"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rtcp_invalid_auth_tag() -> Result<()> {
|
||||||
|
let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
|
||||||
|
|
||||||
|
let mut decrypt_context = Context::new(
|
||||||
|
&RTCP_TEST_MASTER_KEY,
|
||||||
|
&RTCP_TEST_MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let decrypt_result = decrypt_context.decrypt_rtcp(&RTCP_TEST_CASES[0].encrypted)?;
|
||||||
|
assert_eq!(
|
||||||
|
decrypt_result, RTCP_TEST_CASES[0].decrypted,
|
||||||
|
"RTCP failed to decrypt"
|
||||||
|
);
|
||||||
|
|
||||||
|
// Zero out auth tag
|
||||||
|
let mut rtcp_packet = BytesMut::new();
|
||||||
|
rtcp_packet.extend_from_slice(&RTCP_TEST_CASES[0].encrypted);
|
||||||
|
let rtcp_packet_len = rtcp_packet.len();
|
||||||
|
rtcp_packet[rtcp_packet_len - auth_tag_len..].copy_from_slice(&vec![0; auth_tag_len]);
|
||||||
|
let rtcp_packet = rtcp_packet.freeze();
|
||||||
|
let decrypt_result = decrypt_context.decrypt_rtcp(&rtcp_packet);
|
||||||
|
assert!(
|
||||||
|
decrypt_result.is_err(),
|
||||||
|
"Was able to decrypt RTCP packet with invalid Auth Tag"
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rtcp_replay_detector_separation() -> Result<()> {
|
||||||
|
let mut decrypt_context = Context::new(
|
||||||
|
&RTCP_TEST_MASTER_KEY,
|
||||||
|
&RTCP_TEST_MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
Some(srtcp_replay_protection(10)),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let rtcp_packet1 = RTCP_TEST_CASES[0].encrypted.clone();
|
||||||
|
let decrypt_result1 = decrypt_context.decrypt_rtcp(&rtcp_packet1)?;
|
||||||
|
assert_eq!(
|
||||||
|
decrypt_result1, RTCP_TEST_CASES[0].decrypted,
|
||||||
|
"RTCP failed to decrypt"
|
||||||
|
);
|
||||||
|
|
||||||
|
let rtcp_packet2 = RTCP_TEST_CASES[1].encrypted.clone();
|
||||||
|
let decrypt_result2 = decrypt_context.decrypt_rtcp(&rtcp_packet2)?;
|
||||||
|
assert_eq!(
|
||||||
|
decrypt_result2, RTCP_TEST_CASES[1].decrypted,
|
||||||
|
"RTCP failed to decrypt"
|
||||||
|
);
|
||||||
|
|
||||||
|
let result = decrypt_context.decrypt_rtcp(&rtcp_packet1);
|
||||||
|
assert!(
|
||||||
|
result.is_err(),
|
||||||
|
"Was able to decrypt duplicated RTCP packet"
|
||||||
|
);
|
||||||
|
|
||||||
|
let result = decrypt_context.decrypt_rtcp(&rtcp_packet2);
|
||||||
|
assert!(
|
||||||
|
result.is_err(),
|
||||||
|
"Was able to decrypt duplicated RTCP packet"
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_rtcp_index(encrypted: &Bytes, auth_tag_len: usize) -> u32 {
|
||||||
|
let tail_offset = encrypted.len() - (auth_tag_len + SRTCP_INDEX_SIZE);
|
||||||
|
let reader = &mut encrypted.slice(tail_offset..tail_offset + SRTCP_INDEX_SIZE);
|
||||||
|
//^(1 << 31)
|
||||||
|
reader.get_u32() & 0x7FFFFFFF
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_encrypt_rtcp_separation() -> Result<()> {
|
||||||
|
let mut encrypt_context = Context::new(
|
||||||
|
&RTCP_TEST_MASTER_KEY,
|
||||||
|
&RTCP_TEST_MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
|
||||||
|
|
||||||
|
let mut decrypt_context = Context::new(
|
||||||
|
&RTCP_TEST_MASTER_KEY,
|
||||||
|
&RTCP_TEST_MASTER_SALT,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
Some(srtcp_replay_protection(10)),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let inputs = vec![
|
||||||
|
RTCP_TEST_CASES[0].decrypted.clone(),
|
||||||
|
RTCP_TEST_CASES[1].decrypted.clone(),
|
||||||
|
RTCP_TEST_CASES[0].decrypted.clone(),
|
||||||
|
RTCP_TEST_CASES[1].decrypted.clone(),
|
||||||
|
];
|
||||||
|
let mut encrypted_rctps = vec![];
|
||||||
|
|
||||||
|
for input in &inputs {
|
||||||
|
let encrypted = encrypt_context.encrypt_rtcp(input)?;
|
||||||
|
encrypted_rctps.push(encrypted);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i, expected_index) in [1, 1, 2, 2].iter().enumerate() {
|
||||||
|
assert_eq!(
|
||||||
|
*expected_index,
|
||||||
|
get_rtcp_index(&encrypted_rctps[i], auth_tag_len),
|
||||||
|
"RTCP index does not match"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i, output) in encrypted_rctps.iter().enumerate() {
|
||||||
|
let decrypted = decrypt_context.decrypt_rtcp(output)?;
|
||||||
|
assert_eq!(inputs[i], decrypted);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
+70
@@ -0,0 +1,70 @@
|
|||||||
|
use bytes::Bytes;
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::error::Result;
|
||||||
|
|
||||||
|
impl Context {
|
||||||
|
pub fn decrypt_rtp_with_header(
|
||||||
|
&mut self,
|
||||||
|
encrypted: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let roc = {
|
||||||
|
let state = self.get_srtp_ssrc_state(header.ssrc);
|
||||||
|
if let Some(replay_detector) = &mut state.replay_detector {
|
||||||
|
if !replay_detector.check(header.sequence_number as u64) {
|
||||||
|
return Err(Error::SrtpSsrcDuplicated(
|
||||||
|
header.ssrc,
|
||||||
|
header.sequence_number,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
state.next_rollover_count(header.sequence_number)
|
||||||
|
};
|
||||||
|
|
||||||
|
let dst = self.cipher.decrypt_rtp(encrypted, header, roc)?;
|
||||||
|
{
|
||||||
|
let state = self.get_srtp_ssrc_state(header.ssrc);
|
||||||
|
if let Some(replay_detector) = &mut state.replay_detector {
|
||||||
|
replay_detector.accept();
|
||||||
|
}
|
||||||
|
state.update_rollover_count(header.sequence_number);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(dst)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// DecryptRTP decrypts a RTP packet with an encrypted payload
|
||||||
|
pub fn decrypt_rtp(&mut self, encrypted: &[u8]) -> Result<Bytes> {
|
||||||
|
let mut buf = encrypted;
|
||||||
|
let header = rtp::header::Header::unmarshal(&mut buf)?;
|
||||||
|
self.decrypt_rtp_with_header(encrypted, &header)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn encrypt_rtp_with_header(
|
||||||
|
&mut self,
|
||||||
|
payload: &[u8],
|
||||||
|
header: &rtp::header::Header,
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let roc = self
|
||||||
|
.get_srtp_ssrc_state(header.ssrc)
|
||||||
|
.next_rollover_count(header.sequence_number);
|
||||||
|
|
||||||
|
let dst = self.cipher.encrypt_rtp(payload, header, roc)?;
|
||||||
|
|
||||||
|
self.get_srtp_ssrc_state(header.ssrc)
|
||||||
|
.update_rollover_count(header.sequence_number);
|
||||||
|
|
||||||
|
Ok(dst)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// EncryptRTP marshals and encrypts an RTP packet, writing to the dst buffer provided.
|
||||||
|
/// If the dst buffer does not have the capacity to hold `len(plaintext) + 10` bytes, a new one will be allocated and returned.
|
||||||
|
pub fn encrypt_rtp(&mut self, plaintext: &[u8]) -> Result<Bytes> {
|
||||||
|
let mut buf = plaintext;
|
||||||
|
let header = rtp::header::Header::unmarshal(&mut buf)?;
|
||||||
|
self.encrypt_rtp_with_header(plaintext, &header)
|
||||||
|
}
|
||||||
|
}
|
||||||
+188
@@ -0,0 +1,188 @@
|
|||||||
|
use bytes::Bytes;
|
||||||
|
use lazy_static::lazy_static;
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
struct RTPTestCase {
|
||||||
|
sequence_number: u16,
|
||||||
|
encrypted: Bytes,
|
||||||
|
}
|
||||||
|
|
||||||
|
lazy_static! {
|
||||||
|
static ref RTP_TEST_CASE_DECRYPTED: Bytes = Bytes::from_static(&[0x00, 0x01, 0x02, 0x03, 0x04, 0x05]);
|
||||||
|
static ref RTP_TEST_CASES: Vec<RTPTestCase> = vec![
|
||||||
|
RTPTestCase {
|
||||||
|
sequence_number: 5000,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x6d, 0xd3, 0x7e, 0xd5, 0x99, 0xb7, 0x2d, 0x28, 0xb1, 0xf3, 0xa1, 0xf0, 0xc, 0xfb,
|
||||||
|
0xfd, 0x8
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTPTestCase {
|
||||||
|
sequence_number: 5001,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0xda, 0x47, 0xb, 0x2a, 0x74, 0x53, 0x65, 0xbd, 0x2f, 0xeb, 0xdc, 0x4b, 0x6d, 0x23,
|
||||||
|
0xf3, 0xde
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTPTestCase {
|
||||||
|
sequence_number: 5002,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x6e, 0xa7, 0x69, 0x8d, 0x24, 0x6d, 0xdc, 0xbf, 0xec, 0x2, 0x1c, 0xd1, 0x60, 0x76,
|
||||||
|
0xc1, 0x0e
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTPTestCase {
|
||||||
|
sequence_number: 5003,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x24, 0x7e, 0x96, 0xc8, 0x7d, 0x33, 0xa2, 0x92, 0x8d, 0x13, 0x8d, 0xe0, 0x76, 0x9f,
|
||||||
|
0x08, 0xdc
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTPTestCase {
|
||||||
|
sequence_number: 5004,
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0x75, 0x43, 0x28, 0xe4, 0x3a, 0x77, 0x59, 0x9b, 0x2e, 0xdf, 0x7b, 0x12, 0x68, 0x0b,
|
||||||
|
0x57, 0x49
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
RTPTestCase{
|
||||||
|
sequence_number: 65535, // upper boundary
|
||||||
|
encrypted: Bytes::from_static(&[
|
||||||
|
0xaf, 0xf7, 0xc2, 0x70, 0x37, 0x20, 0x83, 0x9c, 0x2c, 0x63, 0x85, 0x15, 0x0e, 0x44,
|
||||||
|
0xca, 0x36
|
||||||
|
]),
|
||||||
|
},
|
||||||
|
];
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build_test_context() -> Result<Context> {
|
||||||
|
let master_key = Bytes::from_static(&[
|
||||||
|
0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28,
|
||||||
|
0x89,
|
||||||
|
]);
|
||||||
|
let master_salt = Bytes::from_static(&[
|
||||||
|
0x62, 0x77, 0x60, 0x38, 0xc0, 0x6d, 0xc9, 0x41, 0x9f, 0x6d, 0xd9, 0x43, 0x3e, 0x7c,
|
||||||
|
]);
|
||||||
|
|
||||||
|
Context::new(
|
||||||
|
&master_key,
|
||||||
|
&master_salt,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rtp_invalid_auth() -> Result<()> {
|
||||||
|
let master_key = Bytes::from_static(&[
|
||||||
|
0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28,
|
||||||
|
0x89,
|
||||||
|
]);
|
||||||
|
let invalid_salt = Bytes::from_static(&[
|
||||||
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||||
|
]);
|
||||||
|
|
||||||
|
let mut encrypt_context = build_test_context()?;
|
||||||
|
let mut invalid_context = Context::new(
|
||||||
|
&master_key,
|
||||||
|
&invalid_salt,
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
for test_case in &*RTP_TEST_CASES {
|
||||||
|
let pkt = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
sequence_number: test_case.sequence_number,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: RTP_TEST_CASE_DECRYPTED.clone(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let pkt_raw = pkt.marshal()?;
|
||||||
|
let out = encrypt_context.encrypt_rtp(&pkt_raw)?;
|
||||||
|
|
||||||
|
let result = invalid_context.decrypt_rtp(&out);
|
||||||
|
assert!(
|
||||||
|
result.is_err(),
|
||||||
|
"Managed to decrypt with incorrect salt for packet with SeqNum: {}",
|
||||||
|
test_case.sequence_number
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_rtp_lifecycle() -> Result<()> {
|
||||||
|
let mut encrypt_context = build_test_context()?;
|
||||||
|
let mut decrypt_context = build_test_context()?;
|
||||||
|
let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
|
||||||
|
|
||||||
|
for test_case in RTP_TEST_CASES.iter() {
|
||||||
|
// Keep consecutive indices within RFC 3711's half-sequence-space window.
|
||||||
|
// The known-answer vector at 65535 still uses ROC 0, as before.
|
||||||
|
if test_case.sequence_number == 65535 {
|
||||||
|
for sequence_number in [32000, 64000] {
|
||||||
|
let bridge = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
sequence_number,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: RTP_TEST_CASE_DECRYPTED.clone(),
|
||||||
|
}
|
||||||
|
.marshal()?;
|
||||||
|
let encrypted = encrypt_context.encrypt_rtp(&bridge)?;
|
||||||
|
assert_eq!(decrypt_context.decrypt_rtp(&encrypted)?, bridge);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let decrypted_pkt = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
sequence_number: test_case.sequence_number,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: RTP_TEST_CASE_DECRYPTED.clone(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let decrypted_raw = decrypted_pkt.marshal()?;
|
||||||
|
|
||||||
|
let encrypted_pkt = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
sequence_number: test_case.sequence_number,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: test_case.encrypted.clone(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let encrypted_raw = encrypted_pkt.marshal()?;
|
||||||
|
let actual_encrypted = encrypt_context.encrypt_rtp(&decrypted_raw)?;
|
||||||
|
assert_eq!(
|
||||||
|
actual_encrypted, encrypted_raw,
|
||||||
|
"RTP packet with SeqNum invalid encryption: {}",
|
||||||
|
test_case.sequence_number
|
||||||
|
);
|
||||||
|
|
||||||
|
let actual_decrypted = decrypt_context.decrypt_rtp(&encrypted_raw)?;
|
||||||
|
assert_ne!(
|
||||||
|
encrypted_raw[..encrypted_raw.len() - auth_tag_len].to_vec(),
|
||||||
|
actual_decrypted,
|
||||||
|
"DecryptRTP improperly encrypted in place"
|
||||||
|
);
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
actual_decrypted, decrypted_raw,
|
||||||
|
"RTP packet with SeqNum invalid decryption: {}",
|
||||||
|
test_case.sequence_number,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
//TODO: BenchmarkEncryptRTP
|
||||||
|
//TODO: BenchmarkEncryptRTPInPlace
|
||||||
|
//TODO: BenchmarkDecryptRTP
|
||||||
Vendored
+120
@@ -0,0 +1,120 @@
|
|||||||
|
use std::io;
|
||||||
|
|
||||||
|
use thiserror::Error;
|
||||||
|
use tokio::sync::mpsc::error::SendError as MpscSendError;
|
||||||
|
|
||||||
|
pub type Result<T> = std::result::Result<T, Error>;
|
||||||
|
|
||||||
|
#[derive(Error, Debug, PartialEq)]
|
||||||
|
#[non_exhaustive]
|
||||||
|
pub enum Error {
|
||||||
|
#[error("duplicated packet")]
|
||||||
|
ErrDuplicated,
|
||||||
|
#[error("SRTP master key is not long enough")]
|
||||||
|
ErrShortSrtpMasterKey,
|
||||||
|
#[error("SRTP master salt is not long enough")]
|
||||||
|
ErrShortSrtpMasterSalt,
|
||||||
|
#[error("no such SRTP Profile")]
|
||||||
|
ErrNoSuchSrtpProfile,
|
||||||
|
#[error("indexOverKdr > 0 is not supported yet")]
|
||||||
|
ErrNonZeroKdrNotSupported,
|
||||||
|
#[error("exporter called with wrong label")]
|
||||||
|
ErrExporterWrongLabel,
|
||||||
|
#[error("no config provided")]
|
||||||
|
ErrNoConfig,
|
||||||
|
#[error("no conn provided")]
|
||||||
|
ErrNoConn,
|
||||||
|
#[error("failed to verify auth tag")]
|
||||||
|
ErrFailedToVerifyAuthTag,
|
||||||
|
#[error("packet is too short to be rtcp packet")]
|
||||||
|
ErrTooShortRtcp,
|
||||||
|
#[error("payload differs")]
|
||||||
|
ErrPayloadDiffers,
|
||||||
|
#[error("started channel used incorrectly, should only be closed")]
|
||||||
|
ErrStartedChannelUsedIncorrectly,
|
||||||
|
#[error("stream has not been inited, unable to close")]
|
||||||
|
ErrStreamNotInited,
|
||||||
|
#[error("stream is already closed")]
|
||||||
|
ErrStreamAlreadyClosed,
|
||||||
|
#[error("stream is already inited")]
|
||||||
|
ErrStreamAlreadyInited,
|
||||||
|
#[error("failed to cast child")]
|
||||||
|
ErrFailedTypeAssertion,
|
||||||
|
|
||||||
|
#[error("index_over_kdr > 0 is not supported yet")]
|
||||||
|
UnsupportedIndexOverKdr,
|
||||||
|
#[error("SRTP Master Key must be len {0}, got {1}")]
|
||||||
|
SrtpMasterKeyLength(usize, usize),
|
||||||
|
#[error("SRTP Salt must be len {0}, got {1}")]
|
||||||
|
SrtpSaltLength(usize, usize),
|
||||||
|
#[error("SyntaxError: {0}")]
|
||||||
|
ExtMapParse(String),
|
||||||
|
#[error("srtp ssrc={0} index={1}: duplicated")]
|
||||||
|
SrtpSsrcDuplicated(u32, u16),
|
||||||
|
#[error("srtcp ssrc={0} index={1}: duplicated")]
|
||||||
|
SrtcpSsrcDuplicated(u32, usize),
|
||||||
|
#[error("ssrc {0} not exist in srtcp_ssrc_state")]
|
||||||
|
SsrcMissingFromSrtcp(u32),
|
||||||
|
#[error("Stream with ssrc {0} exists")]
|
||||||
|
StreamWithSsrcExists(u32),
|
||||||
|
#[error("Session RTP/RTCP type must be same as input buffer")]
|
||||||
|
SessionRtpRtcpTypeMismatch,
|
||||||
|
#[error("Session EOF")]
|
||||||
|
SessionEof,
|
||||||
|
#[error("too short SRTP packet: only {0} bytes, expected > {1} bytes")]
|
||||||
|
SrtpTooSmall(usize, usize),
|
||||||
|
#[error("too short SRTCP packet: only {0} bytes, expected > {1} bytes")]
|
||||||
|
SrtcpTooSmall(usize, usize),
|
||||||
|
#[error("failed to verify rtp auth tag")]
|
||||||
|
RtpFailedToVerifyAuthTag,
|
||||||
|
#[error("too short auth tag: only {0} bytes, expected > {1} bytes")]
|
||||||
|
RtcpInvalidLengthAuthTag(usize, usize),
|
||||||
|
#[error("failed to verify rtcp auth tag")]
|
||||||
|
RtcpFailedToVerifyAuthTag,
|
||||||
|
#[error("SessionSRTP has been closed")]
|
||||||
|
SessionSrtpAlreadyClosed,
|
||||||
|
#[error("this stream is not a RTPStream")]
|
||||||
|
InvalidRtpStream,
|
||||||
|
#[error("this stream is not a RTCPStream")]
|
||||||
|
InvalidRtcpStream,
|
||||||
|
|
||||||
|
#[error("{0}")]
|
||||||
|
Io(#[source] IoError),
|
||||||
|
#[error("{0}")]
|
||||||
|
KeyingMaterial(#[from] util::KeyingMaterialExporterError),
|
||||||
|
#[error("mpsc send: {0}")]
|
||||||
|
MpscSend(String),
|
||||||
|
#[error("{0}")]
|
||||||
|
Util(#[from] util::Error),
|
||||||
|
#[error("{0}")]
|
||||||
|
Rtcp(#[from] rtcp::Error),
|
||||||
|
#[error("aes gcm: {0}")]
|
||||||
|
AesGcm(#[from] aes_gcm::Error),
|
||||||
|
|
||||||
|
#[error("{0}")]
|
||||||
|
Other(String),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Error)]
|
||||||
|
#[error("io error: {0}")]
|
||||||
|
pub struct IoError(#[from] pub io::Error);
|
||||||
|
|
||||||
|
// Workaround for wanting PartialEq for io::Error.
|
||||||
|
impl PartialEq for IoError {
|
||||||
|
fn eq(&self, other: &Self) -> bool {
|
||||||
|
self.0.kind() == other.0.kind()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<io::Error> for Error {
|
||||||
|
fn from(e: io::Error) -> Self {
|
||||||
|
Error::Io(IoError(e))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Because Tokio SendError is parameterized, we sadly lose the backtrace.
|
||||||
|
impl<T> From<MpscSendError<T>> for Error {
|
||||||
|
fn from(e: MpscSendError<T>) -> Self {
|
||||||
|
Error::MpscSend(e.to_string())
|
||||||
|
}
|
||||||
|
}
|
||||||
+173
@@ -0,0 +1,173 @@
|
|||||||
|
use aes::cipher::generic_array::GenericArray;
|
||||||
|
use aes::cipher::BlockEncrypt;
|
||||||
|
use aes::Aes128;
|
||||||
|
use aes_gcm::KeyInit;
|
||||||
|
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
|
||||||
|
pub const LABEL_SRTP_ENCRYPTION: u8 = 0x00;
|
||||||
|
pub const LABEL_SRTP_AUTHENTICATION_TAG: u8 = 0x01;
|
||||||
|
pub const LABEL_SRTP_SALT: u8 = 0x02;
|
||||||
|
pub const LABEL_SRTCP_ENCRYPTION: u8 = 0x03;
|
||||||
|
pub const LABEL_SRTCP_AUTHENTICATION_TAG: u8 = 0x04;
|
||||||
|
pub const LABEL_SRTCP_SALT: u8 = 0x05;
|
||||||
|
|
||||||
|
pub(crate) const SRTCP_INDEX_SIZE: usize = 4;
|
||||||
|
|
||||||
|
pub(crate) fn aes_cm_key_derivation(
|
||||||
|
label: u8,
|
||||||
|
master_key: &[u8],
|
||||||
|
master_salt: &[u8],
|
||||||
|
index_over_kdr: usize,
|
||||||
|
out_len: usize,
|
||||||
|
) -> Result<Vec<u8>> {
|
||||||
|
if index_over_kdr != 0 {
|
||||||
|
// 24-bit "index DIV kdr" must be xored to prf input.
|
||||||
|
return Err(Error::UnsupportedIndexOverKdr);
|
||||||
|
}
|
||||||
|
|
||||||
|
// https://tools.ietf.org/html/rfc3711#appendix-B.3
|
||||||
|
// The input block for AES-CM is generated by exclusive-oring the master salt with the
|
||||||
|
// concatenation of the encryption key label 0x00 with (index DIV kdr),
|
||||||
|
// - index is 'rollover count' and DIV is 'divided by'
|
||||||
|
|
||||||
|
let n_master_key = master_key.len();
|
||||||
|
let n_master_salt = master_salt.len();
|
||||||
|
|
||||||
|
let mut prf_in = vec![0u8; n_master_key];
|
||||||
|
prf_in[..n_master_salt].copy_from_slice(master_salt);
|
||||||
|
|
||||||
|
prf_in[7] ^= label;
|
||||||
|
|
||||||
|
//The resulting value is then AES encrypted using the master key to get the cipher key.
|
||||||
|
let key = GenericArray::from_slice(master_key);
|
||||||
|
let block = Aes128::new(key);
|
||||||
|
|
||||||
|
let mut out = vec![0u8; ((out_len + n_master_key) / n_master_key) * n_master_key];
|
||||||
|
for (i, n) in (0..out_len).step_by(n_master_key).enumerate() {
|
||||||
|
//BigEndian.PutUint16(prfIn[nMasterKey-2:], i)
|
||||||
|
prf_in[n_master_key - 2] = ((i >> 8) & 0xFF) as u8;
|
||||||
|
prf_in[n_master_key - 1] = (i & 0xFF) as u8;
|
||||||
|
|
||||||
|
out[n..n + n_master_key].copy_from_slice(&prf_in);
|
||||||
|
let out_key = GenericArray::from_mut_slice(&mut out[n..n + n_master_key]);
|
||||||
|
block.encrypt_block(out_key);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(out[..out_len].to_vec())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generate IV https://tools.ietf.org/html/rfc3711#section-4.1.1
|
||||||
|
/// where the 128-bit integer value IV SHALL be defined by the SSRC, the
|
||||||
|
/// SRTP packet index i, and the SRTP session salting key k_s, as below.
|
||||||
|
/// ROC = a 32-bit unsigned rollover counter (roc), which records how many
|
||||||
|
/// times the 16-bit RTP sequence number has been reset to zero after
|
||||||
|
/// passing through 65,535
|
||||||
|
/// ```nobuild
|
||||||
|
/// i = 2^16 * roc + SEQ
|
||||||
|
/// IV = (salt*2 ^ 16) | (ssrc*2 ^ 64) | (i*2 ^ 16)
|
||||||
|
/// ```
|
||||||
|
pub(crate) fn generate_counter(
|
||||||
|
sequence_number: u16,
|
||||||
|
rollover_counter: u32,
|
||||||
|
ssrc: u32,
|
||||||
|
session_salt: &[u8],
|
||||||
|
) -> [u8; 16] {
|
||||||
|
assert!(session_salt.len() <= 16);
|
||||||
|
|
||||||
|
let mut counter = [0; 16];
|
||||||
|
|
||||||
|
let ssrc_be = ssrc.to_be_bytes();
|
||||||
|
let rollover_be = rollover_counter.to_be_bytes();
|
||||||
|
let seq_be = ((sequence_number as u32) << 16).to_be_bytes();
|
||||||
|
|
||||||
|
counter[4..8].copy_from_slice(&ssrc_be);
|
||||||
|
counter[8..12].copy_from_slice(&rollover_be);
|
||||||
|
counter[12..16].copy_from_slice(&seq_be);
|
||||||
|
|
||||||
|
for i in 0..session_salt.len() {
|
||||||
|
counter[i] ^= session_salt[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
counter
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
use super::*;
|
||||||
|
use crate::protection_profile::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_valid_session_keys() -> Result<()> {
|
||||||
|
// Key Derivation Test Vectors from https://tools.ietf.org/html/rfc3711#appendix-B.3
|
||||||
|
let master_key = vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
];
|
||||||
|
let master_salt = vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
];
|
||||||
|
|
||||||
|
let expected_session_key = vec![
|
||||||
|
0xC6, 0x1E, 0x7A, 0x93, 0x74, 0x4F, 0x39, 0xEE, 0x10, 0x73, 0x4A, 0xFE, 0x3F, 0xF7,
|
||||||
|
0xA0, 0x87,
|
||||||
|
];
|
||||||
|
let expected_session_salt = vec![
|
||||||
|
0x30, 0xCB, 0xBC, 0x08, 0x86, 0x3D, 0x8C, 0x85, 0xD4, 0x9D, 0xB3, 0x4A, 0x9A, 0xE1,
|
||||||
|
];
|
||||||
|
let expected_session_auth_tag = vec![
|
||||||
|
0xCE, 0xBE, 0x32, 0x1F, 0x6F, 0xF7, 0x71, 0x6B, 0x6F, 0xD4, 0xAB, 0x49, 0xAF, 0x25,
|
||||||
|
0x6A, 0x15, 0x6D, 0x38, 0xBA, 0xA4,
|
||||||
|
];
|
||||||
|
|
||||||
|
let session_key = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_ENCRYPTION,
|
||||||
|
&master_key,
|
||||||
|
&master_salt,
|
||||||
|
0,
|
||||||
|
master_key.len(),
|
||||||
|
)?;
|
||||||
|
assert_eq!(
|
||||||
|
session_key, expected_session_key,
|
||||||
|
"Session Key:\n{session_key:?} \ndoes not match expected:\n{expected_session_key:?}\nMaster Key:\n{master_key:?}\nMaster Salt:\n{master_salt:?}\n",
|
||||||
|
);
|
||||||
|
|
||||||
|
let session_salt = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_SALT,
|
||||||
|
&master_key,
|
||||||
|
&master_salt,
|
||||||
|
0,
|
||||||
|
master_salt.len(),
|
||||||
|
)?;
|
||||||
|
assert_eq!(
|
||||||
|
session_salt, expected_session_salt,
|
||||||
|
"Session Salt {session_salt:?} does not match expected {expected_session_salt:?}"
|
||||||
|
);
|
||||||
|
|
||||||
|
let auth_key_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_key_len();
|
||||||
|
|
||||||
|
let session_auth_tag = aes_cm_key_derivation(
|
||||||
|
LABEL_SRTP_AUTHENTICATION_TAG,
|
||||||
|
&master_key,
|
||||||
|
&master_salt,
|
||||||
|
0,
|
||||||
|
auth_key_len,
|
||||||
|
)?;
|
||||||
|
assert_eq!(
|
||||||
|
session_auth_tag, expected_session_auth_tag,
|
||||||
|
"Session Auth Tag {session_auth_tag:?} does not match expected {expected_session_auth_tag:?}",
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
// This test asserts that calling aesCmKeyDerivation with a non-zero indexOverKdr fails
|
||||||
|
// Currently this isn't supported, but the API makes sure we can add this in the future
|
||||||
|
#[test]
|
||||||
|
fn test_index_over_kdr() -> Result<()> {
|
||||||
|
let result = aes_cm_key_derivation(LABEL_SRTP_AUTHENTICATION_TAG, &[], &[], 1, 0);
|
||||||
|
assert!(result.is_err());
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
Vendored
+14
@@ -0,0 +1,14 @@
|
|||||||
|
#![warn(rust_2018_idioms)]
|
||||||
|
#![allow(dead_code)]
|
||||||
|
|
||||||
|
mod cipher;
|
||||||
|
pub mod config;
|
||||||
|
pub mod context;
|
||||||
|
mod error;
|
||||||
|
mod key_derivation;
|
||||||
|
pub mod option;
|
||||||
|
pub mod protection_profile;
|
||||||
|
pub mod session;
|
||||||
|
pub mod stream;
|
||||||
|
|
||||||
|
pub use error::Error;
|
||||||
Vendored
+36
@@ -0,0 +1,36 @@
|
|||||||
|
use util::replay_detector::*;
|
||||||
|
|
||||||
|
pub type ContextOption = Box<dyn (Fn() -> Box<dyn ReplayDetector + Send + 'static>) + Send + Sync>;
|
||||||
|
|
||||||
|
pub(crate) const MAX_SEQUENCE_NUMBER: u16 = 65535;
|
||||||
|
pub(crate) const MAX_SRTCP_INDEX: usize = 0x7FFFFFFF;
|
||||||
|
|
||||||
|
/// srtp_replay_protection sets SRTP replay protection window size.
|
||||||
|
pub fn srtp_replay_protection(window_size: usize) -> ContextOption {
|
||||||
|
Box::new(move || -> Box<dyn ReplayDetector + Send> {
|
||||||
|
Box::new(WrappedSlidingWindowDetector::new(
|
||||||
|
window_size,
|
||||||
|
MAX_SEQUENCE_NUMBER as u64,
|
||||||
|
))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Sets SRTCP replay protection window size.
|
||||||
|
pub fn srtcp_replay_protection(window_size: usize) -> ContextOption {
|
||||||
|
Box::new(move || -> Box<dyn ReplayDetector + Send> {
|
||||||
|
Box::new(WrappedSlidingWindowDetector::new(
|
||||||
|
window_size,
|
||||||
|
MAX_SRTCP_INDEX as u64,
|
||||||
|
))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// srtp_no_replay_protection disables SRTP replay protection.
|
||||||
|
pub fn srtp_no_replay_protection() -> ContextOption {
|
||||||
|
Box::new(|| -> Box<dyn ReplayDetector + Send> { Box::<NoOpReplayDetector>::default() })
|
||||||
|
}
|
||||||
|
|
||||||
|
/// srtcp_no_replay_protection disables SRTCP replay protection.
|
||||||
|
pub fn srtcp_no_replay_protection() -> ContextOption {
|
||||||
|
Box::new(|| -> Box<dyn ReplayDetector + Send> { Box::<NoOpReplayDetector>::default() })
|
||||||
|
}
|
||||||
+37
@@ -0,0 +1,37 @@
|
|||||||
|
/// ProtectionProfile specifies Cipher and AuthTag details, similar to TLS cipher suite
|
||||||
|
#[derive(Default, Debug, Clone, Copy)]
|
||||||
|
#[repr(u8)]
|
||||||
|
pub enum ProtectionProfile {
|
||||||
|
#[default]
|
||||||
|
Aes128CmHmacSha1_80 = 0x0001,
|
||||||
|
AeadAes128Gcm = 0x0007,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ProtectionProfile {
|
||||||
|
pub(crate) fn key_len(&self) -> usize {
|
||||||
|
match *self {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 | ProtectionProfile::AeadAes128Gcm => 16,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn salt_len(&self) -> usize {
|
||||||
|
match *self {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 => 14,
|
||||||
|
ProtectionProfile::AeadAes128Gcm => 12,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn auth_tag_len(&self) -> usize {
|
||||||
|
match *self {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 => 10, //CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN,
|
||||||
|
ProtectionProfile::AeadAes128Gcm => 16, //CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn auth_key_len(&self) -> usize {
|
||||||
|
match *self {
|
||||||
|
ProtectionProfile::Aes128CmHmacSha1_80 => 20,
|
||||||
|
ProtectionProfile::AeadAes128Gcm => 0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
+271
@@ -0,0 +1,271 @@
|
|||||||
|
#[cfg(test)]
|
||||||
|
mod session_rtcp_test;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod session_rtp_test;
|
||||||
|
|
||||||
|
use std::collections::{HashMap, HashSet};
|
||||||
|
use std::marker::{Send, Sync};
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
use bytes::Bytes;
|
||||||
|
use tokio::sync::{mpsc, Mutex};
|
||||||
|
use util::conn::Conn;
|
||||||
|
use util::marshal::*;
|
||||||
|
|
||||||
|
use crate::config::*;
|
||||||
|
use crate::context::*;
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
use crate::option::*;
|
||||||
|
use crate::stream::*;
|
||||||
|
|
||||||
|
const DEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOW: usize = 64;
|
||||||
|
const DEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOW: usize = 64;
|
||||||
|
|
||||||
|
/// Session implements io.ReadWriteCloser and provides a bi-directional SRTP session
|
||||||
|
/// SRTP itself does not have a design like this, but it is common in most applications
|
||||||
|
/// for local/remote to each have their own keying material. This provides those patterns
|
||||||
|
/// instead of making everyone re-implement
|
||||||
|
pub struct Session {
|
||||||
|
local_context: Arc<Mutex<Context>>,
|
||||||
|
streams_map: Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
|
||||||
|
new_stream_rx: Arc<Mutex<mpsc::Receiver<Arc<Stream>>>>,
|
||||||
|
close_stream_tx: mpsc::Sender<u32>,
|
||||||
|
close_session_tx: mpsc::Sender<()>,
|
||||||
|
pub(crate) udp_tx: Arc<dyn Conn + Send + Sync>,
|
||||||
|
is_rtp: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Session {
|
||||||
|
pub async fn new(
|
||||||
|
conn: Arc<dyn Conn + Send + Sync>,
|
||||||
|
config: Config,
|
||||||
|
is_rtp: bool,
|
||||||
|
) -> Result<Self> {
|
||||||
|
let local_context = Context::new(
|
||||||
|
&config.keys.local_master_key,
|
||||||
|
&config.keys.local_master_salt,
|
||||||
|
config.profile,
|
||||||
|
config.local_rtp_options,
|
||||||
|
config.local_rtcp_options,
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let mut remote_context = Context::new(
|
||||||
|
&config.keys.remote_master_key,
|
||||||
|
&config.keys.remote_master_salt,
|
||||||
|
config.profile,
|
||||||
|
if config.remote_rtp_options.is_none() {
|
||||||
|
Some(srtp_replay_protection(
|
||||||
|
DEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOW,
|
||||||
|
))
|
||||||
|
} else {
|
||||||
|
config.remote_rtp_options
|
||||||
|
},
|
||||||
|
if config.remote_rtcp_options.is_none() {
|
||||||
|
Some(srtcp_replay_protection(
|
||||||
|
DEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOW,
|
||||||
|
))
|
||||||
|
} else {
|
||||||
|
config.remote_rtcp_options
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let streams_map = Arc::new(Mutex::new(HashMap::new()));
|
||||||
|
let (mut new_stream_tx, new_stream_rx) = mpsc::channel(8);
|
||||||
|
let (close_stream_tx, mut close_stream_rx) = mpsc::channel(8);
|
||||||
|
let (close_session_tx, mut close_session_rx) = mpsc::channel(8);
|
||||||
|
let udp_tx = Arc::clone(&conn);
|
||||||
|
let udp_rx = Arc::clone(&conn);
|
||||||
|
let cloned_streams_map = Arc::clone(&streams_map);
|
||||||
|
let cloned_close_stream_tx = close_stream_tx.clone();
|
||||||
|
|
||||||
|
tokio::spawn(async move {
|
||||||
|
let mut buf = vec![0u8; 8192];
|
||||||
|
|
||||||
|
loop {
|
||||||
|
let incoming_stream = Session::incoming(
|
||||||
|
&udp_rx,
|
||||||
|
&mut buf,
|
||||||
|
&cloned_streams_map,
|
||||||
|
&cloned_close_stream_tx,
|
||||||
|
&mut new_stream_tx,
|
||||||
|
&mut remote_context,
|
||||||
|
is_rtp,
|
||||||
|
);
|
||||||
|
let close_stream = close_stream_rx.recv();
|
||||||
|
let close_session = close_session_rx.recv();
|
||||||
|
|
||||||
|
tokio::select! {
|
||||||
|
result = incoming_stream => match result{
|
||||||
|
Ok(()) => {},
|
||||||
|
Err(err) => log::info!("{}", err),
|
||||||
|
},
|
||||||
|
opt = close_stream => if let Some(ssrc) = opt {
|
||||||
|
Session::close_stream(&cloned_streams_map, ssrc).await
|
||||||
|
},
|
||||||
|
_ = close_session => break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
Ok(Session {
|
||||||
|
local_context: Arc::new(Mutex::new(local_context)),
|
||||||
|
streams_map,
|
||||||
|
new_stream_rx: Arc::new(Mutex::new(new_stream_rx)),
|
||||||
|
close_stream_tx,
|
||||||
|
close_session_tx,
|
||||||
|
udp_tx,
|
||||||
|
is_rtp,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn close_stream(streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>, ssrc: u32) {
|
||||||
|
let mut streams = streams_map.lock().await;
|
||||||
|
streams.remove(&ssrc);
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn incoming(
|
||||||
|
udp_rx: &Arc<dyn Conn + Send + Sync>,
|
||||||
|
buf: &mut [u8],
|
||||||
|
streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
|
||||||
|
close_stream_tx: &mpsc::Sender<u32>,
|
||||||
|
new_stream_tx: &mut mpsc::Sender<Arc<Stream>>,
|
||||||
|
remote_context: &mut Context,
|
||||||
|
is_rtp: bool,
|
||||||
|
) -> Result<()> {
|
||||||
|
let n = udp_rx.recv(buf).await?;
|
||||||
|
if n == 0 {
|
||||||
|
return Err(Error::SessionEof);
|
||||||
|
}
|
||||||
|
|
||||||
|
let decrypted = if is_rtp {
|
||||||
|
remote_context.decrypt_rtp(&buf[0..n])?
|
||||||
|
} else {
|
||||||
|
remote_context.decrypt_rtcp(&buf[0..n])?
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut buf = &decrypted[..];
|
||||||
|
let ssrcs = if is_rtp {
|
||||||
|
vec![rtp::header::Header::unmarshal(&mut buf)?.ssrc]
|
||||||
|
} else {
|
||||||
|
let pkts = rtcp::packet::unmarshal(&mut buf)?;
|
||||||
|
destination_ssrc(&pkts)
|
||||||
|
};
|
||||||
|
|
||||||
|
for ssrc in ssrcs {
|
||||||
|
let (stream, is_new) =
|
||||||
|
Session::get_or_create_stream(streams_map, close_stream_tx.clone(), is_rtp, ssrc)
|
||||||
|
.await;
|
||||||
|
if is_new {
|
||||||
|
log::trace!(
|
||||||
|
"srtp session got new {} stream {}",
|
||||||
|
if is_rtp { "rtp" } else { "rtcp" },
|
||||||
|
ssrc
|
||||||
|
);
|
||||||
|
new_stream_tx.send(Arc::clone(&stream)).await?;
|
||||||
|
}
|
||||||
|
|
||||||
|
match stream.buffer.write(&decrypted).await {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(err) => {
|
||||||
|
// Silently drop data when the buffer is full.
|
||||||
|
if util::Error::ErrBufferFull != err {
|
||||||
|
return Err(err.into());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn get_or_create_stream(
|
||||||
|
streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
|
||||||
|
close_stream_tx: mpsc::Sender<u32>,
|
||||||
|
is_rtp: bool,
|
||||||
|
ssrc: u32,
|
||||||
|
) -> (Arc<Stream>, bool) {
|
||||||
|
let mut streams = streams_map.lock().await;
|
||||||
|
|
||||||
|
if let Some(stream) = streams.get(&ssrc) {
|
||||||
|
(Arc::clone(stream), false)
|
||||||
|
} else {
|
||||||
|
let stream = Arc::new(Stream::new(ssrc, close_stream_tx, is_rtp));
|
||||||
|
streams.insert(ssrc, Arc::clone(&stream));
|
||||||
|
(stream, true)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// open on the given SSRC to create a stream, it can be used
|
||||||
|
/// if you want a certain SSRC, but don't want to wait for Accept
|
||||||
|
pub async fn open(&self, ssrc: u32) -> Arc<Stream> {
|
||||||
|
let (stream, _) = Session::get_or_create_stream(
|
||||||
|
&self.streams_map,
|
||||||
|
self.close_stream_tx.clone(),
|
||||||
|
self.is_rtp,
|
||||||
|
ssrc,
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
|
||||||
|
stream
|
||||||
|
}
|
||||||
|
|
||||||
|
/// accept returns a stream to handle RTCP for a single SSRC
|
||||||
|
pub async fn accept(&self) -> Result<Arc<Stream>> {
|
||||||
|
let mut new_stream_rx = self.new_stream_rx.lock().await;
|
||||||
|
let result = new_stream_rx.recv().await;
|
||||||
|
if let Some(stream) = result {
|
||||||
|
Ok(stream)
|
||||||
|
} else {
|
||||||
|
Err(Error::SessionSrtpAlreadyClosed)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn close(&self) -> Result<()> {
|
||||||
|
self.close_session_tx.send(()).await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn write(&self, buf: &Bytes, is_rtp: bool) -> Result<usize> {
|
||||||
|
if self.is_rtp != is_rtp {
|
||||||
|
return Err(Error::SessionRtpRtcpTypeMismatch);
|
||||||
|
}
|
||||||
|
|
||||||
|
let encrypted = {
|
||||||
|
let mut local_context = self.local_context.lock().await;
|
||||||
|
|
||||||
|
if is_rtp {
|
||||||
|
local_context.encrypt_rtp(buf)?
|
||||||
|
} else {
|
||||||
|
local_context.encrypt_rtcp(buf)?
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
Ok(self.udp_tx.send(&encrypted).await?)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn write_rtp(&self, pkt: &rtp::packet::Packet) -> Result<usize> {
|
||||||
|
let raw = pkt.marshal()?;
|
||||||
|
self.write(&raw, true).await
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn write_rtcp(
|
||||||
|
&self,
|
||||||
|
pkt: &(dyn rtcp::packet::Packet + Send + Sync),
|
||||||
|
) -> Result<usize> {
|
||||||
|
let raw = pkt.marshal()?;
|
||||||
|
self.write(&raw, false).await
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// create a list of Destination SSRCs
|
||||||
|
/// that's a superset of all Destinations in the slice.
|
||||||
|
fn destination_ssrc(pkts: &[Box<dyn rtcp::packet::Packet + Send + Sync>]) -> Vec<u32> {
|
||||||
|
let mut ssrc_set = HashSet::new();
|
||||||
|
for p in pkts {
|
||||||
|
for ssrc in p.destination_ssrc() {
|
||||||
|
ssrc_set.insert(ssrc);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ssrc_set.into_iter().collect()
|
||||||
|
}
|
||||||
+239
@@ -0,0 +1,239 @@
|
|||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
use bytes::{Bytes, BytesMut};
|
||||||
|
use rtcp::payload_feedbacks::*;
|
||||||
|
use tokio::sync::{mpsc, Mutex};
|
||||||
|
use util::conn::conn_pipe::*;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::error::Result;
|
||||||
|
use crate::protection_profile::*;
|
||||||
|
|
||||||
|
async fn build_session_srtcp_pair() -> Result<(Session, Session)> {
|
||||||
|
let (ua, ub) = pipe();
|
||||||
|
|
||||||
|
let ca = Config {
|
||||||
|
profile: ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
keys: SessionKeys {
|
||||||
|
local_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
local_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
remote_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
remote_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
},
|
||||||
|
|
||||||
|
local_rtp_options: None,
|
||||||
|
remote_rtp_options: None,
|
||||||
|
|
||||||
|
local_rtcp_options: None,
|
||||||
|
remote_rtcp_options: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let cb = Config {
|
||||||
|
profile: ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
keys: SessionKeys {
|
||||||
|
local_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
local_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
remote_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
remote_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
},
|
||||||
|
|
||||||
|
local_rtp_options: None,
|
||||||
|
remote_rtp_options: None,
|
||||||
|
|
||||||
|
local_rtcp_options: None,
|
||||||
|
remote_rtcp_options: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let sa = Session::new(Arc::new(ua), ca, false).await?;
|
||||||
|
let sb = Session::new(Arc::new(ub), cb, false).await?;
|
||||||
|
|
||||||
|
Ok((sa, sb))
|
||||||
|
}
|
||||||
|
|
||||||
|
const TEST_SSRC: u32 = 5000;
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtcp_accept() -> Result<()> {
|
||||||
|
let (sa, sb) = build_session_srtcp_pair().await?;
|
||||||
|
|
||||||
|
let rtcp_packet = picture_loss_indication::PictureLossIndication {
|
||||||
|
media_ssrc: TEST_SSRC,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
|
||||||
|
let test_payload = rtcp_packet.marshal()?;
|
||||||
|
sa.write_rtcp(&rtcp_packet).await?;
|
||||||
|
|
||||||
|
let read_stream = sb.accept().await?;
|
||||||
|
let ssrc = read_stream.get_ssrc();
|
||||||
|
assert_eq!(
|
||||||
|
ssrc, TEST_SSRC,
|
||||||
|
"SSRC mismatch during accept exp({TEST_SSRC}) actual({ssrc})"
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(test_payload.len());
|
||||||
|
read_buffer.resize(test_payload.len(), 0u8);
|
||||||
|
read_stream.read(&mut read_buffer).await?;
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[..],
|
||||||
|
"Sent buffer does not match the one received exp({:?}) actual({:?})",
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[..]
|
||||||
|
);
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtcp_listen() -> Result<()> {
|
||||||
|
let (sa, sb) = build_session_srtcp_pair().await?;
|
||||||
|
|
||||||
|
let rtcp_packet = picture_loss_indication::PictureLossIndication {
|
||||||
|
media_ssrc: TEST_SSRC,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
|
||||||
|
let test_payload = rtcp_packet.marshal()?;
|
||||||
|
let read_stream = sb.open(TEST_SSRC).await;
|
||||||
|
|
||||||
|
sa.write_rtcp(&rtcp_packet).await?;
|
||||||
|
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(test_payload.len());
|
||||||
|
read_buffer.resize(test_payload.len(), 0u8);
|
||||||
|
read_stream.read(&mut read_buffer).await?;
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[..],
|
||||||
|
"Sent buffer does not match the one received exp({:?}) actual({:?})",
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[..]
|
||||||
|
);
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_srtcp(
|
||||||
|
context: &mut Context,
|
||||||
|
pkt: &(dyn rtcp::packet::Packet + Send + Sync),
|
||||||
|
) -> Result<Bytes> {
|
||||||
|
let decrypted = pkt.marshal()?;
|
||||||
|
let encrypted = context.encrypt_rtcp(&decrypted)?;
|
||||||
|
Ok(encrypted)
|
||||||
|
}
|
||||||
|
|
||||||
|
const PLI_PACKET_SIZE: usize = 8;
|
||||||
|
|
||||||
|
async fn get_sender_ssrc(read_stream: &Arc<Stream>) -> Result<u32> {
|
||||||
|
let auth_tag_size = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
|
||||||
|
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(PLI_PACKET_SIZE + auth_tag_size);
|
||||||
|
read_buffer.resize(PLI_PACKET_SIZE + auth_tag_size, 0u8);
|
||||||
|
|
||||||
|
let pkts = read_stream.read_rtcp(&mut read_buffer).await?;
|
||||||
|
let mut bytes = &pkts[0].marshal()?[..];
|
||||||
|
let pli = picture_loss_indication::PictureLossIndication::unmarshal(&mut bytes)?;
|
||||||
|
|
||||||
|
Ok(pli.sender_ssrc)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtcp_replay_protection() -> Result<()> {
|
||||||
|
let (sa, sb) = build_session_srtcp_pair().await?;
|
||||||
|
|
||||||
|
let read_stream = sb.open(TEST_SSRC).await;
|
||||||
|
|
||||||
|
// Generate test packets
|
||||||
|
let mut packets = vec![];
|
||||||
|
let mut expected_ssrc = vec![];
|
||||||
|
{
|
||||||
|
let mut local_context = sa.local_context.lock().await;
|
||||||
|
for i in 0..0x10u32 {
|
||||||
|
expected_ssrc.push(i);
|
||||||
|
|
||||||
|
let packet = picture_loss_indication::PictureLossIndication {
|
||||||
|
media_ssrc: TEST_SSRC,
|
||||||
|
sender_ssrc: i,
|
||||||
|
};
|
||||||
|
|
||||||
|
let encrypted = encrypt_srtcp(&mut local_context, &packet)?;
|
||||||
|
|
||||||
|
packets.push(encrypted);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let (done_tx, mut done_rx) = mpsc::channel::<()>(1);
|
||||||
|
|
||||||
|
let received_ssrc = Arc::new(Mutex::new(vec![]));
|
||||||
|
let cloned_received_ssrc = Arc::clone(&received_ssrc);
|
||||||
|
let count = expected_ssrc.len();
|
||||||
|
|
||||||
|
tokio::spawn(async move {
|
||||||
|
let mut i = 0;
|
||||||
|
while i < count {
|
||||||
|
match get_sender_ssrc(&read_stream).await {
|
||||||
|
Ok(ssrc) => {
|
||||||
|
let mut r = cloned_received_ssrc.lock().await;
|
||||||
|
r.push(ssrc);
|
||||||
|
|
||||||
|
i += 1;
|
||||||
|
}
|
||||||
|
Err(_) => break,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
drop(done_tx);
|
||||||
|
});
|
||||||
|
|
||||||
|
// Write with replay attack
|
||||||
|
for packet in &packets {
|
||||||
|
sa.udp_tx.send(packet).await?;
|
||||||
|
|
||||||
|
// Immediately replay
|
||||||
|
sa.udp_tx.send(packet).await?;
|
||||||
|
}
|
||||||
|
for packet in &packets {
|
||||||
|
// Delayed replay
|
||||||
|
sa.udp_tx.send(packet).await?;
|
||||||
|
}
|
||||||
|
|
||||||
|
done_rx.recv().await;
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
{
|
||||||
|
let received_ssrc = received_ssrc.lock().await;
|
||||||
|
assert_eq!(&expected_ssrc[..], &received_ssrc[..]);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
+308
@@ -0,0 +1,308 @@
|
|||||||
|
use std::collections::HashMap;
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
use bytes::{Bytes, BytesMut};
|
||||||
|
use tokio::net::UdpSocket;
|
||||||
|
use tokio::sync::{mpsc, Mutex};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use crate::error::Result;
|
||||||
|
use crate::protection_profile::*;
|
||||||
|
|
||||||
|
async fn build_session_srtp_pair() -> Result<(Session, Session)> {
|
||||||
|
let ua = UdpSocket::bind("127.0.0.1:0").await?;
|
||||||
|
let ub = UdpSocket::bind("127.0.0.1:0").await?;
|
||||||
|
|
||||||
|
ua.connect(ub.local_addr()?).await?;
|
||||||
|
ub.connect(ua.local_addr()?).await?;
|
||||||
|
|
||||||
|
let ca = Config {
|
||||||
|
profile: ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
keys: SessionKeys {
|
||||||
|
local_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
local_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
remote_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
remote_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
},
|
||||||
|
|
||||||
|
local_rtp_options: None,
|
||||||
|
remote_rtp_options: None,
|
||||||
|
|
||||||
|
local_rtcp_options: None,
|
||||||
|
remote_rtcp_options: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let cb = Config {
|
||||||
|
profile: ProtectionProfile::Aes128CmHmacSha1_80,
|
||||||
|
keys: SessionKeys {
|
||||||
|
local_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
local_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
remote_master_key: vec![
|
||||||
|
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
|
||||||
|
0x41, 0x39,
|
||||||
|
],
|
||||||
|
remote_master_salt: vec![
|
||||||
|
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
|
||||||
|
],
|
||||||
|
},
|
||||||
|
|
||||||
|
local_rtp_options: None,
|
||||||
|
remote_rtp_options: None,
|
||||||
|
|
||||||
|
local_rtcp_options: None,
|
||||||
|
remote_rtcp_options: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let sa = Session::new(Arc::new(ua), ca, true).await?;
|
||||||
|
let sb = Session::new(Arc::new(ub), cb, true).await?;
|
||||||
|
|
||||||
|
Ok((sa, sb))
|
||||||
|
}
|
||||||
|
|
||||||
|
const TEST_SSRC: u32 = 5000;
|
||||||
|
const RTP_HEADER_SIZE: usize = 12;
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtp_accept() -> Result<()> {
|
||||||
|
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len());
|
||||||
|
read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8);
|
||||||
|
let (sa, sb) = build_session_srtp_pair().await?;
|
||||||
|
|
||||||
|
let packet = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
ssrc: TEST_SSRC,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: test_payload.clone(),
|
||||||
|
};
|
||||||
|
sa.write_rtp(&packet).await?;
|
||||||
|
|
||||||
|
let read_stream = sb.accept().await?;
|
||||||
|
let ssrc = read_stream.get_ssrc();
|
||||||
|
assert_eq!(
|
||||||
|
ssrc, TEST_SSRC,
|
||||||
|
"SSRC mismatch during accept exp({TEST_SSRC}) actual({ssrc})"
|
||||||
|
);
|
||||||
|
|
||||||
|
read_stream.read(&mut read_buffer).await?;
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[RTP_HEADER_SIZE..],
|
||||||
|
"Sent buffer does not match the one received exp({:?}) actual({:?})",
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[RTP_HEADER_SIZE..]
|
||||||
|
);
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtp_listen() -> Result<()> {
|
||||||
|
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len());
|
||||||
|
read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8);
|
||||||
|
let (sa, sb) = build_session_srtp_pair().await?;
|
||||||
|
|
||||||
|
let packet = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
ssrc: TEST_SSRC,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: test_payload.clone(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let read_stream = sb.open(TEST_SSRC).await;
|
||||||
|
|
||||||
|
sa.write_rtp(&packet).await?;
|
||||||
|
|
||||||
|
read_stream.read(&mut read_buffer).await?;
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[RTP_HEADER_SIZE..],
|
||||||
|
"Sent buffer does not match the one received exp({:?}) actual({:?})",
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[RTP_HEADER_SIZE..]
|
||||||
|
);
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtp_multi_ssrc() -> Result<()> {
|
||||||
|
let ssrcs = vec![5000, 5001, 5002];
|
||||||
|
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len());
|
||||||
|
read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8);
|
||||||
|
let (sa, sb) = build_session_srtp_pair().await?;
|
||||||
|
|
||||||
|
let mut read_streams = HashMap::new();
|
||||||
|
for ssrc in &ssrcs {
|
||||||
|
let read_stream = sb.open(*ssrc).await;
|
||||||
|
read_streams.insert(*ssrc, read_stream);
|
||||||
|
}
|
||||||
|
|
||||||
|
for ssrc in &ssrcs {
|
||||||
|
let packet = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
ssrc: *ssrc,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: test_payload.clone(),
|
||||||
|
};
|
||||||
|
sa.write_rtp(&packet).await?;
|
||||||
|
|
||||||
|
if let Some(read_stream) = read_streams.get_mut(ssrc) {
|
||||||
|
read_stream.read(&mut read_buffer).await?;
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[RTP_HEADER_SIZE..],
|
||||||
|
"Sent buffer does not match the one received exp({:?}) actual({:?})",
|
||||||
|
&test_payload[..],
|
||||||
|
&read_buffer[RTP_HEADER_SIZE..]
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
panic!("ssrc {} not found", *ssrc);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn encrypt_srtp(context: &mut Context, pkt: &rtp::packet::Packet) -> Result<Bytes> {
|
||||||
|
let decrypted = pkt.marshal()?;
|
||||||
|
let encrypted = context.encrypt_rtp(&decrypted)?;
|
||||||
|
Ok(encrypted)
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn payload_srtp(
|
||||||
|
read_stream: &Arc<Stream>,
|
||||||
|
header_size: usize,
|
||||||
|
expected_payload: &[u8],
|
||||||
|
) -> Result<u16> {
|
||||||
|
let mut read_buffer = BytesMut::with_capacity(header_size + expected_payload.len());
|
||||||
|
read_buffer.resize(header_size + expected_payload.len(), 0u8);
|
||||||
|
|
||||||
|
let pkt = read_stream.read_rtp(&mut read_buffer).await?;
|
||||||
|
|
||||||
|
assert_eq!(
|
||||||
|
expected_payload,
|
||||||
|
&pkt.payload[..],
|
||||||
|
"Sent buffer does not match the one received exp({:?}) actual({:?})",
|
||||||
|
expected_payload,
|
||||||
|
&pkt.payload[..]
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(pkt.header.sequence_number)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::test]
|
||||||
|
async fn test_session_srtp_replay_protection() -> Result<()> {
|
||||||
|
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
|
||||||
|
|
||||||
|
let (sa, sb) = build_session_srtp_pair().await?;
|
||||||
|
|
||||||
|
let read_stream = sb.open(TEST_SSRC).await;
|
||||||
|
|
||||||
|
// Generate test packets
|
||||||
|
let mut packets = vec![];
|
||||||
|
let mut expected_sequence_number = vec![];
|
||||||
|
{
|
||||||
|
let mut local_context = sa.local_context.lock().await;
|
||||||
|
let mut i = 0xFFF0u16;
|
||||||
|
while i != 0x10 {
|
||||||
|
expected_sequence_number.push(i);
|
||||||
|
|
||||||
|
let packet = rtp::packet::Packet {
|
||||||
|
header: rtp::header::Header {
|
||||||
|
ssrc: TEST_SSRC,
|
||||||
|
sequence_number: i,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
payload: test_payload.clone(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let encrypted = encrypt_srtp(&mut local_context, &packet)?;
|
||||||
|
|
||||||
|
packets.push(encrypted);
|
||||||
|
|
||||||
|
if i == 0xFFFF {
|
||||||
|
i = 0;
|
||||||
|
} else {
|
||||||
|
i += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let (done_tx, mut done_rx) = mpsc::channel::<()>(1);
|
||||||
|
|
||||||
|
let received_sequence_number = Arc::new(Mutex::new(vec![]));
|
||||||
|
let cloned_received_sequence_number = Arc::clone(&received_sequence_number);
|
||||||
|
let count = expected_sequence_number.len();
|
||||||
|
|
||||||
|
tokio::spawn(async move {
|
||||||
|
let mut i = 0;
|
||||||
|
while i < count {
|
||||||
|
let seq = payload_srtp(&read_stream, RTP_HEADER_SIZE, &test_payload)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
let mut r = cloned_received_sequence_number.lock().await;
|
||||||
|
r.push(seq);
|
||||||
|
|
||||||
|
i += 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
drop(done_tx);
|
||||||
|
});
|
||||||
|
|
||||||
|
// Write with replay attack
|
||||||
|
for packet in &packets {
|
||||||
|
sa.udp_tx.send(packet).await?;
|
||||||
|
|
||||||
|
// Immediately replay
|
||||||
|
sa.udp_tx.send(packet).await?;
|
||||||
|
}
|
||||||
|
for packet in &packets {
|
||||||
|
// Delayed replay
|
||||||
|
sa.udp_tx.send(packet).await?;
|
||||||
|
}
|
||||||
|
|
||||||
|
done_rx.recv().await;
|
||||||
|
|
||||||
|
sa.close().await?;
|
||||||
|
sb.close().await?;
|
||||||
|
|
||||||
|
{
|
||||||
|
let received_sequence_number = received_sequence_number.lock().await;
|
||||||
|
assert_eq!(&received_sequence_number[..], &expected_sequence_number[..]);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
Vendored
+91
@@ -0,0 +1,91 @@
|
|||||||
|
use tokio::sync::mpsc;
|
||||||
|
use util::marshal::*;
|
||||||
|
use util::Buffer;
|
||||||
|
|
||||||
|
use crate::error::{Error, Result};
|
||||||
|
|
||||||
|
/// Limit the buffer size to 1MB
|
||||||
|
pub const SRTP_BUFFER_SIZE: usize = 1000 * 1000;
|
||||||
|
|
||||||
|
/// Limit the buffer size to 100KB
|
||||||
|
pub const SRTCP_BUFFER_SIZE: usize = 100 * 1000;
|
||||||
|
|
||||||
|
/// Stream handles decryption for a single RTP/RTCP SSRC
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Stream {
|
||||||
|
ssrc: u32,
|
||||||
|
tx: mpsc::Sender<u32>,
|
||||||
|
pub(crate) buffer: Buffer,
|
||||||
|
is_rtp: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Stream {
|
||||||
|
/// Create a new stream
|
||||||
|
pub fn new(ssrc: u32, tx: mpsc::Sender<u32>, is_rtp: bool) -> Self {
|
||||||
|
Stream {
|
||||||
|
ssrc,
|
||||||
|
tx,
|
||||||
|
// Create a buffer with a 1MB limit
|
||||||
|
buffer: Buffer::new(
|
||||||
|
0,
|
||||||
|
if is_rtp {
|
||||||
|
SRTP_BUFFER_SIZE
|
||||||
|
} else {
|
||||||
|
SRTCP_BUFFER_SIZE
|
||||||
|
},
|
||||||
|
),
|
||||||
|
is_rtp,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// GetSSRC returns the SSRC we are demuxing for
|
||||||
|
pub fn get_ssrc(&self) -> u32 {
|
||||||
|
self.ssrc
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if RTP is a stream.
|
||||||
|
pub fn is_rtp_stream(&self) -> bool {
|
||||||
|
self.is_rtp
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read reads and decrypts full RTP packet from the nextConn
|
||||||
|
pub async fn read(&self, buf: &mut [u8]) -> Result<usize> {
|
||||||
|
Ok(self.buffer.read(buf, None).await?)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// ReadRTP reads and decrypts full RTP packet and its header from the nextConn
|
||||||
|
pub async fn read_rtp(&self, buf: &mut [u8]) -> Result<rtp::packet::Packet> {
|
||||||
|
if !self.is_rtp {
|
||||||
|
return Err(Error::InvalidRtpStream);
|
||||||
|
}
|
||||||
|
|
||||||
|
let n = self.buffer.read(buf, None).await?;
|
||||||
|
let mut b = &buf[..n];
|
||||||
|
let pkt = rtp::packet::Packet::unmarshal(&mut b)?;
|
||||||
|
|
||||||
|
Ok(pkt)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// read_rtcp reads and decrypts full RTP packet and its header from the nextConn
|
||||||
|
pub async fn read_rtcp(
|
||||||
|
&self,
|
||||||
|
buf: &mut [u8],
|
||||||
|
) -> Result<Vec<Box<dyn rtcp::packet::Packet + Send + Sync>>> {
|
||||||
|
if self.is_rtp {
|
||||||
|
return Err(Error::InvalidRtcpStream);
|
||||||
|
}
|
||||||
|
|
||||||
|
let n = self.buffer.read(buf, None).await?;
|
||||||
|
let mut b = &buf[..n];
|
||||||
|
let pkt = rtcp::packet::unmarshal(&mut b)?;
|
||||||
|
|
||||||
|
Ok(pkt)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close removes the ReadStream from the session and cleans up any associated state
|
||||||
|
pub async fn close(&self) -> Result<()> {
|
||||||
|
self.buffer.close().await;
|
||||||
|
let _ = self.tx.send(self.ssrc).await;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in new issue
Block a user