//! 建连认证:PSK 挑战-应答。 //! //! # 解决什么 //! //! 改造前 `TcpMesh` 的握手是 `write_party(me)` / `read_party()` —— //! **对方说自己是谁就信谁**。任何能连到端口的人都能冒充第 j 方, //! 并在 `open` 阶段拿到被公开的中间量。会话主种子又走 `--seed` argv, //! 进程列表可见,等于没有密钥。 //! //! # 协议(三步,双向认证) //! //! ```text //! 主动方 C(标注为 client) 被动方 S(标注为 server) //! REQ { idx=C, na } ──────► //! ◄────── ACK { idx=S, nb, tag_s } //! OK { tag_c } ──────► //! ``` //! //! ```text //! ctx = idx_c ‖ idx_s ‖ na ‖ nb (定长 34 字节,无歧义拼接) //! tag_s = KDF(psk, domain::SESSION_S2C, ctx) 服务端对 ctx 的签名 //! tag_c = KDF(psk, domain::SESSION_C2S, ctx) 客户端对 ctx 的签名 //! ``` //! //! 两侧用**不同的 label**,所以不能把对方的 tag 原样打回来冒充自己。 //! `na`/`nb` 各由一侧生成,任何一方都无法单方面决定 ctx —— 防重放 //! (旧会话的 tag 换不回新 nonce)。 //! //! # 单边配置怎么办:**拒绝,不降级** //! //! | 本端 | 对端 | 结果 | //! |---|---|---| //! | 有 PSK | 有 PSK | 认证通过 | //! | 有 PSK | 无 PSK | 报错(否则中间人可以把 ACK 改成 NONE 让你降级) | //! | 无 PSK | 有 PSK | 报错(对端要求认证) | //! | 无 PSK | 无 PSK | 通过,但这是**无认证**模式,调用方必须明确告知使用者 | //! //! 最后一行是给存量两进程 demo 留的兼容路径,不是推荐用法。 use std::io::{Read, Write}; use std::net::TcpStream; use mpc_core::hmac::{ct_eq, derive_labeled}; use crate::entropy; use crate::NodeError; /// nonce 长度(字节)。 pub const NONCE_LEN: usize = 16; const TAG_NONE: u8 = 0; const TAG_REQ: u8 = 1; const TAG_ACK: u8 = 2; const TAG_OK: u8 = 3; /// 挑战-应答的上下文:`idx_c ‖ idx_s ‖ na ‖ nb`,定长 34 字节。 /// /// 定长是关键:变长拼接会让 `("ab","c")` 和 `("a","bc")` 编码相同, /// 于是两段不同输入得到同一个 tag。 fn ctx_bytes( client_idx: u8, server_idx: u8, na: &[u8; NONCE_LEN], nb: &[u8; NONCE_LEN], ) -> [u8; 2 + 2 * NONCE_LEN] { let mut out = [0u8; 2 + 2 * NONCE_LEN]; out[0] = client_idx; out[1] = server_idx; out[2..2 + NONCE_LEN].copy_from_slice(na); out[2 + NONCE_LEN..].copy_from_slice(nb); out } fn tag_server( psk: &[u8; 32], client_idx: u8, server_idx: u8, na: &[u8; NONCE_LEN], nb: &[u8; NONCE_LEN], ) -> [u8; 32] { derive_labeled(psk, b"server", &ctx_bytes(client_idx, server_idx, na, nb), &[]) } fn tag_client( psk: &[u8; 32], client_idx: u8, server_idx: u8, na: &[u8; NONCE_LEN], nb: &[u8; NONCE_LEN], ) -> [u8; 32] { derive_labeled(psk, b"client", &ctx_bytes(client_idx, server_idx, na, nb), &[]) } /// 握手产出的会话密钥:两条方向**独立**的 32 字节密钥。 /// /// 为什么两条而不是一条:ChaCha20-Poly1305 的计数器在两侧各自从 0 开始, /// 如果同一条密钥双向使用,两边的 nonce 会重合成同一条密钥流 —— 这是 AEAD /// 最经典的致命误用(一次一密用了两次)。按方向拆开,两边各数各的, /// 也不会出现「把收到的帧原样打回去」的反射攻击。 #[derive(Clone)] pub struct SessionKeys { c2s: [u8; 32], s2c: [u8; 32], } impl SessionKeys { /// 发起方 → 被动方方向。 pub fn c2s(&self) -> &[u8; 32] { &self.c2s } /// 被动方 → 发起方方向。 pub fn s2c(&self) -> &[u8; 32] { &self.s2c } } /// 由 PSK 和握手上下文派生会话密钥。 /// /// 复用 `ctx`(含双方下标与两个 nonce):会话密钥因此**绑死这一次握手**, /// 旧会话录下来的密钥材料换不回新 nonce 下的一次会话。 pub(crate) fn session_keys( psk: &[u8; 32], client_idx: u8, server_idx: u8, na: &[u8; NONCE_LEN], nb: &[u8; NONCE_LEN], ) -> SessionKeys { let ctx = ctx_bytes(client_idx, server_idx, na, nb); SessionKeys { c2s: derive_labeled(psk, mpc_core::domain::SESSION_C2S, &ctx, &[]), s2c: derive_labeled(psk, mpc_core::domain::SESSION_S2C, &ctx, &[]), } } fn io_write(s: &mut TcpStream, buf: &[u8]) -> Result<(), NodeError> { s.write_all(buf) .map_err(|e| NodeError::Auth(format!("握手写失败: {e}")))?; s.flush() .map_err(|e| NodeError::Auth(format!("握手 flush 失败: {e}"))) } fn io_read(s: &mut TcpStream, buf: &mut [u8]) -> Result<(), NodeError> { s.read_exact(buf) .map_err(|e| NodeError::Auth(format!("握手读失败(对端可能已断开): {e}"))) } /// 认证失败并**主动关闭连接**。 /// /// 只返回错误而不关连接的话,对端会一直阻塞在自己的 `read_exact` 上, /// 直到 120 秒读超时 —— 现场表现是「握手卡了两分钟才报错」, /// 而且看不出到底谁配错了。关掉连接,对端立刻收到 EOF,错误可归因。 fn fail(s: &mut TcpStream, msg: impl Into) -> NodeError { let _ = s.shutdown(std::net::Shutdown::Both); NodeError::Auth(msg.into()) } /// 主动方握手。返回对端声明的下标(`idx_s`),由调用方校验是否与预期一致。 /// /// 只关心身份时用这个;要拿会话密钥(加密链路)请用 [`client_session`]。 pub fn client(s: &mut TcpStream, my_idx: u8, psk: Option<&[u8; 32]>) -> Result { Ok(client_session(s, my_idx, psk)?.0) } /// 主动方握手,同时返回会话密钥。 /// /// `my_idx` 会写进 `REQ` 并参与 tag 计算,所以**不能**在两侧填不同的约定。 /// 返回的密钥为 `None` 表示双方都没配 PSK —— 链路既未认证也未加密。 pub fn client_session( s: &mut TcpStream, my_idx: u8, psk: Option<&[u8; 32]>, ) -> Result<(u8, Option), NodeError> { let mut na = [0u8; NONCE_LEN]; entropy::fill_random(&mut na)?; let mut req = [0u8; 2 + NONCE_LEN]; req[0] = TAG_REQ; req[1] = my_idx; req[2..].copy_from_slice(&na); io_write(s, &req)?; let mut head = [0u8; 2]; io_read(s, &mut head)?; match head[0] { TAG_NONE => { if psk.is_some() { return Err(fail( s, "对端未配置 PSK,拒绝降级为无认证握手(中间人可以伪造这个 NONE)", )); } Ok((head[1], None)) } TAG_ACK => { let psk = match psk { Some(p) => p, None => { return Err(fail( s, "对端要求 PSK 认证,但本端未配置(见 --psk / MPC_PSK)", )) } }; let server_idx = head[1]; let mut nb = [0u8; NONCE_LEN]; io_read(s, &mut nb)?; let mut got = [0u8; 32]; io_read(s, &mut got)?; let want = tag_server(psk, my_idx, server_idx, &na, &nb); if !ct_eq(&got, &want) { return Err(fail(s, "对端 tag 校验失败:PSK 不一致,或链路中间有人")); } let mut ok = [0u8; 1 + 32]; ok[0] = TAG_OK; ok[1..].copy_from_slice(&tag_client(psk, my_idx, server_idx, &na, &nb)); io_write(s, &ok)?; Ok(( server_idx, Some(session_keys(psk, my_idx, server_idx, &na, &nb)), )) } other => Err(fail( s, format!("握手响应标记非法:{other}(期待 NONE/ACK)"), )), } } /// 被动方握手。返回对端声明的下标(`idx_c`)。 /// /// 只关心身份时用这个;要拿会话密钥(加密链路)请用 [`server_session`]。 pub fn server(s: &mut TcpStream, my_idx: u8, psk: Option<&[u8; 32]>) -> Result { Ok(server_session(s, my_idx, psk)?.0) } /// 被动方握手,同时返回会话密钥。 pub fn server_session( s: &mut TcpStream, my_idx: u8, psk: Option<&[u8; 32]>, ) -> Result<(u8, Option), NodeError> { let mut head = [0u8; 2]; io_read(s, &mut head)?; if head[0] != TAG_REQ { return Err(fail( s, format!("握手首帧标记非法:{}(期待 REQ={TAG_REQ})", head[0]), )); } let client_idx = head[1]; let mut na = [0u8; NONCE_LEN]; io_read(s, &mut na)?; match psk { None => { io_write(s, &[TAG_NONE, my_idx])?; Ok((client_idx, None)) } Some(p) => { let mut nb = [0u8; NONCE_LEN]; entropy::fill_random(&mut nb)?; let mut ack = [0u8; 2 + NONCE_LEN + 32]; ack[0] = TAG_ACK; ack[1] = my_idx; ack[2..2 + NONCE_LEN].copy_from_slice(&nb); ack[2 + NONCE_LEN..].copy_from_slice(&tag_server(p, client_idx, my_idx, &na, &nb)); io_write(s, &ack)?; let mut ok = [0u8; 1 + 32]; io_read(s, &mut ok)?; if ok[0] != TAG_OK { return Err(fail( s, format!( "期待 OK 标记,收到 {}(对端 PSK 不一致会在这一步掉)", ok[0] ), )); } let want = tag_client(p, client_idx, my_idx, &na, &nb); if !ct_eq(&ok[1..], &want) { return Err(fail(s, "客户端 tag 校验失败:PSK 不一致,或链路中间有人")); } Ok(( client_idx, Some(session_keys(p, client_idx, my_idx, &na, &nb)), )) } } } #[cfg(test)] mod tests { use super::*; use std::net::{TcpListener, TcpStream}; fn pair() -> (TcpStream, TcpStream) { let l = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.local_addr().unwrap(); let h = std::thread::spawn(move || TcpStream::connect(addr).unwrap()); let (srv, _) = l.accept().unwrap(); (srv, h.join().unwrap()) } /// 两侧都配了同一个 PSK:握通过,且各自拿到对端下标。 #[test] fn happy_path_with_psk() { let (mut srv, mut cli) = pair(); let psk = [9u8; 32]; let h = std::thread::spawn(move || server(&mut srv, 1, Some(&psk))); let got = client(&mut cli, 0, Some(&psk)).unwrap(); assert_eq!(got, 1, "客户端应拿到服务端下标"); assert_eq!(h.join().unwrap().unwrap(), 0, "服务端应拿到客户端下标"); } /// PSK 不一致:两侧都必须失败(服务端在收 OK 时失败,客户端在验 tag 时失败)。 #[test] fn wrong_psk_rejected_both_sides() { let (mut srv, mut cli) = pair(); let p_ok = [9u8; 32]; let p_bad = [8u8; 32]; let h = std::thread::spawn(move || server(&mut srv, 1, Some(&p_ok))); let e = client(&mut cli, 0, Some(&p_bad)).unwrap_err(); assert!(matches!(e, NodeError::Auth(_)), "客户端应报认证失败,得到 {e:?}"); let se = h.join().unwrap().unwrap_err(); assert!(matches!(se, NodeError::Auth(_)), "服务端应报认证失败,得到 {se:?}"); } /// 单边有 PSK:有 PSK 的一侧拒绝降级。 #[test] fn no_downgrade_when_peer_lacks_psk() { let (mut srv, mut cli) = pair(); let psk = [9u8; 32]; // 服务端没配 PSK → 回 NONE;客户端配了 PSK → 必须拒 let h = std::thread::spawn(move || server(&mut srv, 1, None)); let e = client(&mut cli, 0, Some(&psk)).unwrap_err(); assert!(matches!(e, NodeError::Auth(_)), "应拒绝降级,得到 {e:?}"); assert!(h.join().unwrap().is_ok(), "服务端在 NONE 分支正常返回"); } /// 客户端没有 PSK 但服务端要求认证 → 客户端明确报错,不是静默通过。 #[test] fn client_without_psk_rejects_server_challenge() { let (mut srv, mut cli) = pair(); let psk = [9u8; 32]; let h = std::thread::spawn(move || server(&mut srv, 1, Some(&psk))); let e = client(&mut cli, 0, None).unwrap_err(); assert!(matches!(e, NodeError::Auth(_)), "应报未配置 PSK,得到 {e:?}"); // 服务端会因为读不到 OK 而失败,这也是期望行为 let _ = h.join().unwrap(); } /// 两侧都没有 PSK:兼容旧行为(无认证),但要能跑通。 #[test] fn both_without_psk_still_works() { let (mut srv, mut cli) = pair(); let h = std::thread::spawn(move || server(&mut srv, 1, None)); assert_eq!(client(&mut cli, 0, None).unwrap(), 1); assert_eq!(h.join().unwrap().unwrap(), 0); } /// 同一 PSK 下,ctx 任一字节变化都必须导致 tag 不同(防重放的核心)。 #[test] fn tag_binds_every_ctx_byte() { let psk = [3u8; 32]; let na = [1u8; NONCE_LEN]; let nb = [2u8; NONCE_LEN]; let base = tag_server(&psk, 0, 1, &na, &nb); let mut na2 = na; na2[0] ^= 1; assert_ne!(base, tag_server(&psk, 0, 1, &na2, &nb), "na 变化必须换 tag"); let mut nb2 = nb; nb2[NONCE_LEN - 1] ^= 1; assert_ne!(base, tag_server(&psk, 0, 1, &na, &nb2), "nb 变化必须换 tag"); assert_ne!(base, tag_server(&psk, 1, 1, &na, &nb), "client_idx 变化必须换 tag"); assert_ne!(base, tag_server(&psk, 0, 0, &na, &nb), "server_idx 变化必须换 tag"); } /// client / server 两个 label 必须产生不同 tag —— 否则可以把对方的 tag /// 原样打回去冒充自己。 #[test] fn client_and_server_tags_differ() { let psk = [3u8; 32]; let na = [1u8; NONCE_LEN]; let nb = [2u8; NONCE_LEN]; assert_ne!( tag_client(&psk, 0, 1, &na, &nb), tag_server(&psk, 0, 1, &na, &nb) ); } }