From edaa27fe6ba5ce16d22a78d879f04de3a0daec22 Mon Sep 17 00:00:00 2001 From: VallierDev <24893073+VallierDev@users.noreply.github.com> Date: Fri, 16 Oct 2026 11:34:12 +0800 Subject: [PATCH] Log the structure of connect requests (numbers, types, lengths only) Documents what the viewer and cloud send in be-controlled (ConnectOptions nesting, streamer_data and header value types) without rendering string or byte contents, large numbers or identifiers. Co-Authored-By: Claude Opus 5.5 --- src/protocol.rs | 76 ++++++++++++++++++++++++++++++++++++++++++++++++ src/signaling.rs | 3 ++ 2 files changed, 79 insertions(+) diff --git a/src/protocol.rs b/src/protocol.rs index 301b7c1..e9a3d73 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -75,6 +75,66 @@ pub fn decode_wire(input: &[u8]) -> Result>, WireError> { Ok(fields) } +/// Structure-only rendering for diagnostics: field numbers, wire types, lengths and small +/// varints (enums, sizes, fps). String and byte contents are never rendered. +pub fn wire_shape(data: &[u8], depth: u8) -> String { + let Ok(fields) = decode_wire(data) else { return format!("bytes({})", data.len()) }; + let parts: Vec = fields.iter().map(|f| match f.value { + WireValue::Varint(u64::MAX) => format!("{}=-1", f.number), + WireValue::Varint(v) if v <= 0xFFFF => format!("{}={v}", f.number), + WireValue::Varint(_) => format!("{}=big", f.number), + WireValue::Fixed32(_) => format!("{}:f32", f.number), + WireValue::Fixed64(_) => format!("{}:f64", f.number), + WireValue::Bytes(b) => format!("{}:{}", f.number, bytes_shape(b, depth)), + }).collect(); + format!("{{{}}}", parts.join(",")) +} +fn bytes_shape(b: &[u8], depth: u8) -> String { + let printable = !b.is_empty() && std::str::from_utf8(b).is_ok_and(|t| t.chars().all(|c| !c.is_control())); + if printable { return format!("str({})", b.len()); } + if depth > 0 && !b.is_empty() && decode_wire(b).is_ok_and(|f| !f.is_empty() && f.iter().all(|x| (1..=128).contains(&x.number))) { + return wire_shape(b, depth - 1); + } + format!("bytes({})", b.len()) +} + +/// JSON counterpart: keys and value types; strings as lengths (or nested JSON/base64-protobuf +/// shape), numbers only when small. Values that could identify a user are never rendered. +pub fn json_shape(value: &serde_json::Value, depth: u8) -> String { + use base64::Engine; + use serde_json::Value; + match value { + Value::Null => "null".into(), + Value::Bool(b) => b.to_string(), + Value::Number(n) => match n.as_i64() { Some(v) if v.abs() <= 0xFFFF => v.to_string(), _ => "num".into() }, + Value::String(t) => { + if depth > 0 { + if let Ok(inner @ (Value::Object(_) | Value::Array(_))) = serde_json::from_str::(t) { + return format!("json{}", json_shape(&inner, depth - 1)); + } + if t.len() >= 8 && t.len() % 4 == 0 { + if let Ok(raw) = base64::engine::general_purpose::STANDARD.decode(t) { + if decode_wire(&raw).is_ok_and(|f| !f.is_empty()) { return format!("b64{}", wire_shape(&raw, depth - 1)); } + } + } + } + format!("str({})", t.len()) + } + Value::Array(items) => match items.first() { + Some(first) if depth > 0 => format!("[{}x{}]", items.len(), json_shape(first, depth - 1)), + _ => format!("[{}]", items.len()), + }, + Value::Object(map) if depth > 0 => { + let parts: Vec = map.iter().take(48).map(|(k, v)| { + let key: String = k.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '_').take(40).collect(); + format!("{key}:{}", json_shape(v, depth - 1)) + }).collect(); + format!("{{{}}}", parts.join(",")) + } + Value::Object(map) => format!("{{{} keys}}", map.len()), + } +} + #[cfg(test)] mod tests { use super::*; @@ -105,4 +165,20 @@ mod tests { assert_eq!(decode_wire(&[11]), Err(WireError::UnsupportedWireType(3))); assert_eq!(decode_wire(&[255, 255, 255, 255, 31]), Err(WireError::InvalidField)); } + + #[test] + fn shapes_never_render_contents() { + // {1:1, 2:-1, 4:{1:60,2:2}, 9:"device-secret", 12:big} + let mut data = vec![0x08, 0x01, 0x10]; + data.extend([0xff; 9]); data.push(0x01); + data.extend([0x22, 0x04, 0x08, 0x3c, 0x10, 0x02]); + data.extend([0x4a, 0x0d]); data.extend(b"device-secret"); + data.extend([0x60, 0x80, 0x80, 0x80, 0x80, 0x10]); + let shape = super::wire_shape(&data, 3); + assert_eq!(shape, "{1=1,2=-1,4:{1=60,2=2},9:str(13),12=big}"); + let header = serde_json::json!({"streamer_data": "{\"token\":\"secret-value\",\"n\":3}", "city": "Somewhere", "id": 123456789}); + let shape = super::json_shape(&header, 4); + assert!(!shape.contains("secret") && !shape.contains("Somewhere") && !shape.contains("123456789"), "{shape}"); + assert!(shape.contains("streamer_data:json{n:3,token:str(12)}"), "{shape}"); + } } diff --git a/src/signaling.rs b/src/signaling.rs index d940a0d..47897f3 100644 --- a/src/signaling.rs +++ b/src/signaling.rs @@ -356,6 +356,9 @@ impl SignalingClient { let ice_id = ["ice_id", "iceId"].iter().find_map(|k| header.get(*k).or_else(|| header.get("data").and_then(|d| d.get(*k)))) .and_then(|v| v.as_str()).map(str::to_owned); log::info!("be-controlled connect request: capture_type={} header_keys={:?} ice_id_present={}", capture_type, keys, ice_id.is_some()); + // Structure only (numbers, types, lengths): documents what the viewer and cloud send. + let header_shape: String = crate::protocol::json_shape(&header, 4).chars().take(6000).collect(); + log::info!("Connect request shape: app_data={} header={}", crate::protocol::wire_shape(data, 3), header_shape); // ConnectOptions 4 decoder_cap_list: DecoderCap {1 fps, 2 codec_type (1 H264, 2 H265), // 3 width, 4 height, 5 chroma_format (1 4:2:0, 3 4:4:4)}. Numbers only. let caps: Vec> = fields.iter().flatten().filter(|f| f.number == 4).filter_map(|f| match f.value {