From 84643bff5ecec0ed9d4524a02f5f8688737fa8cd Mon Sep 17 00:00:00 2001 From: zhy200308 <2258391712@qq.com> Date: Tue, 11 Aug 2026 17:29:00 +0800 Subject: [PATCH] =?UTF-8?q?feat(desktop):=20PC=E2=86=94PC=20=E6=94=B9?= =?UTF-8?q?=E7=94=A8=E8=BF=9E=E6=8E=A5=E7=A0=81=EF=BC=8C=E4=B8=80=E4=B8=B2?= =?UTF-8?q?=E6=90=9E=E5=AE=9A=EF=BC=8C=E4=B8=8D=E5=86=8D=E5=8D=95=E7=8B=AC?= =?UTF-8?q?=E8=BE=93=20IP?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 此前发送方要分别念/输三样东西:IP、端口、6 位配对码。现在合成一串 可口述的连接码,**地址就编在码里**,所以拿到码即可直连——不需要广播、 不需要在同一网段,只要 IP 层路由可达即可(同一路由器下的不同 VLAN / 网段正属于这种情况)。 新增 connect_code.rs - 编码:version(3) | kind(3) | 默认端口位 | 地址 | [端口] | 24bit 秘密 | CRC-8 - 按网段压缩地址:192.168.a.b 只需 2 字节,10./172.16-31. 三字节, 其余四字节,IPv6 十六字节 - Crockford Base32(去掉易混的 I/L/O/U),分组显示 - 典型 192.168.a.b:39393 → **12 个字符**,如 4849-3WT1-3ZS0 - 输入容错:大小写、分隔符、空格随意;I/L 归一为 1、O 归一为 0 接收侧 - 6 位配对码 → 3 字节秘密;UI 为**每个网卡各生成一个连接码**, 对方在哪个网段就用哪一串(虚拟网卡排后面) - 新增 pairing::local_ipv4_addresses(),按「最可能被对方看到」排序 发送侧 - 三个输入框(设备列表 / 手动 IP / 配对码)合并为**一个连接码输入框** - 边打边校验:CRC 在连接之前就能发现输错,并实时显示「将连接 http://x.x.x.x:port」 - 广播搜索降级为可选的折叠项——同网段免输码是锦上添花,不再是主路径 一个被测试抓出来的真问题 最初单字符输错的拦截率只有 96%。原因是 12 个 Base32 字符携带 60 bit 而实际只用 56 bit,末尾 4 个填充位被解码器直接丢弃,改动最后一个字符 有 1/16 概率解出完全相同的字节,CRC 根本没机会发现。加上填充位必须为 0 的校验后拦截率 >99%。 必须说清的边界 连接码解决的是「找不到对方」和「输入太繁琐」,不能凭空制造可达性。 若两台机器在 IP 层互不可达(Wi-Fi 客户端隔离、各自在不同物理网络), 任何客户端侧协议都无法建立连接,只能换链路或引入第三方中转—— 后者与 QFT「不经过外网」的定位冲突,本版不做。 验证:cargo test 30/30,含连接码往返(全部地址类型)、容错输入、 单字符输错拦截率统计、以及走完整连接码链路的端到端传输 (编码 → 解码 → 换令牌 → 9MB 并发上传 → SHA-256 比对)。 --- desktop/src/client.rs | 17 +- desktop/src/connect_code.rs | 425 ++++++++++++++++++++++++++++++++++++ desktop/src/main.rs | 159 +++++++------- desktop/src/pairing.rs | 50 +++-- desktop/src/receiver.rs | 17 +- 5 files changed, 559 insertions(+), 109 deletions(-) create mode 100644 desktop/src/connect_code.rs diff --git a/desktop/src/client.rs b/desktop/src/client.rs index 8997544..3c36217 100644 --- a/desktop/src/client.rs +++ b/desktop/src/client.rs @@ -546,11 +546,20 @@ mod integration_tests { let server = ReceiverServer::start(inbox.clone(), token.clone(), tx).unwrap(); let base_url = format!("http://127.0.0.1:{}", server.port); - // 错误配对码必须被拒 - assert!(PeerClient::pair(&base_url, "000000", "tester").is_err() - || server.pair_code == "000000"); + // 走完整的连接码链路:编码 → 用户输入 → 解码 → 换令牌 + let code = crate::connect_code::ConnectCode::new( + std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST), + server.port, + server.secret, + ); + let typed = code.encode(); + let parsed = crate::connect_code::ConnectCode::decode(&typed).expect("连接码应能解析"); + assert_eq!(parsed.base_url(), base_url, "码里解出的地址应与实际服务一致"); - let paired = PeerClient::pair(&base_url, &server.pair_code, "tester").unwrap(); + // 错误秘密必须被拒 + assert!(PeerClient::pair(&base_url, "000000", "tester").is_err()); + + let paired = PeerClient::pair(&base_url, &parsed.secret_hex(), "tester").unwrap(); assert_eq!(paired, token, "配对应返回真实会话令牌"); let client = PeerClient::new(base_url, paired, "tester"); diff --git a/desktop/src/connect_code.rs b/desktop/src/connect_code.rs new file mode 100644 index 0000000..0249f73 --- /dev/null +++ b/desktop/src/connect_code.rs @@ -0,0 +1,425 @@ +//! QFT 连接码:把「去哪连」和「凭什么连」压进一串可口述的短码。 +//! +//! 此前 PC↔PC 要用户分别念 IP、端口、6 位配对码三样东西,既啰嗦又容易错。 +//! 连接码把它们合成一串,**地址就编在码里**,所以发送方拿到码即可直连, +//! 不需要广播、不需要在同一网段——只要 IP 层路由可达即可。 +//! 同一路由器下的不同 VLAN/网段正属于这种情况。 +//! +//! 必须说清的边界:连接码解决的是「找不到对方」和「输入太繁琐」。 +//! 如果两台机器在 IP 层根本互不可达(AP 客户端隔离、各自在不同的物理网络), +//! 任何客户端侧协议都无法凭空造出可达性,只能换链路或引入第三方中转。 +//! +//! 编码 +//! ```text +//! byte0 version(3) | kind(3) | default_port(1) | reserved(1) +//! addr 2~4 字节(按 kind 压缩私有网段)或 16 字节(IPv6) +//! port 2 字节,仅当非默认端口时存在 +//! secret 3 字节(24 bit) +//! crc 1 字节 CRC-8 +//! ``` +//! 典型的 `192.168.a.b:39393` 共 7 字节 → Crockford Base32 → **12 个字符**。 + +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; + +/// Crockford Base32:去掉了容易混淆的 I、L、O、U。 +const ALPHABET: &[u8; 32] = b"0123456789ABCDEFGHJKMNPQRSTVWXYZ"; +const VERSION: u8 = 1; +pub const DEFAULT_PORT: u16 = 39393; +pub const SECRET_LEN: usize = 3; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +enum AddrKind { + /// 192.168.a.b —— 2 字节 + Private192 = 0, + /// 10.a.b.c —— 3 字节 + Private10 = 1, + /// 172.(16..=31).a.b —— 3 字节 + Private172 = 2, + /// 任意 IPv4 —— 4 字节 + FullV4 = 3, + /// IPv6 —— 16 字节。码会长到 32 字符左右,适合复制粘贴而非口述, + /// 但它是「双方都有公网 IPv6 时无需任何服务器即可直连」的唯一途径。 + V6 = 4, +} + +impl AddrKind { + fn from_bits(bits: u8) -> Option { + Some(match bits { + 0 => Self::Private192, + 1 => Self::Private10, + 2 => Self::Private172, + 3 => Self::FullV4, + 4 => Self::V6, + _ => return None, + }) + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct ConnectCode { + pub address: IpAddr, + pub port: u16, + pub secret: [u8; SECRET_LEN], +} + +#[derive(Debug, PartialEq, Eq)] +pub enum CodeError { + /// 长度不对,多半是漏敲或多敲了字符 + Length, + /// 出现了字母表之外的字符 + Alphabet(char), + /// 校验位不匹配——几乎可以肯定是输错了某一位 + Checksum, + /// 版本或地址类型无法识别 + Unsupported, +} + +impl std::fmt::Display for CodeError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Length => write!(f, "连接码长度不对,请检查是否漏敲或多敲了字符"), + Self::Alphabet(ch) => write!(f, "连接码里有无效字符 '{ch}'"), + Self::Checksum => write!(f, "连接码校验失败,请核对后重新输入"), + Self::Unsupported => write!(f, "无法识别的连接码版本"), + } + } +} + +impl std::error::Error for CodeError {} + +impl ConnectCode { + pub fn new(address: IpAddr, port: u16, secret: [u8; SECRET_LEN]) -> Self { + Self { address, port, secret } + } + + /// 秘密的线上表示:6 个小写十六进制字符,放在 `X-QFT-Code` 头里。 + pub fn secret_hex(&self) -> String { + self.secret.iter().map(|b| format!("{b:02x}")).collect() + } + + pub fn base_url(&self) -> String { + match self.address { + IpAddr::V4(v4) => format!("http://{v4}:{}", self.port), + IpAddr::V6(v6) => format!("http://[{v6}]:{}", self.port), + } + } + + /// 编码为分组显示的字符串,例如 `K7M2-9X4P-QR3T`。 + pub fn encode(&self) -> String { + let bytes = self.to_bytes(); + let raw = base32_encode(&bytes); + raw.as_bytes() + .chunks(4) + .map(|chunk| std::str::from_utf8(chunk).unwrap_or_default()) + .collect::>() + .join("-") + } + + /// 解析用户输入。分隔符、大小写、以及 I/L→1、O→0 的手误都会被容忍。 + pub fn decode(text: &str) -> Result { + let (bytes, padding_ok) = base32_decode(text)?; + // 先判长度:码太短时「长度不对」比「校验失败」更能指导用户, + // 再判填充位与 CRC。 + let code = Self::from_bytes(&bytes)?; + if !padding_ok { + return Err(CodeError::Checksum); + } + Ok(code) + } + + fn to_bytes(&self) -> Vec { + let (kind, addr_bytes) = match self.address { + IpAddr::V4(v4) => { + let o = v4.octets(); + match (o[0], o[1]) { + (192, 168) => (AddrKind::Private192, vec![o[2], o[3]]), + (10, _) => (AddrKind::Private10, vec![o[1], o[2], o[3]]), + (172, 16..=31) => (AddrKind::Private172, vec![o[1] - 16, o[2], o[3]]), + _ => (AddrKind::FullV4, o.to_vec()), + } + } + IpAddr::V6(v6) => (AddrKind::V6, v6.octets().to_vec()), + }; + + let default_port = self.port == DEFAULT_PORT; + let mut out = Vec::with_capacity(1 + addr_bytes.len() + 2 + SECRET_LEN + 1); + out.push((VERSION << 5) | ((kind as u8) << 2) | ((default_port as u8) << 1)); + out.extend_from_slice(&addr_bytes); + if !default_port { + out.extend_from_slice(&self.port.to_be_bytes()); + } + out.extend_from_slice(&self.secret); + out.push(crc8(&out)); + out + } + + fn from_bytes(bytes: &[u8]) -> Result { + if bytes.len() < 1 + 2 + SECRET_LEN + 1 { + return Err(CodeError::Length); + } + let (payload, checksum) = bytes.split_at(bytes.len() - 1); + if crc8(payload) != checksum[0] { + return Err(CodeError::Checksum); + } + + let header = payload[0]; + if header >> 5 != VERSION { + return Err(CodeError::Unsupported); + } + let kind = AddrKind::from_bits((header >> 2) & 0b111).ok_or(CodeError::Unsupported)?; + let default_port = (header >> 1) & 1 == 1; + + let addr_len = match kind { + AddrKind::Private192 => 2, + AddrKind::Private10 | AddrKind::Private172 => 3, + AddrKind::FullV4 => 4, + AddrKind::V6 => 16, + }; + let port_len = if default_port { 0 } else { 2 }; + if payload.len() != 1 + addr_len + port_len + SECRET_LEN { + return Err(CodeError::Length); + } + + let addr_slice = &payload[1..1 + addr_len]; + let address = match kind { + AddrKind::Private192 => { + IpAddr::V4(Ipv4Addr::new(192, 168, addr_slice[0], addr_slice[1])) + } + AddrKind::Private10 => { + IpAddr::V4(Ipv4Addr::new(10, addr_slice[0], addr_slice[1], addr_slice[2])) + } + AddrKind::Private172 => { + // 第二个八位组只可能是 16..=31,编码时减了 16 + if addr_slice[0] > 15 { + return Err(CodeError::Unsupported); + } + IpAddr::V4(Ipv4Addr::new(172, addr_slice[0] + 16, addr_slice[1], addr_slice[2])) + } + AddrKind::FullV4 => IpAddr::V4(Ipv4Addr::new( + addr_slice[0], addr_slice[1], addr_slice[2], addr_slice[3], + )), + AddrKind::V6 => { + let mut octets = [0u8; 16]; + octets.copy_from_slice(addr_slice); + IpAddr::V6(Ipv6Addr::from(octets)) + } + }; + + let mut cursor = 1 + addr_len; + let port = if default_port { + DEFAULT_PORT + } else { + let value = u16::from_be_bytes([payload[cursor], payload[cursor + 1]]); + cursor += 2; + value + }; + let mut secret = [0u8; SECRET_LEN]; + secret.copy_from_slice(&payload[cursor..cursor + SECRET_LEN]); + + Ok(Self { address, port, secret }) + } +} + +pub fn new_secret() -> [u8; SECRET_LEN] { + use rand::RngCore; + let mut secret = [0u8; SECRET_LEN]; + rand::rng().fill_bytes(&mut secret); + secret +} + +// ---------------------------------------------------------------- Base32 + +fn base32_encode(bytes: &[u8]) -> String { + let mut out = String::with_capacity(bytes.len() * 8 / 5 + 1); + let mut buffer: u32 = 0; + let mut bits = 0u32; + for &byte in bytes { + buffer = (buffer << 8) | byte as u32; + bits += 8; + while bits >= 5 { + bits -= 5; + out.push(ALPHABET[((buffer >> bits) & 0x1f) as usize] as char); + } + } + if bits > 0 { + out.push(ALPHABET[((buffer << (5 - bits)) & 0x1f) as usize] as char); + } + out +} + +/// 返回 (字节, 末尾填充位是否为 0)。 +fn base32_decode(text: &str) -> Result<(Vec, bool), CodeError> { + let mut buffer: u32 = 0; + let mut bits = 0u32; + let mut out = Vec::new(); + let mut symbols = 0usize; + + for ch in text.chars() { + // 分隔符与空白一律忽略,用户怎么断句都行 + if ch == '-' || ch == ' ' || ch == '_' || ch == '\t' { + continue; + } + let upper = ch.to_ascii_uppercase(); + // Crockford 的容错映射:手写/口述时 I、L 常被当成 1,O 被当成 0 + let normalized = match upper { + 'I' | 'L' => '1', + 'O' => '0', + other => other, + }; + let value = ALPHABET + .iter() + .position(|&c| c as char == normalized) + .ok_or(CodeError::Alphabet(ch))? as u32; + symbols += 1; + buffer = (buffer << 5) | value; + bits += 5; + if bits >= 8 { + bits -= 8; + out.push(((buffer >> bits) & 0xff) as u8); + } + } + if symbols == 0 { + return Err(CodeError::Length); + } + // 5 位一组和 8 位一字节对不齐,末尾会剩几个填充位。编码时填的是 0, + // 必须校验它们仍是 0:否则改动最后一个字符有 1/2^bits 的概率 + // 解出完全相同的字节序列,CRC 根本没机会发现(修复前实测漏检率 4%)。 + let padding_ok = bits == 0 || (buffer & ((1 << bits) - 1)) == 0; + Ok((out, padding_ok)) +} + +fn crc8(bytes: &[u8]) -> u8 { + let mut crc = 0u8; + for &byte in bytes { + crc ^= byte; + for _ in 0..8 { + crc = if crc & 0x80 != 0 { (crc << 1) ^ 0x07 } else { crc << 1 }; + } + } + crc +} + +#[cfg(test)] +mod tests { + use super::*; + + fn code(ip: &str, port: u16) -> ConnectCode { + ConnectCode::new(ip.parse().unwrap(), port, [0xAB, 0xCD, 0xEF]) + } + + #[test] + fn typical_home_address_fits_in_twelve_characters() { + let encoded = code("192.168.1.20", DEFAULT_PORT).encode(); + let symbols = encoded.chars().filter(|c| *c != '-').count(); + assert_eq!(symbols, 12, "常见家庭网段应压到 12 个字符,实得 {encoded}"); + assert_eq!(encoded.matches('-').count(), 2, "应分成三组便于口述"); + } + + #[test] + fn round_trips_every_address_kind() { + let cases = [ + ("192.168.1.20", DEFAULT_PORT), + ("192.168.255.255", DEFAULT_PORT), + ("10.0.0.5", DEFAULT_PORT), + ("10.255.255.254", 8080), + ("172.16.0.1", DEFAULT_PORT), + ("172.31.255.254", 1), + ("100.64.0.1", DEFAULT_PORT), // CGNAT,落到 FullV4 + ("127.0.0.1", 65535), + ("2001:db8::1", DEFAULT_PORT), + ("fe80::1", 39393), + ]; + for (ip, port) in cases { + let original = code(ip, port); + let decoded = ConnectCode::decode(&original.encode()) + .unwrap_or_else(|e| panic!("{ip}:{port} 解码失败:{e}")); + assert_eq!(decoded, original, "{ip}:{port} 往返不一致"); + } + } + + #[test] + fn accepts_sloppy_user_input() { + let original = code("192.168.1.20", DEFAULT_PORT); + let canonical = original.encode(); + let sloppy = [ + canonical.to_lowercase(), + canonical.replace('-', ""), + canonical.replace('-', " "), + format!(" {canonical} "), + ]; + for text in sloppy { + assert_eq!(ConnectCode::decode(&text).unwrap(), original, "应容忍:{text}"); + } + } + + #[test] + fn confusable_letters_map_to_digits() { + // 口述时 I/L 常被听成 1,O 被听成 0。字母表里本就没有这些字母, + // 所以把它们映射回数字是安全的,不会和真实字符冲突。 + let original = code("192.168.1.20", DEFAULT_PORT); + let canonical = original.encode(); + let mangled = canonical.replace('1', "I").replace('0', "O"); + if mangled != canonical { + assert_eq!(ConnectCode::decode(&mangled).unwrap(), original); + } + } + + #[test] + fn single_character_typo_is_caught_by_checksum() { + let canonical = code("192.168.1.20", DEFAULT_PORT).encode(); + let mut caught = 0; + let mut total = 0; + for (index, ch) in canonical.char_indices() { + if ch == '-' { + continue; + } + for &replacement in ALPHABET.iter() { + if replacement as char == ch { + continue; + } + let mut mangled: Vec = canonical.chars().collect(); + mangled[index] = replacement as char; + let text: String = mangled.into_iter().collect(); + total += 1; + if ConnectCode::decode(&text).is_err() { + caught += 1; + } + } + } + // CRC-8 理论漏检率约 1/256;这里要求实测拦截率高于 99% + let rate = caught as f64 / total as f64; + assert!(rate > 0.99, "单字符输错的拦截率只有 {:.3},太低", rate); + } + + #[test] + fn rejects_malformed_input() { + assert_eq!(ConnectCode::decode(""), Err(CodeError::Length)); + assert_eq!(ConnectCode::decode("---"), Err(CodeError::Length)); + assert!(matches!(ConnectCode::decode("K7M2!9X4"), Err(CodeError::Alphabet('!')))); + assert_eq!(ConnectCode::decode("K7M2"), Err(CodeError::Length)); + } + + #[test] + fn secret_hex_is_stable_and_lowercase() { + let value = code("192.168.1.20", DEFAULT_PORT); + assert_eq!(value.secret_hex(), "abcdef"); + assert_eq!(value.base_url(), "http://192.168.1.20:39393"); + } + + #[test] + fn ipv6_code_is_long_but_valid() { + let value = code("2001:db8::1", DEFAULT_PORT); + let encoded = value.encode(); + let symbols = encoded.chars().filter(|c| *c != '-').count(); + // IPv6 地址本身就 16 字节,码必然长,适合复制粘贴而不是口述 + assert!(symbols > 24, "IPv6 码应明显更长,实得 {symbols}"); + assert_eq!(ConnectCode::decode(&encoded).unwrap(), value); + } + + #[test] + fn secrets_differ_between_sessions() { + let a = new_secret(); + let b = new_secret(); + assert_ne!(a, b, "每次生成的秘密必须不同"); + } +} diff --git a/desktop/src/main.rs b/desktop/src/main.rs index 6310a1b..b815d1f 100644 --- a/desktop/src/main.rs +++ b/desktop/src/main.rs @@ -1,5 +1,6 @@ mod base45; mod client; +mod connect_code; mod direct_ap; mod discovery; mod optical_cache; @@ -128,8 +129,6 @@ struct PcPeerState { server: Option, // 发送侧 peers: Vec, - selected_peer: Option, - manual_address: String, code_input: String, token: Option, connected_base: Option, @@ -223,8 +222,6 @@ impl QftApp { save_dir: Some(platform::default_download_dir()), server: None, peers: Vec::new(), - selected_peer: None, - manual_address: String::new(), code_input: String::new(), token: None, connected_base: None, @@ -1044,29 +1041,43 @@ impl QftApp { let Some(server) = self.pc.server.as_ref() else { return }; let port = server.port; - let code = server.pair_code.clone(); + let secret = server.secret; + // 每个网卡各生成一个连接码:对方在哪个网段,就用哪一个。 + // 地址已经编在码里,所以对方不需要再单独输入 IP。 + let codes: Vec<(std::net::IpAddr, String)> = pairing::local_ipv4_addresses() + .into_iter() + .map(|address| { + let code = connect_code::ConnectCode::new(std::net::IpAddr::V4(address), port, secret); + (std::net::IpAddr::V4(address), code.encode()) + }) + .collect(); + ui.add_space(14.0); ui.group(|ui| { - ui.heading("把这两项告诉发送方"); - ui.add_space(6.0); - ui.horizontal_wrapped(|ui| { - ui.label("配对码:"); - ui.heading(egui::RichText::new(&code).monospace().strong()); - if ui.small_button("复制").clicked() { - ui.ctx().copy_text(code.clone()); - } - }); - ui.small("输错 5 次该码即作废,需要重新启动接收。"); + ui.heading("把连接码告诉发送方"); + ui.small("码里已经包含地址,对方只需输入这一串,不用再报 IP 和端口。"); ui.add_space(8.0); - ui.label("本机地址(发现不到时可让对方手动输入其中一个):"); - for endpoint in pairing::local_ipv4_endpoints(port) { + if codes.is_empty() { + ui.colored_label(egui::Color32::from_rgb(220, 120, 60), "没有可用的局域网地址,请检查网络连接。"); + } + for (index, (address, code)) in codes.iter().enumerate() { ui.horizontal(|ui| { - ui.monospace(&endpoint); - if ui.small_button("复制").clicked() { - ui.ctx().copy_text(endpoint.clone()); + if index == 0 { + ui.heading(egui::RichText::new(code).monospace().strong()); + } else { + ui.monospace(egui::RichText::new(code).strong()); } + if ui.small_button("复制").clicked() { + ui.ctx().copy_text(code.clone()); + } + ui.weak(format!("({address})")); }); } + ui.add_space(6.0); + ui.small("输错 5 次该码即作废,需要重新启动接收。"); + if codes.len() > 1 { + ui.small("本机有多个网卡:对方在哪个网段就用对应的那一串。"); + } }); ui.add_space(14.0); @@ -1088,52 +1099,59 @@ impl QftApp { fn pc_send_ui(&mut self, ui: &mut egui::Ui) { ui.group(|ui| { - ui.heading("1 · 找到对方"); + ui.heading("1 · 输入对方的连接码"); ui.horizontal_wrapped(|ui| { - if ui.add_enabled(!self.pc.busy, egui::Button::new("搜索附近的电脑")).clicked() { - self.browse_pc_peers(); - } - ui.label("或手动输入:"); - ui.add(egui::TextEdit::singleline(&mut self.pc.manual_address) - .hint_text("192.168.1.20:39393") - .desired_width(190.0)); - }); - ui.small("UDP 广播只覆盖同一个网段。跨网段或开了 AP 隔离的 Wi-Fi 上搜不到,请手动输入地址。"); - - ui.add_space(6.0); - for (index, peer) in self.pc.peers.iter().enumerate() { - let label = format!("{} · {} · {}", peer.name, peer.platform, peer.base_url()); - if ui.selectable_label(self.pc.selected_peer == Some(index), label).clicked() { - self.pc.selected_peer = Some(index); - } - } - if self.pc.peers.is_empty() { - ui.weak("尚未搜索到设备。请确认对方已在「我要接收」里启动接收。"); - } - }); - - ui.add_space(12.0); - ui.group(|ui| { - ui.heading("2 · 输入对方屏幕上的 6 位配对码"); - ui.horizontal_wrapped(|ui| { - ui.add(egui::TextEdit::singleline(&mut self.pc.code_input) - .hint_text("123456") - .desired_width(110.0)); - let can_pair = !self.pc.busy - && self.pc.code_input.trim().len() == 6 - && (self.pc.selected_peer.is_some() || !self.pc.manual_address.trim().is_empty()); - if ui.add_enabled(can_pair, egui::Button::new("连接")).clicked() { + let response = ui.add( + egui::TextEdit::singleline(&mut self.pc.code_input) + .hint_text("K7M2-9X4P-QR3T") + .desired_width(240.0) + .font(egui::TextStyle::Monospace), + ); + let submitted = response.lost_focus() + && ui.input(|i| i.key_pressed(egui::Key::Enter)); + let parsed = connect_code::ConnectCode::decode(&self.pc.code_input); + let can_connect = !self.pc.busy && parsed.is_ok(); + if (ui.add_enabled(can_connect, egui::Button::new("连接")).clicked() + || (submitted && can_connect)) + { self.pair_pc_peer(); } if self.pc.token.is_some() { ui.colored_label(egui::Color32::from_rgb(80, 200, 120), "● 已连接"); } }); + // 边打边校验:CRC 能在连接之前就发现输错,不用等超时 + if !self.pc.code_input.trim().is_empty() { + match connect_code::ConnectCode::decode(&self.pc.code_input) { + Ok(code) => ui.weak(format!("将连接 {}", code.base_url())), + Err(e) => ui.colored_label(egui::Color32::from_rgb(220, 120, 60), e.to_string()), + }; + } + ui.add_space(4.0); + ui.small("连接码里已包含对方地址,不需要在同一网段——只要网络能路由到对方即可。"); + }); + + ui.add_space(12.0); + ui.collapsing("搜索同网段的设备(可选)", |ui| { + ui.small("同一网段时可以免输码。跨网段、或 Wi-Fi 开了客户端隔离时搜不到,请改用连接码。"); + if ui.add_enabled(!self.pc.busy, egui::Button::new("搜索")).clicked() { + self.browse_pc_peers(); + } + for peer in &self.pc.peers { + if ui.button(format!("{} · {} · {}", peer.name, peer.platform, peer.base_url())).clicked() { + // 直接把对端地址填进码输入框还不够——秘密只有对方屏幕上有, + // 所以这里只做地址提示,仍需用户补齐连接码 + self.pc.status = format!("请输入 {} 屏幕上显示的连接码", peer.name); + } + } + if self.pc.peers.is_empty() { + ui.weak("尚未搜索到设备。"); + } }); ui.add_space(12.0); ui.group(|ui| { - ui.heading("3 · 选择文件并发送"); + ui.heading("2 · 选择文件并发送"); ui.horizontal_wrapped(|ui| { if ui.button("选择文件").clicked() { if let Some(files) = rfd::FileDialog::new().pick_files() { @@ -1174,8 +1192,7 @@ impl QftApp { let (tx, rx) = mpsc::channel(); match ReceiverServer::start(dir, token, tx) { Ok(server) => { - self.pc.status = format!( - "接收中。把配对码 {} 告诉发送方即可。", server.pair_code); + self.pc.status = "接收中。把下面的连接码告诉发送方即可。".into(); self.pc.server = Some(server); self.receive.events = Some(rx); self.receive.connected_device = "等待对方连接".into(); @@ -1201,36 +1218,17 @@ impl QftApp { }); } - /// 选中的对端,或手动输入的地址。手动输入允许省略 http:// 与端口。 - fn pc_target_base_url(&self) -> Option { - if let Some(index) = self.pc.selected_peer { - if let Some(peer) = self.pc.peers.get(index) { - return Some(peer.base_url()); - } - } - let raw = self.pc.manual_address.trim(); - if raw.is_empty() { - return None; - } - let raw = raw.trim_start_matches("http://").trim_end_matches('/'); - let with_port = if raw.contains(':') { - raw.to_string() - } else { - format!("{raw}:{}", receiver::PREFERRED_PORT) - }; - Some(format!("http://{with_port}")) - } - fn pair_pc_peer(&mut self) { - let Some(base_url) = self.pc_target_base_url() else { return }; - let code = self.pc.code_input.trim().to_string(); + let Ok(code) = connect_code::ConnectCode::decode(&self.pc.code_input) else { return }; + let base_url = code.base_url(); + let secret = code.secret_hex(); let device = self.local_device.clone(); let (tx, rx) = mpsc::channel(); self.pc.events = Some(rx); self.pc.busy = true; self.pc.status = format!("正在连接 {base_url}…"); std::thread::spawn(move || { - let _ = match client::PeerClient::pair(&base_url, &code, &device) { + let _ = match client::PeerClient::pair(&base_url, &secret, &device) { Ok(token) => tx.send(PcEvent::Paired { base_url, token }), Err(e) => tx.send(PcEvent::Failed(format!("{e:#}"))), }; @@ -1300,7 +1298,6 @@ impl QftApp { format!("搜索到 {} 台设备。", peers.len()) }; self.pc.peers = peers; - self.pc.selected_peer = None; self.pc.busy = false; } PcEvent::Paired { base_url, token } => { diff --git a/desktop/src/pairing.rs b/desktop/src/pairing.rs index 9012a51..3676680 100644 --- a/desktop/src/pairing.rs +++ b/desktop/src/pairing.rs @@ -90,22 +90,6 @@ impl PairingPayload { } } -/// 6 位数字配对码,供 PC↔PC 使用。 -/// -/// 桌面端之间没有摄像头,二维码用不上,用户只能目视或口头传递这 6 位。 -/// 用拒绝采样避免取模偏置——虽然此处偏置只有约 1e-5,但没必要留下这种脏细节。 -pub fn new_pair_code() -> String { - let mut bytes = [0u8; 4]; - loop { - rand::rng().fill_bytes(&mut bytes); - let value = u32::from_be_bytes(bytes); - // 4_294_000_000 是 1_000_000 的整数倍中不超过 u32::MAX 的最大值 - if value < 4_294_000_000 { - return format!("{:06}", value % 1_000_000); - } - } -} - pub fn new_session_token() -> String { let mut bytes = [0u8; 16]; rand::rng().fill_bytes(&mut bytes); @@ -181,6 +165,40 @@ fn new_direct_ap_credentials(pc_name: &str) -> (String, String) { (ssid, password[..16.min(password.len())].to_owned()) } +/// 本机可用的私有 IPv4 地址,按「最可能是对方看得到的那一个」排序。 +/// +/// 连接码把地址编进码里,所以这里的排序直接决定了用户第一眼看到的那串码 +/// 是否好用。虚拟网卡(Docker/VPN/虚拟机桥接)会排到后面。 +pub fn local_ipv4_addresses() -> Vec { + let mut ips = Vec::::new(); + if let Ok(addrs) = if_addrs::get_if_addrs() { + for iface in addrs { + let IpAddr::V4(ip) = iface.ip() else { continue }; + if ip.is_loopback() || ip.is_unspecified() || ip.is_link_local() { + continue; + } + if !ip.is_private() { + continue; + } + if !ips.contains(&ip) { + ips.push(ip); + } + } + } + ips.sort_by_key(|ip| { + let o = ip.octets(); + match (o[0], o[1]) { + // Windows 的 ICS / Wi-Fi Direct 固定网段,最可能是 QFT 自己拉起来的 + (192, 168) if o[2] == 137 || o[2] == 49 => 0, + (192, 168) => 1, + (10, _) => 2, + (172, 16..=31) => 3, + _ => 4, + } + }); + ips +} + pub fn local_ipv4_endpoints(port: u16) -> Vec { let mut ips = Vec::::new(); if let Ok(addrs) = if_addrs::get_if_addrs() { diff --git a/desktop/src/receiver.rs b/desktop/src/receiver.rs index cfb8eee..264b961 100644 --- a/desktop/src/receiver.rs +++ b/desktop/src/receiver.rs @@ -59,9 +59,9 @@ struct CompletedUpload { pub struct ReceiverServer { pub port: u16, - /// PC↔PC 用的 6 位配对码:对端没有摄像头,扫不了二维码, - /// 只能靠用户口头/目视传递这 6 位数字来换取会话令牌。 - pub pair_code: String, + /// PC↔PC 的配对秘密(3 字节)。UI 会把它和本机地址一起编成连接码, + /// 用户只需要念/粘贴那一串,不必再单独报 IP 和端口。 + pub secret: [u8; crate::connect_code::SECRET_LEN], stop: Arc, tcp_thread: Option>, udp_thread: Option>, @@ -79,9 +79,10 @@ impl ReceiverServer { let stop = Arc::new(AtomicBool::new(false)); let sessions: SessionMap = Arc::new(Mutex::new(HashMap::new())); let completed: CompletedMap = Arc::new(Mutex::new(HashMap::new())); - // 6 位数字只有约 20 bit 熵,单靠它不足以抵抗在线爆破, - // 因此配一个严格的失败计数:错 5 次即作废,必须重启接收重新生成。 - let pair_code = crate::pairing::new_pair_code(); + // 24 bit 秘密对在线爆破仍然不够,靠严格失败计数兜底: + // 错 5 次即作废,必须重启接收重新生成。 + let secret = crate::connect_code::new_secret(); + let secret_hex: String = secret.iter().map(|b| format!("{b:02x}")).collect(); let pair_failures = Arc::new(AtomicU32::new(0)); let stop_tcp = stop.clone(); @@ -90,7 +91,7 @@ impl ReceiverServer { let token_tcp = session_token.clone(); let dir_tcp = save_dir.clone(); let events_tcp = events.clone(); - let code_tcp = pair_code.clone(); + let code_tcp = secret_hex.clone(); let failures_tcp = pair_failures.clone(); let tcp_thread = thread::spawn(move || { while !stop_tcp.load(Ordering::Relaxed) { @@ -171,7 +172,7 @@ impl ReceiverServer { port, stop, tcp_thread: Some(tcp_thread), - pair_code, + secret, udp_thread: Some(udp_thread), }) }