Files
ssw-mpc/crates/mpc-cli/src/main.rs
T
admin f676a6aa97 fix(registry): 节点自报支持 optee/none,平台名解析收敛为一份口径
PlatformKind 新增 ALL/as_str/parse,Display 由 as_str 派生;规范名解析唯一来源下沉到枚举定义处。

TeeNode::parse 删除手写 parse_kind;hostd parse_platform 与 CLI 四处别名表复用同一份规范名,历史别名继续可用。

影响:kind=optee/none/tdx 可登记并出现在 GET /nodes;admit()/builtin() 不变,注册不因缺少 guest 启动规格被拒。

回归:规范名契约、全变体 descriptor 往返、optee/none 端到端注册单测;全量测试与 25 步门禁全绿。
2026-11-11 15:11:52 +08:00

4267 lines
176 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.
//! `mpc` —— 单二进制入口。
//!
//! 这一版只有 `selftest`:在**本机单进程**里把算子核的关键路径跑一遍,
//! 用来确认"二进制能起来、密码学没写错、TEE 抽象可用"。
//!
//! 真正的多进程集群(`mpc node` / `mpc run`)在 P1/P2 落地,
//! 见 `docs/ARCHITECTURE.md` 的路线图。
use std::process::ExitCode;
use std::time::Duration;
use mpc_core::prg::Stream;
use mpc_core::ring;
use mpc_core::share::{reconstruct_into, split_into, Dealer};
use mpc_node::{
run_lr_session, run_lr_vertical_session, run_psi_session, run_session, Frame, LrConfig,
NodeError, PsiConfig, SessionConfig, TcpMesh, TcpTransport, Transport, VerticalLrConfig,
VaultError,
};
use mpc_orch::{Agent, Assign, JobPlan, Orchestrator, Report, StateLog};
use mpc_orch::state as orch_state;
use mpc_fl::fedavg::{ClientData, FedAvg};
use mpc_tee::mock::MockTee;
use mpc_tee::Tee;
/// 进度/诊断行 —— `println!` 的替代品。
///
/// `--report json` 时会自动改走 stderr,让 stdout 保持纯 JSON 流。
/// 用的地方和执行顺序都跟原来的 `println!` 一致,文本模式观感不变。
///
/// 定义在 `mod` 声明之前:`macro_rules!` 是按文本顺序生效的,
/// 放在后面的话 `sql_demo` / `sql_join` 这些子模块就看不见它。
macro_rules! note {
($($t:tt)*) => { $crate::report::note(format_args!($($t)*)) };
}
// ★ guest 静态产物(musl 目标)不得携带宿主控制面。
// 忘了 --no-default-features 时,openssl-sys 只会报一句含混的
// "pkg-config has not been configured to support cross-compilation",
// 很容易被误当成「装个依赖就好」而把 OpenSSL 编进 enclave。
// 这里把边界写成编译期硬拒绝,报错直接指出正确做法。
//
// ★ 两种 musl 产物的区别(2026-11-07 真机联调时定下的):
//
// 1. **guest 产物**(TEE enclave 里跑的那个):
// `--no-default-features` —— **不含任何**宿主控制面。
// 只带 attest-* / kbs-get / verify / selfcheck 这一族。
// 2. **宿主侧 musl 产物**(TEE 真机上跑的 hostd):
// `--no-default-features --features host-only` —— 含 mpc-hostd,
// **不含** mpc-chain(后者要系统 OpenSSL,musl 下没有)。
// 真机没有 Rust 工具链,需要自包含静态二进制把 hostd 跑起来;
// hostd 不含 OpenSSL,所以 musl 静态链接得出来。
//
// 两份产物**不是同一个二进制**,边界由主门禁第 4 条 +
// tools/check-guest-artifact.py 分别钉死。
#[cfg(all(target_env = "musl", feature = "control-plane"))]
compile_error!(
"musl 静态产物是 TEE guest,禁止链接宿主控制面(mpc-hostd / mpc-chain / OpenSSL);\n\
\x20 · guest 产物(跑在 TEE 里):交叉编译请加 --no-default-features\n\
\x20 · 宿主侧产物(跑在 TEE 真机上的 hostd):\
请加 --no-default-features --features host-only"
);
#[cfg(feature = "secure")]
mod pg_source;
mod report;
/// SA 扩展模式:`sa-serve`(安全世界侧)/ `sa-client`(外挂 VM 侧)。
///
/// ★ 这两个命令**要**进 guest 静态产物 —— SA 服务端要跑在板子上,
/// 而板子没有 Rust 工具链,只能靠交叉编译的静态二进制。
/// 它们只依赖 `mpc-tee`(零 crates.io 依赖),不碰 hostd / chain,
/// 所以不破坏 guest 边界(见 tools/check-guest-artifact.py)。
mod sa;
#[cfg(feature = "secure")]
mod sql_demo;
#[cfg(feature = "secure")]
mod sql_join;
// ★ ★ 宿主控制面模块的门控是「`control-plane` **或** `host-only` 任一成立」。
//
// 两个 feature 的区别在**依赖**,不在**模块**:
// - `control-plane` = 宿主端完整控制面(hostd + link + chain + OpenSSL);
// - `host-only` = 只带 hostd(**不含** chain,因为 chain 要 OpenSSL,
// 而 musl 下没有 libcrypto)—— 真机没有 Rust 工具链,
// 要的就是这份自包含静态二进制。
//
// ★ 若这里只写 `#[cfg(feature = "control-plane")]`:
// host-only 产物里 `mod hostd` 不成立 ⇒ hostd 代码根本没编进去
// ⇒ 产物与 guest 产物**一模一样大、且不含 hostd 标识**。
// 症状极隐蔽:编译通过、门禁第 4 条的「host 产物更大」判据才红。
#[cfg(any(feature = "control-plane", feature = "host-only"))]
mod hostd;
/// 集群控制面命令(CubeMaster 等价物):收自报 / 选址 / 对账 / 公布端点。
#[cfg(any(feature = "control-plane", feature = "host-only"))]
mod control_plane;
#[cfg(any(feature = "control-plane", feature = "host-only"))]
mod link;
/// ★ `chain` 只在 `control-plane` 下存在 —— 它依赖系统 OpenSSL,
/// musl 目标下拉不进来(见 Cargo.toml 的 target 依赖声明)。
#[cfg(feature = "control-plane")]
mod chain;
const VERSION: &str = env!("CARGO_PKG_VERSION");
/// CLI 输入层的平台解析:规范名走 [`mpc_tee::PlatformKind::parse`] 这一份
/// 协议口径,历史别名只在 CLI 这一层放宽。
///
/// 早先四个子命令各写一份 `match`,新增变体时总有一处漏(issue #3 的
/// 同类漂移)。现在规范名只有枚举定义处一份,这里只管别名。
pub(crate) fn parse_platform_loose(raw: &str) -> Option<mpc_tee::PlatformKind> {
use mpc_tee::PlatformKind as K;
if let Some(kind) = K::parse(raw) {
return Some(kind);
}
match raw {
"snp" | "amd" => Some(K::SevSnp),
"csv" | "hygon" => Some(K::HygonCsv),
_ => None,
}
}
fn main() -> ExitCode {
let raw: Vec<String> = std::env::args().skip(1).collect();
// `--report` 是全局开关,出现在子命令前后都认;摘掉再分发,
// 免得 `mpc --report json fl` 把 "--report" 当成命令名。
let (args, json) = match split_report_flag(&raw) {
Ok(v) => v,
Err(e) => {
eprintln!("失败: {e}");
return ExitCode::from(2);
}
};
report::set_json(json);
let cmd = args.first().map(String::as_str).unwrap_or("help");
let r = match cmd {
"selftest" => selftest(),
"selfcheck" => cmd_selfcheck(&args[1..]),
"trust" => cmd_trust(&args[1..]),
"tee" => cmd_tee(&args[1..]),
// ★ 宿主控制面这一族**只在宿主产物里存在**。
// guest 静态产物(--no-default-features)不含这些模块,
// 所以 dispatch 分支必须与 `mod` 声明**用同一个 cfg** ——
// 否则 guest 产物编译不过(模块找不到)。
// ★ `chain` 只在 `control-plane` 下(它要 OpenSSL),
// 其余三个 `control-plane` / `host-only` 任一即可。
#[cfg(any(feature = "control-plane", feature = "host-only"))]
"hostd" => hostd::cmd_hostd(&args[1..]),
#[cfg(any(feature = "control-plane", feature = "host-only"))]
"control-plane" => control_plane::cmd_control_plane(&args[1..]),
#[cfg(any(feature = "control-plane", feature = "host-only"))]
"link" => link::cmd_link(&args[1..]),
#[cfg(feature = "control-plane")]
"chain" => chain::cmd_chain(&args[1..]),
"plan" => cmd_plan(&args[1..]),
"node" => cmd_node(&args[1..]),
"cluster" => cmd_cluster(&args[1..]),
"orch" => cmd_orch(&args[1..]),
"agent" => cmd_agent(&args[1..]),
"psi" => cmd_psi(&args[1..]),
"lr" => cmd_lr(&args[1..]),
"lr-vertical" => cmd_lr_vertical(&args[1..]),
"fl" => cmd_fl(&args[1..]),
#[cfg(feature = "secure")]
"sql" => sql_demo::run(&args[1..]),
#[cfg(feature = "secure")]
"sql-plan" => cmd_sql_plan(&args[1..]),
#[cfg(feature = "secure")]
"sql-join" => cmd_sql_join(&args[1..]),
#[cfg(feature = "secure")]
"pg" => pg_source::cmd(&args[1..]),
"version" | "-V" | "--version" => {
note!("mpc {VERSION}");
Ok(())
}
"help" | "-h" | "--help" => {
usage();
Ok(())
}
other => {
eprintln!("未知命令: {other}\n");
usage();
return ExitCode::from(2);
}
};
match r {
Ok(()) => ExitCode::SUCCESS,
Err(e) => {
eprintln!("失败: {e}");
ExitCode::FAILURE
}
}
}
fn usage() {
#[cfg(not(any(feature = "control-plane", feature = "host-only")))]
note!(
"★ 本产物是 TEE guest 静态二进制(--no-default-features),不含宿主控制面:\
下文 mpc hostd / link / chain 与 mpc tee up|ps|attest|down 条目均不可用,\
请在宿主端 mpc 上执行。\n"
);
// ★ host-only 产物(真机上的 hostd)有 hostd / control-plane / link,
// 但**没有** chain(chain 要系统 OpenSSL,musl 下拉不进来)。
#[cfg(all(feature = "host-only", not(feature = "control-plane")))]
note!(
"★ 本产物是 TEE 真机侧的 hostd 静态二进制(--features host-only):\
含 mpc hostd / control-plane / link,但**不含**链上层(mpc chain 需要系统 OpenSSL)。\n"
);
note!(
"ssw-mpc {VERSION} —— 尚数网-多方安全计算
用法:
mpc selftest 跑一遍算子核与 TEE 抽象的端到端自检
mpc selfcheck 报出本二进制的 SHA-256 / 体积(产物自校验,可 --expect 复核)
mpc trust 按各方 TEE 状况算出可信度方案 L0–L3(不联网)
mpc tee paths 列出内置的 AMD SEV-SNP / 海光 CSV 直接启动规格(不联网)
mpc tee plan 按宿主预检结果做 fail-closed 准入,输出 qemu 启动规格(不联网)
mpc hostd 启动宿主控制面 mpc-hostd(e2b 兼容 API,默认只听回环)
mpc control-plane serve|nodes|sessions|set-desired|report
集群控制面(CubeMaster 等价物):收节点自报 / 选址 / 对账下发 /
公布已证明通过的会话端点(与单机 hostd 面分开,默认只听回环)
mpc tee up|ps|attest|down
宿主端:起/列/查证明/停 TEE 实例,走 --host HOST:PORT
mpc link plan|verdict|credential
会话级链路:生成 EasyTier argv / 判实际路径 / 签发撤销凭据
(与 e2b 兼容面独立;长驻进程由部署层 exec,不归框架托管)
mpc plan 把纵向 LR 梯度图编译成执行计划,报出交互轮数(不联网)
mpc node 启动一方节点,与对端跑一次密文会话
mpc psi 启动一方节点,与其余方做一次隐私求交(n 方 ECDH-PSI)
mpc lr-vertical 真纵向 LR:各方持不同客户/不同特征列,n 方(PSI → 对齐 → 密态训练)
mpc fl 横向联邦平均(FedAvg)本地演示(无网络,合成数据)
mpc orch run 按计划文件跑多作业(DAG),状态可落盘
mpc orch status 从状态目录读回作业进展(不依赖进程还活着)
mpc sql in-process 2 方密态 SQL 演示(编译需 --features secure)
mpc sql-plan 把一条聚合查询编译成执行计划,报出交互轮数(不联网,需 --features secure)
mpc sql-join 真两进程 TCP 的 JOIN×PSI×密态 SQL(编译需 --features secure)
mpc sql / mpc sql-plan 都支持 --group-mode exact|coded(默认 exact):
coded 走整数分组码前缀和,8 组时 13 → 12 轮;要求分组码是 0..n-1 的整数,
且不支持 MIN/MAX(前缀和还原不出分组极值)
mpc pg 连一条 PostgreSQL 跑一条 SQL,把列类型摊开(排障用,需 --features secure)
mpc version 打印版本
mpc help 显示本帮助
全局开关(可放在子命令前后):
--report text|json
text(默认)给人看;json 输出 NDJSON,一行一个对象。
对象字段固定为 kind / title / header / rows(table),或 kind / rows(kv),
进度行改走 stderr,因此 `mpc fl --report json | jq .` 直接可用。
mpc selfcheck 参数:
--file PATH 校验指定文件而不是自身(核对分发出去的产物)
--expect HEX 与已知摘要比对,不一致则非零退出
--out PATH 写一份清单 JSON(tool/version/size/sha256/platform/tee)
--tee-sign 额外用 TEE 设备密钥对摘要签名(当前仅 mock 平台)
mpc trust 参数:
--parties A=K[:tcb][+attested],B=none,... 各方 TEE 状况(必填)
K 取 none / optee / sev-snp / tdx / hygon-csv
`+attested` 表示该方已通过远端证明验证(不做默认假设)
--min-tcb N 可接受的最低 TCB 版本(默认 0)
--allow-plaintext-merge 明示允许 L2 把明文合到一处算(默认不允许)
打开它等于放弃 MPC 那层数学保障,只信 TEE 隔离
mpc tee 参数(直接调度 TEE,不经过任何容器编排层):
mpc tee paths
列出内置平台规格:guest policy / KBC / 证明通道 / qemu 对象 / 配额。
mpc tee plan --node PATH --session-id HEX --pubkey HEX
--node PATH 宿主预检产出的节点描述(key=value,见 deploy/tee/README.md)
--session-id HEX 本轮会话标识(64 位十六进制)
--pubkey HEX 本轮会话公钥哈希(64 位十六进制)
--min-tcb N 最低 TCB(默认 0)
--variant NAME 海光代际 csv|csv2|csv3|csv-dcu(默认 csv2)
--kbc MODE 节点实际启用哪种密钥代理 online|offline
(覆盖节点描述的 kbc=;缺省按节点描述)
--require-kbc MODE 准入要求必须是哪种模式,不符即拒绝
--kbs-endpoint URL 在线 KBS 地址(覆盖节点描述的 kbs_endpoint=)
--pin HEX 额外 pin 一份镜像度量(64 位十六进制)
--argv 额外打印可直接执行的 qemu argv
--demo 用固定示例会话值做离线演练(会明确警告,不能上生产)
准入任一项不满足即失败,不存在降级通过;输出的是启动规格,不是部署清单。
mpc tee verify --report FILE --platform snp|csv|tdx|optee
--report PATH 证明报告原始字节文件
--platform K 报告所属平台(给了 --node 时可省,取节点描述里的平台)
--user-data HEX 报告里那 64 字节挑战值(128 位十六进制)
--session-id HEX 本轮会话标识(64 位十六进制)
--pubkey HEX 本轮会话公钥哈希(64 位十六进制)
--site NAME 本方站点名(给了 --node 时可省)
--measurement HEX 代码度量 pin(给了 --node 时可省,取节点描述里的 measurement)
--tcb N 节点 TCB(给了 --node 时可省,取节点描述里的 tcb)
--node PATH 节点描述文件:**与 tee plan 用同一份**。
site / measurement / tcb / platform 默认全部取自它 ——
这几个值参与 user_data 绑定,手工重填极易对不上,
而对不上时报出来的是「疑似重放报告」,会误导排查方向。
--min-tcb N 最低 TCB 门槛(默认 0)
--pin HEX 额外 pin 一份度量(64 位十六进制)
--verifier PATH 外部芯片验签器(stdout 打印 OK 或 verified=true 视为通过)
--verifier-arg A 传给验签器的额外参数(可重复)
--certs PATH 证书链文件(传给验签器)
结论里严格区分「芯片签名未验证」与「已验证」,Ok 不等于硬件证明通过。
mpc tee kbs-get --endpoint HOST:PORT --repo R --kind K --session-id HEX
guest 内从 KBS 取回密钥物料(在线 KBC 用)。
mpc hostd
启动宿主控制面 mpc-hostd(e2b 兼容 API + /attestation)。
--listen ADDR 监听地址(默认 127.0.0.1:3010)
--reap-interval N reaper 扫描间隔秒(默认 5)
--state-file PATH 状态落盘路径(重启后按 pid + 启动标识校验孤儿)
--shared-secret S 站点端与宿主端共享的密钥(至少 32 字节)。
也可用环境变量 MPC_HOSTD_SHARED_SECRET 传(**参数优先**,
密钥进 argv 会出现在 ps 输出里)。
配了它 = 凭据模式:每个请求都要带
Authorization: Bearer <secret>,缺/错一律 401。
★ 同一个密钥也用于「向控制面自报」的鉴权
(控制面在凭据模式下会拒掉没带 token 的自报)。
不配 = 回环信任模式(不带凭据的请求放行)。
--allow-remote 允许绑非回环地址。**必须同时配 --shared-secret** ——
没有共享密钥时,--allow-remote 只是把无鉴权的控制面
挂到网上,任何人都能起 guest、读远程证明。
★ 节点自报(Cubelet 自描述等价物):本宿主探测自己的 TEE 能力并
周期推给集群控制面,省掉「人手喂节点描述」。
--node-platform P 本宿主平台(snp / csv)。**不给就不自报**。
--node-site S 本方 site 名
--node-host H 宿主地址
--node-tcb N TCB 版本号
--node-qemu PATH qemu 可执行文件
--node-firmware PATH 固件路径
--node-kernel PATH guest 内核
--node-initrd PATH guest initrd
--node-kbc MODE online / offline(给了 --node-kbs-endpoint 默认为 online)
--node-kbs-endpoint E KBS 端点(在线 KBC 用)
--node-capacity N 本宿主能并发承载的 TEE 会话数(默认 1)
--control-plane HOST:PORT 集群控制面地址;配了它就周期把自报推过去
--report-interval N 自报推送间隔秒(默认 15)
★ 能力位由探针**核实文件是否存在**得出:路径填了但文件不在 ⇒
该能力位为 false ⇒ 准入端拒这个节点(不猜、不降级)。
★ 注册阶段不 pin 度量(每台启动后才有真实度量),pin 留给会话级准入。
★ 配了 --control-plane 却没配 --node-platform ⇒ **拒绝启动**
(推送线程会永远空转 = 假就绪信号)。
★ 芯片验签器(宿主侧独立判定用):
--attest-verifier PATH 外部验签器程序(stdout 打印 OK 或 verified=true 视为通过)
--attest-verifier-arg A 传给验签器的额外参数(**一个 flag 一个 argv**,可重复)
--attest-chain-dir PATH 证书链缓存目录(**必须已存在**;不存在会退化成联网取证书,
真机离线 ⇒ 每次验签都失败,而症状只是 chip_sig 一直 false)
★ 不配验签器不是错,但宿主侧会记「未提供验签器」(= **没验**,不是「验了没过」),
集群面按 require_chip_sig=true 门控时端点**不会**被公布。
★ guest 回传证明材料(宿主要独立判定,必须拿到原始证明包字节):
--guest-endpoint HOST:PORT **guest 能路由到的**宿主地址
(如 tap 网段里的 10.93.0.1:3010)。宿主监听 0.0.0.0 对 guest 无效。
配了它,hostd 会给每个实例生成**一次性**上传令牌,
连同 sandbox_id 写进一个每实例一个的目录,用 **9p** 挂给 guest
(令牌**绝不进 argv** —— argv 在宿主上明文可见)。
不配 ⇒ 不下发手牌 ⇒ guest 传不回材料 ⇒ 判定停在 pending ⇒
端点不公布(**诚实**的失败,不是缺陷)。
mpc tee up|ps|attest|down --host HOST:PORT
宿主端:走 e2b 兼容 API 操作 mpc-hostd。
--host HOST:PORT 宿主控制面地址(默认 127.0.0.1:3010)
--token TOKEN 站点端与宿主端的**共享密钥**(放进 Authorization: Bearer 头)。
宿主端配了密钥时**强制校验**:缺/错一律 401。
★ 这**不是**「站点端签发的短期 token」——
那一层(session_admit 产物,带会话绑定与有效期)
还没落地;当前只是静态共享密钥。
up 还需要 --session S --site S --platform snp|csv|tdx|optee --program PROG,
可重复 --arg A 传程序参数,--timeout N 秒。
attest 输出里 user_data_ok / meas_ok / tcb_ok / chip_sig **四个布尔分开报**;
chip_sig=0 的含义是「绑定关系成立,但没做芯片验签」,不是「验证通过」。
--endpoint HOST:PORT KBS 地址(不带 scheme)
--repo R 资源仓库名(默认 mpc)
--kind K 物料种类 psk|seed|root-key
--session-id HEX 本轮会话标识(64 位十六进制,作资源 tag)
--tag TAG 直接指定资源 tag(与 --session-id 二选一)
--token T 证明代理产物(原样带给服务端;服务端必须自己验证明)
--out PATH 写文件(不给则打到 stdout)
响应必须带准确的 Content-Length(非 chunked),非 200 一律报错 ——
不返回任何物料,没有「先给个默认值」的分支。
mpc node 参数:
--site NAME 本方站点名(必填)
--sites A,B 全体站点,逗号分隔(必填,各方必须一致)
--listen ADDR 监听地址(两方被动方 / n 方必填)
--connect ADDR 连接对端地址(仅两方主动方)
--peers A=ADDR,B=ADDR,... n 方地址表(与 --listen 搭配)
--data V,V,... 本方持有的数据(浮点,逗号分隔)
--fxp N 定点小数位(默认 18)
--seed HEX 会话主种子,64 位十六进制(默认全 0,仅测试)
--psk-file PATH 身份认证用的预共享密钥(64 位十六进制,推荐;文件设 0600)
--psk HEX 同上,但会出现在 ps / 进程列表里(排障用,别上生产)
也可用环境变量 MPC_PSK。配了即双向认证 + 全链路加密(ChaCha20-Poly1305);
不配 = 既不认证也不加密,启动会明确警告
接 Ray 做成员目录(需 `cargo build --features ray`):
设了 MPC_RAY_RAYLET 就会先把本进程注册成 Ray cluster 的一个 driver,
拿到 raylet 分配的 node id,再跑下面的会话。Ray 只提供「我在哪台机、
带什么标签」,计算仍走 mpc 自己的 TCP 帧。
MPC_RAY_GCS GCS 的 redis 地址,如 127.0.0.1:6400(1.0.1 用 redis,不是 gRPC 端口)
MPC_RAY_RAYLET 本节点 raylet socket 路径(必填,设了它就启用)
MPC_RAY_PLASMA 本节点 plasma socket 路径(必填)
MPC_RAY_NM_PORT raylet 的 node_manager 端口(必填)
MPC_RAY_NODE_IP 本机 IP,默认 127.0.0.1
MPC_RAY_JOB job id 整数,默认 1
两进程示例:
mpc node --site bob --sites alice,bob --listen 127.0.0.1:9444 --data 4,5,6 &
mpc node --site alice --sites alice,bob --connect 127.0.0.1:9444 --data 1,2,3
# 两侧都会算出 (x·y+1) 的求和 = 35
三进程示例(网状直连,算出 x·y·z + 1 的求和):
mpc node --site alice --sites alice,bob,carol --listen 127.0.0.1:9450 \
--peers alice=127.0.0.1:9450,bob=127.0.0.1:9451,carol=127.0.0.1:9452 --data 2 &
mpc node --site bob --sites alice,bob,carol --listen 127.0.0.1:9451 \
--peers alice=127.0.0.1:9450,bob=127.0.0.1:9451,carol=127.0.0.1:9452 --data 3 &
mpc node --site carol --sites alice,bob,carol --listen 127.0.0.1:9452 \
--peers alice=127.0.0.1:9450,bob=127.0.0.1:9451,carol=127.0.0.1:9452 --data 5
# 三方都输出 2·3·5 + 1 = 31
mpc psi 参数:
--site / --sites / --listen / --connect / --peers / --seed 同 mpc node
--ids 1,2,3,... 本方的 ID 集合(非负整数,逗号分隔)
两进程示例:
mpc psi --site bob --sites alice,bob --listen 127.0.0.1:9445 --ids 3,4,5,6,7 &
mpc psi --site alice --sites alice,bob --connect 127.0.0.1:9445 --ids 1,2,3,4,5
# 交集 = 3,4,5
三进程示例(环协议,n 方求交):
S=alice,bob,carol
P=alice=127.0.0.1:9450,bob=127.0.0.1:9451,carol=127.0.0.1:9452
mpc psi --site alice --sites $S --listen 127.0.0.1:9450 --peers $P --ids 1,2,3,4,5 &
mpc psi --site bob --sites $S --listen 127.0.0.1:9451 --peers $P --ids 3,4,5,6,7 &
mpc psi --site carol --sites $S --listen 127.0.0.1:9452 --peers $P --ids 4,5,6,7,8
# 三方都输出 4,5(两两求交会多出 3 和 6,7)
mpc lr 参数:
--site / --sites / --listen / --connect / --seed / --fxp 同上
--data-x V,V,... 本方特征矩阵(平铺 n×d,行主序)
--data-y V,V,... 标签(长度 n;两方都要传同样的标签)
--n N 样本数
--d N 特征数
--epochs N 训练轮数(默认 40)
--lr F 学习率(默认 0.5)
两进程示例:
mpc lr --site bob --sites alice,bob --listen 127.0.0.1:9446 \
--data-x 1,2,3,4,5,6 --data-y 0,1,0 --n 3 --d 2 &
mpc lr --site alice --sites alice,bob --connect 127.0.0.1:9446 \
--data-x 1,2,3,4,5,6 --data-y 0,1,0 --n 3 --d 2
# 双方都输出训练后的权重(--data-x 是 n×d 个,--data-y 是 n 个)
mpc lr-vertical 参数:
--site / --sites / --listen / --connect / --peers / --seed / --fxp 同上
--col-blocks A:OFF:LEN,B:... 各方列块(site:offset:len),必须铺满 0..d_total
例 alice:0:1,bob:1:1,carol:2:1 —— 三方各持 1 列,按序拼接
--label-owner NAME 标签由哪一方提供(必须恰好一方,其余方不要给 --data-y)
--data-ids V,V,... 本方的 join 键(长度 = 样本数)
--data-x V,V,... 本方特征(平铺 样本数×本方列数,行主序)
--data-y V,V,... 标签(只有 label-owner 给)
--epochs N / --lr F 训练轮数(默认 40)/ 学习率(默认 0.3)
密态通道走 --listen / --peers 的**端口 +1**,不用再给一组地址。
n 方用 --listen + --peers;两方才可用 --connect。
三方示例:
mpc lr-vertical --site alice --sites alice,bob,carol --listen 127.0.0.1:39301 \
--peers alice=127.0.0.1:39301,bob=127.0.0.1:39311,carol=127.0.0.1:39321 \
--col-blocks alice:0:1,bob:1:1,carol:2:1 --label-owner bob \
--data-ids 7,2,4,1,8,3,9,5 --data-x 0,-0.75,-0.25,-1,0.75,-0.5,1,0
# 其余两方类似(bob 额外给 --data-y)
mpc orch run 参数(多作业 DAG):
--plan FILE 计划文件(文本,格式见下)
--sites A,B 全体站点(必填,与运行时上线的 agent 一致)
--listen ADDR 监听地址(默认 0.0.0.0:9447)
--state-dir DIR 状态落盘目录(强烈建议给;不给就只在内存里)
--fxp / --seed / --timeout 同 mpc cluster
mpc orch status 参数:
--state-dir DIR 与 run 时同一个目录
--job NAME 只看这一个作业(多打一张各方明细表)
计划文件格式(# 开头是注释,空行忽略):
job A ← 作业名
deps - ← 依赖,- 表示没有;多个写 deps A,B
expect 35 ← 可选:算完之后的后置条件,不符即判失败
data alice=1,2,3 bob=4,5,6 ← 各方输入;不写就用该方 agent 自己的 --data
job B
deps A
expect 999
job C
deps B ← B 失败时 C 会被跳过,并记下原因
三终端示例:
mpc orch run --plan demo.plan --sites alice,bob --state-dir /var/lib/mpc/state
mpc agent --site alice --orch 127.0.0.1:9447 --listen 127.0.0.1:9451
mpc agent --site bob --orch 127.0.0.1:9447 --listen 127.0.0.1:9452
# 跑完看进展(进程退了也能看):
mpc orch status --state-dir /var/lib/mpc/state
mpc fl 参数(本地演示,无需网络):
--clients N 客户端数(默认 3)
--features D 特征维数(默认 4,权重 = D+1 含偏置)
--per-client M 每客户端样本数(默认 40)
--rounds R 联邦轮数(默认 12)
--local-epochs E 每轮本地训练轮数(默认 2)
--lr F / --l2 F 学习率(0.5)/ L2 正则(0.0)
--clip F / --noise F DP 裁剪阈值 / 高斯噪声乘数(默认 0 = 关闭)
--seed HEX 主种子,64 位十六进制(默认全 0)
示例:
mpc fl --clients 4 --features 6 --per-client 50 --rounds 15 --lr 0.6
# 合成可分离数据上跑横向 FedAvg,逐轮打印 loss/acc/auc
mpc sql-join 参数(需 --features secure):
--site / --sites / --listen / --connect / --seed / --fxp 同 mpc node
--schema C1,C2,... 全局列序(两方必须完全一致)
--agg-col NAME 要聚合的列(必须在 schema 里)
--pred A>=B 可选,密态 WHERE(列 vs 列 / 列 vs 常量)
本方数据二选一:
--ids 1,2,3 --data balance=700,200,... 手输
--pg-url postgres://u@host:5432/db --pg-query \"SELECT uid, balance FROM t\" \
[--pg-id-col uid] 直连业务库(整数键 + 数值列)
--pg-url 也可以用环境变量 MPC_PG_URL;密码放 MPC_PG_PASSWORD(别写进 argv)
示例(两终端,一方读库一方手输):
mpc sql-join --site bob --sites alice,bob --listen 127.0.0.1:9449 \
--pg-url postgres://[email protected]:5432/shop \
--pg-query \"SELECT uid, spend FROM orders\" \
--schema balance,spend --agg-col spend
mpc sql-join --site alice --sites alice,bob --connect 127.0.0.1:9449 \
--ids 2,3,4 --data balance=200,400,300 \
--schema balance,spend --agg-col spend
mpc pg 参数(排障用,需 --features secure):
--url postgres://u@host:5432/db 或环境变量 MPC_PG_URL
--sql \"SELECT ...\" 只跑一条(Simple Query)
--frames 额外打印「真正进密态计算的那几列」
用途:sql-join 连不上/列被丢/键不是整数时,先用它把「库这条路」单独跑通
示例: mpc pg --url postgres://[email protected]:5432/db --sql \"select uid, balance from t\" --frames
本地没有 Postgres?tools/pg-dev/ 里有 PGlite(真 Postgres 的 WASM 版):
tools/pg-dev/e2e.sh 一键起两个库 + 跑完整两方密态聚合 + 断言
规划中 (见 docs/ARCHITECTURE.md):
mpc run <plan.yaml> 执行计算计划
mpc audit show 查看审计链"
);
}
// ---------------------------------------------------------------------------
fn selftest() -> Result<(), String> {
note!("mpc {VERSION} selftest");
// 每步返回「一行说明」,由 selftest 统一成表 —— 文本模式和
// `--report json` 用的是同一份数据,不会出现两边口径不一致。
type Step = (&'static str, fn() -> Result<String, String>);
let steps: [Step; 5] = [
("定点编码往返", step_fixed_point),
("两方分片 / 重建", step_share_roundtrip),
("两方 Beaver 乘法", step_beaver_mul),
("TEE 密封 / 解封 / 证明", step_tee_seal),
("明文域 / 密态域一致性", step_device),
];
let mut rows: Vec<Vec<report::Cell>> = Vec::new();
let mut failed: Option<String> = None;
for (i, (name, f)) in steps.iter().enumerate() {
match f() {
Ok(detail) => rows.push(vec![
report::Cell::int((i + 1) as i64),
report::Cell::txt(*name),
report::Cell::flag(true),
report::Cell::txt(detail),
]),
Err(e) => {
rows.push(vec![
report::Cell::int((i + 1) as i64),
report::Cell::txt(*name),
report::Cell::flag(false),
report::Cell::txt(e.clone()),
]);
failed = Some(e);
break;
}
}
}
report::table("自检步骤", &["#", "步骤", "通过", "说明"], &rows);
match failed {
Some(e) => Err(e),
None => {
note!("\n全部通过");
Ok(())
}
}
}
fn step_fixed_point() -> Result<String, String> {
let vals = [0.0f64, 1.0, -1.0, 3.14159265358979, -987.654, 0.125];
for v in vals {
let e = ring::encode(v, 18).map_err(|e| e.to_string())?;
let d = ring::decode(e, 18);
if (d - v).abs() > 1e-4 {
return Err(format!("{v} -> {d} 误差过大"));
}
}
// 银行家舍入必须与 numpy 的 np.rint 一致
if ring::encode(2.5, 0).map_err(|e| e.to_string())? != 2 {
return Err("银行家舍入错误:2.5 应舍到 2".into());
}
if ring::encode(3.5, 0).map_err(|e| e.to_string())? != 4 {
return Err("银行家舍入错误:3.5 应入到 4".into());
}
Ok("含银行家舍入,与 np.rint 一致".into())
}
fn step_share_roundtrip() -> Result<String, String> {
let n = 2usize;
let secret: Vec<u64> = (0..64).map(|i| (i * 7919) as u64).collect();
let mut s = Stream::new(&[42u8; 32]);
let mut shares = vec![0u64; n * secret.len()];
split_into(&secret, n, &mut s, &mut shares, 18).map_err(|e| e.to_string())?;
let mut back = vec![0u64; secret.len()];
reconstruct_into(&shares, n, secret.len(), &mut back).map_err(|e| e.to_string())?;
if back != secret {
return Err("重建结果与原始秘密不一致".into());
}
if shares[..secret.len()] == secret[..] {
return Err("单方分片等于秘密本身,分片没起作用".into());
}
Ok(format!("{} 个元素,单方分片 ≠ 秘密", secret.len()))
}
/// 两方 Beaver 乘法 —— MPC 的核心协议,在这里一步不省地跑一遍。
///
/// 全程只有两次 `open`(把带随机掩码的差值公开),其余都是本地运算。
fn step_beaver_mul() -> Result<String, String> {
let n = 2usize;
const FXP: u32 = 0; // 用整数域验证协议本身,避免截断干扰
let x: u64 = 12345;
let y: u64 = 6789;
let mut dealer = Dealer::new([7u8; 32], n, FXP);
// 离线:Beaver 三元组 a*b=c
let mut a_sh = vec![0u64; n];
let mut b_sh = vec![0u64; n];
let mut c_sh = vec![0u64; n];
dealer
.mul_triple(1, &mut a_sh, &mut b_sh, &mut c_sh)
.map_err(|e| e.to_string())?;
// 输入分片:x 拆给两方,y 也拆给两方
let mut s = Stream::new(&[11u8; 32]);
let mut x_sh = vec![0u64; n];
let mut y_sh = vec![0u64; n];
split_into(&[x], n, &mut s, &mut x_sh, FXP).map_err(|e| e.to_string())?;
split_into(&[y], n, &mut s, &mut y_sh, FXP).map_err(|e| e.to_string())?;
// 第一轮 open:d = x − a, e = y − b(各方本地算分片,然后公开求和)
let mut d_sh = vec![0u64; n];
let mut e_sh = vec![0u64; n];
ring::sub_into(&x_sh, &a_sh, &mut d_sh).map_err(|e| e.to_string())?;
ring::sub_into(&y_sh, &b_sh, &mut e_sh).map_err(|e| e.to_string())?;
let mut d = [0u64; 1];
let mut e = [0u64; 1];
reconstruct_into(&d_sh, n, 1, &mut d).map_err(|x| x.to_string())?;
reconstruct_into(&e_sh, n, 1, &mut e).map_err(|x| x.to_string())?;
// 本地乘:z_i = c_i + d·b_i + e·a_i (i==0 再补 d·e)
let mut z_sh = vec![0u64; n];
for (i, zi) in z_sh.iter_mut().enumerate() {
let mut acc = c_sh[i];
acc = acc.wrapping_add(d[0].wrapping_mul(b_sh[i]));
acc = acc.wrapping_add(e[0].wrapping_mul(a_sh[i]));
if i == 0 {
acc = acc.wrapping_add(d[0].wrapping_mul(e[0]));
}
*zi = acc;
}
// 第二次 open:还原结果
let mut z = [0u64; 1];
reconstruct_into(&z_sh, n, 1, &mut z).map_err(|x| x.to_string())?;
let want = x.wrapping_mul(y);
if z[0] != want {
return Err(format!("Beaver 乘法结果错: {:#x} != {:#x}", z[0], want));
}
Ok(format!("{x} × {y} = {},两次 open", z[0]))
}
fn step_tee_seal() -> Result<String, String> {
let tee = MockTee::new([3u8; 32]);
let plaintext = "alice 的明文密钥材料".as_bytes();
let blob = tee.seal(plaintext, b"session-1").map_err(|e| e.to_string())?;
let back = tee.unseal(&blob, b"session-1").map_err(|e| e.to_string())?;
if back != plaintext {
return Err("解封结果与明文不一致".into());
}
// 换了 aad 必须解不开
if tee.unseal(&blob, b"session-2").is_ok() {
return Err("aad 不匹配却解封成功".into());
}
let att = tee.attest(&[7u8; 64]).map_err(|e| e.to_string())?;
tee.verify_attestation(&att).map_err(|e| e.to_string())?;
Ok(format!(
"平台={},aad 绑定生效,报告可验",
tee.platform().kind
))
}
/// 明文域 / 密态域的同一份表达式是否给出同一结果。
///
/// 这一步存在的意义:`mpc-runtime::device` 是「双阶段执行」那句话的实现,
/// 如果只在库里躺着、没人跑过,它就还是注释。selftest 是每次发版都会跑的地方,
/// 放这里才叫真的接上了。
fn step_device() -> Result<String, String> {
use mpc_runtime::device::{DeviceKind, Plain, Secret, Value};
const FXP: u32 = 18;
let vals = [120.5, 300.25, 500.0, 12.75];
// 公开掩码(k-匿名抑制那类场景:阈值是合规方公开给定的)
let keep = [true, true, false, true];
let plain = Value::plain(FXP, &[("amount", &vals)]).map_err(|e| e.to_string())?;
let want: Vec<f64> = plain
.mask_public("amount", &keep)
.map_err(|e| e.to_string())?
.sum("amount")
.map_err(|e| e.to_string())?
.decode("sum(amount)")
.map_err(|e| e.to_string())?;
// 同一个表达式,放到两方密态域上各算一遍,再重建
let dev = Secret::new(2, [0x5au8; 32]);
let mut shares = Vec::new();
for site in 0..2 {
let s = plain.to(&dev.at(site)).map_err(|e| e.to_string())?;
if s.kind() != DeviceKind::Secret {
return Err(format!("第 {site} 方没进密态域"));
}
shares.push(
s.mask_public("amount", &keep)
.map_err(|e| e.to_string())?
.sum("amount")
.map_err(|e| e.to_string())?,
);
}
let got = Value::reconstruct(&shares)
.map_err(|e| e.to_string())?
.decode("sum(amount)")
.map_err(|e| e.to_string())?;
if got[0].to_bits() != want[0].to_bits() {
return Err(format!(
"两域结果不一致:明文 {} vs 密态 {}",
want[0], got[0]
));
}
// 非线性算子必须被显式挡住(换算法,不是换指针)
let sec = plain.to(&Secret::new(2, [0x5au8; 32])).map_err(|e| e.to_string())?;
match sec.lt_mask("amount", 400.0) {
Err(e) if e.is_unsupported() => {}
Err(e) => return Err(format!("密态域比较的错误类型不对:{e}")),
Ok(_) => return Err("密态域竟然允许逐元素比较,这会静默算错".into()),
}
// 明文域上它是能算的
let mask = plain
.lt_mask("amount", 400.0)
.map_err(|e| e.to_string())?
.raw("(amount < 400)")
.ok_or("明文域比较没产出掩码列")?
.to_vec();
// 空转一下 Plain,确认 trait 对象路径也通
let again = plain.to(&Plain).map_err(|e| e.to_string())?;
if again != plain {
return Err("to(Plain) 不是恒等映射".into());
}
Ok(format!(
"两域逐位一致 sum={};掩码 {mask:?};密态域拒绝非线性算子",
want[0]
))
}
// ---------------------------------------------------------------------------
// mpc selfcheck —— 产物自校验
// ---------------------------------------------------------------------------
/// 读文件、算 SHA-256,边读边算(不把二进制整个读进内存)。
fn sha256_file(path: &std::path::Path) -> Result<(String, u64), String> {
use std::io::Read;
let mut f =
std::fs::File::open(path).map_err(|e| format!("打开 {} 失败: {e}", path.display()))?;
let mut h = mpc_core::hash::Sha256::new();
let mut buf = vec![0u8; 64 * 1024];
let mut size = 0u64;
loop {
let n = f
.read(&mut buf)
.map_err(|e| format!("读 {} 失败: {e}", path.display()))?;
if n == 0 {
break;
}
h.update(&buf[..n]);
size += n as u64;
}
Ok((hex_bytes(&h.finalize()), size))
}
/// 解析一方的 TEE 声明:`site=kind[:tcb][+attested]` 或 `site=none`。
///
/// 例:`alice=sev-snp:5+attested`、`bob=optee`、`carol=none`。
///
/// 没有把 `attested` 的默认值做成 `true` —— 默认"已验证"等于默认少做一步,
/// 而这一步恰恰是 L2 唯一的依据。
fn parse_party_tee(spec: &str) -> Result<mpc_tee::PartyTee, String> {
let (site, rest) = spec
.split_once('=')
.ok_or_else(|| format!("{spec:?} 缺少 `=`,应形如 alice=sev-snp:5+attested"))?;
let site = site.trim();
if site.is_empty() {
return Err(format!("{spec:?} 的 site 名为空"));
}
let rest = rest.trim();
if rest == "none" {
return Ok(mpc_tee::PartyTee::without_tee(site));
}
let (body, attested) = match rest.strip_suffix("+attested") {
Some(b) => (b, true),
None => (rest, false),
};
let (kind_s, tcb) = match body.split_once(':') {
Some((k, t)) => {
let tcb: u32 = t
.parse()
.map_err(|_| format!("{spec:?} 的 tcb {t:?} 不是非负整数"))?;
(k, tcb)
}
None => (body, 0),
};
let kind = parse_platform_loose(kind_s).ok_or_else(|| {
format!("未知平台 {kind_s:?}(可选 none / optee / sev-snp / tdx / hygon-csv)")
})?;
if kind == mpc_tee::PlatformKind::None {
return Err("平台 none 请写成 `site=none`".into());
}
Ok(mpc_tee::PartyTee::with_tee(site, kind, tcb, attested))
}
/// `mpc tee` 子命令用法文本。
///
/// ★ 抽成常量是刻意的:测试要对着**同一份**文本校验「帮助里写的每个 flag
/// 都真的被实现解析」,否则测试与运行各有一份文本就会漂移。
/// 2026-11-09 实测踩过:改帮助文本时把 `attest-upload` 的
/// `--upload-path-file` 漏掉了,而实现里它是**必填**(缺了就报错)⇒
/// 照帮助敲命令必然失败。守卫测试 `tee_usage_flags_are_all_implemented` 钉死这条。
const TEE_USAGE: &str = "用法: mpc tee paths | plan --node FILE | verify --report FILE --platform snp|csv|tdx|optee \
| kbs-get --endpoint HOST:PORT --repo R --kind K \
| attest-collect --platform csv --user-data HEX --out FILE \
| attest-check --bundle FILE --platform csv --session-id HEX --site S --pubkey HEX --measurement HEX \
| attest-mkbundle --session-id HEX --site S --pubkey HEX --measurement HEX --tcb N --out FILE \
| attest-post --endpoint HOST:PORT --bundle FILE --session-id HEX --out FILE \
| attest-upload --host HOST:PORT --sandbox ID --token-file F --upload-path-file F --bundle FILE \
| sa-serve --listen HOST:PORT [--root-key-file F] [--shared-secret-file F] [--platform none|optee] [--tcb N] \
| sa-client --endpoint HOST:PORT [--shared-secret-file F] [--aad-hex H] \
seal --plaintext-hex H | unseal --blob-hex H | attest --user-data-hex H \
| sign --message-hex H | master-seed --session-id HEX \
| party-seed --session-id HEX --site SITE \
| up|ps|attest|down (宿主端,走 --host HOST:PORT)";
/// `mpc tee`:直接调度 TEE —— 列平台规格 / 做节点准入 / 产出 qemu 启动规格。
///
/// 这一族命令**不生成任何容器编排清单**,也不连接主机;节点能力全部来自
/// 宿主预检脚本产出的文本描述。框架只做判定,执行由部署侧照着 `LaunchSpec` 做。
fn cmd_tee(args: &[String]) -> Result<(), String> {
match args.first().map(String::as_str).unwrap_or("") {
"paths" => cmd_tee_paths(),
"plan" => cmd_tee_plan(&args[1..]),
"verify" => cmd_tee_verify(&args[1..]),
"kbs-get" => cmd_tee_kbs_get(&args[1..]),
// ★ SA 扩展模式:安全世界供能力、算力挂外部 VM。
// sa-serve 跑在安全世界那一侧(板子),sa-client 跑在 VM 那一侧。
"sa-serve" => sa::cmd_sa_serve(&args[1..]),
"sa-client" => sa::cmd_sa_client(&args[1..]),
"attest-collect" => cmd_tee_attest_collect(&args[1..]),
"attest-check" => cmd_tee_attest_check(&args[1..]),
"attest-mkbundle" => cmd_tee_attest_mkbundle(&args[1..]),
"attest-post" => cmd_tee_attest_post(&args[1..]),
"attest-upload" => cmd_tee_attest_upload(&args[1..]),
// 宿主端:走 e2b 兼容 API 操作本机/远端的 mpc-hostd。
// guest 静态二进制里这四个命令必须明确拒绝,不能悄悄落到 help 上
// ——「参数收了但没人执行」就是假接口。
#[cfg(any(feature = "control-plane", feature = "host-only"))]
"up" | "ps" | "attest" | "down" => hostd::cmd_tee_host(args),
#[cfg(not(any(feature = "control-plane", feature = "host-only")))]
"up" | "ps" | "attest" | "down" => Err(String::from(
"该命令属于宿主控制面,guest 静态二进制不含 mpc-hostd;请在宿主端 mpc 上执行",
)),
_ => Err(String::from(TEE_USAGE)),
}
}
fn cmd_tee_paths() -> Result<(), String> {
let mut rows: Vec<Vec<report::Cell>> = Vec::new();
for p in mpc_tee::platform::builtin_profiles() {
rows.push(vec![
report::Cell::txt(p.name()),
report::Cell::txt(p.kind.to_string()),
report::Cell::txt(match p.guest_policy {
Some(v) => format!("0x{v:x}"),
None => String::from("default"),
}),
report::Cell::txt(p.kbc.as_str()),
report::Cell::txt(p.attest_channel.as_str()),
report::Cell::txt(p.sev_object),
report::Cell::int(p.vcpus as i64),
report::Cell::int(p.memory_mib as i64),
]);
}
report::table(
"内置 TEE 直接启动规格",
&[
"profile",
"platform",
"policy",
"kbc",
"attest",
"qemu-object",
"vcpus",
"mem_mib",
],
&rows,
);
Ok(())
}
fn cmd_tee_plan(args: &[String]) -> Result<(), String> {
let node_path = parse_flag(args, "--node").ok_or("缺少 --node")?;
let src = std::fs::read_to_string(node_path)
.map_err(|e| format!("读节点描述 {node_path} 失败: {e}"))?;
let mut node = mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?;
// `--kbc` 在节点描述里是「节点实际启用的模式」,在命令行里历史上被当成
// 「要求什么模式」。两者语义不同、混用会出怪事,这里显式分开:
// `--kbc` 节点实际启用哪种密钥代理(覆盖节点描述的 kbc=)
// `--require-kbc` 准入要求必须是哪种(不匹配就拒绝)
// 节点描述的 kbs_endpoint= 是现场部署事实,也可用命令行覆盖。
if let Some(v) = parse_flag(args, "--kbc") {
node.kbc = match v {
"online" | "cc_kbc" => mpc_tee::platform::KbcMode::Online,
"offline" | "offline_fs_kbc" => mpc_tee::platform::KbcMode::Offline,
_ => return Err(format!("--kbc {v:?} 只认 online/offline")),
};
}
if let Some(v) = parse_flag(args, "--kbs-endpoint") {
node.kbs_endpoint = Some(v.to_string());
}
let demo = args.iter().any(|a| a == "--demo");
let (session_id, pubkey) = if demo {
note!("警告: --demo 使用固定示例会话值,仅用于离线计划演练,不能上生产");
([1u8; 32], [2u8; 32])
} else {
(
cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?,
cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?,
)
};
let binding = mpc_tee::session::SessionBinding::new(
session_id,
node.site.clone(),
pubkey,
node.measurement,
);
let min_tcb: u32 = match parse_flag(args, "--min-tcb") {
Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?,
None => 0,
};
let mut req = mpc_tee::schedule::TeeRequirement::new(node.platform.kind, min_tcb);
if let Some(v) = parse_flag(args, "--variant") {
req.csv_variant = Some(cli_parse_csv_variant(v)?);
}
if let Some(v) = parse_flag(args, "--require-kbc") {
req.required_kbc = Some(match v {
"online" | "cc_kbc" => mpc_tee::platform::KbcMode::Online,
"offline" | "offline_fs_kbc" => mpc_tee::platform::KbcMode::Offline,
_ => return Err(format!("--require-kbc {v:?} 只认 online/offline")),
});
}
if let Some(v) = parse_flag(args, "--pin") {
req.pinned_measurement = Some(cli_parse_hex32(v)?);
}
let spec = mpc_tee::schedule::admit(&req, &node, &binding).map_err(|e| e.to_string())?;
let policy = match spec.profile.guest_policy {
Some(v) => format!("0x{v:x}"),
None => String::from("default"),
};
let rows: Vec<(&str, report::Cell)> = vec![
("profile", report::Cell::txt(spec.profile.name())),
("platform", report::Cell::txt(spec.platform.to_string())),
("site", report::Cell::txt(spec.site.clone())),
("host", report::Cell::txt(spec.host.clone())),
("qemu", report::Cell::txt(spec.qemu_bin.clone())),
("firmware", report::Cell::txt(spec.firmware.clone())),
("kernel", report::Cell::txt(spec.kernel.clone())),
("initrd", report::Cell::txt(spec.initrd.clone())),
("policy", report::Cell::txt(policy)),
("kbc", report::Cell::txt(spec.kbc.as_str())),
("measurement", report::Cell::txt(cli_hex_bytes(&spec.measurement))),
("user_data", report::Cell::txt(cli_hex_bytes(&spec.user_data))),
("kernel_params", report::Cell::txt(spec.kernel_params.clone())),
];
report::kv("TEE 启动规格(fail-closed 准入通过)", &rows);
if args.iter().any(|a| a == "--argv") {
let argv = spec.qemu_argv();
report::kv(
"qemu argv",
&[
// 给人看:一行概览。注意 `-append` 的值含空格,这一行**不能**
// 直接丢给 shell;执行必须用下面的 argv_json 保留参数边界。
("argv", report::Cell::txt(argv.join(" "))),
("argv_json", report::Cell::txt(cli_json_array(&argv))),
],
);
}
Ok(())
}
fn cmd_tee_verify(args: &[String]) -> Result<(), String> {
let report_path = parse_flag(args, "--report").ok_or("缺少 --report(证明报告原始字节文件)")?;
// 节点描述:验证方与启动方读**同一份**真相源。
//
// 为什么必须有这个:`user_data` 的第二段哈希绑的是
// 「代码度量 + 平台标签 + TCB」,其中 **TCB 来自节点描述**。
// 启动时 `tee plan` 用 node 里的 tcb 算绑定值,验证时若手工重填
// `--tcb`(或漏填 → 默认 0),算出来的期望值必然对不上,报出来的是
// 「user_data 与本次会话绑定不一致」——一个指向重放攻击的误导性结论。
let node = match parse_flag(args, "--node") {
Some(p) => {
let src = std::fs::read_to_string(p).map_err(|e| format!("读节点描述 {p} 失败: {e}"))?;
Some(mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?)
}
None => None,
};
let platform = match parse_flag(args, "--platform") {
Some(p) => parse_platform_loose(p)
.ok_or_else(|| format!("--platform {p:?} 只认 none/optee/snp/csv/tdx"))?,
None => node
.as_ref()
.map(|n| n.platform.kind)
.ok_or("缺少 --platform(也没给 --node)")?,
};
// 节点描述与显式 --platform 不一致 = 拿 A 节点的报告去按 B 平台验,
// 必须直接拒绝,不能「以 --platform 为准」闷头算下去。
if let (Some(n), Some(p)) = (node.as_ref(), parse_flag(args, "--platform")) {
let nk = n.platform.kind;
if nk != platform {
return Err(format!(
"--node 的平台是 {},与 --platform {p:?} 不一致",
nk
));
}
}
// 报告在参数都合法之后再读 —— 参数错误比 IO 错误更早暴露,
// 免得排查时被「文件不存在」盖住真正的语义问题。
let report = std::fs::read(report_path).map_err(|e| format!("读报告 {report_path} 失败: {e}"))?;
let user_data = mpc_tee::platform::parse_hex::<64>(
parse_flag(args, "--user-data").ok_or("缺少 --user-data(64 字节 / 128 位十六进制)")?,
)
.ok_or("user-data 不是 128 位十六进制")?;
let cert_chain: Vec<Vec<u8>> = match parse_flag(args, "--certs") {
Some(p) => vec![std::fs::read(p).map_err(|e| format!("读证书 {p} 失败: {e}"))?],
None => Vec::new(),
};
let att = mpc_tee::Attestation {
platform,
user_data,
report,
cert_chain,
};
let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?;
// site / measurement / tcb 优先取节点描述(与 `tee plan` 同源),
// 显式传参才覆盖 —— 手工重填这些值是绑定对不上的头号来源。
let site = match parse_flag(args, "--site") {
Some(s) => s.to_string(),
None => node
.as_ref()
.map(|n| n.site.clone())
.filter(|s| !s.is_empty())
.ok_or("缺少 --site(也没给 --node)")?,
};
let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?;
let measurement = match parse_flag(args, "--measurement") {
Some(m) => cli_parse_hex32(m)?,
None => node
.as_ref()
.map(|n| n.measurement)
.ok_or("缺少 --measurement(也没给 --node)")?,
};
let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement);
let tcb: u32 = match parse_flag(args, "--tcb") {
Some(v) => v.parse().map_err(|_| format!("--tcb {v:?} 不是整数"))?,
None => node.as_ref().map(|n| n.platform.tcb).unwrap_or(0),
};
let min_tcb: u32 = match parse_flag(args, "--min-tcb") {
Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?,
None => 0,
};
let pin = match parse_flag(args, "--pin") {
Some(v) => Some(cli_parse_hex32(v)?),
None => None,
};
let verifier: Option<mpc_tee::verify::ExternalVerifier> = match parse_flag(args, "--verifier") {
Some(prog) => {
let mut v = mpc_tee::verify::ExternalVerifier::new(prog);
let mut i = 0;
while i < args.len() {
if args[i].as_str() == "--verifier-arg" && i + 1 < args.len() {
v = v.arg(args[i + 1].clone());
i += 2;
} else {
i += 1;
}
}
// ★ --chain-dir 单独一个选项名,不走 --verifier-arg。
// 原因:argparse 遇到「以 - 开头的值」会把它当成下一个选项 ——
// 实测 `--verifier-arg --chain-dir X` 直接报
// "argument --verifier-arg: expected one argument"。
// 证书链目录这类「路径」参数必须有独立的选项名。
if let Some(dir) = parse_flag(args, "--chain-dir") {
if !dir.is_empty() {
v = v.arg(String::from("--chain-dir")).arg(dir.to_string());
}
}
Some(v)
}
None => None,
};
let result = mpc_tee::verify::verify_attestation(
&att,
&binding,
platform,
tcb,
min_tcb,
pin.as_ref(),
verifier.as_ref().map(|x| x as &dyn mpc_tee::verify::ChipVerifier),
)
.map_err(|e| e.to_string())?;
let chip = match &result.chip {
mpc_tee::verify::ChipVerdict::NotVerified => String::from("未验证"),
mpc_tee::verify::ChipVerdict::VerifiedBy(n) => format!("已验证({n})"),
mpc_tee::verify::ChipVerdict::Failed(_) => String::from("失败"),
};
let rows: Vec<(&str, report::Cell)> = vec![
("structure_ok", report::Cell::txt(result.structure_ok.to_string())),
("bound_ok", report::Cell::txt(result.bound_ok.to_string())),
("chip", report::Cell::txt(chip)),
("verdict", report::Cell::txt(result.verdict.clone())),
];
report::kv("证明校验结论", &rows);
Ok(())
}
fn cmd_tee_kbs_get(args: &[String]) -> Result<(), String> {
let endpoint = parse_flag(args, "--endpoint").ok_or("缺少 --endpoint(host:port,不带 scheme)")?;
let repo = parse_flag(args, "--repo").ok_or("缺少 --repo")?.to_string();
let kind = parse_flag(args, "--kind").ok_or("缺少 --kind")?.to_string();
let token = parse_flag(args, "--token").map(|s| s.to_string());
let resource = match parse_flag(args, "--session-id") {
Some(sid) => {
let sid = cli_parse_hex32(sid)?;
mpc_tee::kbs::ResourcePath::for_session(&repo, &kind, &sid).map_err(|e| e.to_string())?
}
None => {
let tag = parse_flag(args, "--tag").ok_or("缺少 --tag 或 --session-id")?.to_string();
mpc_tee::kbs::ResourcePath::new(repo, kind, tag).map_err(|e| e.to_string())?
}
};
let mut client = mpc_tee::kbs::KbsClient::new(endpoint).map_err(|e| e.to_string())?;
if let Some(t) = token {
client = client.with_token(t);
}
let bytes = client.get(&resource).map_err(|e| e.to_string())?;
match parse_flag(args, "--out") {
Some(p) => {
std::fs::write(p, &bytes).map_err(|e| format!("写 {p} 失败: {e}"))?;
println!("已写入 {p}({} 字节)", bytes.len());
}
None => {
println!("{} 字节: {}", bytes.len(), cli_hex_bytes(&bytes));
}
}
Ok(())
}
fn cli_parse_hex32(s: &str) -> Result<[u8; 32], String> {
mpc_tee::platform::parse_hex::<32>(s)
.ok_or_else(|| format!("{s:?} 不是 64 位十六进制"))
}
// ---------------------------------------------------------------------------
// mpc tee attest-collect / attest-check
// ---------------------------------------------------------------------------
/// `mpc tee attest-collect`:在 guest 内向芯片要一份证明,打包成证明包。
///
/// 这条命令**只在 guest 里跑**(宿主上没有 `/dev/csv-guest`)。它把框架算出的
/// 64 字节会话绑定值原样递给固件,固件签回一份报告 —— 报告里的 `user_data`
/// 因此就是本轮绑定值,KBS 侧能据此判定「这份报告确实是本轮会话的」。
///
/// 关键点:**挑战值必须是框架的绑定值**,不能用厂商默认的 `"user data"`。
/// 用默认值的话,报告与绑定值对不上,绑定验证形同虚设。
fn cmd_tee_attest_collect(args: &[String]) -> Result<(), String> {
let platform = match parse_flag(args, "--platform") {
Some("csv") | Some("hygon") | Some("hygon-csv") => mpc_tee::PlatformKind::HygonCsv,
Some("snp") | Some("sev-snp") => mpc_tee::PlatformKind::SevSnp,
Some(other) => return Err(format!("--platform {other:?} 只认 csv/snp")),
None => return Err(String::from("缺少 --platform(csv/snp)")),
};
let user_data = mpc_tee::platform::parse_hex::<64>(
parse_flag(args, "--user-data").ok_or("缺少 --user-data(64 字节 / 128 位十六进制)")?,
)
.ok_or("user-data 不是 128 位十六进制")?;
let out = parse_flag(args, "--out").ok_or("缺少 --out(证明包输出路径)")?;
let device = parse_flag(args, "--device").unwrap_or(match platform {
mpc_tee::PlatformKind::HygonCsv => "/dev/csv-guest",
_ => "/dev/sev-guest",
});
let evidence = match platform {
mpc_tee::PlatformKind::HygonCsv => {
// nonce 从 OS 熵源取:nonce 参与 SM3(user_data||mnonce),是报告的
// 新鲜度来源。固定 nonce 等于放弃新鲜性。
let mut nonce = [0u8; 16];
mpc_core::osrand::fill_random(&mut nonce).map_err(|e| format!("取 nonce 失败: {e}"))?;
mpc_tee::collect::collect_csv_report(device, &user_data, &nonce)
.map_err(|e| e.to_string())?
}
_ => mpc_tee::collect::collect_snp_report(device, &user_data).map_err(|e| e.to_string())?,
};
let bundle = mpc_tee::collect::to_bundle(platform, evidence, user_data).map_err(|e| e.to_string())?;
let bytes = bundle.to_bytes();
std::fs::write(out, &bytes).map_err(|e| format!("写 {out} 失败: {e}"))?;
note!("证明包已写出: {out}({} 字节,报告 {} 字节)", bytes.len(), bundle.report.len());
note!("attestation_collected=true");
Ok(())
}
/// `mpc tee attest-check`:校验一份证明包。
///
/// # 为什么做成独立子命令(而不是只留库函数)
///
/// KBS 是 Python 写的,但**证明判定必须只有一份实现** —— 两边各写一套,
/// 就会出现「KBS 判通过、审计端判不通过」或者反过来,两种都不可接受。
///
/// 所以 KBS 通过调用本命令来判定:**判定逻辑在 Rust 里,Python 只负责
/// 搬运字节和看退出码**。本命令的退出码就是判定结果:
///
/// - `0`:通过(结构 + 绑定 + 度量 pin + TCB + 芯片签名,若提供验签器)
/// - `1`:不通过(判定失败,`verdict` 字段说明原因)
/// - `2`:用法错误(参数缺失、文件读不到等)
///
/// 这也是「生成端自检与审计端判定口径一致」这条铁律在证明链上的落实。
fn cmd_tee_attest_check(args: &[String]) -> Result<(), String> {
let bundle_path = parse_flag(args, "--bundle").ok_or("缺少 --bundle(证明包文件路径)")?;
let raw = std::fs::read(bundle_path).map_err(|e| format!("读证明包 {bundle_path} 失败: {e}"))?;
let bundle = mpc_tee::bundle::AttestationBundle::from_bytes(&raw).map_err(|e| e.to_string())?;
let platform = match parse_flag(args, "--platform") {
Some(p) => parse_platform_loose(p)
.ok_or_else(|| format!("--platform {p:?} 只认 none/optee/snp/csv/tdx"))?,
None => bundle.platform,
};
// 节点描述:与 `tee plan` / `tee verify` 同源(site / measurement / tcb)。
let node = match parse_flag(args, "--node") {
Some(p) => {
let src = std::fs::read_to_string(p).map_err(|e| format!("读节点描述 {p} 失败: {e}"))?;
Some(mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?)
}
None => None,
};
let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?;
let site = match parse_flag(args, "--site") {
Some(s) => s.to_string(),
None => node
.as_ref()
.map(|n| n.site.clone())
.filter(|s| !s.is_empty())
.ok_or("缺少 --site(也没给 --node)")?,
};
let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?;
let measurement = match parse_flag(args, "--measurement") {
Some(m) => cli_parse_hex32(m)?,
None => node
.as_ref()
.map(|n| n.measurement)
.ok_or("缺少 --measurement(也没给 --node)")?,
};
let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement);
let tcb: u32 = match parse_flag(args, "--tcb") {
Some(v) => v.parse().map_err(|_| format!("--tcb {v:?} 不是整数"))?,
None => node.as_ref().map(|n| n.platform.tcb).unwrap_or(0),
};
let min_tcb: u32 = match parse_flag(args, "--min-tcb") {
Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?,
None => 0,
};
let pin = match parse_flag(args, "--pin") {
Some(v) => Some(cli_parse_hex32(v)?),
None => None,
};
let verifier: Option<mpc_tee::verify::ExternalVerifier> = match parse_flag(args, "--verifier") {
Some(prog) => {
let mut v = mpc_tee::verify::ExternalVerifier::new(prog);
let mut i = 0;
while i < args.len() {
if args[i].as_str() == "--verifier-arg" && i + 1 < args.len() {
v = v.arg(args[i + 1].clone());
i += 2;
} else {
i += 1;
}
}
// ★ --chain-dir 单独一个选项名,不走 --verifier-arg。
// 原因:argparse 遇到「以 - 开头的值」会把它当成下一个选项 ——
// 实测 `--verifier-arg --chain-dir X` 直接报
// "argument --verifier-arg: expected one argument"。
// 证书链目录这类「路径」参数必须有独立的选项名。
if let Some(dir) = parse_flag(args, "--chain-dir") {
if !dir.is_empty() {
v = v.arg(String::from("--chain-dir")).arg(dir.to_string());
}
}
Some(v)
}
None => None,
};
// 判定。失败要**如实返回不通过**,不降级、不放行。
let verdict = mpc_tee::bundle::verify_bundle(
&bundle,
&binding,
platform,
tcb,
min_tcb,
pin.as_ref(),
verifier.as_ref().map(|x| x as &dyn mpc_tee::verify::ChipVerifier),
);
let (ok, structure_ok, bound_ok, chip, verdict_text) = match &verdict {
Ok(v) => {
let chip = match &v.chip {
mpc_tee::verify::ChipVerdict::NotVerified => "not-verified".to_string(),
mpc_tee::verify::ChipVerdict::VerifiedBy(n) => format!("verified-by:{n}"),
mpc_tee::verify::ChipVerdict::Failed(w) => format!("failed:{w}"),
};
(true, v.structure_ok, v.bound_ok, chip, v.verdict.clone())
}
Err(e) => {
// 判定失败:结构与绑定都按 false 报(不能报一半 true 一半 false)。
(false, false, false, "failed".to_string(), e.to_string())
}
};
if report::is_json() {
let doc = format!(
"{{\"ok\":{ok},\"structure_ok\":{structure_ok},\"bound_ok\":{bound_ok},\
\"chip\":{},\"verdict\":{},\"report_len\":{},\"cert_count\":{}}}",
json_escape(&chip),
json_escape(&verdict_text),
bundle.report.len(),
bundle.cert_chain.len()
);
println!("{doc}");
} else {
let rows: Vec<(&str, report::Cell)> = vec![
("ok", report::Cell::flag(ok)),
("structure_ok", report::Cell::flag(structure_ok)),
("bound_ok", report::Cell::flag(bound_ok)),
("chip", report::Cell::txt(chip.clone())),
("report_len", report::Cell::int(bundle.report.len() as i64)),
("cert_count", report::Cell::int(bundle.cert_chain.len() as i64)),
("verdict", report::Cell::txt(verdict_text.clone())),
];
report::kv("证明包校验结论", &rows);
}
if ok {
Ok(())
} else {
// 退出码 1 = 判定不通过(与用法错误的 2 区分开)。
std::process::exit(1);
}
}
/// `mpc tee attest-mkbundle`:生成一份**自洽的合成证明包**(仅测试/演练)。
///
/// # ⚠️ 这不是硬件证明
///
/// 报告是**合成**的(`synthetic_csv_report`),签名字段是常量填充,
/// 没有真实芯片签名。它能过**结构检查 + 绑定检查**,但**过不了芯片验签**。
///
/// 它的用途只有一个:让「先验证明才下发密钥」这条链路的**正向路径**
/// 在没有真机时也能被自动化测试覆盖 —— 否则只测了拒绝路径,
/// 「通过之后真的会签发 token 并下发密钥」这条路从未被验证过。
///
/// 真机验证必须用 `mpc tee attest-collect`(真芯片报告)。
fn cmd_tee_attest_mkbundle(args: &[String]) -> Result<(), String> {
let platform = match parse_flag(args, "--platform") {
Some("csv") | Some("hygon") | Some("hygon-csv") => mpc_tee::PlatformKind::HygonCsv,
Some("snp") | Some("sev-snp") => mpc_tee::PlatformKind::SevSnp,
Some(other) => return Err(format!("--platform {other:?} 只认 csv/snp")),
None => mpc_tee::PlatformKind::HygonCsv,
};
let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?;
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?;
let measurement = cli_parse_hex32(parse_flag(args, "--measurement").ok_or("缺少 --measurement")?)?;
let tcb: u32 = parse_flag(args, "--tcb")
.unwrap_or("0")
.parse()
.map_err(|_| String::from("--tcb 不是整数"))?;
let out = parse_flag(args, "--out").ok_or("缺少 --out")?;
let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement);
let user_data = binding.user_data(platform, tcb);
let report = match platform {
mpc_tee::PlatformKind::HygonCsv => mpc_tee::verify::synthetic_csv_report(&user_data),
mpc_tee::PlatformKind::SevSnp => mpc_tee::verify::synthetic_snp_report(&user_data),
other => return Err(format!("平台 {other:?} 不支持合成证明包")),
};
let bundle = mpc_tee::bundle::AttestationBundle::new(
platform,
report,
Vec::new(),
user_data,
)
.map_err(|e| e.to_string())?;
let bytes = bundle.to_bytes();
std::fs::write(out, &bytes).map_err(|e| format!("写 {out} 失败: {e}"))?;
note!("合成证明包已写出: {out}({} 字节)", bytes.len());
note!("⚠️ 合成件,非硬件证明:签名字段是常量填充,过不了芯片验签");
Ok(())
}
/// `mpc tee attest-post`:把证明包提交给 KBS,换取证明 token。
///
/// 这是「先验证明,才给密钥」的中枢:guest 采集到芯片证明后,先走这条
/// 提交给 KBS;KBS 校验通过才回 token;拿 token 才能 `kbs-get` 取密钥。
///
/// KBS 拒绝时**原样报出服务端的原因** —— 「为什么被拒」比「被拒了」重要得多。
fn cmd_tee_attest_post(args: &[String]) -> Result<(), String> {
let endpoint = parse_flag(args, "--endpoint")
.ok_or("缺少 --endpoint(host:port,不带 scheme)")?
.to_string();
let bundle_path = parse_flag(args, "--bundle").ok_or("缺少 --bundle(证明包路径)")?;
let session_id = parse_flag(args, "--session-id").ok_or("缺少 --session-id")?;
let out = parse_flag(args, "--out").ok_or("缺少 --out(token 输出路径)")?;
let bundle = std::fs::read(bundle_path).map_err(|e| format!("读证明包 {bundle_path} 失败: {e}"))?;
let token = mpc_tee::kbs::post_attestation(&endpoint, &bundle, session_id)
.map_err(|e| e.to_string())?;
std::fs::write(out, token.as_bytes()).map_err(|e| format!("写 {out} 失败: {e}"))?;
note!("证明 token 已取得: {out}({} 字节)", token.len());
note!("attestation_accepted=true");
Ok(())
}
/// `mpc tee attest-upload`:把证明包回传给**宿主控制面**。
///
/// ★ 与 `attest-post`(发给 KBS)是**两条不同的路**:
/// - `attest-post` → KBS:换密钥用的证明 token;
/// - `attest-upload` → hostd:让宿主**独立判定**用的原始证明包。
/// 后者回传的是**字节**,不是结论 —— guest 不自报「我通过了」。
///
/// ★ 令牌必须从**文件**读(`--token-file`),不能走 argv ——
/// argv 会出现在 `ps` 输出里,任何本机用户都能看到。
/// `--token` 保留但只用于**测试与一次性排障**。
///
/// ★ ★ **上传路径必须由宿主下发**(`--upload-path-file`):
/// 路由形状是**宿主控制面**的事实。本命令(会被编进 guest 静态产物)
/// **不得**持有路由字面量 —— 否则:
/// ① guest 产物带宿主面痕迹(破坏 guest 边界);
/// ② ★ **路由漂移** —— hostd 改路由而 guest 不会跟着改
/// ⇒ guest 静默 POST 到不存在的端点
/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。
/// 路径走 9p 手牌(`/run/mpc-tee/hostd/upload_path`),宿主改路由时
/// 手牌跟着改 ⇒ guest 不用动。
fn cmd_tee_attest_upload(args: &[String]) -> Result<(), String> {
let host = parse_flag(args, "--host")
.ok_or("缺少 --host(宿主控制面地址 host:port)")?
.to_string();
let sandbox = parse_flag(args, "--sandbox")
.ok_or("缺少 --sandbox(实例 id)")?
.to_string();
let bundle_path = parse_flag(args, "--bundle").ok_or("缺少 --bundle(证明包路径)")?;
// ★ 上传路径:宿主下发的那个。
// ★ **不允许从 argv 直接给**(那是「调用方自己拼路由」的路径 ——
// 等于把这个 CLI 变成路由的第二份真相源)。只从文件读。
let upload_path = match parse_flag(args, "--upload-path-file") {
Some(p) => {
let raw = std::fs::read_to_string(p)
.map_err(|e| format!("读上传路径文件 {p} 失败: {e}"))?;
// ★ 只取第一行(手牌文件无尾随换行,但排障时手写文件可能有)。
raw.lines().next().unwrap_or("").trim().to_string()
}
None => parse_flag(args, "--upload-path")
.ok_or(
"缺少 --upload-path-file(宿主下发的上传路径文件;guest 侧是 \
/run/mpc-tee/hostd/upload_path)—— 路由归宿主管,客户端不自己拼",
)?
.to_string(),
};
// 令牌:优先文件(安全路径),其次 argv(排障路径)。
let token = match parse_flag(args, "--token-file") {
Some(p) => {
let raw = std::fs::read_to_string(p)
.map_err(|e| format!("读令牌文件 {p} 失败: {e}"))?;
// ★ 只取第一行:令牌文件常带尾随换行,而换行进请求头就是头注入。
raw.lines().next().unwrap_or("").trim().to_string()
}
None => parse_flag(args, "--token")
.ok_or("缺少 --token-file(实例级上传令牌的路径;排障时才用 --token)")?
.to_string(),
};
let target = mpc_tee::attest_upload::UploadTarget::new(&host, &sandbox, &token, &upload_path)
.map_err(|e| e.to_string())?;
let bundle = std::fs::read(bundle_path)
.map_err(|e| format!("读证明包 {bundle_path} 失败: {e}"))?;
let resp = mpc_tee::attest_upload::upload_bundle(&target, &bundle)
.map_err(|e| e.to_string())?;
let text = String::from_utf8_lossy(&resp).to_string();
note!("证明材料已回传宿主: {} 字节", bundle.len());
note!("hostd_response={}", text.trim());
note!("attestation_uploaded=true");
Ok(())
}
/// 极简 JSON 字符串转义(只处理控制字符、引号、反斜杠)。
fn json_escape(s: &str) -> String {
let mut out = String::with_capacity(s.len() + 2);
out.push('"');
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
c => out.push(c),
}
}
out.push('"');
out
}
// ---------------------------------------------------------------------------
// mpc tee attest-collect / attest-check
// ---------------------------------------------------------------------------
/// `mpc tee attest-collect`:在 guest 内向芯片要一份证明,打包成证明包。
///
/// 这条命令**只在 guest 里跑**(宿主上没有 `/dev/csv-guest`)。它把框架算出的
/// 64 字节会话绑定值原样递给固件,固件签回一份报告 —— 报告里的 `user_data`
/// 因此就是本轮绑定值,KBS 侧能据此判定「这份报告确实是本轮会话的」。
///
/// 关键点:**挑战值必须是框架的绑定值**,不能用厂商默认的 `"user data"`。
/// 用默认值的话,报告与绑定值对不上,绑定验证形同虚设。
fn cli_parse_csv_variant(s: &str) -> Result<mpc_tee::platform::CsvVariant, String> {
use mpc_tee::platform::CsvVariant;
match s {
"csv" => Ok(CsvVariant::Csv),
"csv2" => Ok(CsvVariant::Csv2),
"csv3" => Ok(CsvVariant::Csv3),
"csv-dcu" | "dcu" => Ok(CsvVariant::Dcu),
_ => Err(format!("--variant {s:?} 只认 csv/csv2/csv3/csv-dcu")),
}
}
fn cli_hex_bytes(bytes: &[u8]) -> String {
let mut s = String::with_capacity(bytes.len() * 2);
for b in bytes {
s.push_str(&format!("{b:02x}"));
}
s
}
/// 手写 JSON 字符串转义(不引 serde_json,项目零依赖)。
fn cli_json_string(s: &str) -> String {
let mut out = String::from("\"");
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
c => out.push(c),
}
}
out.push('"');
out
}
/// 把 qemu argv 编成 JSON 数组 —— 部署脚本据此用 `execvp` 保留参数边界。
fn cli_json_array(items: &[String]) -> String {
let mut s = String::from("[");
for (i, v) in items.iter().enumerate() {
if i > 0 {
s.push(',');
}
s.push_str(&cli_json_string(v));
}
s.push(']');
s
}
/// 手写 JSON 字符串转义(不引 serde_json,项目零依赖)。
fn cmd_trust(args: &[String]) -> Result<(), String> {
let spec = parse_flag(args, "--parties").ok_or("缺少 --parties")?;
let mut parties: Vec<mpc_tee::PartyTee> = Vec::new();
for tok in spec.split(',') {
let tok = tok.trim();
if tok.is_empty() {
continue;
}
parties.push(parse_party_tee(tok)?);
}
if parties.is_empty() {
return Err("--parties 为空".into());
}
let min_tcb: u32 = match parse_flag(args, "--min-tcb") {
Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?,
None => 0,
};
let policy = mpc_tee::TrustPolicy {
min_tcb,
allow_plaintext_merge: args.iter().any(|a| a == "--allow-plaintext-merge"),
};
let plan = mpc_tee::TrustPlan::for_parties(&parties, policy).map_err(|e| e.to_string())?;
let mut rows: Vec<Vec<report::Cell>> = Vec::with_capacity(parties.len());
for p in &parties {
let (platform, tcb) = match &p.platform {
Some(pl) => (pl.kind.to_string(), pl.tcb as i64),
None => ("none".to_string(), -1),
};
rows.push(vec![
report::Cell::txt(p.site.clone()),
report::Cell::txt(platform),
if tcb < 0 {
report::Cell::txt("—")
} else {
report::Cell::int(tcb)
},
report::Cell::flag(p.attested),
report::Cell::flag(p.is_trusted(policy.min_tcb)),
]);
}
report::table(
"各方 TEE 状况",
&["site", "platform", "tcb", "attested", "trusted"],
&rows,
);
let untrusted = plan.untrusted_sides(&parties);
report::kv(
"可信度方案",
&[
("grade", report::Cell::txt(plan.grade().to_string())),
("needs_mpc", report::Cell::flag(plan.needs_mpc())),
("needs_tee", report::Cell::flag(plan.needs_tee())),
(
"allow_plaintext_merge",
report::Cell::flag(plan.allows_plaintext_merge()),
),
(
"untrusted_sides",
report::Cell::txt(if untrusted.is_empty() {
"—".to_string()
} else {
untrusted.join(", ")
}),
),
("summary", report::Cell::txt(plan.summary())),
],
);
// L2 是唯一跳过 MPC 的方案,把它的前提再念一遍 ——
// 这条路径一旦开错,泄露的是全体明文,不是精度。
if plan.allows_plaintext_merge() && !policy.allow_plaintext_merge {
return Err("内部矛盾:未明示允许合并却算出 L2".into());
}
Ok(())
}
/// 把一张算子图编译成「几轮交互」,并打印调度结果。
///
/// # 为什么是一个命令而不是一句文档
///
/// 隐语 SPU 的价值有一半在编译器:同样的数学,写得好是 5 轮、写得差是 9 轮,
/// 而这件事在代码里看不出来。mpc 之前没有这层,轮数只能靠人读代码数。
///
/// 把 `mpc-ml` 的**真实**纵向 LR 迭代图编译成执行计划,报出交互轮数。
///
/// 这里不另写一份示例图 —— 用的就是 `VerticalLR::build_epoch`,也就是
/// `mpc lr / mpc lr-vertical` 真跑时用的那张图。所以这几个数字可以直接
/// 拿去估算一次训练要多久:**每轮迭代 N 个往返 × 迭代数**。
///
/// 迁移前没有这个能力:轮数只能靠人数代码里出现了几次 `matmul_trunc`,
/// 而 `scale_public` 后面那次截断特别容易漏。
fn cmd_plan(args: &[String]) -> Result<(), String> {
let rows: usize = match parse_flag(args, "--rows") {
Some(v) => v.parse().map_err(|_| format!("--rows {v:?} 不是整数"))?,
None => 8,
};
let dims: usize = match parse_flag(args, "--features") {
Some(v) => v.parse().map_err(|_| format!("--features {v:?} 不是整数"))?,
None => 4,
};
let lr: f64 = match parse_flag(args, "--lr") {
Some(v) => v.parse().map_err(|_| format!("--lr {v:?} 不是浮点"))?,
None => 0.5,
};
let epochs: usize = match parse_flag(args, "--epochs") {
Some(v) => v.parse().map_err(|_| format!("--epochs {v:?} 不是整数"))?,
None => 40,
};
let l2: f64 = match parse_flag(args, "--l2") {
Some(v) => v.parse().map_err(|_| format!("--l2 {v:?} 不是浮点"))?,
None => 0.0,
};
let degree: usize = match parse_flag(args, "--sigmoid-degree") {
Some(v) => {
v.parse()
.map_err(|_| format!("--sigmoid-degree {v:?} 不是整数"))?
}
None => 7,
};
if rows == 0 || dims == 0 {
return Err("--rows / --features 必须大于 0".into());
}
// 全仓统一的定点位数;真实训练用 `vault.fxp()`,这里不联网所以写死。
const FXP: u32 = 18;
let cfg = mpc_ml::VerticalLR {
lr,
epochs,
l2,
sigmoid_degree: degree,
fit_intercept: true,
};
let eg = cfg
.build_epoch(rows, dims, FXP)
.map_err(|e| e.to_string())?;
let plan = eg.plan;
let mut table: Vec<Vec<report::Cell>> = Vec::with_capacity(plan.stages().len());
{
let g = plan.graph();
let names = |vs: &[usize]| {
if vs.is_empty() {
"—".to_string()
} else {
vs.iter()
.map(|&v| g.node(v).op.name())
.collect::<Vec<_>>()
.join(", ")
}
};
for st in plan.stages() {
table.push(vec![
report::Cell::int(st.round as i64 + 1),
report::Cell::txt(names(&st.comm)),
report::Cell::txt(names(&st.local)),
report::Cell::int(st.comm.len() as i64),
]);
}
}
report::table(
"一次迭代的执行阶段(同阶段的交互算子合并成一个往返)",
&["起始轮", "交互算子", "本地算子", "交互数"],
&table,
);
let mut lifts = 0usize;
for n in plan.graph().nodes() {
if matches!(n.op, mpc_ir::Op::Lift { .. }) {
lifts += 1;
}
}
let per = plan.rounds();
report::kv(
"编译结果",
&[
(
"算子总数",
report::Cell::int(plan.graph().nodes().len() as i64),
),
("交互算子", report::Cell::int(plan.comm_ops() as i64)),
("本地算子", report::Cell::int(plan.local_ops() as i64)),
("公开值抬升", report::Cell::int(lifts as i64)),
("每轮迭代往返", report::Cell::int(per as i64)),
("迭代数", report::Cell::int(epochs as i64)),
(
"训练总往返",
report::Cell::int((per * epochs) as i64),
),
(
"口径",
report::Cell::txt(
"实测相等:线上往返数与计划逐次一致(wire_rounds 测试);\
只有「mul 截断 + 同阶段独立 open」未共享时会略虚高",
),
),
],
);
note!("{}", plan.summary());
Ok(())
}
/// 把一条聚合查询编译成执行计划,报出交互轮数。**不联网、不需要数据。**
///
/// 图只依赖形状(行数、分组数、聚合种类、谓词结构),所以「这条查询要跑几个
/// 往返」在拿到数据之前就能回答。迁移前这个数字只能靠人数代码里出现了几次
/// `bit_lt` —— 而掩码聚合的调用序列有六七步,数错一处就估歪。
///
/// 口径是**上界**,见 [`mpc_sql::secure::query_rounds`] 的两处估计。
#[cfg(feature = "secure")]
fn cmd_sql_plan(args: &[String]) -> Result<(), String> {
// 全仓统一的定点位数;真实会话用 `vault.fxp()`,这里不联网所以写死。
const FXP: u32 = 18;
let rows: usize = match parse_flag(args, "--rows") {
Some(v) => v.parse().map_err(|_| format!("--rows {v:?} 不是整数"))?,
None => 6,
};
if rows == 0 {
return Err("--rows 必须大于 0".into());
}
let groups: Option<usize> = match parse_flag(args, "--groups") {
Some(v) => {
let n: usize = v.parse().map_err(|_| format!("--groups {v:?} 不是整数"))?;
if n == 0 {
return Err("--groups 必须大于 0(不分组的整表聚合请省略这个参数)".into());
}
Some(n)
}
None => None,
};
let aggs = parse_agg_list(&parse_flag(args, "--aggs").unwrap_or_else(|| "count,sum".into()))?;
let pred = match parse_flag(args, "--where") {
Some(s) => Some(parse_simple_pred(&s)?),
None => None,
};
let mode = match parse_flag(args, "--group-mode").as_deref() {
None | Some("exact") => mpc_sql::secure::GroupMode::Exact,
Some("coded") => mpc_sql::secure::GroupMode::IntegerCode,
Some(other) => {
return Err(format!(
"--group-mode {other:?} 不认识(可选 exact / coded)"
))
}
};
let plan = mpc_sql::secure::query_rounds(rows, FXP, 1, pred.as_ref(), groups, &aggs, mode)
.map_err(|e| e.to_string())?;
let coded = mode == mpc_sql::secure::GroupMode::IntegerCode && groups.is_some();
report::table(
if coded {
"前缀段(谓词 → 分组码搬家 → N+1 个单调前缀 → 累积和)"
} else {
"掩码段(谓词 → 0/1 位 → 掩码后列 → 命中数)"
},
&["起始轮", "交互算子", "本地算子", "交互数"],
&stage_rows(&plan.mask),
);
if let Some(a) = &plan.aggs {
report::table(
"聚合段(SUM / AVG / MIN / MAX)",
&["起始轮", "交互算子", "本地算子", "交互数"],
&stage_rows(a),
);
}
let agg_names: Vec<&str> = aggs
.iter()
.map(|a| match a {
mpc_sql::secure::Agg::Count => "COUNT",
mpc_sql::secure::Agg::Sum => "SUM",
mpc_sql::secure::Agg::Avg => "AVG",
mpc_sql::secure::Agg::Min => "MIN",
mpc_sql::secure::Agg::Max => "MAX",
})
.collect();
report::kv(
"编译结果",
&[
("行数", report::Cell::int(rows as i64)),
(
"分组",
match groups {
Some(n) => report::Cell::int(n as i64),
None => report::Cell::txt("无(整表)"),
},
),
(
"分组模式",
report::Cell::txt(if coded {
"整数码(前缀和)"
} else {
"逐组比较"
}),
),
("聚合", report::Cell::txt(agg_names.join(", "))),
(
"谓词",
match &pred {
Some(p) => report::Cell::txt(format!("{p:?}")),
None => report::Cell::txt("无 WHERE"),
},
),
("掩码段往返", report::Cell::int(plan.mask.rounds() as i64)),
("聚合段往返", report::Cell::int(plan.agg_rounds() as i64)),
("总往返", report::Cell::int(plan.rounds() as i64)),
(
"口径",
report::Cell::txt(
"上界:同阶段同类批量(比较 9 轮封顶);AVG 除数按非整数算(多计 1 轮);MIN/MAX 按命中数非零算",
),
),
],
);
note!("{}", plan.summary());
Ok(())
}
/// 计划 → 阶段表。`mpc plan` 与 `mpc sql-plan` 共用同一种排版。
#[cfg(feature = "secure")]
fn stage_rows(plan: &mpc_ir::Plan) -> Vec<Vec<report::Cell>> {
let g = plan.graph();
// 同名算子折叠成 `slice ×1024`。本地算子常常上千个(MIN/MAX 每行一个
// `slice`),逐个列出来会把表格撑到几百 KB —— 而且信息量为零。
let names = |vs: &[usize]| {
if vs.is_empty() {
return "—".to_string();
}
let mut order: Vec<(&str, usize)> = Vec::new();
for &v in vs {
let name = g.node(v).op.name();
match order.iter_mut().find(|(n, _)| *n == name) {
Some((_, c)) => *c += 1,
None => order.push((name, 1)),
}
}
order
.iter()
.map(|(n, c)| {
if *c == 1 {
(*n).to_string()
} else {
format!("{n} ×{c}")
}
})
.collect::<Vec<_>>()
.join(", ")
};
plan.stages()
.iter()
.map(|st| {
vec![
report::Cell::int(st.round as i64 + 1),
report::Cell::txt(names(&st.comm)),
report::Cell::txt(names(&st.local)),
report::Cell::int(st.comm.len() as i64),
]
})
.collect()
}
/// `--aggs count,sum,avg,min,max` → 聚合列表。
#[cfg(feature = "secure")]
fn parse_agg_list(s: &str) -> Result<Vec<mpc_sql::secure::Agg>, String> {
use mpc_sql::secure::Agg;
let mut out = Vec::new();
for part in s.split(',') {
let p = part.trim().to_ascii_lowercase();
if p.is_empty() {
continue;
}
out.push(match p.as_str() {
"count" => Agg::Count,
"sum" => Agg::Sum,
"avg" => Agg::Avg,
"min" => Agg::Min,
"max" => Agg::Max,
other => {
return Err(format!(
"--aggs 里的 {other:?} 不认识(可用 count / sum / avg / min / max)"
))
}
});
}
if out.is_empty() {
return Err("--aggs 不能为空".into());
}
Ok(out)
}
/// `--where "0<400"` → `Pred::Cmp`。
///
/// 只认「列下标 + 比较符 + 字面量」这一种形状。复合谓词(AND/OR/NOT/列 vs 列)
/// 请直接调 [`mpc_sql::secure::query_rounds`],命令行不做半截 SQL 解析 ——
/// 一个只会认一半的解析器比没有更糟。
#[cfg(feature = "secure")]
fn parse_simple_pred(s: &str) -> Result<mpc_sql::secure::Pred, String> {
use mpc_sql::secure::CmpOp;
// 两字符运算符优先,否则 "<=" 会被当成 "<" 加一个 "+" 开头的字面量
for (tok, op) in [
("<=", CmpOp::Le),
(">=", CmpOp::Ge),
("==", CmpOp::Eq),
("!=", CmpOp::Ne),
("<>", CmpOp::Ne),
("<", CmpOp::Lt),
(">", CmpOp::Gt),
("=", CmpOp::Eq),
] {
if let Some((l, r)) = s.split_once(tok) {
let col: usize = l
.trim()
.parse()
.map_err(|_| format!("--where 左边要列下标,收到 {l:?}"))?;
let threshold: f64 = r
.trim()
.parse()
.map_err(|_| format!("--where 右边要字面量,收到 {r:?}"))?;
return Ok(mpc_sql::secure::Pred::Cmp {
col,
op,
threshold,
});
}
}
Err(format!(
"--where {s:?} 认不出:格式是 <列下标><运算符><字面量>,例如 \"0<400\" 或 \"1>=0.5\""
))
}
/// 自校验:报出这份二进制(或 `--file` 指定的文件)的 SHA-256 与体积。
///
/// # 为什么需要它
///
/// Kuscia 那边靠 `AppImage.ID` 在起 pod 前后比对镜像没被换过;mpc 是单二进制
/// 分发,那层校验就落在二进制自己身上:
///
/// - 部署期用 `--out` 产出清单钉进配置/审计,运行期用 `--expect` 复核;
/// - `--tee-sign` 再用 TEE 设备密钥对摘要签名,得到「这台机器上跑的确实是
/// 这份代码」的凭据 —— 正好是 `TrustPlan` 里输入一致性那条链的锚点。
///
/// 注意:**只报事实,不做安全承诺**。摘要能证明文件没变,不能证明它没被换;
/// 后者要靠 `--tee-sign`(真 TEE 平台)或外部发布的期望值。
fn cmd_selfcheck(args: &[String]) -> Result<(), String> {
let path = match parse_flag(args, "--file") {
Some(p) => std::path::PathBuf::from(p),
None => std::env::current_exe().map_err(|e| format!("取自身路径失败: {e}"))?,
};
let (digest, size) = sha256_file(&path)?;
let mut rows: Vec<(&str, report::Cell)> = vec![
("tool", report::Cell::txt("mpc")),
("version", report::Cell::txt(VERSION)),
("binary", report::Cell::txt(path.display().to_string())),
("size", report::Cell::int(size as i64)),
("sha256", report::Cell::txt(digest.clone())),
(
"platform",
report::Cell::txt(format!(
"{}/{}",
std::env::consts::OS,
std::env::consts::ARCH
)),
),
];
// 可选:TEE 设备密钥对摘要签名。当前只有 Mock 实现(平台字段如实写 mock),
// 真平台接进来后语义不变,只是 platform 变成 sev-snp / optee。
let mut tee_json = String::from("null");
if args.iter().any(|a| a == "--tee-sign") {
let tee = MockTee::new([0u8; 32]);
let sig = tee.sign(digest.as_bytes()).map_err(|e| e.to_string())?;
// report_data 是 64 字节定长(按 SNP 的字段定的),摘要 32 字节就填两遍
let mut user_data = [0u8; 64];
let h = mpc_core::hash::sha256(digest.as_bytes());
user_data[..32].copy_from_slice(&h);
user_data[32..].copy_from_slice(&h);
let att = tee.attest(&user_data).map_err(|e| e.to_string())?;
tee.verify_attestation(&att).map_err(|e| e.to_string())?;
// 平台名如实写 mock:`PlatformKind::None` 单看是 "none",
// 放进部署清单容易被误读成「这里没有 TEE 可用」,其实就是个纯软件替身
let platform = format!("mock({})", tee.platform().kind);
rows.push(("tee.platform", report::Cell::txt(platform.clone())));
rows.push(("tee.alg", report::Cell::txt(sig.alg)));
rows.push(("tee.signature", report::Cell::txt(hex_bytes(&sig.bytes))));
rows.push(("tee.attestation", report::Cell::flag(true)));
tee_json = format!(
"{{\"platform\":\"{platform}\",\"alg\":\"{}\",\"signature\":\"{}\",\"report_bytes\":{},\"verified\":true}}",
sig.alg,
hex_bytes(&sig.bytes),
att.report.len()
);
}
// --out:写一份清单,供部署期钉住、运行期 --expect 复核
if let Some(out) = parse_flag(args, "--out") {
let doc = format!(
"{{\"tool\":\"mpc\",\"version\":\"{VERSION}\",\"binary\":{},\"size\":{size},\"sha256\":\"{digest}\",\"platform\":\"{}/{}\",\"tee\":{tee_json}}}\n",
json_str(&path.display().to_string()),
std::env::consts::OS,
std::env::consts::ARCH
);
std::fs::write(out, doc).map_err(|e| format!("写 {out} 失败: {e}"))?;
note!(" 清单已写入 {out}");
}
report::kv("mpc selfcheck", &rows);
// --expect:与已知摘要比对,不一致就非零退出 —— 只打印不判断等于没校验
if let Some(want) = parse_flag(args, "--expect") {
let want = want.trim().to_ascii_lowercase();
if want != digest {
return Err(format!(
"摘要不符:期望 {want},实际 {digest}(二进制被替换,或版本不对)"
));
}
note!(" 摘要与 --expect 一致");
}
Ok(())
}
fn hex_bytes(b: &[u8]) -> String {
let mut s = String::with_capacity(b.len() * 2);
for x in b {
s.push_str(&format!("{x:02x}"));
}
s
}
fn json_str(s: &str) -> String {
let mut out = String::from("\"");
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
c => out.push(c),
}
}
out.push('"');
out
}
// ---------------------------------------------------------------------------
// mpc node
// ---------------------------------------------------------------------------
/// 建立会话连接的等待预算(两侧对称)。
///
/// ★ 默认 [`mpc_node::SESSION_WAIT_BUDGET_SECS`](180s),可用
/// 环境变量 `MPC_SESSION_WAIT_SECS` 覆盖。
///
/// 为什么需要可覆盖:真机上「被动方先做芯片证明验签再进会话」会让
/// 启动时间差到几十秒(SNP 验签要联网拉 KDS 证书链,首次可达 90s)。
/// 默认预算已经覆盖了它,但离线环境拉不到链时会更慢 —— 硬编码就
/// 得改代码重编。
///
/// ⚠ 覆盖值必须**两侧一致**(同一个环境变量),否则主动方和被动方
/// 的等待窗口又不对称了 —— 那正是本函数要消灭的问题。
fn wait_budget() -> Duration {
let secs = std::env::var("MPC_SESSION_WAIT_SECS")
.ok()
.and_then(|v| v.trim().parse::<u64>().ok())
.filter(|s| *s > 0)
.unwrap_or(mpc_node::SESSION_WAIT_BUDGET_SECS);
Duration::from_secs(secs)
}
pub(crate) fn parse_flag<'a>(args: &'a [String], name: &str) -> Option<&'a str> {
args.iter()
.position(|a| a == name)
.and_then(|i| args.get(i + 1))
.map(String::as_str)
}
/// 从 argv 里摘出全局的 `--report text|json`,返回(剩余参数, 是否 JSON)。
///
/// 支持 `--report json` 与 `--report=json` 两种写法,位置不限。
/// 摘掉而不是留给子命令忽略 —— 因为子命令的参数解析(`parse_flag`)是
/// 「找第一个同名字符串」,留着会占掉一个位置,容易和真实参数混淆。
///
/// **例外:`mpc tee verify` 的 `--report` 是证明报告的*文件路径***,与全局的
/// 输出格式参数同名。全局参数在子命令之前解析,若不在这里让位,`tee verify`
/// 就永远拿不到文件路径(真机上表现为
/// `--report 只认 text / json,得到 "report.cert"`)。
/// 判定规则:只有当命令行确实是 `tee verify` 时,`--report` 的非格式值才当文件路径;
/// 其余子命令仍然只认 `text` / `json`,写错就报错。
fn split_report_flag(raw: &[String]) -> Result<(Vec<String>, bool), String> {
// `tee verify` 的 `--report` 是文件路径,让位给它。
let report_is_path = raw
.iter()
.position(|a| a == "tee")
.and_then(|i| raw.get(i + 1))
.map(|a| a == "verify")
.unwrap_or(false);
let mut out = Vec::with_capacity(raw.len());
let mut json = false;
let mut i = 0;
while i < raw.len() {
let a = raw[i].as_str();
let val = if a == "--report" {
let v = raw
.get(i + 1)
.ok_or("--report 后面要跟 text 或 json,或一个文件路径")?;
i += 2;
Some(v.as_str())
} else if let Some(v) = a.strip_prefix("--report=") {
i += 1;
Some(v)
} else {
out.push(raw[i].clone());
i += 1;
None
};
if let Some(v) = val {
match v {
"json" => json = true,
"text" => json = false,
other if report_is_path => {
// 保留分离形式,`parse_flag` 只认精确串 `--report`。
out.push(String::from("--report"));
out.push(String::from(other));
}
other => return Err(format!("--report 只认 text / json,得到 {other:?}")),
}
}
}
Ok((out, json))
}
// ---------------------------------------------------------------------------
// 建连认证的预共享密钥
// ---------------------------------------------------------------------------
/// 解析 PSK,优先级:`--psk-file` > `--psk` > 环境变量 `MPC_PSK`。
///
/// # 为什么推荐 `--psk-file`
///
/// `--psk` 和 `--seed` 一样会出现在 `ps` / `/proc/<pid>/cmdline` 里,
/// 同机任何用户都能读到。文件可以设 0600;环境变量略好于 argv 但仍对同用户可见。
/// 三种入口都留着是为了让测试和现场排障不必先造文件。
fn parse_psk(args: &[String]) -> Result<Option<[u8; 32]>, String> {
let raw = if let Some(path) = parse_flag(args, "--psk-file") {
let s = std::fs::read_to_string(path)
.map_err(|e| format!("读 --psk-file {path} 失败: {e}"))?;
Some(s)
} else if let Some(v) = parse_flag(args, "--psk") {
Some(v.to_string())
} else {
std::env::var("MPC_PSK").ok()
};
let Some(s) = raw else { return Ok(None) };
let hex = s.trim();
if hex.len() != 64 {
return Err(format!(
"PSK 必须是 64 个十六进制字符(32 字节),实际长度 {}",
hex.len()
));
}
let bytes = hex.as_bytes();
let mut out = [0u8; 32];
for i in 0..32 {
let hi = hex_val(bytes[i * 2]).ok_or_else(|| {
format!("PSK 第 {} 个字符不是十六进制", i * 2 + 1)
})?;
let lo = hex_val(bytes[i * 2 + 1]).ok_or_else(|| {
format!("PSK 第 {} 个字符不是十六进制", i * 2 + 2)
})?;
out[i] = (hi << 4) | lo;
}
Ok(Some(out))
}
fn hex_val(b: u8) -> Option<u8> {
match b {
b'0'..=b'9' => Some(b - b'0'),
b'a'..=b'f' => Some(b - b'a' + 10),
b'A'..=b'F' => Some(b - b'A' + 10),
_ => None,
}
}
/// 若环境里给了 raylet socket,就把本进程注册成 Ray 集群的一个 driver。
///
/// 为什么要这一步:mpc 自己不做集群成员管理(谁在线、各带什么资源标签),
/// 这活交给 Ray。注册完成后 mpc 才「知道自己在哪个节点上」,后续按
/// `sites` 与资源标签把各方钉到机器上。计算仍然走 mpc 自己的 TCP 帧。
#[cfg(feature = "ray")]
fn attach_ray(site: &str) -> Result<Option<mpc_ray::RayCluster>, String> {
if std::env::var("MPC_RAY_RAYLET").is_err() {
return Ok(None);
}
let cfg = mpc_ray::config_from_env(&format!("mpc_{site}"))?;
note!(
" 接入 Ray 集群: gcs={} raylet={} nm_port={}",
cfg.gcs_addr, cfg.raylet_socket, cfg.node_manager_port
);
let c = mpc_ray::RayCluster::connect(&cfg)?;
if let Some(nid) = c.node_id() {
note!(" Ray 节点已确认: node_id={nid}(由 raylet 分配)");
}
if let Some(wid) = c.worker_id() {
note!(" Ray worker_id={wid}");
}
Ok(Some(c))
}
#[cfg(not(feature = "ray"))]
fn attach_ray(_site: &str) -> Result<Option<()>, String> {
if std::env::var("MPC_RAY_RAYLET").is_ok() {
return Err(
"这个 mpc 构建没开 ray feature。要用 Ray 做成员目录,请 `cargo build --features ray`"
.into(),
);
}
Ok(None)
}
fn cmd_node(args: &[String]) -> Result<(), String> {
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites")?;
let sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sites.len() < 2 {
return Err(format!("--sites 至少 2 方,得到 {} 个", sites.len()));
}
if !sites.contains(&site) {
return Err(format!("--site {site} 不在 --sites {sites:?} 里"));
}
// ★ 种子先取、先拒 —— **在连网与 Ray 注册之前**。
//
// 理由:全零主种子 ⇒ Beaver 三元组全部可预测 ⇒ 密态乘法隐私性归零,
// 而症状是「不报错、不崩溃、结果数值也对」—— 最难发现的一类失败。
// 所以守卫必须落在**入口**:不能等到连上网、注册进集群之后才发现,
// 那时候对端已经在等你了,失败还会伪装成「网络问题」。
let seed = seed_or_random(args)?;
let listen = parse_flag(args, "--listen");
let connect = parse_flag(args, "--connect");
let peers_raw = parse_flag(args, "--peers");
// Ray 只在部署期起作用:把本进程注册成集群里的一个 driver,拿到成员目录。
// 计算不出这个进程——下面的 transport/MPC 完全是 mpc 自己的帧。
let _ray = attach_ray(&site)?;
// 建连认证:`--psk-file` > `--psk` > `MPC_PSK`。没配就明说,不假装有。
let psk = parse_psk(args)?;
if psk.is_none() {
note!(" ⚠ 未配置 PSK(--psk-file / --psk / MPC_PSK):本次连接既不认证身份、也不加密链路");
}
// 三种连法:两方 --connect(主动)、两方 --listen(被动)、n 方 --listen + --peers
let transport = match (listen, connect, peers_raw) {
(Some(_), Some(_), _) => {
return Err("--listen 与 --connect 只能选一个".into());
}
(None, None, _) => return Err("必须给 --listen 或 --connect".into()),
(Some(l), None, None) if sites.len() == 2 => {
note!(" 等待对端连接...");
let t = match &psk {
Some(p) => TcpTransport::accept_with_psk_within(l, wait_budget(), p),
None => TcpTransport::accept_within(l, wait_budget()),
}
.map_err(|e| e.to_string())?;
AnyTransport::Single(t)
}
(None, Some(c), None) if sites.len() == 2 => {
note!(" 连接对端...");
let t = match &psk {
Some(p) => TcpTransport::connect_with_psk_within(c, wait_budget(), p),
None => TcpTransport::connect_within(c, wait_budget()),
}
.map_err(|e| e.to_string())?;
AnyTransport::Single(t)
}
(None, Some(_), Some(_)) => {
return Err("--peers 只与 --listen 搭配(网状连接需要本方监听地址)".into());
}
(Some(l), None, Some(p)) => {
// 注意:Vault 内部按**字典序**给参与方编号,这里的 addrs 也必须
// 用同一顺序,否则第 p 片的投递对象会整体错位。
let mut sorted = sites.clone();
sorted.sort();
let me = sorted
.iter()
.position(|s| *s == site)
.ok_or_else(|| format!("--site {site} 不在 --sites 里"))?;
let map = parse_peers(p)?;
let mut addrs: Vec<String> = Vec::with_capacity(sorted.len());
for (i, s) in sorted.iter().enumerate() {
if i == me {
addrs.push(String::new()); // 本方那格不用
} else {
let a = map.get(s).ok_or_else(|| {
format!("--peers 缺少站点 {s} 的地址(需要全部 {sorted:?})")
})?;
addrs.push(a.clone());
}
}
note!(" 建立网状连接({} 方,本方 {me} 号)...", sorted.len());
AnyTransport::Mesh(
TcpMesh::connect_mesh_with_psk(me, l, &addrs, psk.as_ref())
.map_err(|e| e.to_string())?,
)
}
(Some(_), None, None) => {
return Err(format!(
"{} 方必须用 --listen + --peers 建网状连接(--connect 只用于两方)",
sites.len()
));
}
(None, Some(_), None) => {
return Err(format!(
"{} 方不能用 --connect(它只连一个对端),请改用 --listen + --peers",
sites.len()
));
}
};
note!(" 已连接");
let data_str = parse_flag(args, "--data").unwrap_or("0");
let fxp: u32 = parse_flag(args, "--fxp")
.unwrap_or("18")
.parse()
.map_err(|_| "--fxp 不是合法整数")?;
// 数据按浮点解析,再编码到定点环
let mut data = Vec::new();
for tok in data_str.split(',') {
let tok = tok.trim();
if tok.is_empty() {
continue;
}
let v: f64 = tok.parse().map_err(|_| format!("--data 里的 {tok:?} 不是浮点"))?;
data.push(mpc_core::ring::encode(v, fxp).map_err(|e| e.to_string())?);
}
if data.is_empty() {
return Err("--data 为空".into());
}
note!("mpc node · site={site} · {} 方 · {} 个元素 · fxp={fxp}", sites.len(), data.len());
let cfg = SessionConfig {
site: site.clone(),
sites,
master_seed: seed,
fxp,
data,
};
let out = run_session(transport, &cfg, true).map_err(|e: NodeError| e.to_string())?;
let value = mpc_core::ring::decode(out[0], fxp);
report::kv(
"会话结果",
&[
("site", report::Cell::txt(site)),
("fxp", report::Cell::int(fxp as i64)),
("value", report::Cell::nump(value, 6)),
],
);
Ok(())
}
// ---------------------------------------------------------------------------
// mpc cluster / mpc agent —— 编排层
//
// 这一层替代 Ray 在 mpc 里的作用,只做两件事:**全局视图** 和
// **把进程放对机器**。不用 ray 包的理由见 `mpc-orch` 的模块注释
// (64MB wheel、无 armv7 支持、数据面对 mpc 无用)。
// ---------------------------------------------------------------------------
fn cmd_cluster(args: &[String]) -> Result<(), String> {
let listen = parse_flag(args, "--listen").unwrap_or(mpc_orch::DEFAULT_ORCH_ADDR);
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites(逗号分隔的全体站点)")?;
let sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sites.len() < 2 {
return Err(format!("--sites 至少 2 方,得到 {} 个", sites.len()));
}
let fxp: u32 = parse_flag(args, "--fxp")
.unwrap_or("18")
.parse()
.map_err(|_| "--fxp 不是合法整数")?;
let seed = seed_or_random(args)?;
let timeout: u64 = parse_flag(args, "--timeout")
.unwrap_or("120")
.parse()
.map_err(|_| "--timeout 不是合法整数")?;
let orch = Orchestrator::bind(listen, sites.len(), fxp, seed, Duration::from_secs(timeout))?;
let addr = orch.local_addr()?;
note!("mpc cluster · 监听 {addr} · 等 {} 方 · fxp={fxp}", sites.len());
note!(
" 各机器执行: mpc agent --site <NAME> --orch <本机IP:{}> --listen 0.0.0.0:0 --data ...",
addr.port()
);
let reports = orch.run(true)?;
// 汇总表:每方一行。失败方也要出现在表里 —— 缺行会让「少了一方」
// 和「这一方没上报」看起来一样。
let mut values = Vec::new();
let mut rows: Vec<Vec<report::Cell>> = Vec::new();
for r in &reports {
let (val, status) = match (&r.value, &r.err) {
(Some(v), _) => {
values.push(*v);
(report::Cell::nump(*v, 6), report::Cell::txt("ok"))
}
(None, Some(e)) => (report::Cell::empty("无"), report::Cell::txt(e)),
(None, None) => (report::Cell::empty("无"), report::Cell::txt("未回报")),
};
rows.push(vec![report::Cell::txt(r.site.clone()), val, status]);
}
report::table("各方结果", &["site", "value", "状态"], &rows);
if values.len() != sites.len() {
return Err(format!(
"{} / {} 方没跑完(有失败或未回报)",
sites.len() - values.len(),
sites.len()
));
}
// 各方必须算出同一个数。不一致说明分片投错方、种子不同步或编号错位,
// 而且这种错不会在协议内部报出来 —— 只能在这里兜住。
let first = values[0];
for v in &values[1..] {
if (v - first).abs() > 1e-9 {
return Err(format!(
"各方结果不一致: {first} vs {v} —— 分片/种子/编号有一处对不上"
));
}
}
note!(" 一致({} 方同值 {first})", values.len());
Ok(())
}
// ---------------------------------------------------------------------------
// mpc orch —— 多作业(DAG)编排与状态查询
// ---------------------------------------------------------------------------
fn cmd_orch(args: &[String]) -> Result<(), String> {
match args.first().map(String::as_str) {
Some("run") => orch_run(&args[1..]),
Some("status") => orch_status(&args[1..]),
Some(other) => Err(format!("未知子命令 {other}(只认 run / status)")),
None => Err("mpc orch 需要子命令:run <计划文件> / status".into()),
}
}
fn orch_run(args: &[String]) -> Result<(), String> {
let plan_path = parse_flag(args, "--plan").ok_or("缺少 --plan <计划文件>")?;
let src = std::fs::read_to_string(plan_path)
.map_err(|e| format!("读计划 {plan_path} 失败: {e}"))?;
let plan = JobPlan::parse(&src).map_err(|e| format!("{plan_path}: {e}"))?;
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites(逗号分隔的全体站点)")?;
let sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sites.len() < 2 {
return Err(format!("--sites 至少 2 方,得到 {} 个", sites.len()));
}
// 计划里写了某个站的 data,那个站就必须在 --sites 里,否则那份数据永远用不上
for j in &plan.jobs {
for s in j.data.keys() {
if !sites.contains(s) {
return Err(format!(
"作业 {} 给了站点 {s} 的数据,但它不在 --sites {sites:?} 里",
j.name
));
}
}
}
let listen = parse_flag(args, "--listen").unwrap_or(mpc_orch::DEFAULT_ORCH_ADDR);
let fxp: u32 = parse_flag(args, "--fxp")
.unwrap_or("18")
.parse()
.map_err(|_| "--fxp 不是合法整数")?;
let seed = seed_or_random(args)?;
let timeout: u64 = parse_flag(args, "--timeout")
.unwrap_or("120")
.parse()
.map_err(|_| "--timeout 不是合法整数")?;
let state_dir = parse_flag(args, "--state-dir").map(std::path::PathBuf::from);
let orch = Orchestrator::bind(listen, sites.len(), fxp, seed, Duration::from_secs(timeout))?;
let addr = orch.local_addr()?;
note!(
"mpc orch · 监听 {addr} · 等 {} 方 · {} 个作业 · fxp={fxp}",
sites.len(),
plan.jobs.len()
);
if let Some(d) = &state_dir {
note!(" 状态目录: {}", d.display());
} else {
note!(" ⚠ 未给 --state-dir:状态只在内存里,进程退出后查不到");
}
let summaries = orch.run_jobs(&plan, state_dir.as_deref(), true)?;
let rows: Vec<Vec<report::Cell>> = summaries
.iter()
.map(|s| {
vec![
report::Cell::txt(s.job.clone()),
report::Cell::txt(s.status.clone()),
match s.value {
Some(v) => report::Cell::nump(v, 6),
None => report::Cell::empty("无"),
},
match &s.detail {
Some(d) => report::Cell::txt(d.clone()),
None => report::Cell::txt(""),
},
]
})
.collect();
report::table("作业结果", &["job", "状态", "值", "说明"], &rows);
// 有作业没成功就非零退出 —— 编排器是给流水线调用的,退出码就是它的返回值
let bad = summaries.iter().filter(|s| s.status != "ok").count();
if bad > 0 {
return Err(format!("{bad} / {} 个作业没成功", summaries.len()));
}
Ok(())
}
fn orch_status(args: &[String]) -> Result<(), String> {
let dir = parse_flag(args, "--state-dir").ok_or("缺少 --state-dir")?;
let dir = std::path::Path::new(dir);
// 指定了 --job 就看单作业明细,否则列全部
if let Some(job) = parse_flag(args, "--job") {
let (evs, skipped) = StateLog::load(dir, job)?;
if skipped > 0 {
note!(" ⚠ 有 {skipped} 行解析失败(多半是写到一半被杀的残行),已跳过");
}
let sums = orch_state::summarize(&evs);
let s = sums
.first()
.ok_or_else(|| format!("作业 {job} 的日志里没有任何事件"))?;
report::kv(
&format!("作业 {}", s.job),
&[
("status", report::Cell::txt(s.status.clone())),
(
"value",
match s.value {
Some(v) => report::Cell::nump(v, 6),
None => report::Cell::empty("无"),
},
),
(
"detail",
match &s.detail {
Some(d) => report::Cell::txt(d.clone()),
None => report::Cell::txt(""),
},
),
("events", report::Cell::int(evs.len() as i64)),
],
);
let rows: Vec<Vec<report::Cell>> = s
.sites
.iter()
.map(|(site, st, v, d)| {
vec![
report::Cell::txt(site.clone()),
report::Cell::txt(st.clone()),
match v {
Some(x) => report::Cell::nump(*x, 6),
None => report::Cell::empty("无"),
},
match d {
Some(x) => report::Cell::txt(x.clone()),
None => report::Cell::txt(""),
},
]
})
.collect();
report::table("参与方", &["site", "状态", "值", "说明"], &rows);
return Ok(());
}
let jobs = StateLog::list_jobs(dir)?;
if jobs.is_empty() {
return Err(format!("{} 里没有任何作业状态", dir.display()));
}
let mut rows: Vec<Vec<report::Cell>> = Vec::new();
let mut total_skipped = 0usize;
for job in jobs {
let (evs, skipped) = StateLog::load(dir, &job)?;
total_skipped += skipped;
for s in orch_state::summarize(&evs) {
rows.push(vec![
report::Cell::txt(s.job),
report::Cell::txt(s.status),
match s.value {
Some(v) => report::Cell::nump(v, 6),
None => report::Cell::empty("无"),
},
match s.detail {
Some(d) => report::Cell::txt(d),
None => report::Cell::txt(""),
},
]);
}
}
if total_skipped > 0 {
note!(" ⚠ 有 {total_skipped} 行解析失败(残行),已跳过");
}
report::table("作业状态(读自状态目录)", &["job", "状态", "值", "说明"], &rows);
Ok(())
}
// ---------------------------------------------------------------------------
// mpc agent
// ---------------------------------------------------------------------------
/// 连 orchestrator,循环领作业:跑会话 → 回报 → 领下一个,直到 `BYE`。
fn cmd_agent(args: &[String]) -> Result<(), String> {
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let orch = parse_flag(args, "--orch").ok_or("缺少 --orch(orchestrator 的 host:port)")?;
let listen = parse_flag(args, "--listen").unwrap_or("0.0.0.0:0");
let timeout: u64 = parse_flag(args, "--timeout")
.unwrap_or("120")
.parse()
.map_err(|_| "--timeout 不是合法整数")?;
// 端口 0 要先探一个真实端口出来:HELLO 里必须报对端能连的端口。
let listen_addr = resolve_listen(listen)?;
let advertise = match parse_flag(args, "--advertise") {
Some(a) => a.to_string(),
// 默认拿本机出口 IP + 监听端口。NAT / 多网卡场景对端未必可达,
// 那时必须显式 --advertise。
None => mpc_orch::advertise_from_listen(&listen_addr)?,
};
note!("mpc agent · site={site} · orchestrator={orch} · 监听 {listen_addr} · 对外 {advertise}");
let mut agent = Agent::connect(orch, &site, &advertise, Duration::from_secs(timeout))?;
note!(" 已注册,等待计划下发…");
let psk = parse_psk(args)?;
if psk.is_none() {
note!(" ⚠ 未配置 PSK:与其它方的连接既不认证身份、也不加密链路");
}
let mut ran = 0usize;
loop {
let plan = match agent.next_assign()? {
Assign::Done => break,
Assign::Skip { job, reason } => {
note!(" 跳过作业 {job}:{reason}");
continue;
}
Assign::Run(p) => p,
};
note!(
" 作业 {} · {} 方 · 本方 {} 号 · fxp={} · peers={}",
plan.job,
plan.sites.len(),
plan.me,
plan.fxp,
plan.peers_arg()
);
// 计划里带了本方输入就用它(多作业模式下每作业不同),否则用自己的 --data。
let data = if plan.data.is_empty() {
let data_str = parse_flag(args, "--data").unwrap_or("0");
let mut v = Vec::new();
for tok in data_str.split(',') {
let tok = tok.trim();
if tok.is_empty() {
continue;
}
let x: f64 = tok
.parse()
.map_err(|_| format!("--data 里的 {tok:?} 不是浮点"))?;
v.push(ring::encode(x, plan.fxp).map_err(|e| e.to_string())?);
}
v
} else {
plan.data.clone()
};
if data.is_empty() {
let msg = "本方没有任何输入数据(计划里没给,--data 也是空)".to_string();
let _ = agent.report(&Report::fail(&site, &msg));
return Err(msg);
}
note!(" 建立网状连接({} 方)…", plan.sites.len());
let addrs = plan.addrs_for_mesh();
// 一条作业失败不代表后面全废:别的分支可能不依赖它,所以回报后继续领下一个。
let transport = match TcpMesh::connect_mesh_with_psk(
plan.me,
&listen_addr,
&addrs,
psk.as_ref(),
) {
Ok(t) => t,
Err(e) => {
let msg = format!("建连失败: {e}");
let _ = agent.report(&Report::fail(&site, &msg));
note!(" 作业 {} 失败:{msg}", plan.job);
continue;
}
};
let cfg = SessionConfig {
site: site.clone(),
sites: plan.sites.clone(),
master_seed: plan.seed,
fxp: plan.fxp,
data,
};
match run_session(transport, &cfg, true) {
Ok(out) => {
let value = ring::decode(out[0], plan.fxp);
agent.report(&Report::ok(&site, value))?;
report::kv(
"会话结果(已上报 orchestrator)",
&[
("job", report::Cell::txt(plan.job.clone())),
("site", report::Cell::txt(site.clone())),
("me", report::Cell::int(plan.me as i64)),
("fxp", report::Cell::int(plan.fxp as i64)),
("value", report::Cell::nump(value, 6)),
],
);
ran += 1;
}
Err(e) => {
// 失败也要回报,否则 orchestrator 会一直等,另外几方也卡在 open 上。
let msg = e.to_string();
let _ = agent.report(&Report::fail(&site, &msg));
note!(" 作业 {} 失败:{msg}", plan.job);
}
}
}
note!(" 全部作业结束,共跑了 {ran} 个");
Ok(())
}
/// `--listen` 端口写 0 时先绑一次拿到真实端口再放开。
///
/// 拿到端口到真正 `TcpMesh` 绑上去之间有个极短窗口,理论上可能被别的进程抢;
/// 抢的后果是绑定时报错(不会静默用错端口),可以接受。
fn resolve_listen(listen: &str) -> Result<String, String> {
let (host, port) = listen
.rsplit_once(':')
.ok_or_else(|| format!("--listen {listen:?} 不是 host:port"))?;
let port: u16 = port
.parse()
.map_err(|_| format!("--listen {listen:?} 的端口不是整数"))?;
if port != 0 {
return Ok(listen.to_string());
}
let l = std::net::TcpListener::bind(listen).map_err(|e| format!("试绑 {listen} 失败: {e}"))?;
let p = l.local_addr().map_err(|e| e.to_string())?.port();
drop(l);
Ok(format!("{host}:{p}"))
}
/// 解析 `alice=1.2.3.4:9441,bob=...` 形式的地址表。
fn parse_peers(raw: &str) -> Result<std::collections::HashMap<String, String>, String> {
let mut map = std::collections::HashMap::new();
for entry in raw.split(',') {
let entry = entry.trim();
if entry.is_empty() {
continue;
}
let (name, addr) = entry
.split_once('=')
.ok_or_else(|| format!("--peers 里 {entry:?} 不是 name=addr 形式"))?;
let (name, addr) = (name.trim(), addr.trim());
if name.is_empty() || addr.is_empty() {
return Err(format!("--peers 里 {entry:?} 的站点名或地址为空"));
}
if map.insert(name.to_string(), addr.to_string()).is_some() {
return Err(format!("--peers 里站点 {name} 重复"));
}
}
if map.is_empty() {
return Err("--peers 为空".into());
}
Ok(map)
}
/// 单连接与网状连接的统一包装 —— `run_session` 对泛型 `T: Transport` 只要求接口一致。
enum AnyTransport {
Single(TcpTransport),
Mesh(TcpMesh),
}
impl Transport for AnyTransport {
fn send_to(&mut self, party: usize, frame: Frame) -> Result<(), VaultError> {
match self {
Self::Single(t) => t.send_to(party, frame),
Self::Mesh(m) => m.send_to(party, frame),
}
}
fn recv_from(&mut self, party: usize) -> Result<Frame, VaultError> {
match self {
Self::Single(t) => t.recv_from(party),
Self::Mesh(m) => m.recv_from(party),
}
}
}
/// 按 `--listen` / `--connect` / `--listen + --peers` 三种形态建一条通道。
///
/// n 方纵向 LR 要建**两条**(PSI 一条、密态一条),所以抽出来共用。
/// 两条都必须是同一套下标语义 —— `sorted_sites` 的顺序即 party 编号。
fn connect_any(
label: &str,
listen: Option<&str>,
connect: Option<&str>,
peers_raw: Option<&str>,
sorted_sites: &[String],
my_idx: usize,
psk: &Option<[u8; 32]>,
) -> Result<AnyTransport, String> {
let n = sorted_sites.len();
let t = match (listen, connect, peers_raw) {
(Some(_), Some(_), _) => return Err("--listen 与 --connect 只能选一个".into()),
(None, None, _) => return Err("必须给 --listen 或 --connect".into()),
(Some(l), None, None) if n == 2 => {
note!(" [{label}] 等待对端连接({l})...");
let t = match psk {
Some(p) => TcpTransport::accept_with_psk_within(l, wait_budget(), p),
None => TcpTransport::accept_within(l, wait_budget()),
}
.map_err(|e| e.to_string())?;
AnyTransport::Single(t)
}
(None, Some(c), None) if n == 2 => {
note!(" [{label}] 连接对端({c})...");
let t = match psk {
Some(p) => TcpTransport::connect_with_psk_within(c, wait_budget(), p),
None => TcpTransport::connect_within(c, wait_budget()),
}
.map_err(|e| e.to_string())?;
AnyTransport::Single(t)
}
(None, Some(_), Some(_)) => {
return Err("--peers 只与 --listen 搭配(网状连接需要本方监听地址)".into());
}
(Some(l), None, Some(p)) => {
let map = parse_peers(p)?;
let mut addrs: Vec<String> = Vec::with_capacity(n);
for (i, s) in sorted_sites.iter().enumerate() {
if i == my_idx {
addrs.push(String::new());
} else {
let a = map.get(s).ok_or_else(|| {
format!("[{label}] --peers 缺少站点 {s} 的地址(需要全部 {sorted_sites:?})")
})?;
addrs.push(a.clone());
}
}
note!(" [{label}] 建立网状连接({n} 方,本方 {my_idx} 号)...");
AnyTransport::Mesh(
TcpMesh::connect_mesh_with_psk(my_idx, l, &addrs, psk.as_ref())
.map_err(|e| e.to_string())?,
)
}
(Some(_), None, None) => {
return Err(format!(
"[{label}] {n} 方必须用 --listen + --peers 建网状连接(--connect 只用于两方)"
));
}
(None, Some(_), None) => {
return Err(format!(
"[{label}] {n} 方不能用 --connect(它只连一个对端),请改用 --listen + --peers"
));
}
};
note!(" [{label}] 已连接");
Ok(t)
}
/// 地址端口 +1。纵向 LR 的第二条通道(密态)用 `--listen` 的下一个端口。
///
/// 为什么用"端口 +1"而不是再加一组参数:n 方要一次给出 n 组地址,
/// 加成 4 组参数(PSI 的 listen/peers + 密态的 listen/peers)容易配漏一个,
/// 而配漏的表现是连不上或串会话,不是清晰报错。
fn bump_port(addr: &str) -> Result<String, String> {
let (host, port) = addr
.rsplit_once(':')
.ok_or_else(|| format!("地址 {addr:?} 缺少端口"))?;
let p: u16 = port
.parse()
.map_err(|_| format!("地址 {addr:?} 的端口 {port:?} 不是整数"))?;
if p == 0 {
return Err(format!(
"地址 {addr:?} 用了随机端口 0 —— 两条通道要分别监听,不能随机"
));
}
if p == u16::MAX {
return Err(format!("地址 {addr:?} 端口已是 65535,没有下一个端口可用"));
}
Ok(format!("{host}:{}", p + 1))
}
/// 把 `--peers` 表里每个地址的端口都 +1。
fn bump_peers(raw: &str) -> Result<String, String> {
let mut out: Vec<String> = Vec::new();
for item in raw.split(',') {
let item = item.trim();
if item.is_empty() {
continue;
}
let (k, v) = item
.split_once('=')
.ok_or_else(|| format!("--peers 里的 {item:?} 缺少 `=`(应形如 alice=host:port)"))?;
out.push(format!("{}={}", k.trim(), bump_port(v.trim())?));
}
if out.is_empty() {
return Err("--peers 为空".into());
}
Ok(out.join(","))
}
/// 解析 `--col-blocks`:`alice:0:1,bob:1:1,carol:2:1`(site:offset:len)。
fn parse_col_blocks(raw: &str) -> Result<Vec<mpc_node::ColBlock>, String> {
let mut out: Vec<mpc_node::ColBlock> = Vec::new();
for item in raw.split(',') {
let item = item.trim();
if item.is_empty() {
continue;
}
let parts: Vec<&str> = item.split(':').map(str::trim).collect();
if parts.len() != 3 {
return Err(format!(
"--col-blocks 里的 {item:?} 不是 site:offset:len 三段"
));
}
let offset: usize = parts[1]
.parse()
.map_err(|_| format!("{item:?} 的 offset {:?} 不是非负整数", parts[1]))?;
let len: usize = parts[2]
.parse()
.map_err(|_| format!("{item:?} 的 len {:?} 不是非负整数", parts[2]))?;
if out.iter().any(|b| b.site == parts[0]) {
return Err(format!("--col-blocks 里 site {} 重复", parts[0]));
}
out.push(mpc_node::ColBlock::new(parts[0], offset, len));
}
if out.is_empty() {
return Err("--col-blocks 为空".into());
}
Ok(out)
}
/// 从 (会话主种子, 本方 site) 派生该方的 PSI 种子。
///
/// # 为什么不让用户直接给 PSI 种子
///
/// ECDH-PSI 的隐私性全部押在"每方私钥不同"上。用户可以给同一个
/// `--seed`(默认值更是每人一样),若直接拿它当 PRG 种子,所有方的
/// 私钥就完全相同 —— 交集**仍然算得对**,但任一方都能从自己那份
/// 盲化点反推别人的原始 ID。不报错、不崩、数也对,是最难发现的一种失败。
///
/// 所以种子一律从 `(主种子, site)` 派生:主种子可以共享(它只是会话
/// 标识),派生结果天然每方不同。
fn derive_psi_seed(seed: [u8; 32], site: &str) -> [u8; 32] {
let mut out = seed;
for (i, b) in site.bytes().enumerate() {
let k = i % 32;
out[k] = out[k].wrapping_add(b).wrapping_mul(31).wrapping_add(i as u8);
}
out
}
fn parse_seed(hex: &str) -> Result<[u8; 32], String> {
let clean: String = hex.chars().filter(|c| !c.is_whitespace()).collect();
if clean.len() != 64 {
return Err(format!("--seed 需要 64 个十六进制字符,实际 {}", clean.len()));
}
let mut out = [0u8; 32];
for i in 0..32 {
out[i] = u8::from_str_radix(&clean[i * 2..i * 2 + 2], 16)
.map_err(|_| format!("--seed 第 {} 字节不是十六进制", i))?;
}
// ★ 全零种子必须拒。
//
// 全零主种子 ⇒ `Dealer` 的所有 Beaver 三元组都由全零派生的
// ChaCha20 流生成 ⇒ **任何一方都能算出掩码** ⇒ 密态乘法隐私性归零。
//
// ★ 而症状是「不报错、不崩溃、结果数值也对」——
// 这是最难发现的一类失败(项目文档里对 PSI 种子的原话)。
// 所以必须在**入口**就拒,不能指望下游发现。
//
// 判据只有一份:`mpc_core::material::seed_is_valid`。
if !mpc_core::material::seed_is_valid(&out) {
return Err(String::from(
"--seed 是全零 —— 拒绝。全零主种子会让 Beaver 三元组全部可预测,\
密态乘法的隐私性归零,而结果数值照样对(不报错、不崩溃,最难发现的一类失败)。\
请给一个非全零的种子,或省略 --seed 让它从系统熵源随机生成。",
));
}
Ok(out)
}
/// 取会话种子:`--seed` 给了就用给的,没给就**从系统熵源随机取**。
///
/// ★ 绝不返回全零兜底 —— 那是本项目最隐蔽的一类失败:
/// Beaver 三元组全部可预测 ⇒ 隐私性归零,而结果数值照样对。
///
/// 拿不到熵源就**报错**,不降级(与 `mpc_core::osrand` 的纪律一致)。
fn seed_or_random(args: &[String]) -> Result<[u8; 32], String> {
match parse_flag(args, "--seed") {
Some(h) => parse_seed(h),
None => mpc_core::osrand::seed32().map_err(|e| {
format!(
"取不到系统熵源: {e} —— 请显式给 --seed(64 位十六进制,不能全零)"
)
}),
}
}
// ---------------------------------------------------------------------------
// mpc sql-join(需 --features secure)
// ---------------------------------------------------------------------------
#[cfg(feature = "secure")]
fn cmd_sql_join(args: &[String]) -> Result<(), String> {
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites")?;
let sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sites.len() != 2 {
return Err(format!("sql-join 目前只支持两方,--sites 得到 {} 个", sites.len()));
}
if !sites.contains(&site) {
return Err(format!("--site {site} 不在 --sites {sites:?} 里"));
}
let listen = parse_flag(args, "--listen");
let connect = parse_flag(args, "--connect");
let addr = match (listen, connect) {
(Some(_), Some(_)) => return Err("--listen 与 --connect 只能选一个".into()),
(None, None) => return Err("必须给 --listen 或 --connect".into()),
(Some(a), None) | (None, Some(a)) => a.to_string(),
};
let seed = seed_or_random(args)?;
let fxp: u32 = parse_flag(args, "--fxp")
.unwrap_or("18")
.parse()
.map_err(|_| "--fxp 不是合法整数")?;
// 本方数据源:`--ids`/`--data`(手输),或 `--pg-url`/`--pg-query`(直连业务库)
let pg_url = parse_flag(args, "--pg-url")
.map(|s| s.to_string())
.or_else(|| std::env::var("MPC_PG_URL").ok().filter(|s| !s.trim().is_empty()));
let (ids, cols) = match pg_url {
Some(url) => {
if parse_flag(args, "--ids").is_some() || args.iter().any(|a| a == "--data") {
return Err("--pg-url 与 --ids/--data 互斥:本方数据只能有一个来源".into());
}
let q = parse_flag(args, "--pg-query")
.ok_or("给了 --pg-url 就要 --pg-query(一条 SELECT)")?;
let loaded = pg_source::load(&url, q, parse_flag(args, "--pg-id-col"))?;
if !loaded.dropped.is_empty() {
eprintln!(" 注意:非数值列已丢弃 {:?}", loaded.dropped);
}
note!(
" PG 数据源 {} · join 键 {} · {} 行 × {} 列",
pg_source::redact(&url),
loaded.id_col,
loaded.ids.len(),
loaded.cols.len()
);
(loaded.ids, loaded.cols)
}
None => {
// --ids:join 键
let ids_raw = parse_flag(args, "--ids").ok_or("缺少 --ids(或给 --pg-url)")?;
let mut ids = Vec::new();
for tok in ids_raw.split(',') {
let tok = tok.trim();
if tok.is_empty() {
continue;
}
let v: u64 = tok
.parse()
.map_err(|_| format!("--ids 里的 {tok:?} 不是非负整数"))?;
ids.push(v);
}
if ids.is_empty() {
return Err("--ids 为空".into());
}
// --data name=v1,v2,...(可重复)
let mut cols: Vec<(String, Vec<f64>)> = Vec::new();
for i in 0..args.len() {
if args[i] == "--data" && i + 1 < args.len() {
cols.push(sql_join::parse_col(&args[i + 1])?);
}
}
(ids, cols)
}
};
if cols.is_empty() {
return Err("至少要有一列数据(--data name=... 或 --pg-query 里的数值列)".into());
}
// --schema col1,col2,...(两方必须一致的全局列序)
let schema_raw = parse_flag(args, "--schema").ok_or("缺少 --schema")?;
let schema = sql_join::parse_schema(schema_raw)?;
let agg_col = parse_flag(args, "--agg-col").ok_or("缺少 --agg-col")?;
let pred = parse_flag(args, "--pred");
note!(
"mpc sql-join · site={site} · {addr} · {} 行 × {} 列 · 聚合列={agg_col}",
ids.len(),
cols.len()
);
note!(" schema: {}", schema.join(","));
if let Some(p) = pred {
note!(" 谓词: WHERE {p}");
}
// 建连认证:与 `mpc node` 用同一套解析(--psk-file > --psk > MPC_PSK)。
let psk = parse_psk(args)?;
if psk.is_none() {
note!(" ⚠ 未配置 PSK(--psk-file / --psk / MPC_PSK):本次连接既不认证身份、也不加密链路");
}
let mut transport = if listen.is_some() {
note!(" 等待对端连接...");
match &psk {
Some(p) => TcpTransport::accept_with_psk_within(&addr, wait_budget(), p),
None => TcpTransport::accept_within(&addr, wait_budget()),
}
.map_err(|e| e.to_string())?
} else {
note!(" 连接对端...");
match &psk {
Some(p) => TcpTransport::connect_with_psk_within(&addr, wait_budget(), p),
None => TcpTransport::connect_within(&addr, wait_budget()),
}
.map_err(|e| e.to_string())?
};
note!(" 已连接");
// PSI 种子从 (vault_seed, site) 派生 —— 同一 --seed 下两方自动取不同值,
// 否则 ECDH 私钥相同,PSI 的隐私性直接破坏(但交集仍会算对,很隐蔽)。
let psi_seed = derive_psi_seed(seed, &site);
let (aligned, vals) = sql_join::run(
&site,
&sites,
&mut transport,
&ids,
&cols,
&schema,
agg_col,
pred,
psi_seed,
seed, // Vault 种子:两方必须一致
fxp,
true,
)?;
note!(" 对齐后的键: {aligned:?}");
let mut rows: Vec<(&str, report::Cell)> =
vec![("aligned_rows", report::Cell::int(aligned.len() as i64))];
rows.extend(sql_join::result_cells(&vals));
report::kv("密态聚合结果(已 reveal)", &rows);
Ok(())
}
// ---------------------------------------------------------------------------
// mpc psi
// ---------------------------------------------------------------------------
fn cmd_psi(args: &[String]) -> Result<(), String> {
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites")?;
let sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sites.len() < 2 {
return Err(format!("--sites 至少 2 方,得到 {} 个", sites.len()));
}
if !sites.contains(&site) {
return Err(format!("--site {site} 不在 --sites {sites:?} 里"));
}
let listen = parse_flag(args, "--listen");
let connect = parse_flag(args, "--connect");
let peers_raw = parse_flag(args, "--peers");
let base_seed = seed_or_random(args)?;
let ids_raw = parse_flag(args, "--ids").ok_or("缺少 --ids")?;
let mut ids: Vec<Vec<u8>> = Vec::new();
let mut id_values: Vec<u64> = Vec::new();
for tok in ids_raw.split(',') {
let tok = tok.trim();
if tok.is_empty() {
continue;
}
let v: u64 = tok.parse().map_err(|_| format!("--ids 里的 {tok:?} 不是非负整数"))?;
ids.push(mpc_psi::id_from_u64(v));
id_values.push(v);
}
if ids.is_empty() {
return Err("--ids 为空".into());
}
// party 编号一律按**字典序**:`TcpMesh` 建的连接按这个顺序编号,
// 填错不会报错,只会把帧送到错误的人手里(表现为交集莫名不对)。
let mut sorted_sites = sites.clone();
sorted_sites.sort();
let my_idx = sorted_sites
.iter()
.position(|s| *s == site)
.ok_or_else(|| format!("--site {site} 不在 --sites 里"))?;
note!(
"mpc psi · site={site}({}/{})· {} 个 ID",
my_idx + 1,
sites.len(),
ids.len()
);
let psk = parse_psk(args)?;
if psk.is_none() {
note!(" ⚠ 未配置 PSK(--psk-file / --psk / MPC_PSK):本次连接既不认证身份、也不加密链路");
}
// 三种连法,与 `mpc node` 一致:两方 --connect / 两方 --listen / n 方 --listen + --peers
let transport = connect_any(
"PSI",
listen,
connect,
peers_raw,
&sorted_sites,
my_idx,
&psk,
)?;
// 种子按 site 派生:n 方共用同一个 --seed 也不会撞私钥(见 derive_psi_seed)
let cfg = PsiConfig {
site: site.clone(),
sites,
my_idx,
ids,
seed: derive_psi_seed(base_seed, &site),
// session 取共享的 --seed(全体一致);上面那把是每方不同的私钥种子
session: mpc_psi::strict::session_id(&base_seed),
};
let idx = run_psi_session(transport, &cfg, true).map_err(|e| e.to_string())?;
// 交集按 ID 大小输出(`idx` 是本方 --ids 的下标序,不是数值序)
let mut hit: Vec<u64> = idx.iter().map(|&i| id_values[i]).collect();
hit.sort_unstable();
let rows: Vec<Vec<report::Cell>> = hit.iter().map(|v| vec![report::Cell::int(*v as i64)]).collect();
report::table(
&format!("交集 {} 条", hit.len()),
&["id"],
&rows,
);
Ok(())
}
// ---------------------------------------------------------------------------
// mpc lr
// ---------------------------------------------------------------------------
fn cmd_lr(args: &[String]) -> Result<(), String> {
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites")?;
let sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sites.len() != 2 {
return Err(format!("LR 目前只支持两方,--sites 得到 {} 个", sites.len()));
}
if !sites.contains(&site) {
return Err(format!("--site {site} 不在 --sites {sites:?} 里"));
}
let listen = parse_flag(args, "--listen");
let connect = parse_flag(args, "--connect");
let addr = match (listen, connect) {
(Some(_), Some(_)) => return Err("--listen 与 --connect 只能选一个".into()),
(None, None) => return Err("必须给 --listen 或 --connect".into()),
(Some(a), None) | (None, Some(a)) => a.to_string(),
};
let seed = seed_or_random(args)?;
let fxp: u32 = parse_flag(args, "--fxp")
.unwrap_or("18")
.parse()
.map_err(|_| "--fxp 不是合法整数")?;
let n: usize = parse_flag(args, "--n")
.ok_or("缺少 --n")?
.parse()
.map_err(|_| "--n 不是合法整数")?;
let d: usize = parse_flag(args, "--d")
.ok_or("缺少 --d")?
.parse()
.map_err(|_| "--d 不是合法整数")?;
let epochs: usize = parse_flag(args, "--epochs")
.unwrap_or("40")
.parse()
.map_err(|_| "--epochs 不是合法整数")?;
let lr: f64 = parse_flag(args, "--lr")
.unwrap_or("0.5")
.parse()
.map_err(|_| "--lr 不是浮点")?;
let parse_f64_list = |name: &str| -> Result<Vec<f64>, String> {
let raw = parse_flag(args, name).ok_or(format!("缺少 {name}"))?;
raw.split(',')
.map(|t| t.trim().parse::<f64>().map_err(|_| format!("{name} 里的 {t:?} 不是浮点")))
.collect()
};
let x = parse_f64_list("--data-x")?;
let y = parse_f64_list("--data-y")?;
if x.len() != n * d {
return Err(format!("--data-x 长度 {} ≠ n×d = {}", x.len(), n * d));
}
if y.len() != n {
return Err(format!("--data-y 长度 {} ≠ n = {}", y.len(), n));
}
note!("mpc lr · site={site} · {addr} · n={n} d={d} · {epochs} 轮 · lr={lr}");
let transport = if listen.is_some() {
note!(" 等待对端连接...");
TcpTransport::accept_within(&addr, wait_budget()).map_err(|e| e.to_string())?
} else {
note!(" 连接对端...");
TcpTransport::connect_within(&addr, wait_budget()).map_err(|e| e.to_string())?
};
note!(" 已连接");
let cfg = LrConfig {
site: site.clone(),
sites,
seed,
fxp,
x,
n,
d,
y,
epochs,
lr,
};
let w = run_lr_session(transport, &cfg, true).map_err(|e| e.to_string())?;
let rows: Vec<Vec<report::Cell>> = w
.iter()
.enumerate()
.map(|(i, &v)| {
vec![
report::Cell::txt(format!("w[{i}]")),
report::Cell::nump(mpc_core::ring::decode(v, fxp), 6),
]
})
.collect();
report::table(&format!("训练权重({} 个)", w.len()), &["权重", "值"], &rows);
Ok(())
}
// ---------------------------------------------------------------------------
// mpc lr-vertical
// ---------------------------------------------------------------------------
/// `mpc lr-vertical`:真纵向 LR —— 各方持不同客户、不同特征列,n 方。
///
/// 与 `mpc lr` 的区别:那个是横向 demo(各方同列、行已对齐);
/// 这个从 PSI 开始 —— 行由求交决定、列由 `--col-blocks` 的公开 schema 定位。
///
/// # 两条通道
///
/// PSI 与密态会话必须走两条独立连接(帧的 op 不同,混在一条会串)。
/// 这里密态通道用 `--listen` / `--peers` 的**端口 +1**,少给两组参数。
fn cmd_lr_vertical(args: &[String]) -> Result<(), String> {
let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string();
let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites")?;
let mut sorted_sites: Vec<String> = sites_raw
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if sorted_sites.len() < 2 {
return Err(format!("--sites 至少 2 方,得到 {} 个", sorted_sites.len()));
}
if !sorted_sites.contains(&site) {
return Err(format!("--site {site} 不在 --sites {sorted_sites:?} 里"));
}
// party 编号 = 字典序,与 `TcpMesh` / `mpc node` / `mpc psi` 一致
sorted_sites.sort();
let my_idx = sorted_sites
.iter()
.position(|s| *s == site)
.ok_or_else(|| format!("--site {site} 不在 --sites 里"))?;
// ---- 列块清单:n 方纵向切分的定义 ----
let blocks_raw = parse_flag(args, "--col-blocks").ok_or(
"缺少 --col-blocks(各方列块,形如 alice:0:1,bob:1:1,carol:2:1)",
)?;
let mut blocks = parse_col_blocks(blocks_raw)?;
for b in &blocks {
if !sorted_sites.contains(&b.site) {
return Err(format!(
"--col-blocks 里的 {} 不在 --sites {sorted_sites:?} 里",
b.site
));
}
}
if blocks.len() != sorted_sites.len() {
return Err(format!(
"--col-blocks 有 {} 条,--sites 有 {} 个 —— 必须一一对应",
blocks.len(),
sorted_sites.len()
));
}
// 重排成与 sorted_sites 同序(party 下标即 blocks 下标)
blocks.sort_by_key(|b| {
sorted_sites
.iter()
.position(|s| s == &b.site)
.unwrap_or(usize::MAX)
});
let d_total: usize = blocks.iter().map(|b| b.len).sum();
let mine = blocks[my_idx].clone();
// ---- 数据 ----
let ids_raw = parse_flag(args, "--data-ids").ok_or("缺少 --data-ids")?;
let mut ids: Vec<Vec<u8>> = Vec::new();
for tok in ids_raw.split(',') {
let tok = tok.trim();
if tok.is_empty() {
continue;
}
let v: u64 = tok
.parse()
.map_err(|_| format!("--data-ids 里的 {tok:?} 不是非负整数"))?;
ids.push(mpc_psi::id_from_u64(v));
}
if ids.is_empty() {
return Err("--data-ids 为空".into());
}
let n = ids.len();
let parse_f64_list = |name: &str| -> Result<Vec<f64>, String> {
let raw = parse_flag(args, name).ok_or(format!("缺少 {name}"))?;
raw.split(',')
.map(|t| {
t.trim()
.parse::<f64>()
.map_err(|_| format!("{name} 里的 {t:?} 不是浮点"))
})
.collect()
};
let x = parse_f64_list("--data-x")?;
if x.len() != n * mine.len {
return Err(format!(
"--data-x 长度 {} ≠ 样本数 {} × 本方列数 {}",
x.len(),
n,
mine.len
));
}
let label_owner =
parse_flag(args, "--label-owner").ok_or("缺少 --label-owner(标签由哪一方提供)")?;
if !sorted_sites.iter().any(|s| s == label_owner) {
return Err(format!(
"--label-owner {label_owner} 不在 --sites {sorted_sites:?} 里"
));
}
let y = if site == label_owner {
let v = parse_f64_list("--data-y")?;
if v.len() != n {
return Err(format!("--data-y 长度 {} ≠ 样本数 {n}", v.len()));
}
v
} else {
if parse_flag(args, "--data-y").is_some() {
return Err(format!(
"本方 {site} 不是 label_owner({label_owner}),不该给 --data-y —— \
多方都会加,标签会被重复计数"
));
}
Vec::new()
};
let fxp: u32 = parse_flag(args, "--fxp")
.unwrap_or("18")
.parse()
.map_err(|_| "--fxp 不是合法整数")?;
let epochs: usize = parse_flag(args, "--epochs")
.unwrap_or("40")
.parse()
.map_err(|_| "--epochs 不是合法整数")?;
let lr: f64 = parse_flag(args, "--lr")
.unwrap_or("0.3")
.parse()
.map_err(|_| "--lr 不是浮点")?;
let base_seed = seed_or_random(args)?;
let listen = parse_flag(args, "--listen");
let connect = parse_flag(args, "--connect");
let peers_raw = parse_flag(args, "--peers");
let vault_listen = listen.map(bump_port).transpose()?;
let vault_connect = connect.map(bump_port).transpose()?;
let vault_peers = peers_raw.map(bump_peers).transpose()?;
note!(
"mpc lr-vertical · site={site}({}/{})· {n} 行 × {d_total} 列",
my_idx + 1,
sorted_sites.len()
);
note!(
" 本方列块 [{}, {}) · 标签方 {label_owner} · {} 轮 · lr={lr}",
mine.offset,
mine.end(),
epochs
);
let psk = parse_psk(args)?;
if psk.is_none() {
note!(" ⚠ 未配置 PSK(--psk-file / --psk / MPC_PSK):本次连接既不认证身份、也不加密链路");
}
// 两条通道按**同样顺序**建立:各方都在 PSI 建完后才建密态,
// 所以进度差被 PSI 的全互连握手挡住了,不会有一方提前等密态超时。
let psi_t = connect_any(
"PSI",
listen,
connect,
peers_raw,
&sorted_sites,
my_idx,
&psk,
)?;
let vault_t = connect_any(
"密态",
vault_listen.as_deref(),
vault_connect.as_deref(),
vault_peers.as_deref(),
&sorted_sites,
my_idx,
&psk,
)?;
let cfg = VerticalLrConfig {
site: site.clone(),
sites: sorted_sites.clone(),
seed: base_seed, // 密态主种子:全体必须一致
fxp,
ids,
psi_seed: derive_psi_seed(base_seed, &site),
x,
d_own: mine.len,
col_offset: mine.offset,
d_total,
blocks,
label_owner: label_owner.to_string(),
y,
epochs,
lr,
};
let (order, w) = run_lr_vertical_session(psi_t, vault_t, &cfg, true)
.map_err(|e| e.to_string())?;
let mut rows: Vec<(&str, report::Cell)> =
vec![("aligned_rows", report::Cell::int(order.len() as i64))];
rows.push((
"col_blocks",
report::Cell::txt(
sorted_sites
.iter()
.map(|s| s.as_str())
.collect::<Vec<_>>()
.join(","),
),
));
report::kv("纵向会话", &rows);
let wrows: Vec<Vec<report::Cell>> = w
.iter()
.enumerate()
.map(|(i, &v)| {
vec![
report::Cell::txt(format!("w[{i}]")),
report::Cell::nump(mpc_core::ring::decode(v, fxp), 6),
]
})
.collect();
report::table(&format!("训练权重({} 个)", w.len()), &["权重", "值"], &wrows);
Ok(())
}
// ---------------------------------------------------------------------------
/// 生成可线性分离的合成数据:真实权重全 1、偏置 0,样本 x∈(0,1),
/// 标签 `y = 1` 当 `Σx > d/2`。确定性(由 `seed` 驱动)。
fn gen_fl_data(
k: usize,
d: usize,
per: usize,
seed: u64,
) -> std::collections::HashMap<String, ClientData> {
use mpc_core::prg::Stream;
let mut sb = [0u8; 32];
sb[..8].copy_from_slice(&seed.to_le_bytes());
let mut s = Stream::new(&sb);
let mut out: std::collections::HashMap<String, ClientData> = std::collections::HashMap::new();
for c in 0..k {
let mut x = Vec::with_capacity(per);
let mut y = Vec::with_capacity(per);
for _ in 0..per {
let mut buf = [0u64; 32];
s.fill_u64(&mut buf);
let mut row = Vec::with_capacity(d);
let mut sum = 0.0;
for j in 0..d {
// u64 → [0,1) 浮点
let f = (buf[j] >> 11) as f64 / (1u64 << 53) as f64;
sum += f;
row.push(f);
}
y.push(if sum > d as f64 / 2.0 { 1.0 } else { 0.0 });
x.push(row);
}
out.insert(format!("c{c}"), ClientData { x, y });
}
out
}
fn cmd_fl(args: &[String]) -> Result<(), String> {
let k: usize = parse_flag(args, "--clients")
.unwrap_or("3")
.parse()
.map_err(|_| "--clients 不是整数")?;
let d: usize = parse_flag(args, "--features")
.unwrap_or("4")
.parse()
.map_err(|_| "--features 不是整数")?;
let per: usize = parse_flag(args, "--per-client")
.unwrap_or("40")
.parse()
.map_err(|_| "--per-client 不是整数")?;
let rounds: usize = parse_flag(args, "--rounds")
.unwrap_or("12")
.parse()
.map_err(|_| "--rounds 不是整数")?;
let local_epochs: usize = parse_flag(args, "--local-epochs")
.unwrap_or("2")
.parse()
.map_err(|_| "--local-epochs 不是整数")?;
let lr: f64 = parse_flag(args, "--lr")
.unwrap_or("0.5")
.parse()
.map_err(|_| "--lr 不是浮点")?;
let l2: f64 = parse_flag(args, "--l2")
.unwrap_or("0.0")
.parse()
.map_err(|_| "--l2 不是浮点")?;
let clip: f64 = parse_flag(args, "--clip")
.unwrap_or("0.0")
.parse()
.map_err(|_| "--clip 不是浮点")?;
let noise: f64 = parse_flag(args, "--noise")
.unwrap_or("0.0")
.parse()
.map_err(|_| "--noise 不是浮点")?;
let seed_bytes = seed_or_random(args)?;
let seed = u64::from_le_bytes(seed_bytes[0..8].try_into().unwrap());
if k < 1 {
return Err("--clients 至少为 1".into());
}
if d < 1 {
return Err("--features 至少为 1".into());
}
let data = gen_fl_data(k, d, per, seed.wrapping_add(0x9E3779B97F4A7C15));
let clients: Vec<String> = (0..k).map(|c| format!("c{c}")).collect();
let client_refs: Vec<&str> = clients.iter().map(|s| s.as_str()).collect();
note!(
"mpc fl · 横向 FedAvg · {} 客户端 × {} 样本 × {} 特征 · {} 轮 · lr={} · 本地{}轮",
k, per, d, rounds, lr, local_epochs
);
let fa = FedAvg::new(&client_refs, d, clip, noise, 0.0, seed);
note!(" 聚合链: {}", fa.describe());
let (w, hist) = fa.fit(
&data, rounds, lr, local_epochs, l2, None, seed, 1,
);
// 逐轮曲线:一行一轮,JSON 模式下 jq 可以直接画图
let rows: Vec<Vec<report::Cell>> = (0..hist.rounds.len())
.map(|i| {
vec![
report::Cell::int(hist.rounds[i] as i64),
report::Cell::nump(hist.loss[i], 4),
report::Cell::nump(hist.acc[i], 4),
report::Cell::nump(hist.auc[i], 4),
]
})
.collect();
report::table("逐轮指标", &["轮次", "loss", "acc", "auc"], &rows);
let wr: Vec<Vec<report::Cell>> = w
.iter()
.enumerate()
.map(|(i, &v)| vec![report::Cell::txt(format!("w[{i}]")), report::Cell::nump(v, 6)])
.collect();
report::table(&format!("最终全局权重({} 个,含偏置)", w.len()), &["权重", "值"], &wr);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
/// ★ 全零种子必须被拒 —— 这是本项目最隐蔽的一类失败。
///
/// 全零主种子 ⇒ Beaver 三元组全部可预测 ⇒ 密态乘法隐私性归零,
/// 而症状是「不报错、不崩溃、结果数值也对」。
#[test]
fn zero_seed_is_rejected() {
let e = parse_seed(&"00".repeat(32)).unwrap_err();
assert!(e.contains("全零"), "错误信息必须点明全零: {e}");
// 错误信息要说清后果,否则用户会以为换个写法就行
assert!(
e.contains("可预测") || e.contains("隐私"),
"错误信息必须说明后果: {e}"
);
}
/// 非全零种子必须能用(正向对照 —— 否则「拒绝全零」可能恒为真)。
#[test]
fn non_zero_seed_is_accepted() {
let s = parse_seed(&"11".repeat(32)).unwrap();
assert_eq!(s, [0x11u8; 32]);
// 只有最后一个字节非零也算有效 —— 判据是「整体非零」
let s2 = parse_seed(&format!("{}{}", "00".repeat(31), "01")).unwrap();
assert_eq!(s2[31], 1);
assert_eq!(s2[0], 0);
}
/// 长度不对 / 非 hex 仍然按原样拒(不能被全零检查掩盖)。
#[test]
fn bad_seed_shapes_are_rejected() {
assert!(parse_seed("00").is_err());
assert!(parse_seed(&"0".repeat(63)).is_err());
assert!(parse_seed(&"0".repeat(65)).is_err());
assert!(parse_seed(&"zz".repeat(32)).is_err());
}
/// ★ 不给 `--seed` 时**不能**返回全零兜底 —— 必须从熵源取。
#[test]
fn missing_seed_comes_from_entropy_not_zero() {
let a = seed_or_random(&[]).unwrap();
assert!(
mpc_core::material::seed_is_valid(&a),
"没给 --seed 时不许返回全零"
);
let b = seed_or_random(&[]).unwrap();
assert_ne!(a, b, "两次取值必须不同(否则不是熵源)");
}
/// 给了 `--seed` 就用给的(确定性)。
#[test]
fn explicit_seed_is_used_as_is() {
let args = vec![String::from("--seed"), String::from("22".repeat(32))];
assert_eq!(seed_or_random(&args).unwrap(), [0x22u8; 32]);
}
/// 各方 PSI 私钥必须不同 —— 同种子 = 同私钥,交集仍对但隐私全失
#[test]
fn psi_seed_differs_per_site() {
let base = [7u8; 32];
let a = derive_psi_seed(base, "alice");
let b = derive_psi_seed(base, "bob");
let c = derive_psi_seed(base, "carol");
assert_ne!(a, b, "alice 与 bob 派生出相同 PSI 种子");
assert_ne!(b, c, "bob 与 carol 派生出相同 PSI 种子");
assert_ne!(a, c, "alice 与 carol 派生出相同 PSI 种子");
// 同一 site 必须可复现(重连换私钥会让对照复现失效)
assert_eq!(a, derive_psi_seed(base, "alice"));
// 主种子参与派生
assert_ne!(a, derive_psi_seed([8u8; 32], "alice"));
// 不能让派生结果等于主种子:那样等于没派生
assert_ne!(a, base);
// n 方场景:即便方数很多,也不该出现碰撞
let seeds: std::collections::HashSet<[u8; 32]> = (0..64)
.map(|i| derive_psi_seed(base, &format!("site-{i}")))
.collect();
assert_eq!(seeds.len(), 64, "64 个不同站点名派生出重复种子");
}
/// 摘要算法错了会让 `--expect` 与 `sha256sum` 对不上,
/// 而那种错在自校验场景里等于「校验永远失败」,很难察觉是算法问题。
#[test]
fn sha256_file_matches_known_digest() {
let mut p = std::env::temp_dir();
p.push(format!("mpc-selfcheck-{}.bin", std::process::id()));
std::fs::write(&p, b"abc").expect("写临时文件");
let (d, n) = sha256_file(&p).expect("算摘要");
let _ = std::fs::remove_file(&p);
assert_eq!(n, 3);
// FIPS 180-4 / NIST 向量:sha256("abc")
assert_eq!(
d,
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
}
fn v(s: &[&str]) -> Vec<String> {
s.iter().map(|x| x.to_string()).collect()
}
#[test]
fn tee_paths_lists_both_vendor_paths() {
assert!(cmd_tee_paths().is_ok());
}
#[test]
fn tee_plan_demo_admits_and_denies() {
let p = std::env::temp_dir().join(format!("mpc-cli-tee-{}.node", std::process::id()));
let src = format!(
"site=alice\nhost=192.168.1.7\nkind=sev-snp\ntcb=5\n\
device_present=true\nqemu_present=true\nfirmware_present=true\n\
image_present=true\nkbc=online\nkbs_reachable=true\nmeasurement={}\n\
qemu=/usr/bin/qemu-system-x86_64\nfirmware=/srv/tee/AMDSEV.fd\n\
kernel=/srv/tee/vmlinuz\ninitrd=/srv/tee/initrd.img\n",
"09".repeat(32)
);
std::fs::write(&p, &src).expect("写节点描述");
let node = p.to_str().unwrap();
let good = v(&["plan", "--node", node, "--demo", "--min-tcb", "3"]);
assert!(cmd_tee_plan(&good).is_ok(), "合格节点应准入通过");
let bad = v(&["plan", "--node", node, "--demo", "--min-tcb", "99"]);
assert!(cmd_tee_plan(&bad).is_err(), "TCB 不达标必须拒绝,不能降级");
let missing = v(&["plan", "--node", node]);
assert!(cmd_tee_plan(&missing).is_err(), "缺少会话参数必须拒绝");
let _ = std::fs::remove_file(&p);
}
/// `tee verify` 必须与 `tee plan` 用**同一份**节点描述。
///
/// `user_data` 第二段哈希绑的是「度量 + 平台 + TCB」,TCB 来自节点描述。
/// 启动方用 node 里的 tcb 算绑定值,验证方若手工重填或漏填 `--tcb`
/// (默认 0),期望值必然对不上 —— 而报错是「user_data 与本次会话绑定不一致」,
/// 指向重放攻击,排查方向会被带偏。
#[test]
fn tee_verify_reads_binding_inputs_from_node() {
let p = std::env::temp_dir().join(format!("mpc-cli-teeverify-{}.node", std::process::id()));
let src = format!(
"site=bob\nhost=127.0.0.1\nkind=hygon-csv\ntcb=3\n\
device_present=true\nqemu_present=true\nfirmware_present=true\n\
image_present=true\nkbc=offline\nkbs_reachable=false\nmeasurement={}\n\
qemu=/usr/bin/qemu-system-x86_64\nfirmware=/srv/tee/HYGONCSV.fd\n\
kernel=/srv/tee/vmlinuz\ninitrd=/srv/tee/initrd.img\n",
"53".repeat(32)
);
std::fs::write(&p, &src).expect("写节点描述");
let node = p.to_str().unwrap();
// 缺 --session-id / --pubkey 时必须报错,不能静默用默认值。
let missing = v(&["verify", "--report", "/nonexistent", "--node", node]);
assert!(
cmd_tee_verify(&missing).is_err(),
"缺少报告文件 / 会话参数必须拒绝"
);
// 节点描述与 --platform 冲突必须直接拒绝。
let conflict = v(&[
"verify", "--report", "/nonexistent", "--node", node, "--platform", "snp",
"--session-id", &"ab".repeat(32), "--pubkey", &"cd".repeat(32),
]);
let err = cmd_tee_verify(&conflict).unwrap_err();
assert!(
err.contains("不一致"),
"节点平台与 --platform 冲突必须报错,实际: {err}"
);
let _ = std::fs::remove_file(&p);
}
/// `tee verify` 必须与 `tee plan` 用**同一份**节点描述。
///
/// `user_data` 第二段哈希绑的是「度量 + 平台 + TCB」,TCB 来自节点描述。
/// 启动方用 node 里的 tcb 算绑定值,验证方若手工重填或漏填 `--tcb`
/// (默认 0),期望值必然对不上 —— 而报错是「user_data 与本次会话绑定不一致」,
/// 指向重放攻击,排查方向会被带偏。
#[test]
fn tee_argv_json_keeps_parameter_boundaries() {
let a = vec![String::from("-append"), String::from("a=1 b=2")];
let j = cli_json_array(&a);
assert!(j.starts_with("[\"-append\""));
assert!(j.contains("\"a=1 b=2\""), "含空格的内核参数必须保持为一个元素");
assert!(cli_json_string("a\"b\\c").contains("\\\""));
}
#[test]
fn tee_parsers_reject_bad_input() {
assert!(cli_parse_hex32("zz").is_err());
assert_eq!(cli_parse_hex32(&"ab".repeat(32)).unwrap(), [0xabu8; 32]);
assert!(cli_parse_csv_variant("csv9").is_err());
assert!(cli_parse_csv_variant("csv3").is_ok());
}
#[test]
fn report_flag_can_appear_anywhere() {
// 子命令后面
let (a, j) = split_report_flag(&v(&["fl", "--report", "json", "--rounds", "3"])).unwrap();
assert!(j);
assert_eq!(a, v(&["fl", "--rounds", "3"]));
// 子命令前面 + `=` 写法
let (a, j) = split_report_flag(&v(&["--report=json", "fl"])).unwrap();
assert!(j);
assert_eq!(a, v(&["fl"]));
// 显式 text 不改行为
let (a, j) = split_report_flag(&v(&["fl", "--report", "text"])).unwrap();
assert!(!j);
assert_eq!(a, v(&["fl"]));
// 缺值 / 乱值都要报错,而不是悄悄当 text
assert!(split_report_flag(&v(&["fl", "--report"])).is_err());
assert!(split_report_flag(&v(&["fl", "--report", "yaml"])).is_err());
}
/// 真机回归:`mpc tee verify --report <文件>` 的 `--report` 是**证明报告的
/// 文件路径**,与全局输出格式参数同名。全局参数先解析,若不让位,
/// `tee verify` 就永远拿不到文件路径(真机表现为
/// `--report 只认 text / json,得到 "report.cert"`)。
#[test]
fn tee_verify_report_path_survives_global_report_flag() {
// tee verify 的 --report 是路径,必须原样留给子命令。
let (a, j) = split_report_flag(&v(&["tee", "verify", "--report", "report.cert"])).unwrap();
assert!(!j);
assert_eq!(a, v(&["tee", "verify", "--report", "report.cert"]));
assert_eq!(
parse_flag(&a, "--report"),
Some("report.cert"),
"tee verify 必须能读到文件路径"
);
// `=` 写法同样要还原成分离形式(parse_flag 只认精确串)。
let (a, _j) = split_report_flag(&v(&["tee", "verify", "--report=report.cert"])).unwrap();
assert_eq!(parse_flag(&a, "--report"), Some("report.cert"));
// tee verify 依然可以用全局格式参数(text/json 仍是格式)。
let (a, j) = split_report_flag(&v(&["tee", "verify", "--report", "json"])).unwrap();
assert!(j);
assert_eq!(a, v(&["tee", "verify"]));
// 其它子命令不受影响:非格式值仍然报错。
assert!(split_report_flag(&v(&["fl", "--report", "report.cert"])).is_err());
}
/// ★★ 帮助文本里写的每个 `--flag` 都必须**真的被实现解析**。
///
/// 2026-11-09 实测踩过:改 `mpc tee` 帮助文本时把 `attest-upload` 的
/// `--upload-path-file` 漏掉了,而实现里它是**必填**(缺了就报错)
/// ⇒ 照着帮助敲命令必然失败,而代码照样编译、门禁照样全绿。
///
/// 这类漂移是**静默**的(不报错、不崩),所以必须钉死。
/// 判据:帮助文本里出现的每个 `--xxx`,在 main.rs 或 sa.rs 里
/// 必须能找到对应的解析(`parse_flag(args, "--xxx")` 或字符串字面量)。
#[test]
fn tee_usage_flags_are_all_implemented() {
// 收集帮助文本里所有 `--flag`(去掉方括号与结尾的标点)。
let mut flags: Vec<String> = Vec::new();
let bytes = TEE_USAGE.as_bytes();
let mut i = 0usize;
while i < bytes.len() {
if bytes[i] == b'-' && i + 1 < bytes.len() && bytes[i + 1] == b'-' {
let start = i;
let mut j = i + 2;
while j < bytes.len() {
let c = bytes[j];
if c.is_ascii_alphanumeric() || c == b'-' || c == b'_' {
j += 1;
} else {
break;
}
}
if j > i + 2 {
flags.push(String::from_utf8_lossy(&bytes[start..j]).to_string());
}
i = j;
} else {
i += 1;
}
}
assert!(flags.len() >= 20, "帮助文本里 flag 太少,解析可能坏了: {flags:?}");
// 实现的源码文本。
// ★ 不用 include_str!("main.rs")(自包含语义怪,且内容会随编译缓存漂移),
// 改成读 crate 目录下的两个源文件。
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
let impl_src = format!(
"{}\n{}",
std::fs::read_to_string(dir.join("main.rs")).unwrap_or_default(),
std::fs::read_to_string(dir.join("sa.rs")).unwrap_or_default()
);
// ★★ 判据必须查「**解析调用**」,不能查「裸字符串」——
// 否则**自指**:帮助文本本身就写在 main.rs 里,
// 「文件里出现过这个 flag」恒为真 ⇒ 判据恒绿(2026-11-09 实测踩过:
// 往帮助里塞一个实现里没有的 flag,测试照样 pass)。
// 真正的判据是「实现里有没有 `parse_flag(args, "--xxx")` 这类调用」。
let mut missing: Vec<&String> = Vec::new();
for f in &flags {
let needle = format!("args, \"{f}\"");
if !impl_src.contains(&needle) {
missing.push(f);
}
}
assert!(
missing.is_empty(),
"帮助文本里写了但实现里没有对应解析调用的 flag(照帮助敲命令会失败): {missing:?}"
);
}
/// ★ 反向:SA 子命令的**必填**参数必须在帮助文本里出现。
///
/// 上一条只查「帮助写了但实现没有」;这条查「实现必填但帮助没写」——
/// 用户照帮助敲,会漏掉一个必填参数,然后只看到一句干巴巴的
/// 「缺少 --xxx」,不知道帮助里本来该有它。
#[test]
fn sa_required_flags_appear_in_usage() {
// 从 sa.rs 里抽出「缺少 --xxx」这类必填报错的参数名。
let sa_src = include_str!("sa.rs");
let mut required: Vec<String> = Vec::new();
let mut rest = sa_src;
while let Some(idx) = rest.find("缺少 --") {
rest = &rest[idx + "缺少 --".len()..];
let end = rest
.find(|c: char| !(c.is_ascii_alphanumeric() || c == '-'))
.unwrap_or(rest.len());
let name = &rest[..end];
if !name.is_empty() && !required.iter().any(|x| x == name) {
required.push(String::from(name));
}
}
assert!(
!required.is_empty(),
"没从 sa.rs 里抓到必填参数 —— 判据本身坏了(否则这条恒真)"
);
for name in &required {
let flag = format!("--{name}");
assert!(
TEE_USAGE.contains(&flag),
"sa.rs 里 {flag} 是必填,但帮助文本里没写 —— 用户照帮助敲必然失败"
);
}
}
}