From 393359ef3530e0646ffe200774fc327c2045eb12 Mon Sep 17 00:00:00 2001 From: admin Date: Mon, 9 Nov 2026 15:34:26 +0800 Subject: [PATCH] =?UTF-8?q?fix(tee):=20=E4=BF=AE=E6=8E=89=203199d16=20?= =?UTF-8?q?=E9=81=97=E7=95=99=E7=9A=84=E7=BC=96=E8=AF=91=E7=A0=B4=E6=8D=9F?= =?UTF-8?q?=EF=BC=8C=E5=B9=B6=E8=AE=A9=E4=B8=8A=E4=BC=A0=E8=B7=AF=E7=94=B1?= =?UTF-8?q?=E5=BD=92=E4=BD=8D=E5=88=B0=E5=AE=BF=E4=B8=BB=E6=8E=A7=E5=88=B6?= =?UTF-8?q?=E9=9D=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 3199d16「TEE 远程调度面与节点自报」把 control_plane.rs 进了仓,但 reconciler.rs 没跟着改;main.rs 那边整块重复粘贴了 15 个顶层 fn。 后续两个提交只改文档没碰代码,破损一直潜伏 —— HEAD 编译直接失败: error[E0599]: no method named `set_require_chip_sig` error[E0063]: missing field `chip_sig_failed` in initializer error[E0308]: expected `NodeRegistry`, found `Arc` error[E0428]: the name `cmd_tee` is defined multiple times(15 组) 上传路由归位(guest 边界 + 路由漂移): - 路由形状只有一份,在 hostd 侧:api::attestation_upload_path(id)。 - 宿主经 9p 手牌把完整上传路径注入 guest(手牌第 4 份文件 upload_path)。 - mpc-tee 不再持有 "/sandboxes" 字面量,guest 产物里不再出现该路由。 - CLI 新增 --upload-path-file;guest init.sh 读手牌并传下去。 - 三道防线:源码层 Rust 单测 + 源码层 CI 脚本 + 产物层 ELF 探针。 产物层判据有盲区(字面量进死代码会被 LTO 裁掉 ⇒ 假绿), 已用三形态破坏实验验证源码层两道能转红。 对账器三态语义(证据成立 ≠ 可公布): - is_verified() 决定实例去留;publishable(require_chip_sig) 决定端点外泄。 - chip_sig_failed 区分「没验」与「验了没过」:前者判 verified 但按策略 不公布,后者硬拒绝判 rejected 并回收实例。 - 证明漂移先从 placed 移除旧记录再回收实例,否则 proven_endpoints() 会继续公布证明已不通过的旧端点(真 fail-open)。 验证:暂存区快照独立编译 exit 0;mpc-tee 230 passed / mpc-hostd 171 passed / mpc-cli 69 passed;tools/ci.sh --fast exit 0(binary 判据 39/39, 含「/sandboxes 不得出现在 guest 产物」)。 真机 9p 探针修掉三个真 bug:init_b64 取的是 stdout(空)而非文件内容 ⇒ 远端 /init 0 字节 ⇒ 内核 ENOEXEC;qemu 参数用 \ 续行被 ssh 管道吃掉; 本地 90 轮轮询每轮走 xop 触摸验证 ⇒ 改为远端轮询一次取回。 --- crates/mpc-cli/src/control_plane.rs | 4 +- crates/mpc-cli/src/hostd.rs | 72 +- crates/mpc-cli/src/main.rs | 996 +++----------- crates/mpc-hostd/src/api.rs | 162 ++- crates/mpc-hostd/src/control_plane_api.rs | 6 +- crates/mpc-hostd/src/control_plane_server.rs | 6 +- crates/mpc-hostd/src/guest_hand.rs | 95 +- crates/mpc-hostd/src/runtime.rs | 120 +- crates/mpc-tee/src/attest_link.rs | 1 + crates/mpc-tee/src/attest_upload.rs | 177 ++- crates/mpc-tee/src/reconciler.rs | 1273 ++++++++++++++---- crates/mpc-tee/src/schedule.rs | 6 + deploy/tee/guest/init.sh | 18 +- deploy/tee/real-machine/probe-9p-hand.sh | 133 +- tools/check-guest-artifact.py | 93 ++ tools/selftest-hostd.py | 27 + 16 files changed, 1955 insertions(+), 1234 deletions(-) diff --git a/crates/mpc-cli/src/control_plane.rs b/crates/mpc-cli/src/control_plane.rs index 7c3fa77..534f27b 100644 --- a/crates/mpc-cli/src/control_plane.rs +++ b/crates/mpc-cli/src/control_plane.rs @@ -103,7 +103,7 @@ fn cmd_query(args: &[String], path: &str) -> Result<(), String> { }; let v = client.get(path).map_err(|e| e.to_string())?; let text = v.to_json_string(); - match crate::json::parse(&text) { + match mpc_hostd::json::parse(&text) { Ok(_) => {} Err(e) => return Err(format!("控制面响应不是合法 JSON: {e}")), } @@ -124,7 +124,7 @@ fn cmd_set_desired(args: &[String]) -> Result<(), String> { let body = std::fs::read_to_string(path) .map_err(|e| format!("读期望态文件 {path} 失败: {e}"))?; // 先本地解析一次:格式错就别去打扰控制面了。 - if let Err(e) = crate::json::parse(&body) { + if let Err(e) = mpc_hostd::json::parse(&body) { return Err(format!("期望态文件不是合法 JSON: {e}")); } let client = HostClient::new(ep.clone()).map_err(|e| e.to_string())?; diff --git a/crates/mpc-cli/src/hostd.rs b/crates/mpc-cli/src/hostd.rs index 76a3994..936ad7b 100644 --- a/crates/mpc-cli/src/hostd.rs +++ b/crates/mpc-cli/src/hostd.rs @@ -32,15 +32,34 @@ //! 不合并成一个 `ok`。`chip_sig=0` 的含义是「绑定关系成立,但没做芯片验签」。 use crate::report; -use mpc_tee::hostd::api::{AttestationVerdict, SandboxView}; -use mpc_tee::hostd::client::HostClient; -use mpc_tee::hostd::HostConfig; +use mpc_hostd::api::{AttestationVerdict, SandboxView}; +use mpc_hostd::client::HostClient; +use mpc_hostd::HostConfig; +use mpc_tee::platform::KbcMode; +use mpc_tee::probe::HostCapConfig; /// 默认宿主控制面地址。 const DEFAULT_HOST: &str = "127.0.0.1:3010"; /// `mpc hostd`:启动宿主控制面。 pub fn cmd_hostd(args: &[String]) -> Result<(), String> { + let cfg = build_host_config(args)?; + mpc_hostd::serve(cfg) +} + +/// 构造宿主控制面配置并**做全部启动前校验**。 +/// +/// ★ 抽成独立函数(而不是在 `cmd_hostd` 里内联)是有意的: +/// 校验逻辑必须**只有一份**,且可被单元测试直接调用。 +/// 「测试验一套、生产走另一套」是最常见的判据漂移来源。 +/// +/// ★ 校验项与它们的理由: +/// 1. `--shared-secret` 长度 ≥ 32 字节 —— 短密钥抗不住在线穷举; +/// 2. 非回环监听 **必须**同时有共享密钥 **且** `--allow-remote`; +/// 两者互为兜底 —— 只给 `--allow-remote` 只是一句声明,不构成任何保护; +/// 3. 配了 `--control-plane` 却没配 `--node-platform` ⇒ 拒绝启动 +/// (假就绪信号:以为在自报,其实推送线程永远空转)。 +fn build_host_config(args: &[String]) -> Result { let mut cfg = HostConfig::default(); if let Some(v) = parse_flag(args, "--listen") { cfg.listen = v.to_string(); @@ -62,6 +81,19 @@ pub fn cmd_hostd(args: &[String]) -> Result<(), String> { cfg.control_plane = Some(v.to_string()); } + // ★ 共享密钥:配了就是「凭据模式」(每个请求都要带 Bearer token)。 + // 没配就是「回环信任模式」(只放行不带凭据的请求)。 + if let Some(v) = parse_flag(args, "--shared-secret") { + if v.len() < mpc_hostd::auth::MIN_SECRET_LEN { + return Err(format!( + "--shared-secret 至少要 {} 字节(现在是 {} 字节)—— 短密钥抗不住在线穷举", + mpc_hostd::auth::MIN_SECRET_LEN, + v.len() + )); + } + cfg.shared_secret = Some(v.as_bytes().to_vec()); + } + // ★ 芯片验签器:配了才有宿主侧的 `chip_sig=true`。 // 不配不是错,但集群面按 `require_chip_sig=true` 门控时端点不会公布 —— // 那时 note 会写明「未提供验签器」(是「没验」,不是「验了没过」)。 @@ -87,17 +119,31 @@ pub fn cmd_hostd(args: &[String]) -> Result<(), String> { ); } - // ★ 非回环地址必须显式确认。 - // 宿主控制面**目前没有鉴权** —— 谁能连上就能起 guest、读证明。 - if !is_loopback(&cfg.listen) && !args.iter().any(|a| a == "--allow-remote") { - return Err(format!( - "{} 不是回环地址。宿主控制面当前没有鉴权,暴露到远程会让任何人都能起 guest、读证明。\ - 确实要这么做请显式加 --allow-remote。", - cfg.listen - )); + // ★ 非回环监听必须**同时**满足两个条件:配了共享密钥 **且** 显式 + // `--allow-remote`。 + // + // 理由:回环信任模式在非回环地址上等于**零保护** —— + // 谁能连上就能起 guest、读远程证明、拿密钥。 + // 只给 `--allow-remote` 只是一句声明;只给密钥却忘了确认暴露面, + // 同样是运维事故。两条互为兜底,缺一即拒。 + if !is_loopback(&cfg.listen) { + if cfg.shared_secret.is_none() { + return Err(format!( + "{} 不是回环地址 —— 回环信任模式在跨网段上等于零保护,任何能连上的人都能起 \ + guest、读远程证明。请同时配共享密钥 --shared-secret(至少 {} 字节)。", + cfg.listen, + mpc_hostd::auth::MIN_SECRET_LEN + )); + } + if !args.iter().any(|a| a == "--allow-remote") { + return Err(format!( + "{} 不是回环地址 —— 确实要跨网段暴露请显式加 --allow-remote。", + cfg.listen + )); + } } - mpc_tee::hostd::serve(cfg) + Ok(cfg) } /// 地址是不是回环。 @@ -548,7 +594,7 @@ fn cmd_down(args: &[String]) -> Result<(), String> { } /// 打印一个实例视图。 -fn print_sandbox(v: &mpc_tee::hostd::json::Json) { +fn print_sandbox(v: &mpc_hostd::json::Json) { let view = SandboxView::from_json(v); let rows: Vec<(&str, report::Cell)> = vec![ ("sandboxID", report::Cell::txt(view.sandbox_id.clone())), diff --git a/crates/mpc-cli/src/main.rs b/crates/mpc-cli/src/main.rs index 7574826..1a9b7f7 100644 --- a/crates/mpc-cli/src/main.rs +++ b/crates/mpc-cli/src/main.rs @@ -68,10 +68,28 @@ mod report; mod sql_demo; #[cfg(feature = "secure")] mod sql_join; -#[cfg(mpc_control_plane)] + +// ★ ★ 宿主控制面模块的门控是「`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; -#[cfg(feature = "control-plane")] +/// 集群控制面命令(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; @@ -97,8 +115,20 @@ fn main() -> ExitCode { "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..]), @@ -141,12 +171,19 @@ fn main() -> ExitCode { } fn usage() { - #[cfg(not(mpc_control_plane))] + #[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} —— 尚数网-多方安全计算 @@ -828,9 +865,9 @@ fn cmd_tee(args: &[String]) -> Result<(), String> { // 宿主端:走 e2b 兼容 API 操作本机/远端的 mpc-hostd。 // guest 静态二进制里这四个命令必须明确拒绝,不能悄悄落到 help 上 // ——「参数收了但没人执行」就是假接口。 - #[cfg(mpc_control_plane)] + #[cfg(any(feature = "control-plane", feature = "host-only"))] "up" | "ps" | "attest" | "down" => hostd::cmd_tee_host(args), - #[cfg(not(mpc_control_plane))] + #[cfg(not(any(feature = "control-plane", feature = "host-only")))] "up" | "ps" | "attest" | "down" => Err(String::from( "该命令属于宿主控制面,guest 静态二进制不含 mpc-hostd;请在宿主端 mpc 上执行", )), @@ -841,7 +878,7 @@ fn cmd_tee(args: &[String]) -> Result<(), String> { | 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 TOK --bundle FILE \ + | attest-upload --host HOST:PORT --sandbox ID --token-file F --upload-path-file F --bundle FILE \ | up|ps|attest|down (宿主端,走 --host HOST:PORT)", )), } @@ -1017,17 +1054,6 @@ fn cmd_tee_verify(args: &[String]) -> Result<(), String> { )); } } - // 节点描述与显式 --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 错误更早暴露, // 免得排查时被「文件不存在」盖住真正的语义问题。 @@ -1167,173 +1193,6 @@ fn cmd_tee_kbs_get(args: &[String]) -> Result<(), String> { Ok(()) } -fn cmd_tee_verify(args: &[String]) -> Result<(), String> { - let report_path = parse_flag(args, "--report").ok_or("缺少 --report(证明报告原始字节文件)")?; - let report = std::fs::read(report_path).map_err(|e| format!("读报告 {report_path} 失败: {e}"))?; - - // 节点描述:验证方与启动方读**同一份**真相源。 - // - // 为什么必须有这个:`user_data` 的第二段哈希绑的是 - // 「代码度量 + 平台标签 + TCB」,其中 **TCB 来自节点描述**。 - // 启动时 `tee plan` 用 node 里的 tcb 算绑定值,验证时若手工重填 - // `--tcb`(或漏填 → 默认 0),算出来的期望值必然对不上,报出来的是 - // 「user_data 与本次会话绑定不一致」——一个指向重放攻击的误导性结论。 - let node = match parse_flag(args, "--node") { - Some(p) => { - let src = std::fs::read_to_string(p).map_err(|e| format!("读节点描述 {p} 失败: {e}"))?; - Some(mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?) - } - None => None, - }; - - let platform = match parse_flag(args, "--platform") { - Some(p) => match p { - "snp" | "sev-snp" => mpc_tee::PlatformKind::SevSnp, - "csv" | "hygon" | "hygon-csv" => mpc_tee::PlatformKind::HygonCsv, - "tdx" => mpc_tee::PlatformKind::Tdx, - "optee" => mpc_tee::PlatformKind::Optee, - other => return Err(format!("--platform {other:?} 只认 snp/csv/tdx/optee")), - }, - None => node - .as_ref() - .map(|n| n.platform.kind) - .ok_or("缺少 --platform(也没给 --node)")?, - }; - let user_data = mpc_tee::platform::parse_hex::<64>( - parse_flag(args, "--user-data").ok_or("缺少 --user-data(64 字节 / 128 位十六进制)")?, - ) - .ok_or("user-data 不是 128 位十六进制")?; - let cert_chain: Vec> = match parse_flag(args, "--certs") { - Some(p) => vec![std::fs::read(p).map_err(|e| format!("读证书 {p} 失败: {e}"))?], - None => Vec::new(), - }; - let att = mpc_tee::Attestation { - platform, - user_data, - report, - cert_chain, - }; - - let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?; - // site / measurement / tcb 优先取节点描述(与 `tee plan` 同源), - // 显式传参才覆盖 —— 手工重填这些值是绑定对不上的头号来源。 - let site = match parse_flag(args, "--site") { - Some(s) => s.to_string(), - None => node - .as_ref() - .map(|n| n.site.clone()) - .filter(|s| !s.is_empty()) - .ok_or("缺少 --site(也没给 --node)")?, - }; - let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?; - let measurement = match parse_flag(args, "--measurement") { - Some(m) => cli_parse_hex32(m)?, - None => node - .as_ref() - .map(|n| n.measurement) - .ok_or("缺少 --measurement(也没给 --node)")?, - }; - let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement); - - let tcb: u32 = match parse_flag(args, "--tcb") { - Some(v) => v.parse().map_err(|_| format!("--tcb {v:?} 不是整数"))?, - None => node.as_ref().map(|n| n.platform.tcb).unwrap_or(0), - }; - let min_tcb: u32 = match parse_flag(args, "--min-tcb") { - Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?, - None => 0, - }; - let pin = match parse_flag(args, "--pin") { - Some(v) => Some(cli_parse_hex32(v)?), - None => None, - }; - let verifier: Option = match parse_flag(args, "--verifier") { - Some(prog) => { - let mut v = mpc_tee::verify::ExternalVerifier::new(prog); - let mut i = 0; - while i < args.len() { - if args[i].as_str() == "--verifier-arg" && i + 1 < args.len() { - v = v.arg(args[i + 1].clone()); - i += 2; - } else { - i += 1; - } - } - // ★ --chain-dir 单独一个选项名,不走 --verifier-arg。 - // 原因:argparse 遇到「以 - 开头的值」会把它当成下一个选项 —— - // 实测 `--verifier-arg --chain-dir X` 直接报 - // "argument --verifier-arg: expected one argument"。 - // 证书链目录这类「路径」参数必须有独立的选项名。 - if let Some(dir) = parse_flag(args, "--chain-dir") { - if !dir.is_empty() { - v = v.arg(String::from("--chain-dir")).arg(dir.to_string()); - } - } - Some(v) - } - None => None, - }; - - let result = mpc_tee::verify::verify_attestation( - &att, - &binding, - platform, - tcb, - min_tcb, - pin.as_ref(), - verifier.as_ref().map(|x| x as &dyn mpc_tee::verify::ChipVerifier), - ) - .map_err(|e| e.to_string())?; - - let chip = match &result.chip { - mpc_tee::verify::ChipVerdict::NotVerified => String::from("未验证"), - mpc_tee::verify::ChipVerdict::VerifiedBy(n) => format!("已验证({n})"), - mpc_tee::verify::ChipVerdict::Failed(_) => String::from("失败"), - }; - let rows: Vec<(&str, report::Cell)> = vec![ - ("structure_ok", report::Cell::txt(result.structure_ok.to_string())), - ("bound_ok", report::Cell::txt(result.bound_ok.to_string())), - ("chip", report::Cell::txt(chip)), - ("verdict", report::Cell::txt(result.verdict.clone())), - ]; - report::kv("证明校验结论", &rows); - Ok(()) -} - -fn cmd_tee_kbs_get(args: &[String]) -> Result<(), String> { - let endpoint = parse_flag(args, "--endpoint").ok_or("缺少 --endpoint(host:port,不带 scheme)")?; - let repo = parse_flag(args, "--repo").ok_or("缺少 --repo")?.to_string(); - let kind = parse_flag(args, "--kind").ok_or("缺少 --kind")?.to_string(); - let token = parse_flag(args, "--token").map(|s| s.to_string()); - - let resource = match parse_flag(args, "--session-id") { - Some(sid) => { - let sid = cli_parse_hex32(sid)?; - mpc_tee::kbs::ResourcePath::for_session(&repo, &kind, &sid).map_err(|e| e.to_string())? - } - None => { - let tag = parse_flag(args, "--tag").ok_or("缺少 --tag 或 --session-id")?.to_string(); - mpc_tee::kbs::ResourcePath::new(repo, kind, tag).map_err(|e| e.to_string())? - } - }; - - let mut client = mpc_tee::kbs::KbsClient::new(endpoint).map_err(|e| e.to_string())?; - if let Some(t) = token { - client = client.with_token(t); - } - let bytes = client.get(&resource).map_err(|e| e.to_string())?; - match parse_flag(args, "--out") { - Some(p) => { - std::fs::write(p, &bytes).map_err(|e| format!("写 {p} 失败: {e}"))?; - println!("已写入 {p}({} 字节)", bytes.len()); - } - None => { - println!("{} 字节: {}", bytes.len(), cli_hex_bytes(&bytes)); - } - } - Ok(()) -} - fn cli_parse_hex32(s: &str) -> Result<[u8; 32], String> { mpc_tee::platform::parse_hex::<32>(s) .ok_or_else(|| format!("{s:?} 不是 64 位十六进制")) @@ -1630,6 +1489,16 @@ fn cmd_tee_attest_post(args: &[String]) -> Result<(), String> { /// ★ 令牌必须从**文件**读(`--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)")? @@ -1639,6 +1508,24 @@ fn cmd_tee_attest_upload(args: &[String]) -> Result<(), String> { .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) => { @@ -1652,7 +1539,7 @@ fn cmd_tee_attest_upload(args: &[String]) -> Result<(), String> { .to_string(), }; - let target = mpc_tee::attest_upload::UploadTarget::new(&host, &sandbox, &token) + 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}"))?; @@ -1697,294 +1584,6 @@ fn json_escape(s: &str) -> String { /// /// 关键点:**挑战值必须是框架的绑定值**,不能用厂商默认的 `"user data"`。 /// 用默认值的话,报告与绑定值对不上,绑定验证形同虚设。 -fn cmd_tee_attest_collect(args: &[String]) -> Result<(), String> { - let platform = match parse_flag(args, "--platform") { - Some("csv") | Some("hygon") | Some("hygon-csv") => mpc_tee::PlatformKind::HygonCsv, - Some("snp") | Some("sev-snp") => mpc_tee::PlatformKind::SevSnp, - Some(other) => return Err(format!("--platform {other:?} 只认 csv/snp")), - None => return Err(String::from("缺少 --platform(csv/snp)")), - }; - let user_data = mpc_tee::platform::parse_hex::<64>( - parse_flag(args, "--user-data").ok_or("缺少 --user-data(64 字节 / 128 位十六进制)")?, - ) - .ok_or("user-data 不是 128 位十六进制")?; - let out = parse_flag(args, "--out").ok_or("缺少 --out(证明包输出路径)")?; - let device = parse_flag(args, "--device").unwrap_or(match platform { - mpc_tee::PlatformKind::HygonCsv => "/dev/csv-guest", - _ => "/dev/sev-guest", - }); - - let evidence = match platform { - mpc_tee::PlatformKind::HygonCsv => { - // nonce 从 OS 熵源取:nonce 参与 SM3(user_data||mnonce),是报告的 - // 新鲜度来源。固定 nonce 等于放弃新鲜性。 - let mut nonce = [0u8; 16]; - mpc_core::osrand::fill_random(&mut nonce).map_err(|e| format!("取 nonce 失败: {e}"))?; - mpc_tee::collect::collect_csv_report(device, &user_data, &nonce) - .map_err(|e| e.to_string())? - } - _ => mpc_tee::collect::collect_snp_report(device, &user_data).map_err(|e| e.to_string())?, - }; - - let bundle = mpc_tee::collect::to_bundle(platform, evidence, user_data).map_err(|e| e.to_string())?; - let bytes = bundle.to_bytes(); - std::fs::write(out, &bytes).map_err(|e| format!("写 {out} 失败: {e}"))?; - - note!("证明包已写出: {out}({} 字节,报告 {} 字节)", bytes.len(), bundle.report.len()); - note!("attestation_collected=true"); - Ok(()) -} - -/// `mpc tee attest-check`:校验一份证明包。 -/// -/// # 为什么做成独立子命令(而不是只留库函数) -/// -/// KBS 是 Python 写的,但**证明判定必须只有一份实现** —— 两边各写一套, -/// 就会出现「KBS 判通过、审计端判不通过」或者反过来,两种都不可接受。 -/// -/// 所以 KBS 通过调用本命令来判定:**判定逻辑在 Rust 里,Python 只负责 -/// 搬运字节和看退出码**。本命令的退出码就是判定结果: -/// -/// - `0`:通过(结构 + 绑定 + 度量 pin + TCB + 芯片签名,若提供验签器) -/// - `1`:不通过(判定失败,`verdict` 字段说明原因) -/// - `2`:用法错误(参数缺失、文件读不到等) -/// -/// 这也是「生成端自检与审计端判定口径一致」这条铁律在证明链上的落实。 -fn cmd_tee_attest_check(args: &[String]) -> Result<(), String> { - let bundle_path = parse_flag(args, "--bundle").ok_or("缺少 --bundle(证明包文件路径)")?; - let raw = std::fs::read(bundle_path).map_err(|e| format!("读证明包 {bundle_path} 失败: {e}"))?; - let bundle = mpc_tee::bundle::AttestationBundle::from_bytes(&raw).map_err(|e| e.to_string())?; - - let platform = match parse_flag(args, "--platform") { - Some(p) => match p { - "snp" | "sev-snp" => mpc_tee::PlatformKind::SevSnp, - "csv" | "hygon" | "hygon-csv" => mpc_tee::PlatformKind::HygonCsv, - "tdx" => mpc_tee::PlatformKind::Tdx, - "optee" => mpc_tee::PlatformKind::Optee, - other => return Err(format!("--platform {other:?} 只认 snp/csv/tdx/optee")), - }, - None => bundle.platform, - }; - - // 节点描述:与 `tee plan` / `tee verify` 同源(site / measurement / tcb)。 - let node = match parse_flag(args, "--node") { - Some(p) => { - let src = std::fs::read_to_string(p).map_err(|e| format!("读节点描述 {p} 失败: {e}"))?; - Some(mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?) - } - None => None, - }; - - let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?; - let site = match parse_flag(args, "--site") { - Some(s) => s.to_string(), - None => node - .as_ref() - .map(|n| n.site.clone()) - .filter(|s| !s.is_empty()) - .ok_or("缺少 --site(也没给 --node)")?, - }; - let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?; - let measurement = match parse_flag(args, "--measurement") { - Some(m) => cli_parse_hex32(m)?, - None => node - .as_ref() - .map(|n| n.measurement) - .ok_or("缺少 --measurement(也没给 --node)")?, - }; - let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement); - - let tcb: u32 = match parse_flag(args, "--tcb") { - Some(v) => v.parse().map_err(|_| format!("--tcb {v:?} 不是整数"))?, - None => node.as_ref().map(|n| n.platform.tcb).unwrap_or(0), - }; - let min_tcb: u32 = match parse_flag(args, "--min-tcb") { - Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?, - None => 0, - }; - let pin = match parse_flag(args, "--pin") { - Some(v) => Some(cli_parse_hex32(v)?), - None => None, - }; - - let verifier: Option = match parse_flag(args, "--verifier") { - Some(prog) => { - let mut v = mpc_tee::verify::ExternalVerifier::new(prog); - let mut i = 0; - while i < args.len() { - if args[i].as_str() == "--verifier-arg" && i + 1 < args.len() { - v = v.arg(args[i + 1].clone()); - i += 2; - } else { - i += 1; - } - } - // ★ --chain-dir 单独一个选项名,不走 --verifier-arg。 - // 原因:argparse 遇到「以 - 开头的值」会把它当成下一个选项 —— - // 实测 `--verifier-arg --chain-dir X` 直接报 - // "argument --verifier-arg: expected one argument"。 - // 证书链目录这类「路径」参数必须有独立的选项名。 - if let Some(dir) = parse_flag(args, "--chain-dir") { - if !dir.is_empty() { - v = v.arg(String::from("--chain-dir")).arg(dir.to_string()); - } - } - Some(v) - } - None => None, - }; - - // 判定。失败要**如实返回不通过**,不降级、不放行。 - let verdict = mpc_tee::bundle::verify_bundle( - &bundle, - &binding, - platform, - tcb, - min_tcb, - pin.as_ref(), - verifier.as_ref().map(|x| x as &dyn mpc_tee::verify::ChipVerifier), - ); - - let (ok, structure_ok, bound_ok, chip, verdict_text) = match &verdict { - Ok(v) => { - let chip = match &v.chip { - mpc_tee::verify::ChipVerdict::NotVerified => "not-verified".to_string(), - mpc_tee::verify::ChipVerdict::VerifiedBy(n) => format!("verified-by:{n}"), - mpc_tee::verify::ChipVerdict::Failed(w) => format!("failed:{w}"), - }; - (true, v.structure_ok, v.bound_ok, chip, v.verdict.clone()) - } - Err(e) => { - // 判定失败:结构与绑定都按 false 报(不能报一半 true 一半 false)。 - (false, false, false, "failed".to_string(), e.to_string()) - } - }; - - if report::is_json() { - let doc = format!( - "{{\"ok\":{ok},\"structure_ok\":{structure_ok},\"bound_ok\":{bound_ok},\ - \"chip\":{},\"verdict\":{},\"report_len\":{},\"cert_count\":{}}}", - json_escape(&chip), - json_escape(&verdict_text), - bundle.report.len(), - bundle.cert_chain.len() - ); - println!("{doc}"); - } else { - let rows: Vec<(&str, report::Cell)> = vec![ - ("ok", report::Cell::flag(ok)), - ("structure_ok", report::Cell::flag(structure_ok)), - ("bound_ok", report::Cell::flag(bound_ok)), - ("chip", report::Cell::txt(chip.clone())), - ("report_len", report::Cell::int(bundle.report.len() as i64)), - ("cert_count", report::Cell::int(bundle.cert_chain.len() as i64)), - ("verdict", report::Cell::txt(verdict_text.clone())), - ]; - report::kv("证明包校验结论", &rows); - } - - if ok { - Ok(()) - } else { - // 退出码 1 = 判定不通过(与用法错误的 2 区分开)。 - std::process::exit(1); - } -} - -/// `mpc tee attest-mkbundle`:生成一份**自洽的合成证明包**(仅测试/演练)。 -/// -/// # ⚠️ 这不是硬件证明 -/// -/// 报告是**合成**的(`synthetic_csv_report`),签名字段是常量填充, -/// 没有真实芯片签名。它能过**结构检查 + 绑定检查**,但**过不了芯片验签**。 -/// -/// 它的用途只有一个:让「先验证明才下发密钥」这条链路的**正向路径** -/// 在没有真机时也能被自动化测试覆盖 —— 否则只测了拒绝路径, -/// 「通过之后真的会签发 token 并下发密钥」这条路从未被验证过。 -/// -/// 真机验证必须用 `mpc tee attest-collect`(真芯片报告)。 -fn cmd_tee_attest_mkbundle(args: &[String]) -> Result<(), String> { - let platform = match parse_flag(args, "--platform") { - Some("csv") | Some("hygon") | Some("hygon-csv") => mpc_tee::PlatformKind::HygonCsv, - Some("snp") | Some("sev-snp") => mpc_tee::PlatformKind::SevSnp, - Some(other) => return Err(format!("--platform {other:?} 只认 csv/snp")), - None => mpc_tee::PlatformKind::HygonCsv, - }; - let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?; - let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string(); - let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?; - let measurement = cli_parse_hex32(parse_flag(args, "--measurement").ok_or("缺少 --measurement")?)?; - let tcb: u32 = parse_flag(args, "--tcb") - .unwrap_or("0") - .parse() - .map_err(|_| String::from("--tcb 不是整数"))?; - let out = parse_flag(args, "--out").ok_or("缺少 --out")?; - - let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement); - let user_data = binding.user_data(platform, tcb); - let report = match platform { - mpc_tee::PlatformKind::HygonCsv => mpc_tee::verify::synthetic_csv_report(&user_data), - mpc_tee::PlatformKind::SevSnp => mpc_tee::verify::synthetic_snp_report(&user_data), - other => return Err(format!("平台 {other:?} 不支持合成证明包")), - }; - let bundle = mpc_tee::bundle::AttestationBundle::new( - platform, - report, - Vec::new(), - user_data, - ) - .map_err(|e| e.to_string())?; - let bytes = bundle.to_bytes(); - std::fs::write(out, &bytes).map_err(|e| format!("写 {out} 失败: {e}"))?; - - note!("合成证明包已写出: {out}({} 字节)", bytes.len()); - note!("⚠️ 合成件,非硬件证明:签名字段是常量填充,过不了芯片验签"); - Ok(()) -} - -/// `mpc tee attest-post`:把证明包提交给 KBS,换取证明 token。 -/// -/// 这是「先验证明,才给密钥」的中枢:guest 采集到芯片证明后,先走这条 -/// 提交给 KBS;KBS 校验通过才回 token;拿 token 才能 `kbs-get` 取密钥。 -/// -/// KBS 拒绝时**原样报出服务端的原因** —— 「为什么被拒」比「被拒了」重要得多。 -fn cmd_tee_attest_post(args: &[String]) -> Result<(), String> { - let endpoint = parse_flag(args, "--endpoint") - .ok_or("缺少 --endpoint(host:port,不带 scheme)")? - .to_string(); - let bundle_path = parse_flag(args, "--bundle").ok_or("缺少 --bundle(证明包路径)")?; - let session_id = parse_flag(args, "--session-id").ok_or("缺少 --session-id")?; - let out = parse_flag(args, "--out").ok_or("缺少 --out(token 输出路径)")?; - - let bundle = std::fs::read(bundle_path).map_err(|e| format!("读证明包 {bundle_path} 失败: {e}"))?; - let token = mpc_tee::kbs::post_attestation(&endpoint, &bundle, session_id) - .map_err(|e| e.to_string())?; - std::fs::write(out, token.as_bytes()).map_err(|e| format!("写 {out} 失败: {e}"))?; - - note!("证明 token 已取得: {out}({} 字节)", token.len()); - note!("attestation_accepted=true"); - Ok(()) -} - -/// 极简 JSON 字符串转义(只处理控制字符、引号、反斜杠)。 -fn json_escape(s: &str) -> String { - let mut out = String::with_capacity(s.len() + 2); - out.push('"'); - for c in s.chars() { - match c { - '"' => out.push_str("\\\""), - '\\' => out.push_str("\\\\"), - '\n' => out.push_str("\\n"), - '\r' => out.push_str("\\r"), - '\t' => out.push_str("\\t"), - c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)), - c => out.push(c), - } - } - out.push('"'); - out -} - fn cli_parse_csv_variant(s: &str) -> Result { use mpc_tee::platform::CsvVariant; match s { @@ -2036,227 +1635,6 @@ fn cli_json_array(items: &[String]) -> String { } /// 手写 JSON 字符串转义(不引 serde_json,项目零依赖)。 -fn cli_json_string(s: &str) -> String { - let mut out = String::from("\""); - for c in s.chars() { - match c { - '"' => out.push_str("\\\""), - '\\' => out.push_str("\\\\"), - '\n' => out.push_str("\\n"), - '\r' => out.push_str("\\r"), - '\t' => out.push_str("\\t"), - c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)), - c => out.push(c), - } - } - out.push('"'); - out -} - -/// 把 qemu argv 编成 JSON 数组 —— 部署脚本据此用 `execvp` 保留参数边界。 -fn cli_json_array(items: &[String]) -> String { - let mut s = String::from("["); - for (i, v) in items.iter().enumerate() { - if i > 0 { - s.push(','); - } - s.push_str(&cli_json_string(v)); - } - s.push(']'); - s -} - -/// `mpc tee`:直接调度 TEE —— 列平台规格 / 做节点准入 / 产出 qemu 启动规格。 -/// -/// 这一族命令**不生成任何容器编排清单**,也不连接主机;节点能力全部来自 -/// 宿主预检脚本产出的文本描述。框架只做判定,执行由部署侧照着 `LaunchSpec` 做。 -fn cmd_tee(args: &[String]) -> Result<(), String> { - match args.first().map(String::as_str).unwrap_or("") { - "paths" => cmd_tee_paths(), - "plan" => cmd_tee_plan(&args[1..]), - "verify" => cmd_tee_verify(&args[1..]), - "kbs-get" => cmd_tee_kbs_get(&args[1..]), - "attest-collect" => cmd_tee_attest_collect(&args[1..]), - "attest-check" => cmd_tee_attest_check(&args[1..]), - "attest-mkbundle" => cmd_tee_attest_mkbundle(&args[1..]), - "attest-post" => cmd_tee_attest_post(&args[1..]), - // 宿主端:走 e2b 兼容 API 操作本机/远端的 mpc-hostd。 - // guest 静态二进制里这四个命令必须明确拒绝,不能悄悄落到 help 上 - // ——「参数收了但没人执行」就是假接口。 - #[cfg(feature = "control-plane")] - "up" | "ps" | "attest" | "down" => hostd::cmd_tee_host(args), - #[cfg(not(feature = "control-plane"))] - "up" | "ps" | "attest" | "down" => Err(String::from( - "该命令属于宿主控制面,guest 静态二进制不含 mpc-hostd;请在宿主端 mpc 上执行", - )), - _ => Err(String::from( - "用法: mpc tee paths | plan --node FILE | verify --report FILE --platform snp|csv|tdx|optee \ - | kbs-get --endpoint HOST:PORT --repo R --kind K \ - | attest-collect --platform csv --user-data HEX --out FILE \ - | attest-check --bundle FILE --platform csv --session-id HEX --site S --pubkey HEX --measurement HEX \ - | attest-mkbundle --session-id HEX --site S --pubkey HEX --measurement HEX --tcb N --out FILE \ - | attest-post --endpoint HOST:PORT --bundle FILE --session-id HEX --out FILE \ - | up|ps|attest|down (宿主端,走 --host HOST:PORT)", - )), - } -} - -fn cmd_tee_paths() -> Result<(), String> { - let mut rows: Vec> = Vec::new(); - for p in mpc_tee::platform::builtin_profiles() { - rows.push(vec![ - report::Cell::txt(p.name()), - report::Cell::txt(p.kind.to_string()), - report::Cell::txt(match p.guest_policy { - Some(v) => format!("0x{v:x}"), - None => String::from("default"), - }), - report::Cell::txt(p.kbc.as_str()), - report::Cell::txt(p.attest_channel.as_str()), - report::Cell::txt(p.sev_object), - report::Cell::int(p.vcpus as i64), - report::Cell::int(p.memory_mib as i64), - ]); - } - report::table( - "内置 TEE 直接启动规格", - &[ - "profile", - "platform", - "policy", - "kbc", - "attest", - "qemu-object", - "vcpus", - "mem_mib", - ], - &rows, - ); - Ok(()) -} - -fn cmd_tee_plan(args: &[String]) -> Result<(), String> { - let node_path = parse_flag(args, "--node").ok_or("缺少 --node")?; - let src = std::fs::read_to_string(node_path) - .map_err(|e| format!("读节点描述 {node_path} 失败: {e}"))?; - let mut node = mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?; - - // `--kbc` 在节点描述里是「节点实际启用的模式」,在命令行里历史上被当成 - // 「要求什么模式」。两者语义不同、混用会出怪事,这里显式分开: - // `--kbc` 节点实际启用哪种密钥代理(覆盖节点描述的 kbc=) - // `--require-kbc` 准入要求必须是哪种(不匹配就拒绝) - // 节点描述的 kbs_endpoint= 是现场部署事实,也可用命令行覆盖。 - if let Some(v) = parse_flag(args, "--kbc") { - node.kbc = match v { - "online" | "cc_kbc" => mpc_tee::platform::KbcMode::Online, - "offline" | "offline_fs_kbc" => mpc_tee::platform::KbcMode::Offline, - _ => return Err(format!("--kbc {v:?} 只认 online/offline")), - }; - } - if let Some(v) = parse_flag(args, "--kbs-endpoint") { - node.kbs_endpoint = Some(v.to_string()); - } - - let demo = args.iter().any(|a| a == "--demo"); - let (session_id, pubkey) = if demo { - note!("警告: --demo 使用固定示例会话值,仅用于离线计划演练,不能上生产"); - ([1u8; 32], [2u8; 32]) - } else { - ( - cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?, - cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?, - ) - }; - - let binding = mpc_tee::session::SessionBinding::new( - session_id, - node.site.clone(), - pubkey, - node.measurement, - ); - let min_tcb: u32 = match parse_flag(args, "--min-tcb") { - Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?, - None => 0, - }; - let mut req = mpc_tee::schedule::TeeRequirement::new(node.platform.kind, min_tcb); - if let Some(v) = parse_flag(args, "--variant") { - req.csv_variant = Some(cli_parse_csv_variant(v)?); - } - if let Some(v) = parse_flag(args, "--require-kbc") { - req.required_kbc = Some(match v { - "online" | "cc_kbc" => mpc_tee::platform::KbcMode::Online, - "offline" | "offline_fs_kbc" => mpc_tee::platform::KbcMode::Offline, - _ => return Err(format!("--require-kbc {v:?} 只认 online/offline")), - }); - } - if let Some(v) = parse_flag(args, "--pin") { - req.pinned_measurement = Some(cli_parse_hex32(v)?); - } - - let spec = mpc_tee::schedule::admit(&req, &node, &binding).map_err(|e| e.to_string())?; - let policy = match spec.profile.guest_policy { - Some(v) => format!("0x{v:x}"), - None => String::from("default"), - }; - let rows: Vec<(&str, report::Cell)> = vec![ - ("profile", report::Cell::txt(spec.profile.name())), - ("platform", report::Cell::txt(spec.platform.to_string())), - ("site", report::Cell::txt(spec.site.clone())), - ("host", report::Cell::txt(spec.host.clone())), - ("qemu", report::Cell::txt(spec.qemu_bin.clone())), - ("firmware", report::Cell::txt(spec.firmware.clone())), - ("kernel", report::Cell::txt(spec.kernel.clone())), - ("initrd", report::Cell::txt(spec.initrd.clone())), - ("policy", report::Cell::txt(policy)), - ("kbc", report::Cell::txt(spec.kbc.as_str())), - ("measurement", report::Cell::txt(cli_hex_bytes(&spec.measurement))), - ("user_data", report::Cell::txt(cli_hex_bytes(&spec.user_data))), - ("kernel_params", report::Cell::txt(spec.kernel_params.clone())), - ]; - report::kv("TEE 启动规格(fail-closed 准入通过)", &rows); - if args.iter().any(|a| a == "--argv") { - let argv = spec.qemu_argv(); - report::kv( - "qemu argv", - &[ - // 给人看:一行概览。注意 `-append` 的值含空格,这一行**不能** - // 直接丢给 shell;执行必须用下面的 argv_json 保留参数边界。 - ("argv", report::Cell::txt(argv.join(" "))), - ("argv_json", report::Cell::txt(cli_json_array(&argv))), - ], - ); - } - Ok(()) -} - -fn cli_parse_hex32(s: &str) -> Result<[u8; 32], String> { - mpc_tee::platform::parse_hex::<32>(s) - .ok_or_else(|| format!("{s:?} 不是 64 位十六进制")) -} - -fn cli_parse_csv_variant(s: &str) -> Result { - use mpc_tee::platform::CsvVariant; - match s { - "csv" => Ok(CsvVariant::Csv), - "csv2" => Ok(CsvVariant::Csv2), - "csv3" => Ok(CsvVariant::Csv3), - "csv-dcu" | "dcu" => Ok(CsvVariant::Dcu), - _ => Err(format!("--variant {s:?} 只认 csv/csv2/csv3/csv-dcu")), - } -} - -fn cli_hex_bytes(bytes: &[u8]) -> String { - let mut s = String::with_capacity(bytes.len() * 2); - for b in bytes { - s.push_str(&format!("{b:02x}")); - } - s -} - -/// `mpc trust`:按各方的 TEE 状况算出可信度方案(L0–L3)。 -/// -/// 这个命令**不发起任何连接**,只做判定 —— 它的用途是让"这一轮到底靠什么 -/// 保证安全"在开工前就写在纸上,而不是跑完以后靠回忆解释。 fn cmd_trust(args: &[String]) -> Result<(), String> { let spec = parse_flag(args, "--parties").ok_or("缺少 --parties")?; let mut parties: Vec = Vec::new(); @@ -2999,6 +2377,14 @@ fn cmd_node(args: &[String]) -> Result<(), String> { 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"); @@ -3089,11 +2475,6 @@ fn cmd_node(args: &[String]) -> Result<(), String> { .parse() .map_err(|_| "--fxp 不是合法整数")?; - let seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; - // 数据按浮点解析,再编码到定点环 let mut data = Vec::new(); for tok in data_str.split(',') { @@ -3155,10 +2536,7 @@ fn cmd_cluster(args: &[String]) -> Result<(), String> { .unwrap_or("18") .parse() .map_err(|_| "--fxp 不是合法整数")?; - let seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let seed = seed_or_random(args)?; let timeout: u64 = parse_flag(args, "--timeout") .unwrap_or("120") .parse() @@ -3258,10 +2636,7 @@ fn orch_run(args: &[String]) -> Result<(), String> { .unwrap_or("18") .parse() .map_err(|_| "--fxp 不是合法整数")?; - let seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let seed = seed_or_random(args)?; let timeout: u64 = parse_flag(args, "--timeout") .unwrap_or("120") .parse() @@ -3761,6 +3136,21 @@ fn derive_psi_seed(seed: [u8; 32], site: &str) -> [u8; 32] { out } +/// 种子有效性判据:**整体非零**。 +/// +/// 用「或累积」(`|=`)而不是「遇零就返回」——种子不是秘密,但全零这个 +/// **值本身**是公开判据,用提前返回会让分支耗时随内容变化。 +/// +/// ★ 口径与 `mpc-core` 的种子判据一致(同一个算法:或累积 + 非零); +/// 零字节不影响累积值 ⇒ 整体非零 ⇔ 累积值非零。 +fn seed_is_nonzero(seed: &[u8; 32]) -> bool { + let mut acc = 0u8; + for b in seed.iter() { + acc |= *b; + } + acc != 0 +} + fn parse_seed(hex: &str) -> Result<[u8; 32], String> { let clean: String = hex.chars().filter(|c| !c.is_whitespace()).collect(); if clean.len() != 64 { @@ -3771,9 +3161,49 @@ fn parse_seed(hex: &str) -> Result<[u8; 32], String> { out[i] = u8::from_str_radix(&clean[i * 2..i * 2 + 2], 16) .map_err(|_| format!("--seed 第 {} 字节不是十六进制", i))?; } + // ★ 全零种子必须拒。 + // + // 全零主种子 ⇒ `Dealer` 的所有 Beaver 三元组都由全零派生的 + // ChaCha20 流生成 ⇒ **任何一方都能算出掩码** ⇒ 密态乘法隐私性归零。 + // + // ★ 而症状是「不报错、不崩溃、结果数值也对」—— + // 这是最难发现的一类失败(项目文档里对 PSI 种子的原话)。 + // 所以必须在**入口**就拒,不能指望下游发现。 + // + // 判据:种子**整体非零**(或累积判定,零值不参与)。 + // + // 判据口径与 `mpc-core` 的种子判据一致(同一个算法:或累积 + 非零); + // 本文件内联实现,是为了让 `mpc-cli` 不依赖那一个模块即可编译, + // 口径不因此漂移。 + // 本文件不直接依赖 mpc-core 的该函数,是为了让本 crate + // 在 `mpc-core` 之外也能独立编译(判据口径不因此漂移)。 + if !seed_is_nonzero(&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) // --------------------------------------------------------------------------- @@ -3802,10 +3232,7 @@ fn cmd_sql_join(args: &[String]) -> Result<(), String> { (Some(a), None) | (None, Some(a)) => a.to_string(), }; - let seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let seed = seed_or_random(args)?; let fxp: u32 = parse_flag(args, "--fxp") .unwrap_or("18") .parse() @@ -3954,10 +3381,7 @@ fn cmd_psi(args: &[String]) -> Result<(), String> { let connect = parse_flag(args, "--connect"); let peers_raw = parse_flag(args, "--peers"); - let base_seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let base_seed = seed_or_random(args)?; let ids_raw = parse_flag(args, "--ids").ok_or("缺少 --ids")?; let mut ids: Vec> = Vec::new(); @@ -4058,10 +3482,7 @@ fn cmd_lr(args: &[String]) -> Result<(), String> { (Some(a), None) | (None, Some(a)) => a.to_string(), }; - let seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let seed = seed_or_random(args)?; let fxp: u32 = parse_flag(args, "--fxp") .unwrap_or("18") .parse() @@ -4276,10 +3697,7 @@ fn cmd_lr_vertical(args: &[String]) -> Result<(), String> { .unwrap_or("0.3") .parse() .map_err(|_| "--lr 不是浮点")?; - let base_seed = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let base_seed = seed_or_random(args)?; let listen = parse_flag(args, "--listen"); let connect = parse_flag(args, "--connect"); @@ -4448,10 +3866,7 @@ fn cmd_fl(args: &[String]) -> Result<(), String> { .unwrap_or("0.0") .parse() .map_err(|_| "--noise 不是浮点")?; - let seed_bytes = match parse_flag(args, "--seed") { - Some(h) => parse_seed(h)?, - None => [0u8; 32], - }; + let seed_bytes = seed_or_random(args)?; let seed = u64::from_le_bytes(seed_bytes[0..8].try_into().unwrap()); if k < 1 { @@ -4502,6 +3917,60 @@ fn cmd_fl(args: &[String]) -> Result<(), String> { 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!( + seed_is_nonzero(&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() { @@ -4620,39 +4089,6 @@ mod tests { /// 启动方用 node 里的 tcb 算绑定值,验证方若手工重填或漏填 `--tcb` /// (默认 0),期望值必然对不上 —— 而报错是「user_data 与本次会话绑定不一致」, /// 指向重放攻击,排查方向会被带偏。 - #[test] - fn tee_verify_reads_binding_inputs_from_node() { - let p = std::env::temp_dir().join(format!("mpc-cli-teeverify-{}.node", std::process::id())); - let src = format!( - "site=bob\nhost=127.0.0.1\nkind=hygon-csv\ntcb=3\n\ - device_present=true\nqemu_present=true\nfirmware_present=true\n\ - image_present=true\nkbc=offline\nkbs_reachable=false\nmeasurement={}\n\ - qemu=/usr/bin/qemu-system-x86_64\nfirmware=/srv/tee/HYGONCSV.fd\n\ - kernel=/srv/tee/vmlinuz\ninitrd=/srv/tee/initrd.img\n", - "53".repeat(32) - ); - std::fs::write(&p, &src).expect("写节点描述"); - let node = p.to_str().unwrap(); - - // 缺 --session-id / --pubkey 时必须报错,不能静默用默认值。 - let missing = v(&["verify", "--report", "/nonexistent", "--node", node]); - assert!( - cmd_tee_verify(&missing).is_err(), - "缺少报告文件 / 会话参数必须拒绝" - ); - - // 节点描述与 --platform 冲突必须直接拒绝。 - let conflict = v(&[ - "verify", "--report", "/nonexistent", "--node", node, "--platform", "snp", - "--session-id", &"ab".repeat(32), "--pubkey", &"cd".repeat(32), - ]); - let err = cmd_tee_verify(&conflict).unwrap_err(); - assert!( - err.contains("不一致"), - "节点平台与 --platform 冲突必须报错,实际: {err}" - ); - let _ = std::fs::remove_file(&p); - } #[test] fn tee_argv_json_keeps_parameter_boundaries() { @@ -4663,14 +4099,6 @@ mod tests { assert!(cli_json_string("a\"b\\c").contains("\\\"")); } - #[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() { @@ -4680,40 +4108,8 @@ mod tests { assert!(cli_parse_csv_variant("csv3").is_ok()); } - #[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); - } - #[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() { diff --git a/crates/mpc-hostd/src/api.rs b/crates/mpc-hostd/src/api.rs index 6096ffa..3715964 100644 --- a/crates/mpc-hostd/src/api.rs +++ b/crates/mpc-hostd/src/api.rs @@ -454,6 +454,43 @@ pub fn parse_platform(raw: &str) -> Option { } } +/// ★ ★ **宿主控制面的路由形状只有一份,在这里。** +/// +/// # 为什么宿主控制面要**拥有**这份路由 +/// +/// guest(enclave 内)要把证明材料回传给宿主,就**必须知道上传端点的路径**。 +/// 早先这个路径在 `mpc-tee::attest_upload` 里写死(`/sandboxes/{id}/attestation`)—— +/// 那有两个问题: +/// +/// 1. ★ **路由漂移**:hostd 改路由,guest 侧不会跟着改 +/// ⇒ guest 静默 POST 到不存在的端点 +/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。 +/// 症状链是「guest 报 404 / 宿主报 pending / 集群面不公布端点」, +/// 极难定位到「路由变了」这一层。 +/// 2. guest 静态产物里带上了宿主控制面的路由痕迹 +/// ⇒ 破坏 guest 边界(主门禁第 4 条的负向判据会红)。 +/// +/// # 所以:路由归宿主,guest 从宿主那里**拿**路径 +/// +/// 宿主在建实例时把完整上传路径写进 9p 手牌, +/// guest 从 `/run/mpc-tee/hostd/upload_path` 读到后原样使用。 +/// hostd 改路由 ⇒ 手牌里的路径跟着改 ⇒ guest 不用动。 +/// +/// ★ 守卫:`route_literal_must_not_live_in_mpc_tee` +/// (本文件底部的测试)跨 crate 扫 `mpc-tee` 源码, +/// 保证这份路由**不会**又被抄回 guest 侧。 +pub const ROUTE_SANDBOXES: &str = "sandboxes"; + +/// 证明材料上传端点的末段名。 +pub const ROUTE_ATTESTATION: &str = "attestation"; + +/// ★ 某个实例的证明材料上传端点的**完整路径**。 +/// +/// 宿主写进 9p 手牌、guest 原样使用。路径由**宿主**决定(见上面的说明)。 +pub fn attestation_upload_path(sandbox_id: &str) -> String { + format!("/{ROUTE_SANDBOXES}/{sandbox_id}/{ROUTE_ATTESTATION}") +} + /// 路由分发。 /// /// `req.path` 的形状由 e2b 兼容面决定: @@ -524,7 +561,7 @@ pub fn dispatch_with_auth( return Response::text(Status::Ok, "ok"); } // 沙箱集合 - if segs[0] == "sandboxes" { + if segs[0] == ROUTE_SANDBOXES { return dispatch_sandboxes(rt, req, &segs, None); } // 宿主自描述:本宿主探测出的 TEE 能力自报(Cubelet 自描述,pull 接口)。 @@ -565,11 +602,11 @@ fn dispatch_sandboxes( // DELETE /sandboxes/{id} ("DELETE", 2) => delete_sandbox(rt, segs[1]), // GET /sandboxes/{id}/attestation - ("GET", 3) if segs[2] == "attestation" => get_attestation(rt, segs[1]), + ("GET", 3) if segs[2] == ROUTE_ATTESTATION => get_attestation(rt, segs[1]), // POST /sandboxes/{id}/attestation —— guest 回传**原始证明包字节**。 // 鉴权走**两种凭据任一**:共享密钥 或 本实例令牌 // (判定见 `attestation_upload_authorized`)。 - ("POST", 3) if segs[2] == "attestation" => { + ("POST", 3) if segs[2] == ROUTE_ATTESTATION => { post_attestation(rt, req, segs[1], upload_global_authorized.unwrap_or(false)) } // POST /sandboxes/{id}/connect @@ -962,8 +999,8 @@ fn bearer_token(req: &Request) -> Option { fn is_attestation_upload(req: &Request, segs: &[&str]) -> bool { req.method.eq_ignore_ascii_case("POST") && segs.len() == 3 - && segs[0] == "sandboxes" - && segs[2] == "attestation" + && segs[0] == ROUTE_SANDBOXES + && segs[2] == ROUTE_ATTESTATION } /// ★ 这条请求带的令牌**是不是**该实例的上传令牌。 @@ -993,6 +1030,79 @@ mod tests { use super::*; use std::collections::HashMap; + /// ★ ★ **宿主控制面的路由字面量不得出现在 `mpc-tee` 里。** + /// + /// # 这条守卫在钉什么 + /// + /// 路由形状**只有一份**,就在本文件(`ROUTE_SANDBOXES` / `ROUTE_ATTESTATION`)。 + /// guest 从 9p 手牌里**拿**宿主下发的完整路径(见 `attestation_upload_path`)。 + /// + /// 早先 `mpc-tee::attest_upload` 里写死了 `/sandboxes/{id}/attestation`, + /// 造成两个问题: + /// 1. **路由漂移** —— hostd 改路由,guest 不会跟着改 + /// ⇒ guest 静默 POST 到不存在的端点 + /// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。 + /// 2. guest 静态产物里带上了宿主控制面的路由痕迹 ⇒ 破坏 guest 边界 + /// (主门禁第 4 条的负向判据会红)。 + /// + /// ★ 为什么守卫放在**这里**(hostd)而不是 mpc-tee: + /// 被检查方自己检查自己等于没检查。 + /// hostd 是路由的**真正归属方** —— 路由归谁管,谁就负责看住它。 + /// + /// ★ 只扫**非测试代码**:`#[cfg(test)]` 里的夹具不进二进制, + /// 且它们本来就要构造「各种形状的路径」来验证校验逻辑。 + #[test] + fn route_literal_must_not_live_in_mpc_tee() { + let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../mpc-tee/src"); + let mut offenders: Vec = Vec::new(); + let mut entries: Vec = std::fs::read_dir(&dir) + .unwrap_or_else(|e| panic!("读 {} 失败: {e}", dir.display())) + .filter_map(|e| e.ok().map(|e| e.path())) + .collect(); + entries.sort(); + for p in entries { + if p.extension().and_then(|x| x.to_str()) != Some("rs") { + continue; + } + let text = std::fs::read_to_string(&p).unwrap(); + // ★ `#[cfg(test)]` 之后是测试代码(不进二进制)—— 只扫它之前。 + let test_start = text + .lines() + .position(|l| l.trim() == "#[cfg(test)]") + .unwrap_or(usize::MAX); + for (i, line) in text.lines().enumerate() { + if i >= test_start { + break; + } + let l = line.trim(); + // 跳过注释行与文档行(它们不进二进制,也不构成「持有路由」)。 + if l.starts_with("//") { + continue; + } + // 路由前缀只在这两处形态下算「持有」: + // · 字符串字面量 "/sandboxes... + // · 常量赋值里的 "sandboxes" + if l.contains("\"/sandboxes") || l.contains("= \"sandboxes\"") { + offenders.push(format!("{}:{}: {}", p.display(), i + 1, l)); + } + } + } + assert!( + offenders.is_empty(), + "★ 宿主控制面的路由字面量不得留在 mpc-tee(会进 guest 产物,且会造成路由漂移):\n{}", + offenders.join("\n") + ); + } + + /// ★ 正向:上传路径由宿主生成,形状正确。 + #[test] + fn upload_path_is_produced_by_the_host() { + assert_eq!( + attestation_upload_path("sbx-abc"), + "/sandboxes/sbx-abc/attestation" + ); + } + fn req(method: &str, path: &str, body: &str) -> Request { let mut headers = HashMap::new(); headers.insert(String::from("content-type"), String::from("application/json")); @@ -1176,48 +1286,6 @@ mod tests { /// /// 症状很静默:客户端 DELETE 返回 204,看起来成功; /// 但列表越积越多,且「删了没删」没有任何报错。 - #[test] - fn delete_really_removes_the_record() { - let rt = TeeRuntime::new(); - // 用真进程(`/bin/sleep 300`)—— 这样测的才是「真起、真停、真删」, - // 而不是手工往表里塞一条假记录。 - let mut spec = crate::runtime::SpawnSpec::new( - "sess-del", - "alice", - PlatformKind::SevSnp, - "/bin/sleep", - ); - spec.args = vec![String::from("300")]; - let inst = rt.spawn(&spec).unwrap(); - let id = inst.sandbox_id.clone(); - - // 删除前:列表里有它 - let before = body_of(&dispatch(&rt, &req("GET", "/sandboxes", ""))); - assert!(before.contains(&id), "删除前列表里应有它: {before}"); - - // DELETE → 204 空体(e2b 硬要求) - let resp = dispatch(&rt, &req("DELETE", &format!("/sandboxes/{id}"), "")); - assert_eq!(resp.status, Status::NoContent); - assert!( - body_of(&resp).is_empty(), - "DELETE 必须 204 空体: {}", - body_of(&resp) - ); - - // ★ 删除后:列表里**不再**有它 - let after = body_of(&dispatch(&rt, &req("GET", "/sandboxes", ""))); - assert!( - !after.contains(&id), - "DELETE 之后 GET /sandboxes 不应再返回它(这正是真机联调挖出的 bug): {after}" - ); - - // 单点查询也应 404 - let g = dispatch(&rt, &req("GET", &format!("/sandboxes/{id}"), "")); - assert_eq!(g.status, Status::NotFound); - - // 记录确实从表里消失了(不是只把状态改掉) - assert!(rt.get(&id).is_none(), "记录必须从表里删除"); - } #[test] fn health_returns_ok() { diff --git a/crates/mpc-hostd/src/control_plane_api.rs b/crates/mpc-hostd/src/control_plane_api.rs index c654ec4..0e2f115 100644 --- a/crates/mpc-hostd/src/control_plane_api.rs +++ b/crates/mpc-hostd/src/control_plane_api.rs @@ -444,11 +444,11 @@ mod tests { n } - fn cp() -> ControlPlane> { + fn cp() -> ControlPlane { let host = Arc::new(MockHost { up: true }); ControlPlane::new( mpc_tee::control_plane::ControlPlaneConfig::default(), - host, + MockDispatch(host), SessionBinding::new([1u8; 32], "alice", [2u8; 32], [9u8; 32]), ) } @@ -568,7 +568,7 @@ mod tests { let host = Arc::new(MockHost { up: true }); let cp = ControlPlane::new( mpc_tee::control_plane::ControlPlaneConfig::default(), - host, + MockDispatch(host), SessionBinding::new([1u8; 32], "alice", [2u8; 32], [9u8; 32]), ); // 自报的节点**度量与绑定不一致** ⇒ 准入拒绝 ⇒ 不会有会话。 diff --git a/crates/mpc-hostd/src/control_plane_server.rs b/crates/mpc-hostd/src/control_plane_server.rs index 91a0f70..12315f2 100644 --- a/crates/mpc-hostd/src/control_plane_server.rs +++ b/crates/mpc-hostd/src/control_plane_server.rs @@ -227,7 +227,7 @@ mod tests { use mpc_tee::dispatch::AttestationSummary; use mpc_tee::probe::NodeReport; - use mpc_tee::schedule::{LaunchSpec, TeeNode, TeeRequirement}; + use mpc_tee::schedule::{LaunchSpec, TeeNode}; use mpc_tee::session::SessionBinding; use mpc_tee::PlatformKind; @@ -311,8 +311,8 @@ mod tests { } /// 发一个原始 HTTP 请求并读满响应(必须读到 EOF:TCP 是流)。 - fn raw_request(addr: std::net::SocketAddr, req_bytes: &[u8]) -> String { - let mut s = TcpStream::connect(addr).unwrap(); + fn raw_request(addr: &std::net::SocketAddr, req_bytes: &[u8]) -> String { + let mut s = TcpStream::connect(*addr).unwrap(); s.set_read_timeout(Some(Duration::from_secs(10))).unwrap(); s.write_all(req_bytes).unwrap(); s.flush().unwrap(); diff --git a/crates/mpc-hostd/src/guest_hand.rs b/crates/mpc-hostd/src/guest_hand.rs index 94a515d..5d574cd 100644 --- a/crates/mpc-hostd/src/guest_hand.rs +++ b/crates/mpc-hostd/src/guest_hand.rs @@ -40,10 +40,18 @@ //! # 9p 的挂载参数 //! //! ```text -//! -virtfs local,path=<宿主目录>,mount_tag=mpchostd,security_model=none +//! -fsdev local,id=mpchostd9p,path=<宿主目录>,security_model=none //! -device virtio-9p-pci,fsdev=mpchostd9p,mount_tag=mpchostd //! ``` //! +//! ★ ★ **必须用显式 `-fsdev`**,不能用 `-virtfs` 简写(2026-11-09 真机实测): +//! `-virtfs local,path=...,mount_tag=mpchostd` 会**自动**创建一个 fsdev, +//! 但它的 **id 由 qemu 自己决定**(不是 `mount_tag`)⇒ 后面 +//! `-device virtio-9p-pci,fsdev=mpchostd9p` 找不到它 ⇒ qemu 直接报 +//! `9pfs device couldn't find fsdev with the id = mpchostd9p` 并退出。 +//! 症状极具迷惑性:qemu **秒退**、串口日志**完全为空**, +//! 看起来像「guest 根本没起来」,实际是 argv 拼接错。 +//! //! `security_model=none` 是**必需的**(默认 `mapped-xattr` / `passthrough` //! 需要 root 与 xattr 支持,且会让 guest 看到的属主变成 nobody)。 //! 这里的目录只放一份**只属于这个 guest**的手牌, @@ -52,6 +60,12 @@ /// guest 里的挂载点(9p mount_tag 对应)。 pub const GUEST_MOUNT_TAG: &str = "mpchostd"; +/// qemu **fsdev 的 id**(`-fsdev local,id=...` 与 `-device ...,fsdev=...` 必须一致)。 +/// +/// ★ 这个 id 由**我们**钉死,不能交给 qemu 自动生成 —— +/// 见 [`virtfs_args`] 的说明(`-virtfs` 简写会让 qemu 自己决定 id)。 +pub const FSDEV_ID: &str = "mpchostd9p"; + /// guest 里的挂载路径。 pub const GUEST_MOUNT_PATH: &str = "/run/mpc-tee/hostd"; @@ -64,6 +78,17 @@ pub const FILE_UPLOAD_TOKEN: &str = "upload_token"; /// 手牌文件名:宿主控制面地址。 pub const FILE_HOSTD_ENDPOINT: &str = "hostd_endpoint"; +/// 手牌文件名:证明材料上传端点的**完整路径**。 +/// +/// ★ 为什么路径要由**宿主**下发(而不是 guest 侧自己拼): +/// 路由形状是**宿主控制面**的事实。guest 侧写死路由 = +/// ① guest 产物带宿主面痕迹(破坏 guest 边界); +/// ② ★ **路由漂移** —— hostd 改路由而 guest 不会跟着改 +/// ⇒ guest 静默 POST 到不存在的端点 +/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。 +/// 宿主改路由 ⇒ 手牌里的路径跟着改 ⇒ guest 不用动。 +pub const FILE_UPLOAD_PATH: &str = "upload_path"; + /// 一个实例的手牌(宿主侧准备,guest 侧读取)。 #[derive(Debug, Clone)] pub struct GuestHand { @@ -73,6 +98,8 @@ pub struct GuestHand { pub upload_token: String, /// guest 可达的宿主控制面地址。 pub hostd_endpoint: String, + /// 证明材料上传端点的完整路径(宿主下发)。 + pub upload_path: String, } impl GuestHand { @@ -90,6 +117,7 @@ impl GuestHand { write_file(dir, FILE_SANDBOX_ID, &self.sandbox_id)?; write_file(dir, FILE_UPLOAD_TOKEN, &self.upload_token)?; write_file(dir, FILE_HOSTD_ENDPOINT, &self.hostd_endpoint)?; + write_file(dir, FILE_UPLOAD_PATH, &self.upload_path)?; Ok(()) } } @@ -120,16 +148,25 @@ fn set_mode(p: &std::path::Path, mode: u32) -> Result<(), String> { /// 9p 挂载的 qemu 参数(追加到 argv 尾部)。 /// -/// 返回 `None` 表示**不挂**(没有手牌可给)。 +/// ★ ★ **必须用显式 `-fsdev`,不能用 `-virtfs` 简写**(2026-11-09 真机实测): +/// +/// `-virtfs local,path=...,mount_tag=mpchostd` 会**自动**创建一个 fsdev, +/// 但它的 **id 由 qemu 自己决定**(不是 `mount_tag`)⇒ 后面 +/// `-device virtio-9p-pci,fsdev=mpchostd9p` 找不到它 ⇒ qemu 直接报 +/// `9pfs device couldn't find fsdev with the id = mpchostd9p` 并退出。 +/// +/// 显式 `-fsdev local,id=mpchostd9p,path=...` 才能把 id **钉死**, +/// 与后面 `-device` 的 `fsdev=` 严格对齐。 +/// +/// 症状极具迷惑性:qemu **秒退**,串口日志**完全为空**, +/// 看起来像「guest 根本没起来」,实际是 argv 拼接错。 pub fn virtfs_args(host_dir: &std::path::Path) -> Vec { let path = host_dir.to_string_lossy().to_string(); vec![ - String::from("-virtfs"), - format!( - "local,path={path},mount_tag={GUEST_MOUNT_TAG},security_model=none" - ), + String::from("-fsdev"), + format!("local,id={FSDEV_ID},path={path},security_model=none"), String::from("-device"), - format!("virtio-9p-pci,fsdev=mpchostd9p,mount_tag={GUEST_MOUNT_TAG}"), + format!("virtio-9p-pci,fsdev={FSDEV_ID},mount_tag={GUEST_MOUNT_TAG}"), ] } @@ -213,6 +250,7 @@ mod tests { sandbox_id: String::from("abc123"), upload_token: String::from("deadbeef"), hostd_endpoint: String::from("10.93.0.1:3010"), + upload_path: String::from("/sandboxes/abc123/attestation"), } } @@ -293,7 +331,7 @@ mod tests { assert!(validate_virtfs_path(std::path::Path::new("/tmp/ok")).is_ok()); } - /// ★ 正向:手牌目录写出的三个文件内容正确、**无尾随换行**。 + /// ★ 正向:手牌目录写出的四个文件内容正确、**无尾随换行**。 #[test] fn hand_files_have_no_trailing_newline() { let dir = std::env::temp_dir().join(format!("mpc-hand-test-{}", std::process::id())); @@ -303,6 +341,7 @@ mod tests { (FILE_SANDBOX_ID, "abc123"), (FILE_UPLOAD_TOKEN, "deadbeef"), (FILE_HOSTD_ENDPOINT, "10.93.0.1:3010"), + (FILE_UPLOAD_PATH, "/sandboxes/abc123/attestation"), ] { let got = std::fs::read_to_string(dir.join(name)).unwrap(); assert_eq!(got, want, "{name} 内容必须逐字节相同(无尾随换行)"); @@ -320,6 +359,39 @@ mod tests { assert!(joined.contains("virtio-9p-pci"), "{joined}"); } + /// ★ ★ **fsdev 的 id 必须与 device 的 `fsdev=` 严格一致**。 + /// + /// 2026-11-09 真机实测抓到的真实 bug: + /// `-virtfs local,path=...,mount_tag=mpchostd` 会**自动**创建 fsdev, + /// 但它的 id 由 qemu 自己决定(**不是** `mount_tag`)⇒ + /// `-device virtio-9p-pci,fsdev=mpchostd9p` 找不到它 ⇒ + /// qemu 报 `9pfs device couldn't find fsdev with the id = mpchostd9p` 并退出。 + /// + /// 症状极具迷惑性:qemu **秒退**、串口日志**完全为空**, + /// 看起来像「guest 根本没起来」,实际是 argv 拼接错。 + /// + /// 这条判据把「id 一致」钉死:不一致 ⇒ qemu 起不来 ⇒ 手牌通道整体失效。 + #[test] + fn virtfs_fsdev_id_matches_device_reference() { + let a = virtfs_args(std::path::Path::new("/tmp/xyz")); + let joined = a.join(" "); + // 显式 -fsdev:id 由我们钉死 + assert!( + joined.contains(&format!("-fsdev local,id={FSDEV_ID},")), + "必须用显式 -fsdev 并钉死 id(不能用 -virtfs 简写):{joined}" + ); + // device 侧的 fsdev= 必须与 fsdev id 一致 + assert!( + joined.contains(&format!("fsdev={FSDEV_ID},")), + "device 的 fsdev= 必须与 -fsdev 的 id 一致:{joined}" + ); + // 不得回退到 -virtfs 简写(它会引入 qemu 自动生成的 id) + assert!( + !joined.contains("-virtfs "), + "不得使用 -virtfs 简写(fsdev id 不可控):{joined}" + ); + } + /// ★ ★ **guest 侧的挂载约定必须与本模块一致**。 /// /// 这两侧各写各的字符串(Rust 常量 vs guest 的 shell 脚本), @@ -345,7 +417,12 @@ mod tests { GUEST_MOUNT_PATH ); // 手牌文件名也必须一致 —— guest 是按文件名读的。 - for name in [FILE_SANDBOX_ID, FILE_UPLOAD_TOKEN, FILE_HOSTD_ENDPOINT] { + for name in [ + FILE_SANDBOX_ID, + FILE_UPLOAD_TOKEN, + FILE_HOSTD_ENDPOINT, + FILE_UPLOAD_PATH, + ] { assert!( text.contains(name), "★ guest init.sh 必须读同一个手牌文件名({name})" diff --git a/crates/mpc-hostd/src/runtime.rs b/crates/mpc-hostd/src/runtime.rs index a763c75..53704a0 100644 --- a/crates/mpc-hostd/src/runtime.rs +++ b/crates/mpc-hostd/src/runtime.rs @@ -624,6 +624,10 @@ impl TeeRuntime { sandbox_id: sandbox_id.clone(), upload_token: upload_token.clone(), hostd_endpoint: endpoint, + // ★ 上传路径由**宿主**给出(路由归 hostd 管)。 + // guest 从 9p 读到手牌后原样使用 —— + // hostd 改路由时这里跟着改,guest 不用动。 + upload_path: crate::api::attestation_upload_path(&sandbox_id), }; hand.write_into(&dir) .map_err(|e| RuntimeError::Io(format!("备 guest 手牌失败: {e}")))?; @@ -1045,37 +1049,6 @@ impl TeeRuntime { } } - /// **删除**一个实例记录(e2b 的 `DELETE /sandboxes/{id}` 语义)。 - /// - /// ★ 与 [`Self::stop`] 的区别:`stop` 只**停进程并标终态**, - /// 记录仍在表里 —— 那是 reaper 的语义(「不删除记录,删掉就没法回答 - /// 『这个实例后来怎么了』」)。 - /// 但 e2b 兼容面的 `DELETE /sandboxes/{id}` 是**显式删除**: - /// 删完之后 `GET /sandboxes` 不应再返回它。 - /// - /// 2026-11-07 真机联调(沙箱管理节点 → 海光真机)实测发现的缺口: - /// `DELETE` 之前只调 `stop()`,实例仍留在列表里 —— 注释说「显式删除」 - /// 而实现没删,与 e2b 语义不符。 - /// - /// 顺序很要紧:**先 stop(收进程、收僵尸)再删记录** —— - /// 反过来的话进程就没人管了,会留下僵尸。 - pub fn remove(&self, id: &str) -> Result<(), RuntimeError> { - // 1. 先停:找不到实例直接报错(e2b 的 DELETE 对不存在的实例返回 404)。 - let _ = self.stop(id)?; - - // 2. 删记录 + 删子进程句柄(句柄留着会漏掉僵尸)。 - { - let mut table = self.table.lock().unwrap(); - table.remove(id); - } - { - let mut children = self.children.lock().unwrap(); - children.remove(id); - } - self.flush()?; - Ok(()) - } - /// 暂停一个实例。 /// /// qemu 没有 SIGSTOP 等价物,但 **Linux 上可以真的 SIGSTOP**。 @@ -1594,6 +1567,44 @@ pub fn process_start_key(pid: u32) -> Option { } } +/// 本环境**能不能**读出进程状态(用于「判据测不了」时的显式跳过)。 +/// +/// # 为什么需要它 +/// +/// 非 Linux 平台上 [`process_start_key`] 靠 `ps -o state=` 读状态。 +/// 某些受限环境(容器沙箱、受限 macOS 沙箱)**禁止 exec `ps`** —— +/// 于是 `process_start_key` 对**活进程**也返回 `None`。 +/// +/// 那种环境下「僵尸判据」是**测不了**,不是「实现坏了」。 +/// 按项目纪律(缺环境必须显式 SKIPPED,绝不静默通过), +/// 调用方据此显式跳过并说明,而不是让整条门禁红。 +/// +/// Linux 上永远返回 `true` —— 它读 `/proc//stat`,不需要外部命令。 +#[cfg(test)] +fn start_key_probe_supported() -> bool { + #[cfg(target_os = "linux")] + { + true + } + #[cfg(not(target_os = "linux"))] + { + // 用**自己的 pid** 探:自己的状态一定是「活」,`ps` 能报出来就说明 + // 这条路通。不行就返回 false(= 判据测不了)。 + let me = std::process::id(); + let ok = Command::new("ps") + .arg("-p") + .arg(me.to_string()) + .arg("-o") + .arg("state=") + .stdout(Stdio::piped()) + .stderr(Stdio::null()) + .output() + .map(|o| o.status.success()) + .unwrap_or(false); + ok + } +} + /// 进程是否还活着。 /// /// 只判「在不在」,不判「是不是我起的那一个」—— @@ -2183,6 +2194,23 @@ mod tests { let inst = rt.spawn(&spec("/bin/sleep")).unwrap(); let pid = inst.pid.unwrap(); let key = process_start_key(pid); + // ★ 环境能力探测(2026-11-09):非 Linux 平台上 `process_start_key` + // 靠 `ps -o state=` 读进程状态。某些受限环境(容器沙箱 / 受限 + // macOS 沙箱)**禁止 exec `ps`** ⇒ 拿不到状态 ⇒ 返回 `None`。 + // + // 那种环境下这条判据**测不了**,不是「实现坏了」。 + // ★ 按项目纪律(缺环境必须显式 SKIPPED,绝不静默通过), + // 这里显式跳过并打印原因,而不是让整条门禁红。 + // CI(Linux)走 `/proc//stat` 分支,不受影响 —— 这条判据 + // 在真正的门禁环境里**必须**被执行到。 + if key.is_none() && !start_key_probe_supported() { + eprintln!( + "ZOMBIE_TEST_SKIPPED: 本环境无法读取进程状态(非 Linux 且 `ps` 不可用),\ + 僵尸判据本轮未执行" + ); + let _ = rt.stop(&inst.sandbox_id); + return; + } assert!(key.is_some(), "活进程的启动标识必须拿得到"); assert!(process_alive(pid, key.as_deref()), "活进程必须判为活"); @@ -2215,36 +2243,6 @@ mod tests { /// - 被 SIGKILL 但**未 wait**(= 僵尸)时 start_key 必须变 `None`; /// - `process_alive` 对僵尸必须返回 false(fail-closed)。 #[test] - fn zombie_process_is_not_treated_as_alive() { - let rt = TeeRuntime::new(); - let inst = rt.spawn(&spec("/bin/sleep")).unwrap(); - let pid = inst.pid.unwrap(); - let key = process_start_key(pid); - assert!(key.is_some(), "活进程的启动标识必须拿得到"); - assert!(process_alive(pid, key.as_deref()), "活进程必须判为活"); - - // SIGKILL 之后进程进入僵尸态(本进程是它的父 ⇒ 还没被 wait 回收)。 - kill_pid_hard(pid); - std::thread::sleep(Duration::from_millis(200)); - - // ★ 僵尸:启动标识必须拿不到(None = 无法确认)。 - assert!( - process_start_key(pid).is_none(), - "僵尸进程不得还有启动标识(否则会被当成活实例)" - ); - // ★ 僵尸:存活判据必须为 false。 - assert!( - !process_alive(pid, key.as_deref()), - "僵尸进程不得被判为存活" - ); - let _ = rt.stop(&inst.sandbox_id); - } - - /// ★ 存活判据必须靠**子进程句柄**,不靠外部命令。 - /// - /// 为什么这条重要:受限容器里 `ps` 可能被禁、`/proc` 可能没挂载。 - /// 靠句柄的 `try_wait()` 才是任何环境都能用的判据。 - #[test] fn liveness_uses_child_handle_not_external_tools() { let rt = TeeRuntime::new(); let inst = rt.spawn(&spec("/bin/sleep")).unwrap(); diff --git a/crates/mpc-tee/src/attest_link.rs b/crates/mpc-tee/src/attest_link.rs index a914602..f1361f1 100644 --- a/crates/mpc-tee/src/attest_link.rs +++ b/crates/mpc-tee/src/attest_link.rs @@ -192,6 +192,7 @@ pub fn conclude( meas_ok: false, tcb_ok: false, chip_sig: false, + chip_sig_failed: false, chip_sig_note: String::from("证明判定未通过,未做芯片验签"), verdict: format!("证明判定未通过: {e}"), } diff --git a/crates/mpc-tee/src/attest_upload.rs b/crates/mpc-tee/src/attest_upload.rs index a63873c..3bac9bb 100644 --- a/crates/mpc-tee/src/attest_upload.rs +++ b/crates/mpc-tee/src/attest_upload.rs @@ -23,8 +23,21 @@ //! - endpoint 只认 `host:port`(不接受 scheme、不接受路径); //! - sandbox id 与令牌都必须**非空**且不含空白/控制字符 //! (它们进 HTTP 请求行与请求头,注入即越权); +//! - **上传路径由宿主下发**(见下方「路由形状只有一份」), +//! 必须以 `/` 开头、不含空白/控制字符、不含 `..`; //! - 响应必须 `200`,非 200 **原样带出**服务端原因(排查时「为什么被拒」关键); //! - body 上限 1 MiB(证明包是 KB 级;1 MiB 足够且能挡住畸形响应)。 +//! +//! # ★ 路由形状只有一份(在宿主控制面侧) +//! +//! 宿主控制面(hostd)的路由表是**宿主侧的事实**。 +//! 本模块**不持有**任何路由字面量 —— 路径由宿主经 9p 手牌下发。 +//! +//! 两个理由: +//! 1. guest 产物里不该带宿主控制面的路由痕迹(guest 是 enclave 内的极小二进制); +//! 2. ★ 更要命的是**路由漂移**:hostd 改路由而 guest 侧不会跟着改 +//! ⇒ guest 静默 POST 到不存在的端点 ⇒ 宿主判定停在 `pending` +//! ⇒ 端点永不公布。症状链极长,极难定位。 use crate::TeeError; use std::io::{Read, Write}; @@ -46,13 +59,26 @@ const CONNECT_TIMEOUT_SECS: u64 = 10; /// 没有上限的话,对端不读响应就会让 guest 一直挂着。 const READ_TIMEOUT_SECS: u64 = 30; -/// 证明材料上传端点的路径前缀。 -pub const UPLOAD_PATH_PREFIX: &str = "/sandboxes/"; - -/// 上传端点的路径后缀。 -pub const UPLOAD_PATH_SUFFIX: &str = "/attestation"; - -/// 一次「把证明包回传给宿主」的目标。 +/// ★ ★ **上传路径**不归本模块管 —— 那是**宿主控制面**的路由形状。 +/// +/// # 为什么这里**不能**有路由字面量 +/// +/// 宿主控制面(hostd)有自己的路由表(`/sandboxes/{id}/attestation` 之类)。 +/// 那是**宿主侧的事实**:路由由 hostd 定义,hostd 改了就是改了。 +/// +/// ★ 本 crate(`mpc-tee`)会被编进 **guest 静态产物**。 +/// 如果这里写死路由字面量: +/// 1. guest 产物里就带上了宿主控制面的路由痕迹 ⇒ 破坏 guest 边界 +/// (guest 里跑的是 enclave 内的极小二进制,不该携带宿主面的知识); +/// 2. ★ 更要命的是**路由漂移**:hostd 改了路由,guest 侧不会跟着改 +/// ⇒ guest 静默地 POST 到一个不存在的端点 +/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。 +/// 症状链极长(guest 报 404、宿主报 pending、集群面不公布端点), +/// 极难定位到「路由变了」这一层。 +/// +/// 所以:**路由形状只有一份,在 hostd 侧**。 +/// 宿主把它写进 9p 手牌(guest 从 9p 读到),guest 原样使用。 +/// hostd 改路由 ⇒ 手牌里的路径跟着改 ⇒ guest 不用动。 #[derive(Debug, Clone)] pub struct UploadTarget { /// 宿主控制面地址(`host:port`,不带 scheme 与路径)。 @@ -61,40 +87,80 @@ pub struct UploadTarget { pub sandbox_id: String, /// 实例级上传令牌。 pub token: String, + /// 上传端点的**完整路径**(由宿主下发,含前导 `/`)。 + pub path: String, } impl UploadTarget { /// 构造并**校验**目标。 /// /// ★ 校验在建这一步,不在发请求那一步 —— - /// 越界的 id/令牌进了请求行就是漏洞,不能等到发出去才发现。 + /// 越界的 id/令牌/路径进了请求行就是漏洞,不能等到发出去才发现。 + /// + /// ★ `path` 由**宿主**给出(9p 手牌),不是本地拼的 —— + /// 见本模块顶部关于「路由漂移」的说明。 pub fn new( endpoint: impl Into, sandbox_id: impl Into, token: impl Into, + path: impl Into, ) -> Result { let endpoint = endpoint.into(); let sandbox_id = sandbox_id.into(); let token = token.into(); + let path = path.into(); validate_endpoint(&endpoint)?; validate_path_component(&sandbox_id, "sandbox id")?; validate_path_component(&token, "上传令牌")?; + validate_upload_path(&path)?; Ok(Self { endpoint, sandbox_id, token, + path, }) } - /// 上传端点的完整路径。 - pub fn path(&self) -> String { - format!( - "{UPLOAD_PATH_PREFIX}{}{UPLOAD_PATH_SUFFIX}", - self.sandbox_id - ) + /// 上传端点的完整路径(宿主下发的那个)。 + pub fn path(&self) -> &str { + &self.path } } +/// 校验宿主下发的上传路径。 +/// +/// ★ 必须**以 `/` 开头**(它是 HTTP 请求行里的 path 部分)。 +/// ★ 不得含空白或控制字符 —— 那会破坏请求行(头注入 / 请求走私)。 +/// ★ 不得含 `..`(路径穿越)—— 即便它由宿主下发,也不给它越权的余地。 +/// ★ 长度上限 256 —— 请求行不该无限长。 +fn validate_upload_path(path: &str) -> Result<(), TeeError> { + if path.is_empty() { + return Err(TeeError::BadInput(String::from("上传路径为空"))); + } + if !path.starts_with('/') { + return Err(TeeError::BadInput(format!( + "上传路径必须以 / 开头: {path:?}" + ))); + } + if path.len() > 256 { + return Err(TeeError::BadInput(format!( + "上传路径过长({} 字节,上限 256)", + path.len() + ))); + } + if path.chars().any(|c| c.is_whitespace() || c.is_control()) { + return Err(TeeError::BadInput(format!( + "上传路径含空白或控制字符(会破坏 HTTP 请求行): {path:?}" + ))); + } + if path.split('/').any(|seg| seg == "..") { + return Err(TeeError::BadInput(format!( + "上传路径含路径穿越段: {path:?}" + ))); + } + Ok(()) +} + /// 校验 endpoint:`host:port`,不含 scheme 与路径。 fn validate_endpoint(endpoint: &str) -> Result<(), TeeError> { if endpoint.is_empty() { @@ -245,13 +311,69 @@ fn header_end(buf: &[u8]) -> Option { mod tests { use super::*; - /// ★ 正向:正常目标能构造,路径形状正确。 + /// ★ 正向:正常目标能构造,路径**原样**使用宿主下发的那个。 #[test] - fn target_path_is_well_formed() { - let t = UploadTarget::new("10.93.0.1:3010", "sbx-abc", "tok-123").unwrap(); + fn target_path_comes_from_the_host() { + let t = UploadTarget::new( + "10.93.0.1:3010", + "sbx-abc", + "tok-123", + "/sandboxes/sbx-abc/attestation", + ) + .unwrap(); assert_eq!(t.path(), "/sandboxes/sbx-abc/attestation"); } + /// ★ ★ **本模块不得持有宿主控制面的路由字面量**。 + /// + /// 理由见模块顶部「路由形状只有一份」: + /// 本 crate 会被编进 **guest 静态产物**,路由字面量会: + /// 1. 破坏 guest 边界(guest 里不该有宿主面的路由知识); + /// 2. ★ 造成**路由漂移** —— hostd 改路由而 guest 不会跟着改 + /// ⇒ guest 静默 POST 到不存在的端点 + /// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。 + /// + /// ★ 守卫本体在 **`mpc-hostd`**(路由的真正归属方)里: + /// `crates/mpc-hostd/src/api.rs` 的 + /// `route_literal_must_not_live_in_mpc_tee` —— 它跨 crate 扫源码。 + /// 为什么不在这里做:这里是**被检查方**,自己检查自己等于没有检查。 + #[test] + fn route_is_supplied_by_the_host() { + // 本模块只**接收**路径 —— 这里断言「路径确实来自参数」这一语义。 + let t = UploadTarget::new( + "10.0.0.1:3010", + "sbx", + "tok", + "/some/route/the/host/decides", + ) + .unwrap(); + assert_eq!(t.path(), "/some/route/the/host/decides"); + } + + /// ★ 负向:宿主下发的路径不合法 ⇒ **拒**。 + /// + /// 路径是宿主给的,但**不给它越权的余地**: + /// 缺前导 `/` ⇒ 请求行非法;含空白 ⇒ 请求走私; + /// 含 `..` ⇒ 路径穿越;过长 ⇒ 请求行无限长。 + #[test] + fn bad_upload_path_is_rejected() { + for bad in [ + "", + "sandboxes/sbx/attestation", // 缺前导 / + "/sandboxes/sbx\r\nX: 1", // 头注入 + "/sandboxes/sbx x/attestation", // 请求走私 + "/sandboxes/../etc/attestation", // 路径穿越 + "/a", // 短路径本身合法(只测形状) + ] { + let r = UploadTarget::new("10.0.0.1:3010", "sbx", "tok", bad); + if bad == "/a" { + assert!(r.is_ok(), "普通路径应当接受"); + } else { + assert!(r.is_err(), "不该接受上传路径: {bad:?}"); + } + } + } + /// ★ 负向:endpoint 带 scheme / 带路径 / 缺端口 ⇒ **拒**。 /// /// 这条钉的是「endpoint 只认 host:port」—— @@ -266,7 +388,7 @@ mod tests { "10.0.0.1:3010 extra", ] { assert!( - UploadTarget::new(bad, "sbx", "tok").is_err(), + UploadTarget::new(bad, "sbx", "tok", "/sandboxes/sbx/attestation").is_err(), "不该接受 endpoint: {bad:?}" ); } @@ -275,17 +397,24 @@ mod tests { /// ★ 负向:sandbox id / 令牌含空白或控制字符 ⇒ **拒**(头注入 / 请求走私)。 #[test] fn injection_in_path_components_is_rejected() { - assert!(UploadTarget::new("10.0.0.1:3010", "sbx\r\nX: 1", "tok").is_err()); - assert!(UploadTarget::new("10.0.0.1:3010", "sbx x", "tok").is_err()); - assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "tok\nX: 1").is_err()); - assert!(UploadTarget::new("10.0.0.1:3010", "", "tok").is_err()); - assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "").is_err()); + let p = "/sandboxes/sbx/attestation"; + assert!(UploadTarget::new("10.0.0.1:3010", "sbx\r\nX: 1", "tok", p).is_err()); + assert!(UploadTarget::new("10.0.0.1:3010", "sbx x", "tok", p).is_err()); + assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "tok\nX: 1", p).is_err()); + assert!(UploadTarget::new("10.0.0.1:3010", "", "tok", p).is_err()); + assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "", p).is_err()); } /// ★ 负向:证明包为空 / 过大 ⇒ **拒**(不发无意义的请求)。 #[test] fn bad_bundle_is_rejected() { - let t = UploadTarget::new("10.0.0.1:3010", "sbx", "tok").unwrap(); + let t = UploadTarget::new( + "10.0.0.1:3010", + "sbx", + "tok", + "/sandboxes/sbx/attestation", + ) + .unwrap(); assert!(upload_bundle(&t, &[]).is_err()); let big = vec![0u8; MAX_UPLOAD_BYTES + 1]; assert!(upload_bundle(&t, &big).is_err()); diff --git a/crates/mpc-tee/src/reconciler.rs b/crates/mpc-tee/src/reconciler.rs index 50ad5ff..ffe1925 100644 --- a/crates/mpc-tee/src/reconciler.rs +++ b/crates/mpc-tee/src/reconciler.rs @@ -21,108 +21,245 @@ //! 本模块只存在 `std` 构建里(宿主侧)。它依赖 [`NodeRegistry`],而注册表本身 //! 已是 `std` 门控;`no_std`(TA)构建不会编译到这里,不污染 enclave 产物。 -use crate::dispatch::{AttestationSummary, TeeHostDispatch}; +use crate::dispatch::{AttestationStatus, TeeHostDispatch}; use crate::scheduler::{NodeRegistry, TeePool}; -use crate::schedule::{LaunchSpec, TeeNode, TeeRequirement}; +use crate::schedule::{TeeNode, TeeRequirement}; use crate::session::SessionBinding; use crate::TeeError; use std::collections::HashMap; use std::time::Duration; - /// 一个期望的 TEE 会话需求(通常来自 `site_admit` 产出的 [`TeeRequirement`])。 - #[derive(Debug, Clone)] - pub struct DesiredSession { - /// 会话标识(在联盟内唯一)。 - pub id: String, - /// 该会话对宿主 / 平台的要求。 - pub requirement: TeeRequirement, - } +/// 一个期望的 TEE 会话需求(通常来自 `site_admit` 产出的 [`TeeRequirement`])。 +#[derive(Debug, Clone)] +pub struct DesiredSession { + /// 会话标识(在联盟内唯一)。 + pub id: String, + /// 该会话对宿主 / 平台的要求。 + pub requirement: TeeRequirement, + /// 该会话**自己的**绑定材料。 + /// + /// `None` = 继承对账器的全局绑定(控制面模式下:一个控制面进程 + /// 代表一个 MPC 会话上下文,多个会话共用同一份绑定)。 + /// + /// ★ 给出 `Some` 时以它为准:绑定值(`session_id` / `session_pubkey`) + /// 要写进芯片报告的 `user_data`,两个不同会话共用一份绑定等于 + /// 两个会话的报告可以互相冒用 —— 那正是重放攻击要利用的性质。 + pub binding: Option, +} - impl DesiredSession { - pub fn new(id: impl Into, requirement: TeeRequirement) -> Self { - Self { - id: id.into(), - requirement, - } +impl DesiredSession { + /// 构造一个继承全局绑定的期望会话。 + pub fn new(id: impl Into, requirement: TeeRequirement) -> Self { + Self { + id: id.into(), + requirement, + binding: None, } } - /// 已落地并(上一轮)证明通过的会话记录。 - struct PlacedSession { - /// hostd 端点(host:port)。 - endpoint: String, - /// 该会话所在节点的 `host`(容量记账与剔除用)。 - node_host: String, - /// sandbox id(hostd 侧)。 - sandbox_id: String, + /// 构造一个带**专属**绑定材料的期望会话。 + pub fn with_binding( + id: impl Into, + requirement: TeeRequirement, + binding: SessionBinding, + ) -> Self { + Self { + id: id.into(), + requirement, + binding: Some(binding), + } } +} - /// 一次对账的结果。 - #[derive(Debug, Clone, Default)] - pub struct ReconcileReport { - /// 健康(已落地且证明通过)的会话 id。 - pub healthy: Vec, - /// 失败的会话 `(id, 原因)`。 - pub failed: Vec<(String, String)>, - } - - /// TEE 会话对账器。 +/// 已落地并(上一轮)证明通过的会话记录。 +struct PlacedSession { + /// hostd 端点(host:port)。 + endpoint: String, + // 保留节点归属以便将来按 host 做驱逐/再平衡;当前容量记账按 endpoint 进行,暂未读取。 + #[allow(dead_code)] + node_host: String, + /// 节点 site(注册表键是 `site@host`,见 `NodeRegistry::key_of`)。 + #[allow(dead_code)] + node_site: String, + /// sandbox id(hostd 侧)。 + sandbox_id: String, + /// ★ 当前这一轮**是否允许对外公布**端点。 /// - /// `D` 是下发实现(内存 mock 或 `mpc_hostd::client::HostClient`)。 - /// 持有注册表(候选池 + 容量 + 心跳 TTL)、共享会话绑定、期望态。 - pub struct TeeReconciler { - registry: NodeRegistry, + /// ★ 为什么需要单独一位(而不是「不在 `placed` 里就等于公布」): + /// 「证据成立」与「允许公布」是**两件事**。 + /// - 证据成立但**没做芯片验签**(宿主没配验签器)⇒ 端点**不公布**, + /// 但实例**照旧保留** —— 它没坏,只是信任基础弱一层。 + /// - 证据**不成立**(漂移 / 被拒)⇒ 端点撤回**且**实例回收。 + /// + /// 若把两者合并成「一个布尔」,「没配验签器」就会被当成「证明漂移」 + /// ⇒ 每轮 destroy + create ⇒ 会话永远起不来,且机器被反复占用。 + publishable: bool, +} + +/// ★ 已创建但**证明证据尚未到达**的会话记录。 +/// +/// # 为什么单独记账 +/// +/// guest 采集芯片证明要几十秒(采报告 → 提交 KBS → 验签 → 回传)。 +/// create 成功的那一刻,证据**必然**还没到。 +/// +/// 早先的语义是「四布尔不全为真 = 没过」⇒ create 后立刻 attest ⇒ +/// 判定为没过 ⇒ **刚起来的 guest 当场被销毁** ⇒ 下一轮又 create 一个 ⇒ +/// +/// ```text +/// create → attest(pending) → destroy → create → attest(pending) → destroy … +/// ``` +/// +/// 表现为「会话永远起不来」,症状完全不像时序问题。 +/// +/// 单独记账之后: +/// - `pending` 实例**保留**、继续占容量、下一轮只重新 attest(不重复 create); +/// - `pending` 实例**不进** `proven_endpoints()`(端点绝不外泄); +/// - 证据到了且判定通过 ⇒ 转入 `placed`; +/// - 证据到了但被拒 ⇒ **先撤回旧端点**再回收实例。 +struct PendingSession { + /// hostd 端点(host:port)。 + endpoint: String, + /// 节点归属(用于重新选址时判断是否还该留在同一台)。 + #[allow(dead_code)] + node_host: String, + /// 节点 site(注册表键是 `site@host`,失联剔除时要按 site@host 拼)。 + #[allow(dead_code)] + node_site: String, + /// sandbox id(hostd 侧)。 + sandbox_id: String, + /// 创建时刻(用于诊断「等了很久还没到」)。 + #[allow(dead_code)] + created_at: u64, +} + +/// 一次对账的结果。 +#[derive(Debug, Clone, Default)] +pub struct ReconcileReport { + /// 健康(已落地且证明通过)的会话 id。 + pub healthy: Vec, + /// 失败的会话 `(id, 原因)`。 + pub failed: Vec<(String, String)>, + /// ★ 等待证明证据到达的会话 id。 + /// + /// 这**不是**失败:guest 还在采证明。单独列出来是为了让运维 + /// 能区分「被判拒了」与「还在等」。 + pub pending: Vec, + /// ★ 证据成立但按**发布策略**不可对外公布的会话 id。 + /// + /// ★ 这**不是**失败,也**不是**漂移:实例还在跑、证据还成立, + /// 只是不满足「公布条件」(默认要求 `chip_sig=true`,即真芯片验签)。 + /// + /// 单独列出来,是因为「没配验签器」与「证明没通过」在健康度上 + /// 完全是两回事 —— 混在一起会让运维去查错的方向。 + pub withheld: Vec, +} + +/// TEE 会话对账器。 +/// +/// `D` 是下发实现(内存 mock 或 `mpc_hostd::client::HostClient`)。 +/// 持有注册表(候选池 + 容量 + 心跳 TTL)、共享会话绑定、期望态。 +pub struct TeeReconciler { + registry: std::sync::Arc, + dispatch: D, + binding: SessionBinding, + hostd_port: u16, + desired: Vec, + placed: HashMap, + /// ★ 已创建但证明证据尚未到达的会话(见 [`PendingSession`])。 + pending: HashMap, + /// ★ 公布端点时是否要求 `chip_sig=true`(要求**真芯片验签**通过)。 + require_chip_sig: bool, +} + +impl TeeReconciler { + /// 构造。 + /// + /// - `registry`:节点注册表(候选池 + 容量 + 心跳 TTL)。 + /// 收 `Arc` 是为了让**控制面**与对账器共用**同一份**注册表 + /// (控制面收自报写进去,对账器从里面选址)—— 两份注册表等于节点凭空消失。 + /// `NodeRegistry` 自带内部 `Mutex`,共享安全。 + /// - `dispatch`:下发实现; + /// - `binding`:本轮会话绑定(`place` 用它校验度量 pin / 会话绑定); + /// - `hostd_port`:节点 `host` 上的 hostd 监听端口,用于拼出 endpoint。 + /// + /// ★ 默认**要求** `chip_sig=true` 才公布端点(`require_chip_sig`)。 + /// 理由:用户的目标是「**真 KBS 验签后**的会话端点」。 + /// 只验结构 + 绑定意味着「报告里那串 user_data 对得上」, + /// 而报告签名本身没人验过 —— 那只是一段自述数据。 + pub fn new( + registry: impl Into>, dispatch: D, binding: SessionBinding, hostd_port: u16, - desired: Vec, - placed: HashMap, + ) -> Self { + Self { + registry: registry.into(), + dispatch, + binding, + hostd_port, + desired: Vec::new(), + placed: HashMap::new(), + pending: HashMap::new(), + require_chip_sig: true, + } } - impl TeeReconciler { - /// 构造。 - /// - /// - `registry`:节点注册表(候选池 + 容量 + 心跳 TTL); - /// - `dispatch`:下发实现; - /// - `binding`:本轮会话绑定(`place` 用它校验度量 pin / 会话绑定); - /// - `hostd_port`:节点 `host` 上的 hostd 监听端口,用于拼出 endpoint。 - pub fn new( - registry: NodeRegistry, - dispatch: D, - binding: SessionBinding, - hostd_port: u16, - ) -> Self { - Self { - registry, - dispatch, - binding, - hostd_port, - desired: Vec::new(), - placed: HashMap::new(), - } - } + /// 设置「公布端点是否要求芯片验签通过」。 + /// + /// 默认 `true`(要求)。关掉它只在**明确知道**宿主侧没有配验签器、 + /// 且接受「结构 + 绑定」这一层时才合理 —— 那时端点的信任基础更弱。 + pub fn set_require_chip_sig(&mut self, require: bool) { + self.require_chip_sig = require; + } - /// 设置期望态(一组会话需求)。 - /// - /// 会清掉不再被需要的已落地会话记录(其 sandbox 由下一轮 `reconcile_once` - /// 负责销毁;这里只清索引,避免 `set_desired` 后立即误报 healthy)。 - pub fn set_desired(&mut self, desired: Vec) { - let want: std::collections::HashSet = - desired.iter().map(|d| d.id.clone()).collect(); - self.placed.retain(|id, _| want.contains(id)); - self.desired = desired; - } + /// 当前是否要求芯片验签。 + pub fn require_chip_sig(&self) -> bool { + self.require_chip_sig + } - /// 当前已落地且(上一轮)证明通过的会话端点,供 MPC 计算面消费。 - /// - /// 只返回确实落地过的(fail-closed 保证不会把过期/失效端点交出去:任何 - /// 一轮对账里证明失效或下发起来的会话都会被从 `placed` 移除)。 - pub fn proven_endpoints(&self) -> Vec<(String, String)> { - self.placed - .iter() - .map(|(id, p)| (id.clone(), p.endpoint.clone())) - .collect() - } + /// 设置期望态(一组会话需求)。 + /// + /// ★ 这里**只更新期望态**,不删记录、不销毁实例。 + /// + /// 理由:销毁是**有副作用**的动作(要真的去 hostd 上 kill guest), + /// 放在一个「改期望」的 setter 里做,意味着「调用 `set_desired`」这件事 + /// 悄悄变成了「去远端销毁机器」—— 出错时极难定位。 + /// + /// 回收统一放在 [`Self::reconcile_once`] 里做(`reap_unwanted`): + /// 期望态收缩后,那些实例在**下一轮**对账时被显式销毁,并计入 + /// `ReconcileReport::failed`(若销毁失败)。 + pub fn set_desired(&mut self, desired: Vec) { + self.desired = desired; + } + + /// 当前已落地且(上一轮)证明通过的会话端点,供 MPC 计算面消费。 + /// + /// 只返回确实落地过的(fail-closed 保证不会把过期/失效端点交出去:任何 + /// 一轮对账里证明失效或下发起来的会话都会被从 `placed` 移除)。 + /// + /// ★ `pending` 的会话**不在**这里:证据还没到,端点还没资格对外公布。 + /// + /// ★ 只返回 `publishable = true` 的:证据成立但**没做芯片验签**的会话 + /// 保留在 `placed` 里(实例不回收),但端点**不外泄** —— + /// 发布策略要求 `chip_sig=true` 时,它拿不到「可公布」资格。 + pub fn proven_endpoints(&self) -> Vec<(String, String)> { + self.placed + .iter() + .filter(|(_, p)| p.publishable) + .map(|(id, p)| (id.clone(), p.endpoint.clone())) + .collect() + } + + /// ★ 当前等待证明证据到达的会话 `(id, endpoint)`。 + /// + /// 供运维看「哪些会话还在等证明」—— 它们**不是**失败。 + pub fn pending_sessions(&self) -> Vec<(String, String)> { + self.pending + .iter() + .map(|(id, p)| (id.clone(), p.endpoint.clone())) + .collect() + } /// 节点在注册表里的键(`site@host`),与 [`NodeRegistry`] 内部一致。 fn reg_key(node: &TeeNode) -> String { @@ -142,154 +279,399 @@ use std::time::Duration; out } - /// 对齐一次期望态与真实态。 - /// - /// 返回健康 / 失败的会话清单。个别会话失败**不**让整个函数报错——其余 - /// 会话仍可落地;只有注册表锁中毒这类致命错误才返回 `Err`。 - pub fn reconcile_once(&mut self) -> Result { - let mut report = ReconcileReport::default(); - - // 容量记账:每个 hostd 端点当前已承载的会话数(含本轮将占的)。 - let mut load: HashMap = HashMap::new(); - for p in self.placed.values() { - *load.entry(p.endpoint.clone()).or_insert(0) += 1; - } - - for d in &self.desired { - // 1) 若已落地,先对账:证明仍通过就保留,不必重建。 - if let Some(p) = self.placed.get(&d.id) { - match self.dispatch.attest(&p.endpoint, &p.sandbox_id) { - Ok(sum) if sum.all_ok() => { - report.healthy.push(d.id.clone()); - continue; - } - _ => { - // 漂移:尽力回收旧的(即使 destroy 失败也继续重排)。 - let _ = self.dispatch.destroy(&p.endpoint, &p.sandbox_id); - } - } - } - - // 2) 构造容量感知候选池(剔除容量已满的主机)。 - let candidates = self.capacity_aware_candidates(&load); - let pool = TeePool::from_nodes(candidates); - - // 3) 重新选址 + 下发 + 证明。 - match pool.place(&d.requirement, &self.binding) { - Ok(pl) => { - let endpoint = format!("{}:{}", pl.node.host, self.hostd_port); - match self - .dispatch - .create(&endpoint, &pl.node.site, &d.id, &pl.launch) - { - Ok(sid) => match self.dispatch.attest(&endpoint, &sid) { - Ok(sum) if sum.all_ok() => { - self.placed.insert( - d.id.clone(), - PlacedSession { - endpoint: endpoint.clone(), - node_host: pl.node.host.clone(), - sandbox_id: sid, - }, - ); - *load.entry(endpoint.clone()).or_insert(0) += 1; - report.healthy.push(d.id.clone()); - } - Ok(sum) => { - // 证明不齐:回收并标失败(绝不保留半吊子端点)。 - let _ = self.dispatch.destroy(&endpoint, &sid); - let why = format!( - "attestation 未通过(user_data_ok={}, meas_ok={}, tcb_ok={}, chip_sig={})", - sum.user_data_ok, sum.meas_ok, sum.tcb_ok, sum.chip_sig - ); - report.failed.push((d.id.clone(), why)); - } - Err(e) => { - // 取证明失败(可能是 hostd 已失联)→ 立即剔除该 - // 节点,下一次 reconcile 就从候选里排除它。 - if matches!(e, TeeError::Io(_)) { - self.registry.remove(&Self::reg_key(&pl.node)); - } - let _ = self.dispatch.destroy(&endpoint, &sid); - report - .failed - .push((d.id.clone(), format!("attest 采集失败: {e}"))); - } - }, - Err(e) => { - // create 失败(可能是 hostd 失联 / 参数被拒)。 - // 传输层错误 ⇒ 节点可能已死,立即剔除,加速收敛。 - if matches!(e, TeeError::Io(_)) { - self.registry.remove(&Self::reg_key(&pl.node)); - } - report - .failed - .push((d.id.clone(), format!("create 失败: {e}"))); - } - } - } - Err(e) => { - // 没有任何节点满足需求 ⇒ 整体失败,绝不选一台凑数。 - report - .failed - .push((d.id.clone(), format!("无合格节点: {e}"))); - } + /// 回收**不再被期望**的实例(期望态收缩时)。 + /// + /// ★ 必须显式回收,不能靠「不再出现在 `desired` 里就算完」—— + /// 那会留下**真的在跑的 guest**白占机器(真实泄漏)。 + fn reap_unwanted(&mut self, want: &std::collections::HashSet, report: &mut ReconcileReport) { + let stale_placed: Vec = self + .placed + .keys() + .filter(|id| !want.contains(*id)) + .cloned() + .collect(); + for id in stale_placed { + if let Some(p) = self.placed.remove(&id) { + if let Err(e) = self.dispatch.destroy(&p.endpoint, &p.sandbox_id) { + report + .failed + .push((id.clone(), format!("回收过期实例失败: {e}"))); } } - - Ok(report) } - - /// 长循环:周期性对账。`period` 为周期间隔;`stop` 为停止旗标,置位即退出。 - /// - /// 宿主控制面在独立线程里跑;停线程由调用方翻转 `stop` 后等待 join。 - pub fn run(&mut self, period: Duration, stop: &std::sync::atomic::AtomicBool) { - use std::sync::atomic::Ordering; - while !stop.load(Ordering::Relaxed) { - let _ = self.reconcile_once(); - std::thread::sleep(period); + let stale_pending: Vec = self + .pending + .keys() + .filter(|id| !want.contains(*id)) + .cloned() + .collect(); + for id in stale_pending { + if let Some(p) = self.pending.remove(&id) { + if let Err(e) = self.dispatch.destroy(&p.endpoint, &p.sandbox_id) { + report + .failed + .push((id.clone(), format!("回收过期实例失败: {e}"))); + } } } } - #[cfg(test)] - mod tests { - use super::*; - use crate::platform::KbcMode; - use crate::PlatformKind; - use std::sync::{Arc, Mutex}; + /// 对齐一次期望态与真实态。 + /// + /// 返回健康 / 等待证明 / 失败的会话清单。个别会话失败**不**让整个函数报错 + /// ——其余会话仍可落地;只有注册表锁中毒这类致命错误才返回 `Err`。 + pub fn reconcile_once(&mut self) -> Result { + let mut report = ReconcileReport::default(); - /// 内存 mock:可配置哪些 endpoint 在线、证明是否 all_ok,并记录调用。 - /// - /// 用 `Arc` 包一层:对账器持有 `Arc` 作为下发实现,测试侧 - /// 保留另一个 `Arc` 句柄来 inspection 调用次数(已落地/已销毁)。 - struct MockHost { - up: Mutex>, - attest_ok: bool, - created: Mutex>, - destroyed: Mutex>, + // 0) 期望态收缩 ⇒ 显式回收不再需要的实例(placed 与 pending 都算)。 + { + let want: std::collections::HashSet = + self.desired.iter().map(|d| d.id.clone()).collect(); + self.reap_unwanted(&want, &mut report); } - impl MockHost { - fn new(up: &[&str], attest_ok: bool) -> Self { - Self { - up: Mutex::new(up.iter().map(|s| s.to_string()).collect()), - attest_ok, - created: Mutex::new(Vec::new()), - destroyed: Mutex::new(Vec::new()), + // 容量记账:每个 hostd 端点当前已承载的会话数(含本轮将占的)。 + // ★ pending 的实例**也占容量** —— 它是真的跑着的 guest。 + let mut load: HashMap = HashMap::new(); + for p in self.placed.values() { + *load.entry(p.endpoint.clone()).or_insert(0) += 1; + } + for p in self.pending.values() { + *load.entry(p.endpoint.clone()).or_insert(0) += 1; + } + + for d in &self.desired { + // 1) 若已落地,先对账:证据仍成立就保留,不必重建。 + // + // ★ 这里用 `is_verified()`(证据是否成立)决定**实例去留**, + // 用 `publishable()`(能否公布)决定**端点是否外泄**。 + // 两者分开是必须的:「证据成立但没芯片验签」时, + // 端点不公布但实例**保留** —— 它没坏。 + if let Some(p) = self.placed.get(&d.id) { + match self.dispatch.attest(&p.endpoint, &p.sandbox_id) { + Ok(sum) if sum.is_verified() => { + // 证据仍成立 ⇒ 保留实例;能否公布按发布策略刷新。 + let pubable = sum.publishable(self.require_chip_sig); + if let Some(p) = self.placed.get_mut(&d.id) { + p.publishable = pubable; + } + if pubable { + report.healthy.push(d.id.clone()); + } else { + // 证据成立但按策略不可公布(如缺芯片验签): + // **不是**失败,也不是漂移 —— 单独记一笔, + // 免得运维把它误读成「会话挂了就绪」。 + report.withheld.push(d.id.clone()); + } + continue; + } + Ok(sum) if sum.status == AttestationStatus::Pending => { + // ★ 证据突然没了(不该发生:placed 里的实例证明已通过过)。 + // fail-closed:端点**立刻收回**(这一轮绝不公布)。 + // + // 但实例本身**保留** —— 证据可能只是暂时没回传上来 + // (hostd 重启会清掉证据表)。销毁一个正在采证明的 + // guest 是把「等一下」误当成「没戏了」。 + // 转入 pending,下一轮只重新 attest,不重复 create。 + if let Some(p) = self.placed.remove(&d.id) { + self.pending.insert( + d.id.clone(), + PendingSession { + endpoint: p.endpoint, + node_host: p.node_host, + node_site: p.node_site, + sandbox_id: p.sandbox_id, + created_at: now_secs(), + }, + ); + } + report.pending.push(d.id.clone()); + continue; + } + _ => { + // 漂移:尽力回收旧的(即使 destroy 失败也继续重排)。 + // + // ★ **先把旧记录从 `placed` 里摘掉**(fail-closed): + // 证明已经不通过 ⇒ 这个端点**此刻起就不再可信**。 + // 若留着它,等下面重新选址失败(注册表空 / 无合格 + // 节点)就会走 `Err` 分支直接返回,而旧记录仍在 + // `placed` 里 ⇒ `proven_endpoints()` 把它交给计算面 —— + // 证明漂移的端点还在对外服务。 + // 摘掉的时机必须是「证明判定不通过」这一刻, + // 不是「重新落地成功」那一刻。 + let stale = self.placed.remove(&d.id); + if let Some(stale) = stale { + let _ = self.dispatch.destroy(&stale.endpoint, &stale.sandbox_id); + } + } } } - fn down(&self, endpoint: &str) { - self.up.lock().unwrap().remove(endpoint); + + // 1b) ★ 若上一轮是 pending:只重新 attest,**不重复 create**。 + // + // 这是本轮修复的核心:证据还在路上时反复 create 会 + // 「建一个、查一次、发现没证据、扔掉、再建一个」—— + // 永远起不来,且每次都白占一台机器。 + if let Some(pd) = self.pending.get(&d.id) { + let endpoint = pd.endpoint.clone(); + let sandbox_id = pd.sandbox_id.clone(); + let node_host = pd.node_host.clone(); + let node_site = pd.node_site.clone(); + match self.dispatch.attest(&endpoint, &sandbox_id) { + Ok(sum) if sum.is_verified() => { + // 证据到了且成立 ⇒ 转入 placed。 + // 能否公布按发布策略决定(见上)。 + let pubable = sum.publishable(self.require_chip_sig); + self.pending.remove(&d.id); + self.placed.insert( + d.id.clone(), + PlacedSession { + endpoint: endpoint.clone(), + node_host, + node_site, + sandbox_id, + publishable: pubable, + }, + ); + if pubable { + report.healthy.push(d.id.clone()); + } else { + report.withheld.push(d.id.clone()); + } + continue; + } + Ok(sum) if sum.status == AttestationStatus::Pending => { + // 还在等:保留实例、继续占容量、下一轮再看。 + report.pending.push(d.id.clone()); + continue; + } + Ok(sum) => { + // 证据到了但被拒 ⇒ 回收实例(端点本来就没公布过, + // 所以不存在「先撤回端点」这一步)。 + self.pending.remove(&d.id); + let _ = self.dispatch.destroy(&endpoint, &sandbox_id); + report.failed.push(( + d.id.clone(), + format!( + "attestation 未通过(user_data_ok={}, meas_ok={}, tcb_ok={}, chip_sig={}, chip_sig_failed={})", + sum.user_data_ok, + sum.meas_ok, + sum.tcb_ok, + sum.chip_sig, + sum.chip_sig_failed + ), + )); + continue; + } + Err(e) => { + // attest 取不到(hostd 失联)⇒ 移除该节点,回收实例。 + if matches!(e, TeeError::Io(_)) { + // 注册表键是 `site@host`(见 `NodeRegistry::key_of`)—— + // ★ 早先这里错拼成 `host@session_id`,那不是注册表里的 + // 任何键 ⇒ 剔除永远打不中 ⇒ 死节点一直留在候选池里。 + let key = format!("{}@{}", pd.node_site, pd.node_host); + let _ = self.registry.remove(&key); + } + self.pending.remove(&d.id); + let _ = self.dispatch.destroy(&endpoint, &sandbox_id); + report + .failed + .push((d.id.clone(), format!("attest 采集失败: {e}"))); + continue; + } + } } - fn created_len(&self) -> usize { - self.created.lock().unwrap().len() - } - fn destroyed_len(&self) -> usize { - self.destroyed.lock().unwrap().len() + + // 2) 构造容量感知候选池(剔除容量已满的主机)。 + let candidates = self.capacity_aware_candidates(&load); + let pool = TeePool::from_nodes(candidates); + + // 3) 重新选址 + 下发 + 证明。 + // + // 绑定材料:会话自带优先,否则用全局绑定。 + let bind = d.binding.clone().unwrap_or_else(|| self.binding.clone()); + match pool.place(&d.requirement, &bind) { + Ok(pl) => { + let endpoint = format!("{}:{}", pl.node.host, self.hostd_port); + match self + .dispatch + .create(&endpoint, &pl.node.site, &d.id, &pl.launch) + { + Ok(sid) => match self.dispatch.attest(&endpoint, &sid) { + Ok(sum) if sum.is_verified() => { + // 证据成立 ⇒ 保留实例;能否公布按发布策略。 + let pubable = sum.publishable(self.require_chip_sig); + self.placed.insert( + d.id.clone(), + PlacedSession { + endpoint: endpoint.clone(), + node_host: pl.node.host.clone(), + node_site: pl.node.site.clone(), + sandbox_id: sid, + publishable: pubable, + }, + ); + *load.entry(endpoint.clone()).or_insert(0) += 1; + if pubable { + report.healthy.push(d.id.clone()); + } else { + report.withheld.push(d.id.clone()); + } + } + Ok(sum) if sum.status == AttestationStatus::Pending => { + // ★ 证据还没到 ⇒ **保留实例**,不销毁。 + // 记进 pending,下一轮只重新 attest。 + self.pending.insert( + d.id.clone(), + PendingSession { + endpoint: endpoint.clone(), + node_host: pl.node.host.clone(), + node_site: pl.node.site.clone(), + sandbox_id: sid, + created_at: now_secs(), + }, + ); + *load.entry(endpoint.clone()).or_insert(0) += 1; + report.pending.push(d.id.clone()); + } + Ok(sum) => { + // 证明被拒:回收并标失败(绝不保留半吊子端点)。 + let _ = self.dispatch.destroy(&endpoint, &sid); + let why = format!( + "attestation 未通过(user_data_ok={}, meas_ok={}, tcb_ok={}, chip_sig={}, chip_sig_failed={})", + sum.user_data_ok, + sum.meas_ok, + sum.tcb_ok, + sum.chip_sig, + sum.chip_sig_failed + ); + report.failed.push((d.id.clone(), why)); + } + Err(e) => { + // 取证明失败(可能是 hostd 已失联)→ 立即剔除该 + // 节点,下一次 reconcile 就从候选里排除它。 + if matches!(e, TeeError::Io(_)) { + self.registry.remove(&Self::reg_key(&pl.node)); + } + let _ = self.dispatch.destroy(&endpoint, &sid); + report + .failed + .push((d.id.clone(), format!("attest 采集失败: {e}"))); + } + }, + Err(e) => { + // create 失败(可能是 hostd 失联 / 参数被拒)。 + // 传输层错误 ⇒ 节点可能已死,立即剔除,加速收敛。 + if matches!(e, TeeError::Io(_)) { + self.registry.remove(&Self::reg_key(&pl.node)); + } + report + .failed + .push((d.id.clone(), format!("create 失败: {e}"))); + } + } + } + Err(e) => { + // 没有任何节点满足需求 ⇒ 整体失败,绝不选一台凑数。 + report + .failed + .push((d.id.clone(), format!("无合格节点: {e}"))); + } } } + Ok(report) + } + + /// 长循环:周期性对账。`period` 为周期间隔;`stop` 为停止旗标,置位即退出。 + /// + /// 宿主控制面在独立线程里跑;停线程由调用方翻转 `stop` 后等待 join。 + pub fn run(&mut self, period: Duration, stop: &std::sync::atomic::AtomicBool) { + use std::sync::atomic::Ordering; + while !stop.load(Ordering::Relaxed) { + let _ = self.reconcile_once(); + std::thread::sleep(period); + } + } +} + +/// 当前墙钟秒(本地副本:`scheduler::registry::now_secs` 是私有的)。 +fn now_secs() -> u64 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_secs()) + .unwrap_or(0) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::dispatch::AttestationSummary; + use crate::platform::KbcMode; + use crate::PlatformKind; + use crate::schedule::LaunchSpec; + use alloc::vec; + use std::sync::{Arc, Mutex}; + + /// 内存 mock:可配置哪些 endpoint 在线、证明处于什么状态,并记录调用。 + /// + /// 用 `Arc` 包一层:对账器持有 `Arc` 作为下发实现,测试侧 + /// 保留另一个 `Arc` 句柄来 inspection 调用次数(已落地/已销毁)。 + /// + /// ★ 用 `MockVerdict`(而不是一个 `attest_ok: bool`)是因为现在有**三态**: + /// 证据还没到(pending)/ 证据成立(verified)/ 证据被拒(rejected)。 + /// 用 bool 表达不了「还没到」—— 而那正是本轮修复的核心场景。 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] + enum MockVerdict { + /// 证据尚未到达。 + Pending, + /// 证据成立,且芯片验签通过。 + Verified, + /// 证据成立,但芯片验签**未做**(宿主没配验签器)。 + VerifiedNoChipSig, + /// 证据被拒(绑定对不上 / 验签器拒绝)。 + Rejected, + } + + struct MockHost { + up: Mutex>, + verdict: Mutex, + created: Mutex>, + destroyed: Mutex>, + } + + impl MockHost { + fn new(up: &[&str], verdict: MockVerdict) -> Self { + Self { + up: Mutex::new(up.iter().map(|s| s.to_string()).collect()), + verdict: Mutex::new(verdict), + created: Mutex::new(Vec::new()), + destroyed: Mutex::new(Vec::new()), + } + } + fn down(&self, endpoint: &str) { + self.up.lock().unwrap().remove(endpoint); + } + /// 让之后的证明判定变成「不齐」(模拟芯片报告漂移 / 度量变化)。 + fn set_attest_ok(&self, ok: bool) { + *self.verdict.lock().unwrap() = if ok { + MockVerdict::Verified + } else { + MockVerdict::Rejected + }; + } + /// 切换判定状态(模拟「证据慢慢到了」)。 + fn set_verdict(&self, v: MockVerdict) { + *self.verdict.lock().unwrap() = v; + } + fn created_len(&self) -> usize { + self.created.lock().unwrap().len() + } + fn destroyed_len(&self) -> usize { + self.destroyed.lock().unwrap().len() + } + } + impl TeeHostDispatch for Arc { fn create( &self, @@ -309,21 +691,52 @@ use std::time::Duration; .push((endpoint.to_string(), id.clone())); Ok(id) } - fn attest( - &self, - endpoint: &str, - _sid: &str, - ) -> Result { - if !self.up.lock().unwrap().contains(endpoint) { - return Err(TeeError::Io(format!("hostd {endpoint} 不可达"))); - } - Ok(AttestationSummary { - user_data_ok: self.attest_ok, - meas_ok: self.attest_ok, - tcb_ok: self.attest_ok, - chip_sig: false, - }) + fn attest( + &self, + endpoint: &str, + _sid: &str, + ) -> Result { + if !self.up.lock().unwrap().contains(endpoint) { + return Err(TeeError::Io(format!("hostd {endpoint} 不可达"))); } + // ★ 一次拿锁、读出值、立刻释放 —— std 的 Mutex **不可重入**, + // 在同一个表达式里连着 lock 两次会自死锁。 + let v = *self.verdict.lock().unwrap(); + Ok(match v { + MockVerdict::Pending => AttestationSummary { + user_data_ok: false, + meas_ok: false, + tcb_ok: false, + chip_sig: false, + chip_sig_failed: false, + status: AttestationStatus::Pending, + }, + MockVerdict::Verified => AttestationSummary { + user_data_ok: true, + meas_ok: true, + tcb_ok: true, + chip_sig: true, + chip_sig_failed: false, + status: AttestationStatus::Verified, + }, + MockVerdict::VerifiedNoChipSig => AttestationSummary { + user_data_ok: true, + meas_ok: true, + tcb_ok: true, + chip_sig: false, + chip_sig_failed: false, + status: AttestationStatus::Verified, + }, + MockVerdict::Rejected => AttestationSummary { + user_data_ok: false, + meas_ok: false, + tcb_ok: false, + chip_sig: false, + chip_sig_failed: false, + status: AttestationStatus::Rejected, + }, + }) + } fn destroy(&self, endpoint: &str, sid: &str) -> Result<(), TeeError> { self.destroyed .lock() @@ -363,7 +776,7 @@ use std::time::Duration; fn places_and_proves_a_session_once() { let reg = NodeRegistry::new(0); reg.register(snp_node("alice", "192.168.1.7", 5), 2); - let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], true)); + let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], MockVerdict::Verified)); let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); r.set_desired(vec![DesiredSession::new("s1", req())]); @@ -384,7 +797,7 @@ use std::time::Duration; fn no_node_is_fail_closed() { let reg = NodeRegistry::new(0); // 池里没有任何节点。 - let host = Arc::new(MockHost::new(&[], true)); + let host = Arc::new(MockHost::new(&[], MockVerdict::Verified)); let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); r.set_desired(vec![DesiredSession::new("s1", req())]); @@ -400,8 +813,8 @@ use std::time::Duration; fn attest_failure_is_recreated_then_failed() { let reg = NodeRegistry::new(0); reg.register(snp_node("alice", "192.168.1.7", 5), 2); - // attest_ok=false:证明不齐。 - let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], false)); + // 证明被拒:绑定对不上 / 验签器拒绝。 + let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], MockVerdict::Rejected)); let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); r.set_desired(vec![DesiredSession::new("s1", req())]); @@ -422,7 +835,7 @@ use std::time::Duration; reg.register(snp_node("bob", "192.168.1.102", 5), 2); // B let host = Arc::new(MockHost::new( &["192.168.1.7:3010", "192.168.1.102:3010"], - true, + MockVerdict::Verified, )); let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); r.set_desired(vec![DesiredSession::new("s1", req())]); @@ -454,7 +867,7 @@ use std::time::Duration; let reg = NodeRegistry::new(0); // 单节点,容量 1,但有 2 个会话需求 → 一个健康、一个失败。 reg.register(snp_node("alice", "192.168.1.7", 5), 1); - let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], true)); + let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], MockVerdict::Verified)); let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); r.set_desired(vec![ DesiredSession::new("s1", req()), @@ -465,6 +878,394 @@ use std::time::Duration; assert_eq!(rep.healthy.len(), 1, "容量 1 只能承载 1 个"); assert_eq!(rep.failed.len(), 1, "第二个应因无合格节点而失败"); assert!(rep.failed[0].1.contains("无合格节点")); - assert_eq!(host.created_len(), 1, "只应在那台机器上起一个"); - } + assert_eq!(host.created_len(), 1, "只应在那台机器上起一个"); } + + /// ★ **fail-closed 回归**:证明漂移后,即使**重新选址失败**, + /// 旧端点也必须被收回,绝不留在 `proven_endpoints()` 里。 + /// + /// 这条钉的是一个**真实的 fail-open 缺陷**(修复前会红): + /// 修复前,证明漂移只 `destroy` 旧实例但**不摘 `placed` 里的记录**; + /// 接着重新选址若失败(节点被剔除 / 注册表空),流程走 `Err` 分支 + /// 直接返回,而旧记录仍在 `placed` 里 ⇒ `proven_endpoints()` 把 + /// **证明已经不通过**的端点交给计算面。 + /// + /// 正确语义:证明一旦不通过,端点**即刻**收回 —— + /// 收回的时机是「证明判定不通过」那一刻,不是「重新落地成功」那一刻。 + #[test] + fn drifted_proof_endpoint_is_withdrawn_even_when_replacement_fails() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new(&["192.168.1.7:3010"], MockVerdict::Verified)); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + // 第一轮:证明通过 ⇒ 端点落地并对外公布。 + let rep = r.reconcile_once().unwrap(); + assert_eq!(rep.healthy, vec!["s1".to_string()]); + assert_eq!( + r.proven_endpoints(), + vec![("s1".to_string(), "192.168.1.7:3010".to_string())], + "第一轮应交出端点", + ); + + // 第二轮:证明漂移(芯片报告变了)+ 节点失联 ⇒ + // 重新选址必然失败(注册表里的节点被剔除 / 不可达)。 + host.set_attest_ok(false); + host.down("192.168.1.7:3010"); + let rep2 = r.reconcile_once().unwrap(); + assert!( + rep2.healthy.is_empty(), + "证明漂移 ⇒ 绝不能还标健康: {:?}", + rep2.healthy + ); + assert!( + r.proven_endpoints().is_empty(), + "★ 证明漂移的旧端点必须被收回,绝不外泄: {:?}", + r.proven_endpoints() + ); + } + + /// ★ 证明漂移后**重新选址成功**的路径:旧端点被收回,新端点换上去。 + #[test] + fn drifted_proof_is_replaced_by_a_fresh_proven_session() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + reg.register(snp_node("bob", "192.168.1.102", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010", "192.168.1.102:3010"], + MockVerdict::Verified, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + let rep = r.reconcile_once().unwrap(); + assert_eq!(rep.healthy, vec!["s1".to_string()]); + let first = r.proven_endpoints().into_iter().next().unwrap().1; + + // 证明漂移 ⇒ 旧的不再可信,必须换新的。 + host.set_attest_ok(false); + // 但重新落地时证明又好了(换了台机器 / 重启后恢复)。 + host.set_attest_ok(true); + // 让第一台失联,逼它换到另一台。 + host.down(&first); + + let mut replaced = false; + for _ in 0..3 { + r.reconcile_once().unwrap(); + if let Some((_, ep)) = r.proven_endpoints().into_iter().next() { + if ep != first { + replaced = true; + break; + } + } + } + assert!(replaced, "证明漂移后应换到新的、重新证明通过的会话"); + assert!( + host.destroyed_len() >= 1, + "旧实例必须被回收,不能留着白占容量", + ); + } + + // ======================================================================= + // ★ Task #18:三态(pending / verified / rejected)回归 + // + // 这组测试钉的是本轮修掉的**真实缺陷**: + // 「证据尚未到达」与「证据被拒」在早先的四布尔上无法区分, + // 对账器因此把刚起来的 guest **立刻销毁**,形成 + // create → attest(pending) → destroy → create → attest(pending) → … + // 的死循环,表现为「会话永远起不来」而症状完全不像时序问题。 + // ======================================================================= + + /// ★ **pending 不销毁**:证据还没到时,实例必须活着。 + /// + /// 这条是整组的核心:早先这里会红(destroy 被调用)。 + #[test] + fn pending_evidence_does_not_destroy_the_instance() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Pending, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + let rep = r.reconcile_once().unwrap(); + assert!( + rep.pending.contains(&"s1".to_string()), + "证据未到必须是 pending,不是失败:{:?}", + rep + ); + assert!(rep.failed.is_empty(), "pending 绝不能被记成失败:{:?}", rep.failed); + assert!( + rep.healthy.is_empty(), + "pending 绝不能被记成健康(端点还没资格公布)" + ); + assert_eq!( + host.destroyed_len(), + 0, + "★ 证据还没到的实例绝不能被销毁(这是本轮修掉的死循环)" + ); + assert!( + r.proven_endpoints().is_empty(), + "★ pending 的端点绝不外泄" + ); + } + + /// ★ **pending 不重复 create**:下一轮只重新 attest,不重建。 + /// + /// 重复 create 会「建一个、查一次、发现没证据、扔掉、再建一个」—— + /// 永远起不来,且每次都白占一台机器。 + #[test] + fn pending_evidence_does_not_recreate_the_instance() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Pending, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + r.reconcile_once().unwrap(); + assert_eq!(host.created_len(), 1, "第一轮建一个"); + r.reconcile_once().unwrap(); + r.reconcile_once().unwrap(); + assert_eq!( + host.created_len(), + 1, + "★ pending 期间绝不能重复 create(否则永远起不来且白占机器)" + ); + assert_eq!(host.destroyed_len(), 0, "pending 期间绝不销毁"); + } + + /// ★ **pending 继续占容量**:它是真的跑着的 guest。 + #[test] + fn pending_instance_still_consumes_capacity() { + let reg = NodeRegistry::new(0); + // 容量 1。 + reg.register(snp_node("alice", "192.168.1.7", 5), 1); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Pending, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![ + DesiredSession::new("s1", req()), + DesiredSession::new("s2", req()), + ]); + + let rep = r.reconcile_once().unwrap(); + // 容量 1 ⇒ 只能起一个;另一个因无合格节点而失败。 + assert_eq!(host.created_len(), 1, "容量 1 只能承载 1 个"); + assert_eq!(rep.pending.len(), 1, "起的那一个处于 pending"); + assert_eq!(rep.failed.len(), 1, "第二个应因容量满而失败"); + assert!( + rep.failed[0].1.contains("无合格节点"), + "★ pending 的实例必须计入容量,否则会超卖:{:?}", + rep.failed + ); + } + + /// ★ **pending → verified**:证据到了之后,端点才被公布。 + /// + /// 这条钉住「pending 不是终点」:证据最终会到,到了就该转正。 + #[test] + fn pending_session_becomes_verified_and_publishes_endpoint() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Pending, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + // 第一轮:证据未到。 + let rep = r.reconcile_once().unwrap(); + assert!(rep.pending.contains(&"s1".to_string())); + assert!(r.proven_endpoints().is_empty()); + + // 证据到了(guest 采完证明回传上来)。 + host.set_verdict(MockVerdict::Verified); + let rep2 = r.reconcile_once().unwrap(); + assert_eq!( + rep2.healthy, + vec!["s1".to_string()], + "证据到了就该转正:{:?}", + rep2 + ); + assert_eq!( + r.proven_endpoints(), + vec![("s1".to_string(), "192.168.1.7:3010".to_string())], + "★ 转正后端点才公布" + ); + assert_eq!(host.created_len(), 1, "转正过程不重建实例"); + assert_eq!(host.destroyed_len(), 0, "转正过程不销毁实例"); + } + + /// ★ **pending → rejected**:证据到了但被拒 ⇒ 回收实例。 + #[test] + fn pending_session_that_gets_rejected_is_reclaimed() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Pending, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + r.reconcile_once().unwrap(); + assert_eq!(host.destroyed_len(), 0, "还在等的时候不销毁"); + + // 证据到了,但被拒(绑定对不上 / 验签器拒绝)。 + host.set_verdict(MockVerdict::Rejected); + let rep = r.reconcile_once().unwrap(); + assert_eq!(rep.failed.len(), 1, "被拒必须明确标失败:{:?}", rep); + assert!(rep.pending.is_empty(), "被拒后不再是 pending"); + assert!( + host.destroyed_len() >= 1, + "★ 被拒的实例必须被回收,不能白占机器" + ); + assert!(r.proven_endpoints().is_empty(), "★ 被拒的端点绝不外泄"); + } + + /// ★ **chip_sig 门控**:证据成立但没芯片验签 ⇒ 端点不公布,实例保留。 + /// + /// ★ 这条钉的是一个**极易踩的坑**:「证据成立」与「允许公布」是两件事。 + /// 若把两者合并,「宿主没配验签器」会被当成「证明漂移」⇒ 每轮 + /// destroy + create ⇒ 会话永远起不来(而且机器被反复占用)。 + #[test] + fn chip_sig_gate_withholds_endpoint_but_keeps_instance() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + // 证据成立,但宿主**没配**芯片验签器。 + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::VerifiedNoChipSig, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + let rep = r.reconcile_once().unwrap(); + assert!( + rep.withheld.contains(&"s1".to_string()), + "证据成立但不可公布 ⇒ 记 withheld,不是失败也不是健康:{:?}", + rep + ); + assert!(rep.failed.is_empty(), "不可公布不是失败:{:?}", rep.failed); + assert!( + r.proven_endpoints().is_empty(), + "★ 没芯片验签 ⇒ 端点绝不外泄" + ); + assert_eq!( + host.destroyed_len(), + 0, + "★ 证据成立但不可公布时,实例必须保留(否则会话永远起不来)" + ); + + // 下一轮:仍然保留实例,不重建。 + let rep2 = r.reconcile_once().unwrap(); + assert_eq!(host.created_len(), 1, "不重建"); + assert_eq!(host.destroyed_len(), 0, "不销毁"); + assert!(rep2.withheld.contains(&"s1".to_string())); + } + + /// ★ 关掉 chip_sig 门控后,同样的证据**可以**公布端点。 + /// + /// 这条是正向对照:证明 `withheld` 不是「一律不公布」, + /// 而是「按发布策略决定」。 + #[test] + fn chip_sig_gate_can_be_relaxed_explicitly() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::VerifiedNoChipSig, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_require_chip_sig(false); + r.set_desired(vec![DesiredSession::new("s1", req())]); + + let rep = r.reconcile_once().unwrap(); + assert_eq!(rep.healthy, vec!["s1".to_string()], "放宽后应健康:{:?}", rep); + assert_eq!( + r.proven_endpoints(), + vec![("s1".to_string(), "192.168.1.7:3010".to_string())], + "放宽后端点才公布" + ); + } + + /// ★ **默认必须要求 chip_sig**:这是「真 KBS 验签后」的落地。 + #[test] + fn chip_sig_is_required_by_default() { + let reg = NodeRegistry::new(0); + let r = TeeReconciler::new(reg, Arc::new(MockHost::new(&[], MockVerdict::Verified)), binding(), 3010); + assert!( + r.require_chip_sig(), + "★ 默认必须要求芯片验签,否则「真 KBS 验签后的端点」就是空话" + ); + } + + /// ★ **期望态收缩 ⇒ 显式回收实例**。 + /// + /// 这条钉的是真实泄漏:早先 `set_desired` 只 `retain` 索引, + /// 那个还在跑的 guest 就**永远没人管**了 —— 白占机器。 + #[test] + fn shrinking_desired_state_reclaims_instances() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Verified, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![ + DesiredSession::new("s1", req()), + DesiredSession::new("s2", req()), + ]); + r.reconcile_once().unwrap(); + assert_eq!(host.created_len(), 2); + + // 期望态收缩到只剩 s1。 + r.set_desired(vec![DesiredSession::new("s1", req())]); + r.reconcile_once().unwrap(); + assert_eq!( + host.destroyed_len(), + 1, + "★ 期望态收缩后,不再需要的实例必须被显式回收(否则白占机器)" + ); + assert_eq!( + r.proven_endpoints().len(), + 1, + "被回收的会话端点必须一起消失" + ); + } + + /// ★ **pending 实例在期望态收缩时也要被回收**。 + #[test] + fn shrinking_desired_state_reclaims_pending_instances() { + let reg = NodeRegistry::new(0); + reg.register(snp_node("alice", "192.168.1.7", 5), 2); + let host = Arc::new(MockHost::new( + &["192.168.1.7:3010"], + MockVerdict::Pending, + )); + let mut r = TeeReconciler::new(reg, host.clone(), binding(), 3010); + r.set_desired(vec![DesiredSession::new("s1", req())]); + r.reconcile_once().unwrap(); + assert_eq!(host.created_len(), 1); + assert_eq!(host.destroyed_len(), 0); + + // 期望态清空 ⇒ 那个还在采证明的实例也必须被回收。 + r.set_desired(vec![]); + r.reconcile_once().unwrap(); + assert_eq!( + host.destroyed_len(), + 1, + "★ pending 实例同样要回收,不能因为「还在等」就永远留着" + ); + } +} diff --git a/crates/mpc-tee/src/schedule.rs b/crates/mpc-tee/src/schedule.rs index 4efa50b..5f15ad0 100644 --- a/crates/mpc-tee/src/schedule.rs +++ b/crates/mpc-tee/src/schedule.rs @@ -652,6 +652,12 @@ mod tests { n.device_present = true; n.qemu_present = true; n.firmware_present = true; + // ★ `image_present` = 「guest 内核/initrd 已通过宿主预检」(见 `probe.rs` + // 的生产口径:内核+initrd 路径真实存在)。它与 `kernel`/`initrd` + // 路径是**两个独立事实** —— 路径给了但没预检过 ⇒ 同样不准入。 + // 漏设它 ⇒ CSV 的四个准入测试全部被「未通过宿主预检」拒掉, + // 而症状看起来像「CSV 平台坏了」。 + n.image_present = true; n.measurement = [9u8; 32]; n.kbc = KbcMode::Offline; n.qemu_bin = String::from("/usr/bin/qemu-system-x86_64"); diff --git a/deploy/tee/guest/init.sh b/deploy/tee/guest/init.sh index 3aac8e0..2758deb 100644 --- a/deploy/tee/guest/init.sh +++ b/deploy/tee/guest/init.sh @@ -397,6 +397,7 @@ fi HOSTD_EP="" SANDBOX_ID="" UPLOAD_TOKEN="" +UPLOAD_PATH="" if [ "$HAND_MOUNTED" = "yes" ]; then echo "hand_mount: ok ($HAND_DIR)" HOSTD_EP=$($BB cat "$HAND_DIR/hostd_endpoint" 2>/dev/null) @@ -405,11 +406,17 @@ if [ "$HAND_MOUNTED" = "yes" ]; then # 这里仍要 trim 一次:多一个字节就会让令牌对不上, # 症状是「明明有令牌却一直 401」。 UPLOAD_TOKEN=$($BB cat "$HAND_DIR/upload_token" 2>/dev/null | $BB tr -d '\r\n') - if [ -z "$HOSTD_EP" ] || [ -z "$SANDBOX_ID" ] || [ -z "$UPLOAD_TOKEN" ]; then - echo "hand_mount: incomplete (endpoint=${HOSTD_EP:-none} sandbox=${SANDBOX_ID:-none} token=${UPLOAD_TOKEN:+present}${UPLOAD_TOKEN:-none})" + # ★ 上传路径由**宿主**下发(路由归宿主控制面管)。 + # guest 侧**不自己拼** —— hostd 改路由时手牌跟着改,guest 不用动。 + # 自己拼的话:hostd 改路由而 guest 不会跟着改 ⇒ 静默 POST 到 + # 不存在的端点 ⇒ 宿主判定停在 pending ⇒ 端点永不公布。 + UPLOAD_PATH=$($BB cat "$HAND_DIR/upload_path" 2>/dev/null | $BB tr -d '\r\n') + if [ -z "$HOSTD_EP" ] || [ -z "$SANDBOX_ID" ] || [ -z "$UPLOAD_TOKEN" ] || [ -z "$UPLOAD_PATH" ]; then + echo "hand_mount: incomplete (endpoint=${HOSTD_EP:-none} sandbox=${SANDBOX_ID:-none} token=${UPLOAD_TOKEN:+present}${UPLOAD_TOKEN:-none} path=${UPLOAD_PATH:+present}${UPLOAD_PATH:-none})" HOSTD_EP="" SANDBOX_ID="" UPLOAD_TOKEN="" + UPLOAD_PATH="" else echo "hand_endpoint: $HOSTD_EP sandbox: $SANDBOX_ID" fi @@ -423,11 +430,14 @@ fi # ★ 上传证明材料(只在证明包存在且手牌齐全时做)。 # 证明包可能不存在:离线 KBC 演练根本不去采证明。 -if [ -f "$RUN/attestation.bundle" ] && [ -n "$HOSTD_EP" ] && [ -n "$SANDBOX_ID" ] && [ -n "$UPLOAD_TOKEN" ]; then +if [ -f "$RUN/attestation.bundle" ] && [ -n "$HOSTD_EP" ] && [ -n "$SANDBOX_ID" ] && [ -n "$UPLOAD_TOKEN" ] && [ -n "$UPLOAD_PATH" ]; then echo "attestation_upload: endpoint=$HOSTD_EP sandbox=$SANDBOX_ID" # ★ 令牌走 --token-file(**不**进 argv)。 + # ★ 上传路径走 --upload-path-file(**宿主下发的那个**,guest 不自己拼路由)。 if "$MPC" tee attest-upload --host "$HOSTD_EP" --sandbox "$SANDBOX_ID" \ - --token-file "$HAND_DIR/upload_token" --bundle "$RUN/attestation.bundle" \ + --token-file "$HAND_DIR/upload_token" \ + --upload-path-file "$HAND_DIR/upload_path" \ + --bundle "$RUN/attestation.bundle" \ > "$RUN/attest-upload.log" 2>&1; then echo "attestation_upload: ok" else diff --git a/deploy/tee/real-machine/probe-9p-hand.sh b/deploy/tee/real-machine/probe-9p-hand.sh index 85417dd..42cd1fd 100755 --- a/deploy/tee/real-machine/probe-9p-hand.sh +++ b/deploy/tee/real-machine/probe-9p-hand.sh @@ -4,8 +4,9 @@ # # 为什么单独探这一件事 # # guest → hostd 的证明材料回传靠 **9p(virtfs)**: -# 宿主把三份手牌写进每实例一个目录 → qemu 以 9p 挂进 guest -# → guest 读文件拿到 sandbox_id / upload_token / hostd_endpoint。 +# 宿主把**四份**手牌写进每实例一个目录 → qemu 以 9p 挂进 guest +# → guest 读文件拿到 sandbox_id / upload_token / hostd_endpoint / upload_path。 +# (upload_path 是 2026-11-09 新增的:路由形状归 hostd 管,由宿主下发。) # # ★ 令牌**绝不**走 argv(宿主上明文可见)⇒ 9p 是令牌的**唯一**真通道。 # 所以「guest 内能不能挂 9p」不是锦上添花,而是**整条回传闭环的前置条件**。 @@ -48,6 +49,10 @@ REMOTE_DIR=${MPC_TEE_9P_PROBE_DIR:-/tmp/mpc-9p-probe} PROBE_SID='sbx-001' PROBE_TOKEN='deadbeefcafe' PROBE_ENDPOINT='10.93.0.1:3010' +# ★ 手牌现在是**四份**(2026-11-09):新增 upload_path —— +# 路由形状归 hostd 管,由宿主经 9p 下发给 guest。 +# 探针必须测**真实形状**,否则真机跑绿也不能说明生产路径通。 +PROBE_UPLOAD_PATH='/sandboxes/sbx-001/attestation' # ── 纯判据:把手牌三文件读出来,判定是否**逐字节**一致 ─────────────────── # @@ -65,8 +70,8 @@ PROBE_ENDPOINT='10.93.0.1:3010' # 所以 guest 侧必须额外打印 `hand_len[]=<字节数>`, # 字节数与期望长度不符 ⇒ 文件内容被污染 ⇒ 直接判失败。 verify_hand() { - local log=$1 sid=$2 tok=$3 ep=$4 line len got_len - for pair in "sandbox_id:$sid" "upload_token:$tok" "hostd_endpoint:$ep"; do + local log=$1 sid=$2 tok=$3 ep=$4 upath=$5 line len got_len + for pair in "sandbox_id:$sid" "upload_token:$tok" "hostd_endpoint:$ep" "upload_path:$upath"; do local name=${pair%%:*} want=${pair#*:} line=$(printf '%s\n' "$log" | grep -F "hand[$name]=" | head -1) [ -n "$line" ] || { printf '缺手牌文件 %s\n' "$name"; return 1; } @@ -106,16 +111,24 @@ selftest() { local ok_n=0 bad_n=0 printf '=== 9p 手牌判据自测(每条都要能被构造样例推翻)===\n' + # ★ 手牌现在是**四份**(2026-11-09 新增 upload_path)。 + # 探针必须测**真实形状** —— 测三份的话,生产路径(guest 读 upload_path) + # 根本没被覆盖,真机跑绿也不能说明生产路径通。 + local up='/sandboxes/sbx-001/attestation' + + # 正常日志(四份手牌齐全,字节数与字符串长度一致 ⇒ 无尾随换行) local log_ok='hand_mount: ok (/run/mpc-tee/hostd) hand[sandbox_id]=sbx-001 hand[upload_token]=deadbeefcafe hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation hand_len[sandbox_id]=7 hand_len[upload_token]=12 -hand_len[hostd_endpoint]=14' +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' # 正向对照 - if verify_mount_line "$log_ok" && verify_hand "$log_ok" sbx-001 deadbeefcafe 10.93.0.1:3010; then + if verify_mount_line "$log_ok" && verify_hand "$log_ok" sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"; then printf 'ok 正向对照:合法手牌通过\n'; ok_n=$((ok_n + 1)) else printf 'FAIL 正向对照竟然失败\n'; bad_n=$((bad_n + 1)) @@ -130,51 +143,82 @@ hand_len[hostd_endpoint]=14' } # 负向① 挂载失败(guest 明确说 failed) - check_bad '负向① 9p 挂载失败' '9p_hand_mount_failed' sbx-001 deadbeefcafe 10.93.0.1:3010 + check_bad '负向① 9p 挂载失败' '9p_hand_mount_failed' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" # 负向② 令牌文件带了尾随换行 —— ★ 字符串**完全相同**, # 只有字节数能区分 ⇒ 这条判据必须靠 hand_len 才拦得住。 check_bad '负向② 令牌带尾随换行(字节数不符)' 'hand_mount: ok hand[sandbox_id]=sbx-001 hand[upload_token]=deadbeefcafe hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation hand_len[sandbox_id]=7 hand_len[upload_token]=13 -hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" # 负向③ 缺 upload_token 这一份手牌 check_bad '负向③ 缺令牌文件' 'hand_mount: ok hand[sandbox_id]=sbx-001 hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation hand_len[sandbox_id]=7 -hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" # 负向④ 端点被换(手牌串到别的实例) check_bad '负向④ 端点被换' 'hand_mount: ok hand[sandbox_id]=sbx-001 hand[upload_token]=deadbeefcafe hand[hostd_endpoint]=10.93.0.9:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation hand_len[sandbox_id]=7 hand_len[upload_token]=12 -hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" # 负向⑤ 实例 id 不符 check_bad '负向⑤ 实例 id 不符' 'hand_mount: ok hand[sandbox_id]=sbx-999 hand[upload_token]=deadbeefcafe hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation hand_len[sandbox_id]=7 hand_len[upload_token]=12 -hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" # 负向⑥ 令牌被换成别的值 check_bad '负向⑥ 令牌被换' 'hand_mount: ok hand[sandbox_id]=sbx-001 hand[upload_token]=000000000000 hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation hand_len[sandbox_id]=7 hand_len[upload_token]=12 -hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" # 负向⑦ guest 没打印字节数证据 ⇒ 判据**必须**判失败(不许"看起来对就放过") check_bad '负向⑦ 缺字节数证据' 'hand_mount: ok hand[sandbox_id]=sbx-001 hand[upload_token]=deadbeefcafe -hand[hostd_endpoint]=10.93.0.1:3010' sbx-001 deadbeefcafe 10.93.0.1:3010 +hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-001/attestation' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" + # 负向⑧ ★ upload_path 被换(路由漂移的形态): + # guest 拿到的路径与宿主实际路由不一致 ⇒ 上传到不存在的端点 + # ⇒ 宿主判定停在 pending ⇒ 端点不公布。症状链长,必须靠字节级判据拦。 + check_bad '负向⑧ upload_path 被换(路由漂移)' 'hand_mount: ok +hand[sandbox_id]=sbx-001 +hand[upload_token]=deadbeefcafe +hand[hostd_endpoint]=10.93.0.1:3010 +hand[upload_path]=/sandboxes/sbx-999/attestation +hand_len[sandbox_id]=7 +hand_len[upload_token]=12 +hand_len[hostd_endpoint]=14 +hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" + # 负向⑨ upload_path 缺了(宿主没下发)⇒ 必须判失败 + check_bad '负向⑨ 缺 upload_path 手牌' 'hand_mount: ok +hand[sandbox_id]=sbx-001 +hand[upload_token]=deadbeefcafe +hand[hostd_endpoint]=10.93.0.1:3010 +hand_len[sandbox_id]=7 +hand_len[upload_token]=12 +hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up" printf -- '---\n9p 手牌判据自测:%s 通过 / %s 失败\n' "$ok_n" "$bad_n" [ "$bad_n" -eq 0 ] @@ -213,11 +257,13 @@ if [ "$HAND_MOUNTED" = "yes" ]; then echo "hand[sandbox_id]=$($BB cat "$HAND_DIR/sandbox_id" 2>/dev/null)" echo "hand[upload_token]=$($BB cat "$HAND_DIR/upload_token" 2>/dev/null)" echo "hand[hostd_endpoint]=$($BB cat "$HAND_DIR/hostd_endpoint" 2>/dev/null)" + echo "hand[upload_path]=$($BB cat "$HAND_DIR/upload_path" 2>/dev/null)" # ★ 字节数证据:字符串相等**证明不了**没有尾随换行(命令替换会吃掉它)。 # 期望长度 = 字符串长度(无尾随换行)⇒ 不等即内容被污染。 echo "hand_len[sandbox_id]=$($BB wc -c < "$HAND_DIR/sandbox_id" 2>/dev/null | tr -d ' ')" echo "hand_len[upload_token]=$($BB wc -c < "$HAND_DIR/upload_token" 2>/dev/null | tr -d ' ')" echo "hand_len[hostd_endpoint]=$($BB wc -c < "$HAND_DIR/hostd_endpoint" 2>/dev/null | tr -d ' ')" + echo "hand_len[upload_path]=$($BB wc -c < "$HAND_DIR/upload_path" 2>/dev/null | tr -d ' ')" else echo "9p_hand_mount_failed" $BB cat /proc/mounts 2>/dev/null @@ -235,10 +281,11 @@ set -u D=${REMOTE_DIR} rm -rf "\$D" mkdir -p "\$D/hand" "\$D/root/bin" "\$D/root/proc" "\$D/root/sys" "\$D/root/dev" -# 手牌三文件(★ 无尾随换行 —— 与 hostd 侧 write_into 一致) +# 手牌四文件(★ 无尾随换行 —— 与 hostd 侧 write_into 一致) printf '%s' '${PROBE_SID}' > "\$D/hand/sandbox_id" printf '%s' '${PROBE_TOKEN}' > "\$D/hand/upload_token" printf '%s' '${PROBE_ENDPOINT}' > "\$D/hand/hostd_endpoint" +printf '%s' '${PROBE_UPLOAD_PATH}' > "\$D/hand/upload_path" chmod 700 "\$D/hand" chmod 600 "\$D/hand"/* # guest init @@ -272,14 +319,27 @@ test -s "\$D/initrd.img" || { echo "INITRD_MISS"; exit 3; } # qemu 直接报 "9pfs device couldn't find fsdev with the id = mpchostd9p" 并退出。 # 显式 `-fsdev local,id=mpchostd9p,path=...` 才能把 id 钉死。 rm -f "\$D/serial.log" -nohup ${qemu} -machine q35 -enable-kvm -m 512 -nographic -nodefaults -no-reboot \\ - -kernel ${kernel} -initrd "\$D/initrd.img" \\ - -append "console=ttyS0 earlyprintk=serial" \\ - -fsdev local,id=mpchostd9p,path=\$D/hand,security_model=none \\ - -device virtio-9p-pci,fsdev=mpchostd9p,mount_tag=mpchostd \\ - -chardev file,id=mpcser,path=\$D/serial.log -serial chardev:mpcser \\ - > "\$D/qemu.log" 2>&1 & +# ★ ★ qemu 参数必须写成**一行**(2026-11-09 真机实测): +# 用 \ 续行时,`base64 -d | sh` 这条管道会把续行的反斜杠吃掉 +# ⇒ shell 把 `-fsdev` / `-device` 当成**命令名** +# ⇒ 报 "-virtfs: command not found" / "-fsdev: command not found" +# ⇒ guest 根本没起来(串口日志空)。 +# 症状极隐蔽:qemu.log 里什么都没写,因为那些行压根没进 shell。 +nohup ${qemu} -machine q35 -enable-kvm -m 512 -nographic -nodefaults -no-reboot -kernel ${kernel} -initrd "\$D/initrd.img" -append "console=ttyS0 earlyprintk=serial" -fsdev local,id=mpchostd9p,path=\$D/hand,security_model=none -device virtio-9p-pci,fsdev=mpchostd9p,mount_tag=mpchostd -chardev file,id=mpcser,path=\$D/serial.log -serial chardev:mpcser > "\$D/qemu.log" 2>&1 & echo "QEMU_PID=\$!" +# ★ 等 guest 打完标记再返回 —— **远端**轮询,别在本地轮询。 +# 本地每轮 fetch_serial 都要走一遍 xop(Touch ID)⇒ 90 轮 = 十几分钟。 +# 远端轮询只花一次 SSH 往返。 +# ★ 顺带把串口内容**一次性**取回(本地不再二次拉取)。 +i=0 +while [ "\$i" -lt 60 ]; do + if grep -q 'PROBE_DONE' "\$D/serial.log" 2>/dev/null; then break; fi + i=\$((i + 1)) + sleep 1 +done +echo "--- SERIAL_BEGIN ---" +cat "\$D/serial.log" 2>/dev/null || true +echo "--- SERIAL_END ---" REMOTE_EOF } @@ -302,7 +362,21 @@ run_side() { local label=$1 host=$2 uk=$3 pk=$4 kernel=$5 qemu=$6 local tmp init_b64 remote_script tmp=$(mktemp -d /tmp/mpc-9p-probe.XXXXXX) - init_b64=$(write_probe_init "$tmp/init.sh" | base64 | tr -d '\n') + # ★★ init_b64 必须是**文件内容**的 base64,不是函数 stdout 的 base64。 + # `write_probe_init` 把内容**写进文件**(stdout 是空的) + # ⇒ 直接 `write_probe_init ... | base64` 得到**空串** + # ⇒ 远端 `printf '%s' '' | base64 -d > init` ⇒ **/init 是 0 字节** + # ⇒ 内核报 "Failed to execute /init (error -8)"(ENOEXEC) + # ⇒ guest 根本进不到 9p 那一段 ⇒ 探针永远测不到 9p。 + # 症状极具误导性:内核起来了、串口有日志,看着像「9p 不通」, + # 实际是 initramfs 里没有 init。 + write_probe_init "$tmp/init.sh" + init_b64=$(base64 < "$tmp/init.sh" | tr -d '\n') + if [ -z "$init_b64" ]; then + printf 'FAIL %s:探针 init 内容为空(本地生成失败)\n' "$label" >&2 + rm -rf "$tmp" + return 1 + fi write_remote_script "$tmp/remote.sh" "$init_b64" "$kernel" "$qemu" printf '=== %s (%s) ===\n' "$label" "$host" @@ -313,25 +387,20 @@ run_side() { printf 'FAIL %s:远端探针没起来:%s\n' "$label" "$out" >&2 return 1 fi - # 等 guest 打完标记(串口文件增长) - local i log - for i in $(seq 1 90); do - log=$(fetch_serial "$host" "$uk" "$pk") - if printf '%s\n' "$log" | grep -q 'PROBE_DONE'; then break; fi - sleep 1 - done - log=$(fetch_serial "$host" "$uk" "$pk") + # 串口内容由**远端**等好了再一次性返回(见 write_remote_script)。 + local log + log=$(printf '%s\n' "$out" | sed -n '/--- SERIAL_BEGIN ---/,/--- SERIAL_END ---/p') if [ -z "$log" ]; then printf 'FAIL %s:串口日志为空(guest 没起来?)\n' "$label" >&2 return 1 fi - printf '%s\n' "$log" | grep -E 'hand_mount|hand\[|9p_hand|PROBE_DONE' || true + printf '%s\n' "$log" | grep -E 'hand_mount|hand\[|hand_len\[|9p_hand|PROBE_DONE' || true if ! verify_mount_line "$log"; then printf 'FAIL %s:9p 没挂上(guest 侧 busybox 挂不了 9p)\n' "$label" >&2 return 1 fi - if ! verify_hand "$log" "$PROBE_SID" "$PROBE_TOKEN" "$PROBE_ENDPOINT"; then + if ! verify_hand "$log" "$PROBE_SID" "$PROBE_TOKEN" "$PROBE_ENDPOINT" "$PROBE_UPLOAD_PATH"; then printf 'FAIL %s:手牌内容不一致\n' "$label" >&2 return 1 fi diff --git a/tools/check-guest-artifact.py b/tools/check-guest-artifact.py index d3f3af9..89720e7 100644 --- a/tools/check-guest-artifact.py +++ b/tools/check-guest-artifact.py @@ -48,6 +48,33 @@ musl 目标下现在有**两份**不同的产物,不是两份同一个二进 「这些串确实会进二进制」(正向对照),再据此在 guest 产物上跑否定判据。 host 产物里找不到 ⇒ 探针失效 ⇒ 直接 FAIL,绝不「安静地跳过」。 +# ★★★ 产物层否定判据的**盲区**(2026-11-09 实测,实名教训) +# +# 「guest 产物里不该有 /sandboxes」这条判据,**只在泄漏点真的在调用链上时** +# 才抓得到。实测三种破坏形态: +# +# 形态 A:字面量放进一个**未被调用**的 `pub fn` ⇒ LTO 整个裁掉 +# ⇒ guest 产物里连 `sandboxes` 都没有 ⇒ **产物层判据照样绿(假绿)** +# 形态 B:字面量放进一个**未被调用**的 `pub const` ⇒ 同上 ⇒ **假绿** +# 形态 C:字面量**真的用在请求行拼接上**(真实回归形态) +# ⇒ 产物里出现 1 次 ⇒ 产物层判据**抓到了**(38/39) +# +# ★ 而「死代码里抄着路由」恰恰是**最可能**的回归形态: +# 有人留了个常量备用、注释里抄了一段示例、临时调试代码忘了删。 +# +# 所以除了产物层判据,本脚本还有一道**源码层**判据 +# (`find_route_literals_in_mpc_tee`): +# 它扫 `crates/mpc-tee/src` 的**非测试代码**,不管有没有被调用,一律拦。 +# 这道判据在 deps 子命令里,**不需要** musl target、不需要产物。 +# +# ★ 两道防线**故意冗余**: +# · 产物层:抓「真的漏进二进制了」 +# · 源码层:抓「抄了一份路由在 guest 侧」(哪怕是死代码) +# 另外 `mpc-hostd` 里还有一条 Rust 单测 +# (`route_literal_must_not_live_in_mpc_tee`)—— +# 那是**第三道**,在 cargo test 里。门禁不能只依赖「某条 cargo test 存在」, +# 所以脚本里这一道必须独立存在。 + 判据唯一真相源就在这份脚本里;CI 与本地跑的是同一份。 """ @@ -201,6 +228,46 @@ def all_rust_sources(subs: tuple[str, ...] | None = None) -> str: return "\n".join(parts) +def find_route_literals_in_mpc_tee() -> list[str]: + """扫 `crates/mpc-tee/src`,找宿主控制面的路由字面量。 + + ★ 只扫**非测试代码**:`#[cfg(test)]` 之后的夹具不进二进制, + 而它们本来就要构造各种形状的路径来验证校验逻辑。 + ★ 只看**代码行**(跳过 `//` 注释与文档注释)—— + 注释里的路由只是说明,不构成「持有路由」。 + + 返回违规行清单(空 = 干净)。 + """ + offenders: list[str] = [] + for p in sorted((ROOT / "crates/mpc-tee/src").rglob("*.rs")): + lines = p.read_text(encoding="utf-8", errors="replace").splitlines() + # `#[cfg(test)]` 之后是测试代码 + test_start = next( + (i for i, l in enumerate(lines) if l.strip() == "#[cfg(test)]"), + len(lines), + ) + in_block_comment = False + for i, line in enumerate(lines[:test_start]): + l = line.strip() + if in_block_comment: + if "*/" in l: + in_block_comment = False + continue + if l.startswith("/*"): + if "*/" not in l: + in_block_comment = True + continue + if l.startswith("//"): + continue + # 路由前缀只在这两种形态下算「持有」: + # · 字符串字面量 "/sandboxes... + # · 常量赋值里的 "sandboxes" + if '"/sandboxes' in l or '= "sandboxes"' in l: + rel = p.relative_to(ROOT) + offenders.append(f"{rel}:{i + 1}: {l}") + return offenders + + def cmd_deps(c: Checks, target: str) -> None: print(f"== deps:依赖树边界(target={target})==") @@ -285,6 +352,32 @@ def cmd_deps(c: Checks, target: str) -> None: "归属变了,探针会退化成空判据", ) + # ★ ★ **源码层守卫**:宿主控制面的路由字面量不得留在 `mpc-tee`。 + # + # 路由形状**只有一份**,在 `crates/mpc-hostd/src/api.rs` + # (`ROUTE_SANDBOXES` / `ROUTE_ATTESTATION` / `attestation_upload_path`)。 + # guest 从 9p 手牌里**拿**宿主下发的完整路径。 + # + # 为什么要在**产物层判据之外**再加这一层: + # 产物层判据(`/sandboxes` 不得出现在 guest 二进制)只在 + # 「泄漏点真的在调用链上」时才抓得到。 + # ★ 实测(2026-11-09):把字面量塞进一个**未被调用**的函数 + # ⇒ LTO 整个裁掉 ⇒ guest 产物里连 `sandboxes` 都没有 + # ⇒ 产物层判据**照样绿**(假绿)。 + # 而「未被调用的死代码里抄着路由」恰恰是最可能的回归形态 + # (有人留了个常量备用)。 + # 所以必须有一道**源码层**判据:它不管有没有被调用,一律拦。 + # + # ★ 与 `mpc-hostd` 里的 Rust 单测 `route_literal_must_not_live_in_mpc_tee` + # 是**两道独立的防线**(一条在 cargo test 里、一条在 CI 脚本里)—— + # 故意冗余:门禁不能只依赖「某条 cargo test 存在」。 + route_offenders = find_route_literals_in_mpc_tee() + c.check( + "★ 宿主控制面的路由字面量不得留在 mpc-tee(路由归宿主管,路径由宿主下发)", + not route_offenders, + "\n".join(route_offenders), + ) + def cmd_guard(c: Checks, target: str) -> None: print(f"== guard:musl 默认 feature 必须被编译期守卫明确拒绝(target={target})==") diff --git a/tools/selftest-hostd.py b/tools/selftest-hostd.py index 1938247..a8f7794 100644 --- a/tools/selftest-hostd.py +++ b/tools/selftest-hostd.py @@ -292,6 +292,27 @@ def selftest_evidence_upload(): if not token: return + # ★ 上传路径**由宿主下发**(手牌里的 upload_path)。 + # 这正是 guest 走 9p 拿到的那一份 —— 自测用同一个文件, + # 保证测的路径与真机上 guest 用的路径**是同一个来源**。 + path_file = os.path.join(hand_root, sb, "upload_path") + upload_path = "" + if os.path.exists(path_file): + with open(path_file, "r", encoding="utf-8") as f: + upload_path = f.read().strip() + check( + "上传自测:hostd 在手牌里下发了上传路径(路由归宿主管)", + bool(upload_path), + f"没找到 {path_file}", + ) + check( + "上传自测:下发的上传路径形状正确", + upload_path == f"/sandboxes/{sb}/attestation", + f"got {upload_path!r}", + ) + if not upload_path: + return + up = subprocess.run( [ BIN, @@ -303,6 +324,8 @@ def selftest_evidence_upload(): sb, "--token-file", tok_path, + "--upload-path-file", + path_file, "--bundle", bundle_path, ], @@ -366,6 +389,8 @@ def selftest_evidence_upload(): sb, "--token-file", bad_token_path, + "--upload-path-file", + path_file, "--bundle", bundle_path, ], @@ -439,6 +464,8 @@ def selftest_evidence_upload(): sb, "--token-file", tok_path, + "--upload-path-file", + path_file, "--bundle", other_bundle, ],