Files
ssw-mpc/crates/mpc-cli/src/hostd.rs
T
admin 32419efc27 feat(cluster): 真机端点公布门禁跑通(真 KBS 验签后才公布会话端点)
- 新增 cluster-endpoint-gate-e2e.sh:AMD SNP + 海光 CSV 双节点自报、非回环监听 + 共享密钥、真 KBS 芯片验签后的端点公布;正向公布 / 负向零外泄(带原因)/ 收尾端点收回,真机 20 判据全绿
- mpc-tee / mpc-hostd:补齐控制面期望态绑定、宿主独立判定与 9p 手牌回传;LaunchOverride 支持真机双网卡与额外内核参数
- 修 runtime.rs 额外内核参数校验:CLI 把多个参数空格 join,服务端不得对整串判「含空白即拒」;改掉把错误行为钉死的测试并补跨端守卫
- kbs-net.sh 按端口清旧实例 + 硬判端口释放,杜绝旧参数 KBS 假就绪(端口 LISTEN 不等于本轮实例在跑)
2026-11-09 20:12:32 +08:00

1549 lines
62 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! `mpc hostd` 与 `mpc tee` 的宿主端命令。
//!
//! # 两层控制面在 CLI 上的形状
//!
//! ```text
//! 站点端(联盟级) 宿主机(机器级)
//! mpc hostd mpc tee up|ps|attest|down
//! 起 mpc-hostd 服务 ────────▶ 走 e2b 兼容 API
//! ```
//!
//! `mpc hostd` **只**在本机起服务(绑定回环);`mpc tee up` 等命令是
//! **客户端**,通过 `--host host:port` 连过去。
//!
//! # 为什么 `mpc hostd` 默认只听回环
//!
//! 宿主控制面支持**共享密钥鉴权**(2026-11-07 落地):配了密钥就是凭据模式,
//! 每个请求都必须带正确的 `Authorization: Bearer <secret>`,缺/错一律 401;
//! 没配密钥就是回环信任模式(只准不带凭据的请求)。
//!
//! ★ 但「回环信任模式」在非回环地址上等于**零保护**,所以非回环监听必须
//! **同时**满足两个条件:配了共享密钥 **且** 显式 `--allow-remote`。
//! 两者互为兜底 —— 只给 `--allow-remote` 只是一句声明,不构成任何保护。
//!
//! ★ 共享密钥是**静态**的,只能证明「你是我认识的那个站点端」;
//! 设计中的「站点端签发的短期 token」(`session_admit()` 产物,带会话绑定
//! 与有效期)那一层**还没落地**。
//!
//! # 「验证通过」的四句话
//!
//! `mpc tee attest` 打的是 `/attestation` 端点,输出里
//! `user_data_ok` / `meas_ok` / `tcb_ok` / `chip_sig` **四个布尔分开报**,
//! 不合并成一个 `ok`。`chip_sig=0` 的含义是「绑定关系成立,但没做芯片验签」。
use crate::report;
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<HostConfig, String> {
let mut cfg = HostConfig::default();
if let Some(v) = parse_flag(args, "--listen") {
cfg.listen = v.to_string();
}
if let Some(v) = parse_flag(args, "--reap-interval") {
cfg.reap_interval_secs = v
.parse()
.map_err(|_| format!("--reap-interval {v:?} 不是整数"))?;
}
if let Some(v) = parse_flag(args, "--state-file") {
cfg.state_file = Some(v.to_string());
}
if let Some(v) = parse_flag(args, "--report-interval") {
cfg.report_interval_secs = v
.parse()
.map_err(|_| format!("--report-interval {v:?} 不是整数"))?;
}
if let Some(v) = parse_flag(args, "--control-plane") {
cfg.control_plane = Some(v.to_string());
}
// ★ 共享密钥:配了就是「凭据模式」(每个请求都要带 Bearer token)。
// 没配就是「回环信任模式」(只放行不带凭据的请求)。
//
// ★ 来源有**两个**:命令行参数 与 环境变量 `MPC_HOSTD_SHARED_SECRET`,
// **参数优先**。环境变量这一路是刻意加的 ——
// 密钥进 argv 会出现在 `ps` 输出里(`--shared-secret` 的原话)。
// ★ 2026-11-09 真机联调时发现:帮助文案承诺「也可用环境变量传」,
// 但实现里**只**读参数 ⇒ 文案与实现不一致 ⇒ 照文案写的部署脚本
// 会得到「回环信任模式」的空保护。这是**假就绪信号**,必须修。
// ★ 与 `mpc control-plane` 的同名环境变量是**同一份口径**
// (参数优先、环境变量兜底),别让两侧行为分叉。
let env_secret = std::env::var("MPC_HOSTD_SHARED_SECRET").ok();
if let Some(v) = resolve_shared_secret(args, env_secret.as_deref())? {
cfg.shared_secret = Some(v);
}
// ★ 芯片验签器:配了才有宿主侧的 `chip_sig=true`。
// 不配不是错,但集群面按 `require_chip_sig=true` 门控时端点不会公布 ——
// 那时 note 会写明「未提供验签器」(是「没验」,不是「验了没过」)。
cfg.chip_verifier = build_chip_verifier(args)?;
// ★ Cubelet 自描述:配了 --node-platform 才进入「本宿主要对外自报」模式。
// 能力位由探针核实文件存在性得出 —— 这里只给部署事实(路径/平台/TCB)。
cfg.node_capability = build_node_capability(args)?;
// ★ guest 可达地址:guest 要靠它把证明材料回传回宿主控制面。
// 不配 ⇒ 不下发手牌 ⇒ guest 传不回材料 ⇒ 判定停在 pending ⇒
// 端点不公布(**诚实**的失败,不是缺陷)。
cfg.guest_endpoint = build_guest_endpoint(args)?;
// ★ 启动参数覆盖(真机网卡 / 额外内核参数)。
// 框架的 `-netdev user` 在海光真机上直接起不来(静态 qemu 没编 slirp),
// 真机还要**两张卡**(socket 跨 guest + tap 进宿主网段访问 KBS)。
// ⇒ 这是**这台宿主的事实**,由宿主自己配(与 `guest_endpoint` 同理,
// 不做成请求体字段 —— 否则站点端能让本机 guest 连任意对端)。
cfg.launch_override = build_launch_override(args)?;
// ★ 配了控制面却没配能力 = 永远不会推送 = 「以为在自报,其实没有」。
// 这属于**假就绪信号**,必须拒,不能只警告。
if cfg.control_plane.is_some() && cfg.node_capability.is_none() {
return Err(
"--control-plane 配了控制面地址,但没配 --node-platform —— 本宿主没有任何 TEE \
能力可自报,推送线程会永远空转。请补 --node-platform/--node-site/--node-host/--node-tcb,\
或去掉 --control-plane。"
.to_string(),
);
}
// ★ 非回环监听必须**同时**满足两个条件:配了共享密钥 **且** 显式
// `--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
));
}
}
Ok(cfg)
}
/// 地址是不是回环。
fn is_loopback(listen: &str) -> bool {
let host = listen.rsplit_once(':').map(|(h, _)| h).unwrap_or("");
matches!(host, "127.0.0.1" | "localhost" | "[::1]" | "::1")
}
/// ★ 解析共享密钥:`--shared-secret` 参数优先,其次环境变量兜底。
///
/// ★ 为什么把 env 做成**参数**而不是直接在里面读:
/// 环境变量是**进程级**的,而 Rust 的测试默认并行 ——
/// 测试里 `set_var` 会污染同进程内**其它**用例,导致
/// 「回环信任模式」这类用例随机假红。
/// 把 env 变成入参,测试就能直接喂值,**不碰进程状态**。
///
/// ★ `pub(crate)`:`mpc control-plane` 走**同一份**口径 ——
/// 两边各写各的 ⇒ 迟早分叉(2026-11-09 已经分叉过一次:
/// hostd 只认参数、control-plane 认参数+环境变量)。
///
/// ★ 返回 `None` = 没配密钥(回环信任模式)。
pub(crate) fn resolve_shared_secret(
args: &[String],
env_secret: Option<&str>,
) -> Result<Option<Vec<u8>>, String> {
let secret = match parse_flag(args, "--shared-secret") {
Some(v) => Some(v.to_string()),
None => env_secret.map(String::from),
};
match secret {
None => Ok(None),
Some(v) => {
if v.len() < mpc_hostd::auth::MIN_SECRET_LEN {
return Err(format!(
"共享密钥至少要 {} 字节(现在是 {} 字节)—— 短密钥抗不住在线穷举",
mpc_hostd::auth::MIN_SECRET_LEN,
v.len()
));
}
Ok(Some(v.into_bytes()))
}
}
}
/// 构造 **guest 可达的**宿主控制面地址。
///
/// ★ 这个地址**不是** `listen`:
/// `listen` 是宿主**自己**的绑定地址(可能是 `0.0.0.0`),
/// 而 guest 需要一个**具体可路由**的目的地址 ——
/// guest 在 tap 网段里,`0.0.0.0` 对它没有任何意义。
///
/// ★ 为什么它**不是** create 请求体字段(而是宿主配置):
/// 「guest 从哪个地址能访问到我」是这台宿主的**事实**。
/// 放请求体里会允许站点端把 guest 的回传地址指向任意主机 ——
/// 那等于把 guest 变成一个 SSRF 跳板。
///
/// ★ 校验很硬,因为这个值会进**内核命令行**(`-append`):
/// 含空白 ⇒ 内核参数被截断 ⇒ guest 读到半截地址 ⇒ 连不上;
/// 含 scheme/路径 ⇒ guest 侧拼请求行时出错。
fn build_guest_endpoint(args: &[String]) -> Result<Option<String>, String> {
let Some(v) = parse_flag(args, "--guest-endpoint") else {
return Ok(None);
};
let v = v.trim();
if v.is_empty() {
return Err("--guest-endpoint 不能是空串".to_string());
}
if v.chars().any(|c| c.is_whitespace() || c.is_control()) {
return Err(format!(
"--guest-endpoint {v:?} 含空白或控制字符 —— 它会进内核命令行(空格分隔),\
会被截断"
));
}
if v.contains("://") {
return Err(format!(
"--guest-endpoint {v:?} 不应带 scheme(只认 host:port)"
));
}
if v.contains('/') {
return Err(format!("--guest-endpoint {v:?} 不应带路径(只认 host:port)"));
}
let (host_raw, port) = v
.rsplit_once(':')
.ok_or_else(|| format!("--guest-endpoint {v:?} 必须是 host:port"))?;
if host_raw.is_empty() {
return Err(format!("--guest-endpoint {v:?} 缺主机部分"));
}
// ★ IPv6 必须带方括号(`[::1]:3010`):裸写(`::3010`)时端口边界说不清
// —— 按最后一个冒号切开得到 host=":",到底是 `[::]:3010` 还是 `::3010`?
// 带方括号时 host 是 `[::1]`,去掉方括号再判通配。
let (host, bracketed) = if let Some(inner) = host_raw.strip_prefix('[') {
let Some(inner) = inner.strip_suffix(']') else {
return Err(format!(
"--guest-endpoint {v:?} 的 IPv6 主机部分方括号不配对(应形如 [::1]:3010)"
));
};
(inner, true)
} else {
if host_raw.contains(':') {
return Err(format!(
"--guest-endpoint {v:?} 是裸 IPv6 —— 必须带方括号(如 [::1]:3010)"
));
}
(host_raw, false)
};
if host.is_empty() {
return Err(format!("--guest-endpoint {v:?} 缺主机部分"));
}
let port_num: u16 = port
.parse()
.map_err(|_| format!("--guest-endpoint {v:?} 的端口 {port:?} 不是 1..65535 的整数"))?;
if port_num == 0 {
return Err(format!("--guest-endpoint {v:?} 的端口不能是 0"));
}
// ★ 通配地址对 guest 无意义:guest 需要一个**能路由到**的具体地址。
// 配了 `0.0.0.0` 的人多半是以为「这样 guest 就能连」——
// 实际症状是 guest 连不上(或连到不该连的地址)。
if host == "0.0.0.0" || host == "::" || host == "*" {
return Err(format!(
"--guest-endpoint {v:?} 是通配地址 —— guest 需要一个**具体可路由**的地址\
(如 tap 网段里的宿主地址 10.93.0.1:3010),通配地址对它无效"
));
}
let _ = bracketed;
Ok(Some(v.to_string()))
}
/// 构造宿主本地的**启动参数覆盖**(真机网卡 / 额外内核参数)。
///
/// ★ 返回 `None` = 不覆盖(用框架的默认规格)。
///
/// # 网卡参数(`--guest-netdev`)
///
/// **一个 flag 对应一个 argv 元素**,可给多次,按出现顺序追加。
/// 与 `--attest-verifier-arg` 同一范式 —— 不做「一个 flag 吃掉后面所有 token」
/// 的解析(值本身可能以 `--` 开头,猜错就是给 qemu 传了个错的 argv)。
///
/// 要给两张卡就写四遍:
/// ```text
/// --guest-netdev -netdev --guest-netdev socket,id=mpcnet0,listen=0.0.0.0:19500
/// --guest-netdev -device --guest-netdev virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01
/// ```
///
/// ★ 校验很硬,因为这些值直接进 qemu argv:
/// 1. 不能含空白/控制字符(qemu 的 argv 元素不能有空格分隔的语义);
/// 2. netdev **id 不能重复**(重复 ⇒ qemu 报 "duplicate netdev id");
/// 3. 不得占用 9p 的 id(`mpchostd9p`)与 mount_tag —— 那是手牌通道,
/// 撞了 guest 就拿不到令牌 ⇒ 证明材料传不回来 ⇒ 端点不公布。
///
/// # 额外内核参数(`--guest-kernel-param`)
///
/// 追加到 `-append` 的值。**只能放非凭据** —— 凭据(令牌)走 9p 手牌
/// (见 `guest_hand.rs`)。这里显式拒绝含「token / secret / password / key=」
/// 语义的参数:内核命令行在宿主上是**明文可见**的(`ps` 输出、shell 历史)。
fn build_launch_override(args: &[String]) -> Result<Option<mpc_hostd::LaunchOverride>, String> {
let netdev_args = collect_repeated(args, "--guest-netdev")?;
let kern_params = collect_repeated(args, "--guest-kernel-param")?;
if netdev_args.is_empty() && kern_params.is_empty() {
return Ok(None);
}
// ---- 网卡参数校验 ----
let mut ids: Vec<String> = Vec::new();
let mut i = 0usize;
while i < netdev_args.len() {
let a = &netdev_args[i];
if a.chars().any(|c| c.is_whitespace() || c.is_control()) {
return Err(format!(
"--guest-netdev {a:?} 含空白或控制字符 —— 它会直接进 qemu argv"
));
}
if a == "-netdev" {
let Some(spec) = netdev_args.get(i + 1) else {
return Err("--guest-netdev -netdev 后面缺值".to_string());
};
let id = spec
.split(',')
.find_map(|p| p.strip_prefix("id="))
.map(String::from)
.ok_or_else(|| {
format!("--guest-netdev 的 netdev 规格 {spec:?} 里没有 id= —— 无法核对重复")
})?;
if id.is_empty() {
return Err(format!("--guest-netdev 的 netdev 规格 {spec:?} 里 id= 是空的"));
}
// ★ 不得占用 9p 手牌通道的 id —— 撞了 guest 拿不到令牌。
if id == mpc_hostd::guest_hand::FSDEV_ID {
return Err(format!(
"--guest-netdev 的 netdev id {id:?} 与 9p 手牌通道的 fsdev id 相同 —— \
撞了 guest 拿不到上传令牌,证明材料传不回来"
));
}
if ids.iter().any(|e| e == &id) {
return Err(format!(
"--guest-netdev 的 netdev id {id:?} 重复 —— qemu 会报 duplicate netdev id"
));
}
ids.push(id);
i += 2;
continue;
}
i += 1;
}
// ---- 额外内核参数校验 ----
let mut extra = String::new();
for p in &kern_params {
if p.chars().any(|c| c.is_whitespace() || c.is_control()) {
return Err(format!(
"--guest-kernel-param {p:?} 含空白或控制字符 —— 内核命令行按空格分隔,会被截断"
));
}
let low = p.to_ascii_lowercase();
for bad in ["token", "secret", "password", "passwd", "psk=", "seed="] {
if low.contains(bad) {
return Err(format!(
"--guest-kernel-param {p:?} 看起来带凭据语义({bad})—— \
内核命令行在宿主上明文可见,凭据必须走 9p 手牌"
));
}
}
if !extra.is_empty() {
extra.push(' ');
}
extra.push_str(p);
}
Ok(Some(mpc_hostd::LaunchOverride {
netdev_args,
extra_kernel_params: extra,
}))
}
/// 收集**可重复**的 flag 的所有值(一个 flag 一个值,按出现顺序)。
///
/// ★ 不做「一个 flag 吃掉后面所有 token」的解析 —— 值的形状无法从
/// flag 名推断(值可能以 `--` 开头),猜错就是给 qemu / 验签器传了错 argv。
fn collect_repeated(args: &[String], flag: &str) -> Result<Vec<String>, String> {
let mut out: Vec<String> = Vec::new();
let mut i = 0usize;
while i < args.len() {
if args[i] == flag {
let v = args
.get(i + 1)
.ok_or_else(|| format!("{flag} 后面缺值"))?
.to_string();
out.push(v);
i += 2;
} else {
i += 1;
}
}
Ok(out)
}
/// 构造芯片验签器配置(外部程序)。
///
/// ★ 没有 `--attest-verifier` → 返回 `None`(**不做**芯片验签)。
/// 这不是缺陷:宿主侧会明确记「未提供验签器」,
/// 与「验了没过」区分开。但集群面若按 `require_chip_sig=true` 门控,
/// 端点就**不会**被公布 —— 那时候运维能一眼看出缺哪一块。
///
/// ★ 参数一律**列表**传入,不拼 shell 串 ——
/// 框架的 `ExternalVerifier` 用 `Command::new(program).args(...)`,
/// 绝不走 `sh -c`(命令注入)。
///
/// ★ `--attest-verifier-arg` **一个 flag 对应一个 argv**,可给多次,
/// 按出现顺序追加。**不**做「一个 flag 吃掉后面所有 token」的解析 ——
/// 那无法区分「值」与「下一个 flag」(值本身可能以 `--` 开头),
/// 猜错就是给验签器传了个错的 argv。
/// 要传 `--product Milan` 就写两遍:
/// `--attest-verifier-arg --product --attest-verifier-arg Milan`。
fn build_chip_verifier(
args: &[String],
) -> Result<Option<mpc_hostd::ChipVerifierConfig>, String> {
let program = match parse_flag(args, "--attest-verifier") {
Some(p) => p.to_string(),
None => {
// ★ 给了参数(arg / chain-dir)却没给程序 ⇒ 配置不自洽 ⇒ 拒。
// 静默忽略会让运维以为验签器配了(假就绪信号)。
if args.iter().any(|a| a == "--attest-verifier-arg")
|| args.iter().any(|a| a == "--attest-chain-dir")
{
return Err(
"给了 --attest-verifier-arg / --attest-chain-dir,但没给 --attest-verifier \
(验签器程序路径)—— 配置不自洽。请补 --attest-verifier <路径>,\
或把这些参数一起去掉。"
.to_string(),
);
}
return Ok(None);
}
};
if program.trim().is_empty() {
return Err("--attest-verifier 不能是空串".to_string());
}
let mut vargs: Vec<String> = Vec::new();
let mut i = 0;
while i < args.len() {
if args[i] == "--attest-verifier-arg" {
let val = args
.get(i + 1)
.ok_or("--attest-verifier-arg 后面缺值")?
.to_string();
vargs.push(val);
i += 2;
} else {
i += 1;
}
}
let chain_dir = parse_flag(args, "--attest-chain-dir").map(|s| s.to_string());
// ★ 证书链目录给了但目录不存在 ⇒ **拒**。
// 验签 wrapper 会去这个目录找缓存的证书链;目录不存在时它会
// 退化成「联网取」—— 而真机常常是离线的,于是每次验签都失败,
// 症状是「chip_sig 一直是 false」,但根因是路径打错了。
if let Some(d) = &chain_dir {
if !std::path::Path::new(d).is_dir() {
return Err(format!(
"--attest-chain-dir {d:?} 不是已存在的目录 —— 验签器会在这里找缓存的证书链;\
目录不存在时它会退化成联网取证书(真机常常离线 ⇒ 验签必失败)"
));
}
}
Ok(Some(mpc_hostd::ChipVerifierConfig {
program,
args: vargs,
chain_dir,
}))
}
/// 构造本宿主的 TEE 能力配置(Cubelet 自描述的**部署事实**部分)。
///
/// ★ 没有 `--node-platform` → 返回 `None`(本宿主不自报)。
/// 这是**默认**:hostd 不是 TEE 宿主时不该对外宣称自己有 TEE 能力。
///
/// ★ 平台认不出来 → **拒**,不猜一个。同理 `--node-tcb` 非整数 → 拒。
///
/// ★ 路径**不**在这里校验存在性 —— 那是探针的活(`probe_host_node`):
/// 路径填了但文件不在 → 那个能力位为 `false` → 准入端拒这个节点。
/// 这里若因为文件不在就拒启动,运维就没法「先起服务再补文件」。
fn build_node_capability(args: &[String]) -> Result<Option<HostCapConfig>, String> {
let platform = match parse_flag(args, "--node-platform") {
Some(p) => p,
None => return Ok(None),
};
let kind = mpc_hostd::api::parse_platform(platform).ok_or_else(|| {
format!("--node-platform {platform:?} 认不出来(可用: snp / csv)")
})?;
let site = parse_flag(args, "--node-site")
.ok_or("--node-platform 配了,但缺 --node-site(本方 site 名)")?
.to_string();
let host = parse_flag(args, "--node-host")
.ok_or("--node-platform 配了,但缺 --node-host(宿主地址)")?
.to_string();
let tcb: u32 = match parse_flag(args, "--node-tcb") {
Some(v) => v
.parse()
.map_err(|_| format!("--node-tcb {v:?} 不是整数"))?,
None => return Err("--node-platform 配了,但缺 --node-tcb(TCB 版本号)".to_string()),
};
let mut cap = HostCapConfig::new(site, host, kind, tcb);
if let Some(v) = parse_flag(args, "--node-qemu") {
cap.qemu_bin = v.to_string();
}
if let Some(v) = parse_flag(args, "--node-firmware") {
cap.firmware = v.to_string();
}
if let Some(v) = parse_flag(args, "--node-kernel") {
cap.kernel = v.to_string();
}
if let Some(v) = parse_flag(args, "--node-initrd") {
cap.initrd = v.to_string();
}
if let Some(v) = parse_flag(args, "--node-kbs-endpoint") {
cap.kbs_endpoint = Some(v.to_string());
}
// ★ KBC 模式:默认离线。给 `--node-kbs-endpoint` 却没显式说在线,
// 端点会被当摆设(探针只在在线模式下才算 kbs_reachable)。
cap.kbc = match parse_flag(args, "--node-kbc") {
Some("online") | Some("cc_kbc") => KbcMode::Online,
Some("offline") | Some("offline_fs_kbc") => KbcMode::Offline,
Some(other) => {
return Err(format!(
"--node-kbc {other:?} 认不出来(可用: online / offline)"
))
}
None => {
if cap.kbs_endpoint.is_some() {
KbcMode::Online
} else {
KbcMode::Offline
}
}
};
if let Some(v) = parse_flag(args, "--node-capacity") {
cap.capacity = v
.parse()
.map_err(|_| format!("--node-capacity {v:?} 不是整数"))?;
if cap.capacity == 0 {
return Err("--node-capacity 不能是 0(容量为 0 的节点调度器不会选它)".to_string());
}
}
// ★ 度量是**部署方声明**的事实(与路径同一性质):探针不自己算。
// 不给 ⇒ 全零 ⇒ 该节点永远选不中(admit 要求 has_measurement)。
if let Some(v) = parse_flag(args, "--node-measurement") {
cap.measurement = parse_measurement(v)?;
}
Ok(Some(cap))
}
/// 解析 32 字节度量(64 位十六进制)。
///
/// ★ 长度不对 ⇒ **拒**,不截断、不补零 —— 补零会让「填错」看起来像
/// 「度量恰好是那个值」,而截断会让两��不同的镜像撞成同一个度量。
fn parse_measurement(raw: &str) -> Result<[u8; 32], String> {
let s = raw.trim();
if s.len() != 64 {
return Err(format!(
"--node-measurement 必须是 64 位十六进制(32 字节),得到 {} 位",
s.len()
));
}
let mut out = [0u8; 32];
for (i, chunk) in s.as_bytes().chunks(2).enumerate() {
let hi = hex_digit(chunk[0])?;
let lo = hex_digit(chunk[1])?;
out[i] = (hi << 4) | lo;
}
Ok(out)
}
/// 单个十六进制数字位 → 数值。
fn hex_digit(b: u8) -> Result<u8, String> {
match b {
b'0'..=b'9' => Ok(b - b'0'),
b'a'..=b'f' => Ok(b - b'a' + 10),
b'A'..=b'F' => Ok(b - b'A' + 10),
_ => Err(format!("--node-measurement 含非十六进制字符 {:?}", b as char)),
}
}
/// `mpc tee` 的宿主端子命令。
pub fn cmd_tee_host(args: &[String]) -> Result<(), String> {
match args.first().map(String::as_str).unwrap_or("") {
"up" => cmd_up(&args[1..]),
"ps" => cmd_ps(&args[1..]),
"attest" => cmd_attest(&args[1..]),
"down" => cmd_down(&args[1..]),
other => Err(format!(
"用法: mpc tee up --host HOST:PORT --session S --site S --platform P --program PROG [--arg A]... \
| mpc tee ps --host HOST:PORT \
| mpc tee attest --host HOST:PORT --sandbox ID \
| mpc tee down --host HOST:PORT --sandbox ID\n\
未知子命令: {other}"
)),
}
}
/// 建客户端。
fn client(args: &[String]) -> Result<HostClient, String> {
let host = parse_flag(args, "--host").unwrap_or(DEFAULT_HOST);
let c = HostClient::new(host).map_err(|e| e.to_string())?;
match parse_flag(args, "--token") {
Some(t) => Ok(c.with_token(t)),
None => Ok(c),
}
}
/// `mpc tee up`:在宿主上起一个实例。
fn cmd_up(args: &[String]) -> Result<(), String> {
let c = client(args)?;
let session_id = parse_flag(args, "--session")
.ok_or("缺少 --session(本轮会话标识)")?
.to_string();
let site = parse_flag(args, "--site")
.ok_or("缺少 --site(本方 site 名)")?
.to_string();
let platform = parse_flag(args, "--platform")
.ok_or("缺少 --platform(snp/csv/tdx/optee)")?;
let program = parse_flag(args, "--program")
.ok_or("缺少 --program(要执行的程序)")?
.to_string();
let template = parse_flag(args, "--template").unwrap_or("").to_string();
let timeout_secs: u64 = match parse_flag(args, "--timeout") {
Some(v) => v
.parse()
.map_err(|_| format!("--timeout {v:?} 不是整数(秒)"))?,
None => 0,
};
// 参数按出现顺序收集 —— `--arg` 可以给多次。
let mut program_args: Vec<String> = Vec::new();
let mut i = 0;
while i < args.len() {
if args[i] == "--arg" {
let v = args
.get(i + 1)
.ok_or("--arg 后面缺值")?
.to_string();
program_args.push(v);
i += 2;
} else {
i += 1;
}
}
// JSON body 手写(不引 serde):字段与宿主端 `CreateRequest` 一一对应。
let mut body = String::from("{\"session_id\":");
body.push_str(&json_string(&session_id));
body.push_str(",\"site\":");
body.push_str(&json_string(&site));
body.push_str(",\"platform\":");
body.push_str(&json_string(platform));
body.push_str(",\"template\":");
body.push_str(&json_string(&template));
body.push_str(",\"program\":");
body.push_str(&json_string(&program));
body.push_str(",\"args\":[");
for (n, a) in program_args.iter().enumerate() {
if n > 0 {
body.push(',');
}
body.push_str(&json_string(a));
}
body.push(']');
if timeout_secs > 0 {
body.push_str(",\"timeout_secs\":");
body.push_str(&timeout_secs.to_string());
}
body.push('}');
let v = c.post("/sandboxes", &body).map_err(|e| e.to_string())?;
print_sandbox(&v);
Ok(())
}
/// `mpc tee ps`:列出实例。
fn cmd_ps(args: &[String]) -> Result<(), String> {
let c = client(args)?;
let v = c.get("/sandboxes").map_err(|e| e.to_string())?;
// e2b 兼容面:`GET /sandboxes` 返回**裸数组**。
let items = v
.as_array()
.ok_or("hostd 返回的不是数组(e2b 兼容面要求裸数组)")?;
let mut rows: Vec<Vec<report::Cell>> = Vec::new();
for it in items {
rows.push(vec![
report::Cell::txt(it.get_str("sandboxID").unwrap_or("").to_string()),
report::Cell::txt(it.get_str("sessionID").unwrap_or("").to_string()),
report::Cell::txt(it.get_str("platform").unwrap_or("").to_string()),
report::Cell::txt(it.get_str("state").unwrap_or("").to_string()),
report::Cell::txt(it.get_str("createdAt").unwrap_or("").to_string()),
]);
}
report::table(
"宿主上的 TEE 实例",
&["sandboxID", "sessionID", "platform", "state", "createdAt"],
&rows,
);
Ok(())
}
/// `mpc tee attest`:查一个实例的证明判定。
fn cmd_attest(args: &[String]) -> Result<(), String> {
let c = client(args)?;
let id = parse_flag(args, "--sandbox")
.ok_or("缺少 --sandbox(实例 ID)")?
.to_string();
let v = c
.get(&format!("/sandboxes/{id}/attestation"))
.map_err(|e| e.to_string())?;
let verdict = AttestationVerdict::from_json(&v);
let rows: Vec<(&str, report::Cell)> = vec![
("session_id", report::Cell::txt(verdict.session_id.clone())),
("platform", report::Cell::txt(verdict.platform.to_string())),
("tcb", report::Cell::int(verdict.tcb as i64)),
("min_tcb", report::Cell::int(verdict.min_tcb as i64)),
// ★ 四个布尔分开报,不合并成 ok。
("user_data_ok", report::Cell::flag(verdict.user_data_ok)),
("meas_ok", report::Cell::flag(verdict.meas_ok)),
("tcb_ok", report::Cell::flag(verdict.tcb_ok)),
("chip_sig", report::Cell::flag(verdict.chip_sig)),
("chip_sig_note", report::Cell::txt(verdict.chip_sig_note.clone())),
("verdict", report::Cell::txt(verdict.verdict.clone())),
];
report::kv("远程证明判定(四个布尔分开)", &rows);
Ok(())
}
/// `mpc tee down`:停一个实例。
fn cmd_down(args: &[String]) -> Result<(), String> {
let c = client(args)?;
let id = parse_flag(args, "--sandbox")
.ok_or("缺少 --sandbox(实例 ID)")?
.to_string();
c.delete(&format!("/sandboxes/{id}"))
.map_err(|e| e.to_string())?;
// e2b 的 DELETE 返回 204 空体(不能改 —— 那是 e2b 兼容面的硬要求)。
// 但「停完是什么状态」是要给人看的,所以补一次 GET。
match c.get(&format!("/sandboxes/{id}")) {
Ok(v) => print_sandbox(&v),
Err(_) => {
// 实例已从表里消失也正常(OP-TEE 关会话等场景)。
note!("实例 {id} 已停止(宿主已不再持有该实例)");
}
}
Ok(())
}
/// 打印一个实例视图。
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())),
("sessionID", report::Cell::txt(view.session_id.clone())),
("site", report::Cell::txt(view.site.clone())),
("platform", report::Cell::txt(view.platform.to_string())),
("template", report::Cell::txt(view.template_id.clone())),
("state", report::Cell::txt(view.state.clone())),
("argv", report::Cell::txt(view.argv.join(" "))),
("timeout", report::Cell::int(view.timeout as i64)),
];
report::kv("TEE 实例", &rows);
}
/// JSON 字符串字面量。
fn 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
}
/// 从 argv 里找 `--name value`。
fn parse_flag<'a>(args: &'a [String], name: &str) -> Option<&'a str> {
args.iter()
.position(|a| a == name)
.and_then(|i| args.get(i + 1))
.map(String::as_str)
}
#[cfg(test)]
mod tests {
use super::*;
fn args(v: &[&str]) -> Vec<String> {
v.iter().map(|s| String::from(*s)).collect()
}
const SECRET: &str = "0123456789abcdef0123456789abcdef";
/// ★ 正向:回环 + 无密钥 → 允许(回环信任模式)。
#[test]
fn loopback_without_secret_is_allowed() {
let cfg = build_host_config(&args(&["--listen", "127.0.0.1:3010"])).unwrap();
assert_eq!(cfg.listen, "127.0.0.1:3010");
assert!(cfg.shared_secret.is_none());
}
/// ★ 负向:非回环 + 无密钥 → **必须拒**。
///
/// 这条是本次改动的核心:不配密钥就开远程 = 无鉴权控制面暴露。
#[test]
fn non_loopback_without_secret_is_rejected() {
let e = build_host_config(&args(&[
"--listen",
"0.0.0.0:3010",
"--allow-remote",
]))
.unwrap_err();
assert!(e.contains("共享密钥"), "应说明缺共享密钥: {e}");
}
/// ★ 负向:非回环 + 有密钥但没 `--allow-remote` → **必须拒**。
#[test]
fn non_loopback_without_allow_remote_is_rejected() {
let e = build_host_config(&args(&[
"--listen",
"0.0.0.0:3010",
"--shared-secret",
SECRET,
]))
.unwrap_err();
assert!(e.contains("--allow-remote"), "应要求显式确认: {e}");
}
/// ★ 正向:非回环 + 有密钥 + `--allow-remote` → 允许。
#[test]
fn non_loopback_with_secret_and_allow_remote_is_allowed() {
let cfg = build_host_config(&args(&[
"--listen",
"0.0.0.0:3010",
"--shared-secret",
SECRET,
"--allow-remote",
]))
.unwrap();
assert_eq!(cfg.listen, "0.0.0.0:3010");
assert_eq!(cfg.shared_secret.as_ref().unwrap().len(), SECRET.len());
}
/// ★ 负向:密钥太短 → **必须拒**(不是警告)。
#[test]
fn short_secret_is_rejected() {
let e = build_host_config(&args(&["--shared-secret", "tooshort"])).unwrap_err();
assert!(e.contains("至少"), "应说明长度下限: {e}");
}
/// ★ 负向:密钥正好 31 字节 → 拒;32 字节 → 过。
#[test]
fn secret_length_boundary() {
let s31 = "x".repeat(31);
assert!(build_host_config(&args(&["--shared-secret", &s31])).is_err());
let s32 = "x".repeat(32);
assert!(build_host_config(&args(&["--shared-secret", &s32])).is_ok());
}
/// ★★ 正向:共享密钥可以走**环境变量** `MPC_HOSTD_SHARED_SECRET`。
///
/// ★ 2026-11-09 真机联调时发现:帮助文案承诺「也可用环境变量传」,
/// 但实现里**只**读 `--shared-secret` ⇒ 照文案写的部署脚本
/// 实际跑在**回环信任模式**下(零保护)⇒ 假就绪信号。
///
/// ★ 直接测 `resolve_shared_secret`(不碰进程环境变量)——
/// 环境变量是进程级的,Rust 测试默认并行 ⇒ `set_var` 会污染
/// 同一进程里的其它用例,导致随机假红。
#[test]
fn secret_can_come_from_env() {
let got = resolve_shared_secret(&args(&[]), Some(SECRET)).unwrap();
assert_eq!(
got.as_deref(),
Some(SECRET.as_bytes()),
"环境变量里的共享密钥必须被采用"
);
}
/// ★★ 正向:**参数优先于环境变量**。
///
/// 两侧是同一份密钥的**两个来源**;参数显式给的值必须胜出,
/// 否则「命令行里写的密钥」会被环境里那份悄悄顶掉 ——
/// 部署时极难察觉(两边都「配了密钥」,但不是同一份)。
#[test]
fn cli_flag_overrides_env_secret() {
let from_flag = "flag-secret-00000000000000000000000000";
let got = resolve_shared_secret(
&args(&["--shared-secret", from_flag]),
Some("env-secret-000000000000000000000000000"),
)
.unwrap();
assert_eq!(
got.as_deref(),
Some(from_flag.as_bytes()),
"命令行参数必须压过环境变量"
);
}
/// ★ 负向:环境变量里的密钥太短 → **必须拒**(不是警告)。
#[test]
fn short_secret_from_env_is_rejected() {
let e = resolve_shared_secret(&args(&[]), Some("tooshort")).unwrap_err();
assert!(e.contains("至少"), "应说明长度下限: {e}");
}
/// ★ 负向:参数里的密钥太短 → **必须拒**(环境变量那侧同样)。
#[test]
fn short_secret_from_flag_is_rejected() {
let e = resolve_shared_secret(&args(&["--shared-secret", "tooshort"]), None).unwrap_err();
assert!(e.contains("至少"), "应说明长度下限: {e}");
}
/// ★ 正向:两侧都没配 ⇒ 没密钥(回环信任模式)。
#[test]
fn no_secret_anywhere_means_none() {
assert!(resolve_shared_secret(&args(&[]), None).unwrap().is_none());
}
/// ★ 回环地址的判定不能被「看起来像回环」的串骗过。
#[test]
fn loopback_detection_is_exact() {
assert!(is_loopback("127.0.0.1:3010"));
assert!(is_loopback("localhost:3010"));
assert!(is_loopback("[::1]:3010"));
assert!(!is_loopback("0.0.0.0:3010"));
// ★ 前缀像回环但不是回环 —— `127.0.0.1.evil.com` 不该被当回环。
assert!(!is_loopback("127.0.0.1.evil.com:3010"));
assert!(!is_loopback("192.168.1.7:3010"));
}
/// ★ `--reap-interval` 非整数必须拒。
#[test]
fn bad_reap_interval_is_rejected() {
assert!(build_host_config(&args(&["--reap-interval", "abc"])).is_err());
assert!(build_host_config(&args(&["--reap-interval", "3"])).is_ok());
}
// ---- Cubelet 自描述(节点自报)----
/// ★ 默认:没有 `--node-platform` → 本宿主**不自报**能力。
#[test]
fn no_node_platform_means_no_self_report() {
let cfg = build_host_config(&args(&["--listen", "127.0.0.1:3010"])).unwrap();
assert!(cfg.node_capability.is_none(), "默认不得对外自报 TEE 能力");
assert!(cfg.control_plane.is_none());
}
/// ★ 正向:配全了能力 → 自报配置就绪。
#[test]
fn node_capability_is_parsed() {
let cfg = build_host_config(&args(&[
"--node-platform",
"snp",
"--node-site",
"alice",
"--node-host",
"192.168.1.7",
"--node-tcb",
"5",
"--node-qemu",
"/usr/bin/qemu-system-x86_64",
"--node-kernel",
"/boot/vmlinuz",
"--node-initrd",
"/boot/initrd.img",
"--node-capacity",
"4",
]))
.unwrap();
let cap = cfg.node_capability.expect("应进入自报模式");
assert_eq!(cap.site, "alice");
assert_eq!(cap.host, "192.168.1.7");
assert_eq!(cap.tcb, 5);
assert_eq!(cap.capacity, 4);
assert_eq!(cap.qemu_bin, "/usr/bin/qemu-system-x86_64");
assert_eq!(cap.kernel, "/boot/vmlinuz");
assert_eq!(cap.initrd, "/boot/initrd.img");
}
/// ★ 负向:平台认不出来 → **拒**,不猜。
#[test]
fn unknown_node_platform_is_rejected() {
let e = build_host_config(&args(&[
"--node-platform",
"wat",
"--node-site",
"alice",
"--node-host",
"h",
"--node-tcb",
"5",
]))
.unwrap_err();
assert!(e.contains("认不出来"), "应说明平台认不出来: {e}");
}
/// ★ 负向:缺 site / host / tcb → **拒**(不填默认值)。
#[test]
fn incomplete_node_capability_is_rejected() {
// 缺 site
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-host", "h", "--node-tcb", "5",
]))
.unwrap_err();
assert!(e.contains("--node-site"), "应点名缺 site: {e}");
// 缺 host
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-tcb", "5",
]))
.unwrap_err();
assert!(e.contains("--node-host"), "应点名缺 host: {e}");
// 缺 tcb
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
]))
.unwrap_err();
assert!(e.contains("--node-tcb"), "应点名缺 tcb: {e}");
// tcb 非整数
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h", "--node-tcb", "x",
]))
.unwrap_err();
assert!(e.contains("不是整数"), "应说明 tcb 非整数: {e}");
}
/// ★ 负向:配了控制面却没配能力 → **拒**(假就绪信号)。
#[test]
fn control_plane_without_capability_is_rejected() {
let e = build_host_config(&args(&["--control-plane", "127.0.0.1:3100"])).unwrap_err();
assert!(e.contains("--node-platform"), "应说明缺能力配置: {e}");
}
/// ★ 正向:控制面 + 能力齐 → 允许,且端点被记下。
#[test]
fn control_plane_with_capability_is_accepted() {
let cfg = build_host_config(&args(&[
"--control-plane",
"127.0.0.1:3100",
"--node-platform",
"csv",
"--node-site",
"bob",
"--node-host",
"192.168.1.102",
"--node-tcb",
"4",
"--report-interval",
"30",
]))
.unwrap();
assert_eq!(cfg.control_plane.as_deref(), Some("127.0.0.1:3100"));
assert_eq!(cfg.report_interval_secs, 30);
assert!(cfg.node_capability.is_some());
}
/// ★ 负向:容量为 0 → **拒**(零容量节点调度器永不选它)。
#[test]
fn zero_capacity_is_rejected() {
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-capacity", "0",
]))
.unwrap_err();
assert!(e.contains("容量"), "应说明容量非法: {e}");
}
/// ★ 负向:KBC 模式认不出来 → **拒**。
#[test]
fn unknown_kbc_mode_is_rejected() {
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-kbc", "wat",
]))
.unwrap_err();
assert!(e.contains("--node-kbc"), "应说明 KBC 模式认不出来: {e}");
}
/// ★ 给 KBS 端点但没显式说 KBC 模式 → 判**在线**(否则端点是摆设)。
#[test]
fn kbs_endpoint_implies_online_kbc() {
let cfg = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-kbs-endpoint", "http://127.0.0.1:8080",
]))
.unwrap();
let cap = cfg.node_capability.unwrap();
assert_eq!(cap.kbc, KbcMode::Online, "给了端点就该按在线处理");
assert_eq!(cap.kbs_endpoint.as_deref(), Some("http://127.0.0.1:8080"));
}
/// ★ 显式 offline + 给了端点 → 仍是**离线**(显式优先,不被端点覆盖)。
#[test]
fn explicit_offline_kbc_wins_over_endpoint() {
let cfg = build_host_config(&args(&[
"--node-platform", "csv", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-kbc", "offline",
"--node-kbs-endpoint", "http://127.0.0.1:8080",
]))
.unwrap();
let cap = cfg.node_capability.unwrap();
assert_eq!(cap.kbc, KbcMode::Offline, "显式离线不该被端点改成在线");
}
/// ★ 正向:给了度量 → 原样带出(部署方声明的事实,探针不自己算)。
#[test]
fn node_measurement_is_carried_verbatim() {
let m = "aa".repeat(32);
let cfg = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-measurement", &m,
]))
.unwrap();
let cap = cfg.node_capability.unwrap();
assert_eq!(cap.measurement, [0xaau8; 32]);
assert!(cap.measurement.iter().any(|b| *b != 0), "度量不该是全零");
}
/// ★ 负向:度量长度不对 ⇒ **拒**(不截断、不补零)。
#[test]
fn bad_measurement_length_is_rejected() {
for bad in ["aa".repeat(31), "aa".repeat(33), "aa".to_string(), String::new()] {
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-measurement", &bad,
]))
.unwrap_err();
assert!(
e.contains("--node-measurement"),
"应点名度量参数(长度不对): {e}"
);
}
}
/// ★ 负向:度量含非十六进制字符 ⇒ **拒**。
#[test]
fn non_hex_measurement_is_rejected() {
let mut bad = "aa".repeat(31);
bad.push('z');
let e = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5", "--node-measurement", &bad,
]))
.unwrap_err();
assert!(e.contains("十六进制"), "应说明非十六进制: {e}");
}
/// ★ 不给度量 ⇒ 全零 ⇒ 该节点**选不中**(诚实边界,不是缺陷)。
#[test]
fn missing_measurement_stays_zero() {
let cfg = build_host_config(&args(&[
"--node-platform", "snp", "--node-site", "a", "--node-host", "h",
"--node-tcb", "5",
]))
.unwrap();
let cap = cfg.node_capability.unwrap();
assert_eq!(cap.measurement, [0u8; 32]);
}
// ---- 芯片验签器配置 ----
/// ★ 默认:不配验签器 ⇒ 宿主侧**不做**芯片验签。
///
/// 这不是缺陷:宿主会明确记「未提供验签器」(≠「验了没过」)。
#[test]
fn no_verifier_by_default() {
let cfg = build_host_config(&args(&["--listen", "127.0.0.1:3010"])).unwrap();
assert!(cfg.chip_verifier.is_none(), "默认不得编造一个验签器");
}
/// ★ 正向:配了验签器 ⇒ 原样带出。
#[test]
fn verifier_is_parsed() {
let cfg = build_host_config(&args(&[
"--attest-verifier",
"/opt/mpc/bin/snp-verify-attestation.sh",
"--attest-verifier-arg",
"--offline",
"--attest-verifier-arg",
"--product",
"--attest-verifier-arg",
"Milan",
]))
.unwrap();
let v = cfg.chip_verifier.expect("应进入验签模式");
assert_eq!(v.program, "/opt/mpc/bin/snp-verify-attestation.sh");
// ★ 参数是**列表**,按出现顺序 —— 不拼成 shell 串。
assert_eq!(v.args, vec!["--offline", "--product", "Milan"]);
assert!(v.chain_dir.is_none());
}
/// ★ 负向:`--attest-verifier-arg` 后面缺值 ⇒ **拒**。
///
/// 这条钉的是「一个 flag 对应一个 argv」的严格语义 ——
/// 缺值时若静默忽略,传给验签器的 argv 就与用户意图不符。
#[test]
fn verifier_arg_without_value_is_rejected() {
let e = build_host_config(&args(&[
"--attest-verifier",
"/opt/mpc/bin/snp-verify-attestation.sh",
"--attest-verifier-arg",
]))
.unwrap_err();
assert!(e.contains("缺值"), "应说明缺值: {e}");
}
/// ★ 负向:给了参数却没给程序 ⇒ **拒**(假就绪信号)。
#[test]
fn verifier_args_without_program_is_rejected() {
let e = build_host_config(&args(&["--attest-verifier-arg", "--offline"])).unwrap_err();
assert!(e.contains("--attest-verifier"), "应点名缺程序: {e}");
let e = build_host_config(&args(&["--attest-chain-dir", "/tmp"])).unwrap_err();
assert!(e.contains("--attest-verifier"), "应点名缺程序: {e}");
}
/// ★ 负向:程序路径是空串 ⇒ **拒**。
#[test]
fn empty_verifier_program_is_rejected() {
let e = build_host_config(&args(&["--attest-verifier", " "])).unwrap_err();
assert!(e.contains("空串"), "应说明程序路径非法: {e}");
}
/// ★ 负向:证书链目录不存在 ⇒ **拒**。
///
/// 理由:验签 wrapper 会退化成「联网取证书」,真机离线时
/// 每次验签都失败 ⇒ 症状是 `chip_sig` 恒 false,根因却是路径打错。
#[test]
fn nonexistent_chain_dir_is_rejected() {
let e = build_host_config(&args(&[
"--attest-verifier",
"/opt/mpc/bin/snp-verify-attestation.sh",
"--attest-chain-dir",
"/nonexistent/chain/dir/xyz",
]))
.unwrap_err();
assert!(e.contains("--attest-chain-dir"), "应点名证书链目录: {e}");
}
/// ★ 正向:证书链目录存在 ⇒ 允许,并原样带出。
#[test]
fn existing_chain_dir_is_carried() {
let dir = std::env::temp_dir().join("mpc-cli-verifier-chain-test");
std::fs::create_dir_all(&dir).unwrap();
let cfg = build_host_config(&args(&[
"--attest-verifier",
"/opt/mpc/bin/snp-verify-attestation.sh",
"--attest-chain-dir",
dir.to_str().unwrap(),
]))
.unwrap();
let v = cfg.chip_verifier.expect("应进入验签模式");
assert_eq!(v.chain_dir, Some(dir.to_str().unwrap().to_string()));
let _ = std::fs::remove_dir_all(&dir);
}
/// ★ 正向:`--guest-endpoint` 合法 ⇒ 允许,并原样带出。
#[test]
fn guest_endpoint_is_carried() {
let cfg = build_host_config(&args(&["--guest-endpoint", "10.93.0.1:3010"])).unwrap();
assert_eq!(
cfg.guest_endpoint.as_deref(),
Some("10.93.0.1:3010"),
"guest 可达地址应原样带出"
);
}
/// ★ 正向:不给 `--guest-endpoint` ⇒ 不下发手牌(`None`)。
///
/// 这是**默认**:没配 guest 可达地址 ⇒ guest 传不回证明材料 ⇒
/// 判定停在 `pending` ⇒ 端点不公布(**诚实**的失败)。
#[test]
fn guest_endpoint_is_absent_by_default() {
let cfg = build_host_config(&args(&[])).unwrap();
assert!(cfg.guest_endpoint.is_none(), "默认不该下发手牌");
}
/// ★ 负向:`--guest-endpoint` 含空白 ⇒ **拒**。
///
/// 它会进内核命令行(`-append`),空格分隔 ⇒ 会被截断 ⇒
/// guest 读到半截地址 ⇒ 连不上(症状极具迷惑性)。
#[test]
fn guest_endpoint_with_whitespace_is_rejected() {
let e = build_host_config(&args(&["--guest-endpoint", "10.93.0.1 3010"])).unwrap_err();
assert!(e.contains("--guest-endpoint"), "应点名参数: {e}");
let e2 = build_host_config(&args(&["--guest-endpoint", "10.93.0.1:3010\nx"])).unwrap_err();
assert!(e2.contains("--guest-endpoint"), "应点名参数: {e2}");
}
/// ★ 负向:带 scheme / 带路径 / 缺端口 / 端口非法 ⇒ **拒**。
#[test]
fn malformed_guest_endpoint_is_rejected() {
for bad in [
"http://10.93.0.1:3010",
"10.93.0.1:3010/sandboxes",
"10.93.0.1",
"10.93.0.1:0",
"10.93.0.1:notaport",
":3010",
"",
" ",
] {
assert!(
build_host_config(&args(&["--guest-endpoint", bad])).is_err(),
"不该接受 guest endpoint: {bad:?}"
);
}
}
/// ★ 负向:通配地址 ⇒ **拒**。
///
/// guest 需要一个**具体可路由**的地址;`0.0.0.0` 对 guest 无意义。
/// 配了它的人多半是以为「这样 guest 就能连」——
/// 实际症状是 guest 连不上。
#[test]
fn wildcard_guest_endpoint_is_rejected() {
for bad in ["0.0.0.0:3010", "[::]:3010", "*:3010"] {
let e = build_host_config(&args(&["--guest-endpoint", bad])).unwrap_err();
assert!(
e.contains("通配"),
"应说明通配地址无效: {e}"
);
}
}
/// ★ 负向:裸 IPv6(不带方括号)⇒ **拒**。
///
/// `::3010` 会被按最后一个冒号切开 ⇒ host 变成 `:` ⇒
/// 端口边界说不清(到底是 `[::]:3010` 还是 `::3010`?)。
/// IPv6 必须写成 `[::1]:3010`。
#[test]
fn bare_ipv6_guest_endpoint_is_rejected() {
let e = build_host_config(&args(&["--guest-endpoint", "::3010"])).unwrap_err();
assert!(
e.contains("IPv6") || e.contains("方括号"),
"应说明裸 IPv6 要带方括号: {e}"
);
}
// ---- 宿主本地的启动参数覆盖 ----
/// ★ 正向:`--guest-netdev` 一个 flag 一个 argv 元素,按顺序追加。
#[test]
fn guest_netdev_args_are_collected_in_order() {
let cfg = build_host_config(&args(&[
"--guest-netdev",
"-netdev",
"--guest-netdev",
"socket,id=mpcnet0,listen=0.0.0.0:19500",
"--guest-netdev",
"-device",
"--guest-netdev",
"virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01",
]))
.unwrap();
let ov = cfg.launch_override.expect("应进入覆盖模式");
assert_eq!(
ov.netdev_args,
vec![
"-netdev",
"socket,id=mpcnet0,listen=0.0.0.0:19500",
"-device",
"virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01",
],
"★ 一个 flag 一个 argv 元素,按出现顺序"
);
}
/// ★ 正向:不给覆盖 ⇒ `None`(用框架的默认规格)。
#[test]
fn no_launch_override_by_default() {
let cfg = build_host_config(&args(&[])).unwrap();
assert!(cfg.launch_override.is_none(), "默认不该覆盖启动参数");
}
/// ★ 负向:netdev id 重复 ⇒ **拒**(qemu 会报 duplicate netdev id)。
#[test]
fn duplicate_netdev_id_is_rejected() {
let e = build_host_config(&args(&[
"--guest-netdev",
"-netdev",
"--guest-netdev",
"socket,id=mpcnet0,listen=0.0.0.0:19500",
"--guest-netdev",
"-netdev",
"--guest-netdev",
"socket,id=mpcnet0,connect=192.168.1.7:19500",
]))
.unwrap_err();
assert!(e.contains("重复"), "应说明 id 重复: {e}");
}
/// ★ 负向:占用 9p 手牌通道的 fsdev id ⇒ **拒**。
///
/// ★ 撞了 guest 就挂不上手牌 ⇒ 拿不到上传令牌 ⇒ 证明材料传不回来
/// ⇒ 宿主判定停在 `pending` ⇒ 端点**永不公布**。
#[test]
fn netdev_id_colliding_with_9p_fsdev_is_rejected() {
let e = build_host_config(&args(&[
"--guest-netdev",
"-netdev",
"--guest-netdev",
"socket,id=mpchostd9p,listen=0.0.0.0:19500",
]))
.unwrap_err();
assert!(e.contains("手牌") || e.contains("令牌"), "应点明撞了手牌通道: {e}");
}
/// ★ 负向:netdev 规格里没有 `id=` ⇒ **拒**。
///
/// 没有 id 就无法核对重复 ⇒ 撞 id 了也只有 qemu 自己会报错,
/// 而 qemu 的报错现场(duplicate netdev id)完全看不出是哪个参数。
#[test]
fn netdev_spec_without_id_is_rejected() {
let e = build_host_config(&args(&[
"--guest-netdev",
"-netdev",
"--guest-netdev",
"socket,listen=0.0.0.0:19500",
]))
.unwrap_err();
assert!(e.contains("id="), "应说明缺 id: {e}");
}
/// ★ 负向:`-netdev` 后面缺值 ⇒ **拒**。
#[test]
fn netdev_flag_without_value_is_rejected() {
let e = build_host_config(&args(&["--guest-netdev", "-netdev"])).unwrap_err();
assert!(e.contains("缺值"), "应说明缺值: {e}");
}
/// ★ 负向:内核参数含空白 ⇒ **拒**(会被内核截断)。
#[test]
fn kernel_param_with_whitespace_is_rejected() {
let e = build_host_config(&args(&[
"--guest-kernel-param",
"mpc.tee.ip=10.99.0.2/24 mpc.role=root",
]))
.unwrap_err();
assert!(e.contains("空白"), "应说明含空白: {e}");
}
/// ★★★ 负向:内核参数带**凭据语义** ⇒ **拒**。
///
/// ★ 内核命令行(qemu 的 `-append`)在宿主上是**明文可见**的
/// (`ps` 输出、shell 历史、审计日志)。
/// 凭据走 9p 手牌(见 `guest_hand.rs`)—— 那里才是加密的通道。
///
/// ★ 这条挡的是「顺手把 token 塞进内核参数让它跑通」——
/// 那等于把令牌暴露给宿主上任何能看 ps 的人。
#[test]
fn kernel_param_with_credential_semantics_is_rejected() {
for bad in [
"mpc.tee.token=deadbeef",
"mpc.tee.secret=deadbeef",
"mpc.tee.password=deadbeef",
"mpc.tee.psk=deadbeef",
"mpc.tee.seed=deadbeef",
] {
let e = build_host_config(&args(&["--guest-kernel-param", bad])).unwrap_err();
assert!(
e.contains("凭据"),
"应拒绝带凭据语义的内核参数 {bad:?}: {e}"
);
}
}
/// ★ 正向:非凭据的内核参数 ⇒ 允许,并原样带出。
#[test]
fn benign_kernel_param_is_carried() {
let cfg = build_host_config(&args(&[
"--guest-kernel-param",
"mpc.tee.ip=10.99.0.2/24",
]))
.unwrap();
let ov = cfg.launch_override.expect("应进入覆盖模式");
assert_eq!(ov.extra_kernel_params, "mpc.tee.ip=10.99.0.2/24");
assert!(ov.netdev_args.is_empty());
}
/// ★★★ **正向:多个 `--guest-kernel-param` 必须按单空格 join。**
///
/// ★ 这份字符串会被**服务端** `apply_launch_override()` 再按空格
/// 切分并进 `-append` —— 两端口径必须一致。早先服务端对整串判
/// 「含空白即拒」,与本端的 join 直接冲突 ⇒ 真机给 ≥2 个参数恒挂。
#[test]
fn multiple_kernel_params_are_joined_with_single_spaces() {
let cfg = build_host_config(&args(&[
"--guest-kernel-param",
"mpc.tee.ip=10.99.0.2/24",
"--guest-kernel-param",
"mpc.role=root",
"--guest-kernel-param",
"mpc.tee.data_mac=02:00:00:00:0a:01",
]))
.unwrap();
let ov = cfg.launch_override.expect("应进入覆盖模式");
assert_eq!(
ov.extra_kernel_params,
"mpc.tee.ip=10.99.0.2/24 mpc.role=root mpc.tee.data_mac=02:00:00:00:0a:01"
);
}
/// ★★★ **负向:破坏实验** —— 不加覆盖时,宿主配置里必须**没有**它。
///
/// ★ 「负向判据天然可能恒为真」是项目纪律里反复强调的坑:
/// 显式断言「不给 `--guest-netdev` ⇒ `launch_override` 是 `None`」
/// ⇒ 证明本组判据不是恒真。
#[test]
fn without_the_flags_there_is_no_override() {
let cfg = build_host_config(&args(&["--listen", "127.0.0.1:3010"])).unwrap();
assert!(
cfg.launch_override.is_none(),
"★ 破坏实验:不给 flag 时不得凭空造出覆盖(否则本组判据恒真)"
);
}
}