- 新增 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 不等于本轮实例在跑)
1549 lines
62 KiB
Rust
1549 lines
62 KiB
Rust
//! `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 时不得凭空造出覆盖(否则本组判据恒真)"
|
||
);
|
||
}
|
||
}
|