ci / gate (push) Waiting to run
- 20 个 KDF/HMAC/PSI/TEE/分片/作业种子标签全量换 mpc 前缀,集中到 mpc-core::domain 唯一真相源,业务代码不再写裸字符串 - 等长替换,消息格式与长度不变;mpc-tee 的 COMMIT/EGRESS 消息长度改由 label.len() 计算,避免写死数字漂移 - 不兼容变更:会话密钥、TEE 封存 blob、PSI 盲化点、缓存指纹、分片流全部换钥,参与方须同步升级,旧 blob/缓存/离线物料作废;不提供旧 nax 标签兼容读取 - README/CLAUDE/OPT_PLAN 重写兼容约定与迁移清单;仍保留 refs/nax 路径与 Python 包名 import nax(独立只读仓库真实路径) - golden 向量(ring/paillier/zkp)是纯数学、check_psi.py 只比语义,均不依赖这些标签,无需重生成 - CI 三条闸门全绿(全量测试 / -Dwarnings / mpc-core no_std)
395 lines
14 KiB
Rust
395 lines
14 KiB
Rust
//! 建连认证: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<String>) -> 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<u8, NodeError> {
|
||
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<SessionKeys>), 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<u8, NodeError> {
|
||
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<SessionKeys>), 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)
|
||
);
|
||
}
|
||
}
|