//! `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; #[cfg(feature = "secure")] mod sql_demo; #[cfg(feature = "secure")] mod sql_join; #[cfg(mpc_control_plane)] mod hostd; #[cfg(mpc_control_plane)] mod link; // ★ 链上层单独一个 cfg:mpc-chain 链接系统 OpenSSL, // musl 目标下进不来(见 build.rs)。host-only 产物不含链上层。 #[cfg(mpc_chain_plane)] mod chain; const VERSION: &str = env!("CARGO_PKG_VERSION"); fn main() -> ExitCode { let raw: Vec = 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..]), #[cfg(mpc_control_plane)] "hostd" => hostd::cmd_hostd(&args[1..]), #[cfg(mpc_control_plane)] "link" => link::cmd_link(&args[1..]), #[cfg(mpc_chain_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(mpc_control_plane))] note!( "★ 本产物是 TEE guest 静态二进制(--no-default-features),不含宿主控制面:\ 下文 mpc hostd / link / chain 与 mpc tee up|ps|attest|down 条目均不可用,\ 请在宿主端 mpc 上执行。\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 tee up|ps|attest|down 宿主端:起/列/查证明/停 TEE 实例,走 --host HOST:PORT mpc link plan|verdict|credential 会话级链路:生成 EasyTier argv / 判实际路径 / 签发撤销凭据 (与 e2b 兼容面独立;长驻进程由部署层 exec,不归框架托管) mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governance 链上层:对象摘要 / 幂等补链 / fail-closed 准入 / OpenSSL SM2 软件签名 / distid 三重对齐 / TLCP 准入诊断 / 硬规则与 OPA 分域 (★ flush 的 payload 仍是规范字节,不是已签名交易;RLP/TLCP FFI 未落地) 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 ,缺/错一律 401。 不配 = 回环信任模式(不带凭据的请求放行)。 --allow-remote 允许绑非回环地址。**必须同时配 --shared-secret** —— 没有共享密钥时,--allow-remote 只是把无鉴权的控制面 挂到网上,任何人都能起 guest、读远程证明。 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://shop@127.0.0.1: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://u@127.0.0.1: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 执行计算计划 mpc audit show 查看审计链" ); } // --------------------------------------------------------------------------- fn selftest() -> Result<(), String> { note!("mpc {VERSION} selftest"); // 每步返回「一行说明」,由 selftest 统一成表 —— 文本模式和 // `--report json` 用的是同一份数据,不会出现两边口径不一致。 type Step = (&'static str, fn() -> Result); 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::new(); let mut failed: Option = 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 { 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 { let n = 2usize; let secret: Vec = (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 { 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 { 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 { 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 = 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 { 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 = match kind_s { "optee" => mpc_tee::PlatformKind::Optee, "sev-snp" | "snp" => mpc_tee::PlatformKind::SevSnp, "tdx" => mpc_tee::PlatformKind::Tdx, "hygon-csv" | "csv" => mpc_tee::PlatformKind::HygonCsv, other => { return Err(format!( "未知平台 {other:?}(可选 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`:直接调度 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..]), "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..]), // 宿主端:走 e2b 兼容 API 操作本机/远端的 mpc-hostd。 // guest 静态二进制里这四个命令必须明确拒绝,不能悄悄落到 help 上 // ——「参数收了但没人执行」就是假接口。 #[cfg(mpc_control_plane)] "up" | "ps" | "attest" | "down" => hostd::cmd_tee_host(args), #[cfg(not(mpc_control_plane))] "up" | "ps" | "attest" | "down" => Err(String::from( "该命令属于宿主控制面,guest 静态二进制不含 mpc-hostd;请在宿主端 mpc 上执行", )), _ => Err(String::from( "用法: 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 \ | up|ps|attest|down (宿主端,走 --host HOST:PORT)", )), } } fn cmd_tee_paths() -> Result<(), String> { let mut rows: Vec> = 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) => match p { "snp" | "sev-snp" => mpc_tee::PlatformKind::SevSnp, "csv" | "hygon" | "hygon-csv" => mpc_tee::PlatformKind::HygonCsv, "tdx" => mpc_tee::PlatformKind::Tdx, "optee" => mpc_tee::PlatformKind::Optee, other => return Err(format!("--platform {other:?} 只认 snp/csv/tdx/optee")), }, 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> = 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 = 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) => match p { "snp" | "sev-snp" => mpc_tee::PlatformKind::SevSnp, "csv" | "hygon" | "hygon-csv" => mpc_tee::PlatformKind::HygonCsv, "tdx" => mpc_tee::PlatformKind::Tdx, "optee" => mpc_tee::PlatformKind::Optee, other => return Err(format!("--platform {other:?} 只认 snp/csv/tdx/optee")), }, 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 = 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(()) } /// 极简 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 } fn cli_parse_csv_variant(s: &str) -> Result { 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 } /// `mpc trust`:按各方的 TEE 状况算出可信度方案(L0–L3)。 /// /// 这个命令**不发起任何连接**,只做判定 —— 它的用途是让"这一轮到底靠什么 /// 保证安全"在开工前就写在纸上,而不是跑完以后靠回忆解释。 fn cmd_trust(args: &[String]) -> Result<(), String> { let spec = parse_flag(args, "--parties").ok_or("缺少 --parties")?; let mut parties: Vec = 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::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::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::>() .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 = 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> { 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::>() .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, 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 { 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::().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, 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//cmdline` 里, /// 同机任何用户都能读到。文件可以设 0600;环境变量略好于 argv 但仍对同用户可见。 /// 三种入口都留着是为了让测试和现场排障不必先造文件。 fn parse_psk(args: &[String]) -> Result, 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 { 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, 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, 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 = 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"); // 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 = 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 seed = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; // 数据按浮点解析,再编码到定点环 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 = 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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; 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 --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::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 = 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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; 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> = 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> = 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::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 { 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, 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 { 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 { 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 = 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 { 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 { let mut out: Vec = 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, String> { let mut out: Vec = 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))?; } Ok(out) } // --------------------------------------------------------------------------- // 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 = 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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; 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)> = 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 = 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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; let ids_raw = parse_flag(args, "--ids").ok_or("缺少 --ids")?; let mut ids: Vec> = Vec::new(); let mut id_values: Vec = 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 = idx.iter().map(|&i| id_values[i]).collect(); hit.sort_unstable(); let rows: Vec> = 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 = 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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; 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, String> { let raw = parse_flag(args, name).ok_or(format!("缺少 {name}"))?; raw.split(',') .map(|t| t.trim().parse::().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> = 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 = 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::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, String> { let raw = parse_flag(args, name).ok_or(format!("缺少 {name}"))?; raw.split(',') .map(|t| { t.trim() .parse::() .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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; 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::>() .join(","), ), )); report::kv("纵向会话", &rows); let wrows: Vec> = 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 { 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 = 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 = match parse_flag(args, "--seed") { Some(h) => parse_seed(h)?, None => [0u8; 32], }; 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 = (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> = (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> = 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::*; /// 各方 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 { 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); } #[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()); } }