feat(desktop): PC↔PC 改用连接码,一串搞定,不再单独输 IP

此前发送方要分别念/输三样东西: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 比对)。
This commit is contained in:
zhy200308
2026-08-11 17:29:00 +08:00
parent d2669fb2e4
commit 84643bff5e
5 changed files with 559 additions and 109 deletions
+13 -4
View File
@@ -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");
+425
View File
@@ -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<Self> {
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::<Vec<_>>()
.join("-")
}
/// 解析用户输入。分隔符、大小写、以及 I/L→1、O→0 的手误都会被容忍。
pub fn decode(text: &str) -> Result<Self, CodeError> {
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<u8> {
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<Self, CodeError> {
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<u8>, 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<char> = 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, "每次生成的秘密必须不同");
}
}
+77 -80
View File
@@ -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<ReceiverServer>,
// 发送侧
peers: Vec<discovery::Peer>,
selected_peer: Option<usize>,
manual_address: String,
code_input: String,
token: Option<String>,
connected_base: Option<String>,
@@ -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,28 +1041,42 @@ 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());
ui.heading("把连接码告诉发送方");
ui.small("码里已经包含地址,对方只需输入这一串,不用再报 IP 和端口。");
ui.add_space(8.0);
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| {
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.small("输错 5 次该码即作废,需要重新启动接收。");
ui.add_space(8.0);
ui.label("本机地址(发现不到时可让对方手动输入其中一个):");
for endpoint in pairing::local_ipv4_endpoints(port) {
ui.horizontal(|ui| {
ui.monospace(&endpoint);
if ui.small_button("复制").clicked() {
ui.ctx().copy_text(endpoint.clone());
}
});
ui.add_space(6.0);
ui.small("输错 5 次该码即作废,需要重新启动接收。");
if codes.len() > 1 {
ui.small("本机有多个网卡:对方在哪个网段就用对应的那一串。");
}
});
@@ -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<String> {
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 } => {
+34 -16
View File
@@ -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<Ipv4Addr> {
let mut ips = Vec::<Ipv4Addr>::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<String> {
let mut ips = Vec::<Ipv4Addr>::new();
if let Ok(addrs) = if_addrs::get_if_addrs() {
+9 -8
View File
@@ -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<AtomicBool>,
tcp_thread: Option<JoinHandle<()>>,
udp_thread: Option<JoinHandle<()>>,
@@ -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),
})
}