Files
ssw-mpc/crates/mpc-node/src/auth.rs
T
admin 535c63a690
ci / gate (push) Waiting to run
refactor(domain): 协议域分隔常量统一到 mpc-core::domain,nax → mpc
- 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)
2026-11-05 15:29:33 +08:00

395 lines
14 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 建连认证: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)
);
}
}