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