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 不等于本轮实例在跑)
This commit is contained in:
admin committed 2026-11-09 20:12:32 +08:00
1 parent 74bf24a1b8
commit 32419efc27
9 files changed
+2260 -18

No files matched your search

+314
View File
@@ -111,6 +111,13 @@ fn build_host_config(args: &[String]) -> Result<HostConfig, String> {
// 端点不公布(**诚实**的失败,不是缺陷)。
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() {
@@ -274,6 +281,135 @@ fn build_guest_endpoint(args: &[String]) -> Result<Option<String>, String> {
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`(**不做**芯片验签)。
@@ -1231,4 +1367,182 @@ mod tests {
"应说明裸 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 时不得凭空造出覆盖(否则本组判据恒真)"
);
}
}
+25 -1
View File
@@ -362,6 +362,29 @@ pub fn parse_create_request(body: &str) -> Result<CreateRequest, String> {
let session_id_bytes = v.get_str("bind_session_id");
let session_pubkey = v.get_str("bind_session_pubkey");
let code_measurement = v.get_str("bind_code_measurement");
// ★★ 绑定的 **site** 必须**显式**给(`bind_site`)——
//
// `user_data` 的第一段哈希绑了 site(`session.rs::user_data`)。
// 而「绑定里的 site」与「请求体里的 site」**不是同一件事**:
// · 请求体的 `site` = **这台节点**的 site(选址结果,alice / bob);
// · 绑定的 `site` = **算这份绑定的一方**的 site(会话发起方)。
// 集群面下发的典型场景:控制面 site=alice,选中一台 site=bob 的节点
// (跨网段暴露)⇒ 两者**必然不同**。
//
// ★ 早先这里用请求体的 `site` 顶替绑定的 site ⇒
// 宿主重算的 `user_data` 与 guest 采报告时用的那份**必然不同**
// ⇒ `user_data_ok=false` ⇒ 判定为「重放攻击」。
// 症状极具误导性:报的是「user_data 与本次会话绑定不一致(可能是重放报告)」,
// 而真因是**传输时把 site 换了**。排查方向会被带到「密钥 / nonce / 报告新鲜性」上,
// 实际是「一个字段在两份材料之间对不上」。
//
// ⇒ 现在:`bind_site` 必给;旧调用方(没给 `bind_site`)**退回**请求体的
// `site`,并**保留**旧行为兼容 —— 但控制面下发路径必须显式给
// `bind_site`(见 `host_dispatch::launch_body`)。
let bind_site = v
.get_str("bind_site")
.map(String::from)
.unwrap_or_else(|| site.clone());
let binding = match (session_id_bytes, session_pubkey, code_measurement) {
(None, None, None) => None,
(Some(a), Some(b), Some(c)) => {
@@ -374,7 +397,7 @@ pub fn parse_create_request(body: &str) -> Result<CreateRequest, String> {
let meas = parse_hex32(c).ok_or_else(|| {
String::from("bind_code_measurement 必须是 64 位十六进制(32 字节)")
})?;
Some(SessionBinding::new(sid, site.clone(), pk, meas))
Some(SessionBinding::new(sid, bind_site, pk, meas))
}
_ => {
return Err(String::from(
@@ -382,6 +405,7 @@ pub fn parse_create_request(body: &str) -> Result<CreateRequest, String> {
))
}
};
let tcb = v.get_int("tcb").unwrap_or(0).max(0) as u32;
let min_tcb = v.get_int("min_tcb").unwrap_or(0).max(0) as u32;
let pinned_measurement = match v.get_str("pinned_measurement") {
+122
View File
@@ -146,6 +146,19 @@ fn launch_body(site: &str, session_id: &str, launch: &LaunchSpec) -> Result<Stri
body.push_str("bind_session_id", &hex32(&b.session_id));
body.push_str("bind_session_pubkey", &hex32(&b.session_pubkey));
body.push_str("bind_code_measurement", &hex32(&b.code_measurement));
// ★★ 绑定的 site **必须显式带**。
//
// `user_data` 第一段哈希绑了 site(`session.rs::user_data`),
// 而「绑定的 site」(算绑定的一方)与「请求体的 site」(这台节点的 site)
// **不是同一件事** —— 集群面跨网段选址时两者**必然不同**
// (控制面 site=alice,选中 site=bob 的节点)。
//
// 早先这里没带 ⇒ 宿主用**请求体的 site** 顶替 ⇒ 重算出的 `user_data`
// 与 guest 采报告时用的那份**必然不同** ⇒ `user_data_ok=false`
// ⇒ 判定报「user_data 与本次会话绑定不一致(可能是重放报告)」。
// 那个报错把排查方向带到了「密钥 / nonce / 报告新鲜性」上,
// 而真因是**一个字段在两份材料之间对不上**。
body.push_str("bind_site", &b.site);
body.push_int("tcb", launch.tcb as i64);
body.push_int("min_tcb", launch.min_tcb as i64);
if let Some(p) = &launch.pinned_measurement {
@@ -220,3 +233,112 @@ impl TeeHostDispatch for HostClient {
.map_err(|e| TeeError::Io(format!("删 {endpoint} 的 {sandbox_id} 失败: {e}")))
}
}
#[cfg(test)]
mod tests {
use super::*;
use mpc_tee::platform::KbcMode;
use mpc_tee::schedule::{LaunchSpec, TeeNode};
use mpc_tee::session::SessionBinding;
/// 一台**跨网段**的节点(site = bob),绑定的 site = alice。
///
/// ★ 这正是集群面「控制面 alice 选中 bob 节点」的场景 ——
/// 两个 site **必然不同**。
fn cross_segment_spec() -> LaunchSpec {
let mut node = TeeNode::new("bob", "192.168.1.102", mpc_tee::PlatformKind::HygonCsv, 4);
node.device_present = true;
node.qemu_present = true;
node.firmware_present = true;
node.image_present = true;
node.measurement = [9u8; 32];
node.kbc = KbcMode::Offline;
node.qemu_bin = String::from("/usr/bin/qemu-system-x86_64");
node.firmware = String::from("/srv/tee/HYGONCSV.fd");
node.kernel = String::from("/srv/tee/vmlinuz-csv");
node.initrd = String::from("/srv/tee/initrd-csv.img");
let binding = SessionBinding::new([1u8; 32], "alice", [2u8; 32], node.measurement);
let req = mpc_tee::schedule::TeeRequirement::new(mpc_tee::PlatformKind::HygonCsv, 3);
mpc_tee::schedule::admit(&req, &node, &binding).expect("准入必须通过")
}
/// ★★★ **下发体必须带 `bind_site`,且它与请求体的 `site` 不同**。
///
/// ★ 这条守的是 2026-11-10 真机联调挖出的真 bug:
/// 早先 `launch_body` 不带 `bind_site` ⇒ 宿主用**请求体的 site**
/// 顶替绑定的 site ⇒ 重算出的 `user_data` 与 guest 采报告时用的那份
/// **必然不同** ⇒ `user_data_ok=false` ⇒ 判定报
/// 「user_data 与本次会话绑定不一致(可能是重放报告)」。
///
/// ★ 那个报错极具误导性:把排查方向带到「密钥 / nonce / 报告新鲜性」,
/// 而真因是**一个字段在两份材料之间对不上**。
#[test]
fn launch_body_carries_bind_site_separately_from_node_site() {
let spec = cross_segment_spec();
// 请求体的 site 是**这台节点**的 site(bob)。
let body = launch_body("bob", "sess-1", &spec).unwrap();
let parsed = crate::api::parse_create_request(&body).expect("请求体必须能解析");
// ★ 请求体的 site = 节点 site。
assert_eq!(parsed.site, "bob");
// ★ 绑定材料里的 site = 会话发起方的 site(alice)—— 两者**必须不同**。
let b = parsed.binding.expect("绑定材料必须在");
assert_eq!(b.site, "alice", "★ 绑定的 site 必须来自 bind_site,不是请求体的 site");
assert_ne!(
b.site, parsed.site,
"★ 跨网段场景下两者必然不同 —— 这条判据才有意义"
);
}
/// ★★★ **端到端:宿主重算的 `user_data` 必须与 guest 用的那份一致**。
///
/// ★ 这是这条修复的**真正判据** —— 不是「字段在不在」,
/// 而是「宿主独立重算出来的绑定值与 guest 采报告时用的**逐字节相同**」。
///
/// ★ 判「字段在不在」不够:字段在但值错了(拿成节点 site)一样会红。
/// 而判「重算值一致」才是**唯一**能证明修复有效的判据。
#[test]
fn host_recomputes_the_same_user_data_as_the_guest_used() {
let spec = cross_segment_spec();
let body = launch_body("bob", "sess-1", &spec).unwrap();
let parsed = crate::api::parse_create_request(&body).expect("请求体必须能解析");
let b = parsed.binding.expect("绑定材料必须在");
// 宿主侧独立重算(用请求体里的 tcb 与绑定的 site)。
let recomputed = b.user_data(parsed.platform, parsed.tcb);
// guest 侧用的是调度层算出来的那份(LaunchSpec 里带的就是它)。
assert_eq!(
recomputed, spec.user_data,
"★ 宿主重算的 user_data 必须与 guest 用的那份逐字节相同"
);
assert!(parsed.tcb > 0, "TCB 必须下发(重算绑定值要用它)");
}
/// ★★★ **负向:破坏实验** —— 不带 `bind_site` 时,重算值必然对不上。
///
/// ★ 「负向判据天然可能恒为真」是项目纪律里反复强调的坑:
/// 这里显式构造「**删掉** `bind_site`」的请求体,
/// 断言它**一定**重算出不同的 `user_data` ⇒ 证明本组判据不是恒假。
#[test]
fn dropping_bind_site_breaks_user_data_recomputation() {
let spec = cross_segment_spec();
let body = launch_body("bob", "sess-1", &spec).unwrap();
// ★ 模拟旧行为:请求体里**没有** `bind_site`。
// 解析侧会退回请求体的 `site`(bob)—— 也就是那个真 bug。
let stripped = body.replace(",\"bind_site\":\"alice\"", "");
assert!(
!stripped.contains("bind_site"),
"★ 破坏实验:删掉 bind_site 后请求体不该还含它"
);
let parsed = crate::api::parse_create_request(&stripped).expect("请求体必须能解析");
let b = parsed.binding.expect("绑定材料必须在");
assert_eq!(b.site, "bob", "★ 退回请求体的 site 就是那个 bug 的行为");
let recomputed = b.user_data(parsed.platform, parsed.tcb);
assert_ne!(
recomputed, spec.user_data,
"★ 破坏实验:没有 bind_site 时重算值必然不同(否则本组判据恒真)"
);
}
}
+17 -1
View File
@@ -51,7 +51,7 @@ use crate::runtime::VerifierConfig;
use mpc_tee::probe::{HostCapConfig, NodeReporter};
pub use client::HostClient;
pub use runtime::{Instance, InstanceState, RuntimeError, SpawnSpec, TeeRuntime};
pub use runtime::{Instance, InstanceState, LaunchOverride, RuntimeError, SpawnSpec, TeeRuntime};
pub use runtime::VerifierConfig as ChipVerifierConfig;
use std::sync::Arc;
@@ -94,6 +94,13 @@ pub struct HostConfig {
/// ★ 不配 ⇒ 不下发 guest 手牌 ⇒ guest 传不回证明材料 ⇒
/// 判定停在 `pending` ⇒ 端点不公布(**诚实**的失败,不是缺陷)。
pub guest_endpoint: Option<String>,
/// ★ 宿主本地的**启动参数覆盖**(真机网卡 / 额外内核参数)。
///
/// ★ 为什么是**宿主本地**的事实而不是请求体字段:
/// 网卡后端决定 guest 能连到谁(`socket` 的对端地址、`tap` 的名字)。
/// 放请求体里 ⇒ 站点端可以让本机的 guest 去连**任意**对端
/// ⇒ SSRF / 流量劫持面。与 `guest_endpoint` 同理。
pub launch_override: Option<LaunchOverride>,
}
impl Default for HostConfig {
@@ -108,6 +115,7 @@ impl Default for HostConfig {
report_interval_secs: 15,
chip_verifier: None,
guest_endpoint: None,
launch_override: None,
}
}
}
@@ -152,6 +160,14 @@ pub fn serve(cfg: HostConfig) -> Result<(), String> {
if let Some(e) = &cfg.guest_endpoint {
base = base.with_guest_endpoint(e.clone());
}
// ★ 启动参数覆盖(真机网卡 / 额外内核参数)。
// 这是**这台宿主的事实** —— 框架的 `-netdev user` 在海光真机上
// 直接起不来(没编 slirp),真机还要**两张卡**(socket 跨 guest +
// tap 进宿主网段访问 KBS)。框架的规格是平台中立的,
// 不知道这些 ⇒ 必须由宿主自己覆盖。
if let Some(ov) = &cfg.launch_override {
base = base.with_launch_override(ov.clone());
}
let rt = Arc::new(base);
rt.start_reaper(std::time::Duration::from_secs(cfg.reap_interval_secs.max(1)));
+506
View File
@@ -355,6 +355,44 @@ pub struct TeeRuntime {
/// ★ 这**不是**请求体字段 —— 它是这台宿主的事实。
/// 放请求体里会允许站点端把 guest 的回传地址指向任意主机。
guest_endpoint: Option<String>,
/// ★ 宿主本地的**启动参数覆盖**(真机网卡 / 额外内核参数)。
///
/// ★ 为什么需要它(2026-11-10 真机联调挖出):
/// 框架的 `qemu_argv()` 给的是**平台中立**的规格,其中网卡是
/// `-netdev user,id=mpcnet0`(qemu 自带的 slirp)。
/// 而真机上有两条**硬约束**是框架不知道的:
/// ① 海光真机的静态 qemu(kata-static 裁剪版)**没编 slirp** ——
/// `-netdev user` 直接报 "Parameter 'type' expects a netdev backend type";
/// ② 真机要**两张卡**(跨 guest 密文会话走 `socket` 二层、
/// 访问宿主 KBS 走 `tap` 三层)—— 框架只给一张。
/// 这两条都是**这台宿主的事实**,不是「每次创建时站点端能指定的东西」。
///
/// ★ 为什么**不**做成请求体字段:
/// 与 `guest_endpoint` 同理 —— 网卡后端(`socket` 的对端地址、
/// `tap` 的名字)决定 guest 能连到谁。放请求体里 ⇒ 站点端可以让
/// 本机的 guest 去连**任意**对端 ⇒ SSRF / 流量劫持面。
/// ⇒ 只允许**宿主自己**配(启动参数)。
launch_override: Option<LaunchOverride>,
}
/// ★ 宿主本地的启动参数覆盖。
///
/// 全部是**这台宿主的事实**,由 `mpc hostd` 的启动参数给出:
///
/// - `netdev_args`:整段替换 qemu argv 里的 `-netdev` / `-device` 网卡部分;
/// - `extra_kernel_params`:追加到 `-append` 的内核参数。
#[derive(Debug, Clone, Default)]
pub struct LaunchOverride {
/// 替换网卡参数的**完整 argv 片段**(如
/// `["-netdev","socket,id=mpcnet0,listen=0.0.0.0:19500","-device","virtio-net-pci,netdev=mpcnet0,mac=..."]`)。
///
/// ★ 必须是**完整 argv 元素**(不是 shell 串)—— qemu 的参数里有逗号,
/// 按空格拆再拼会破坏 `key=value,key=value` 的结构。
pub netdev_args: Vec<String>,
/// 追加到 `-append` 的内核参数(空格分隔的整串)。
///
/// ★ 里面**只能**放非凭据。凭据(令牌)走 9p 手牌 —— 见 [`crate::guest_hand`]。
pub extra_kernel_params: String,
}
/// ★ 外部芯片验签器的配置。
@@ -400,9 +438,26 @@ impl TeeRuntime {
hand_root: root,
hand_dirs: Mutex::new(HashMap::new()),
guest_endpoint: None,
launch_override: None,
}
}
/// ★ 配宿主本地的**启动参数覆盖**(真机网卡 / 额外内核参数)。
///
/// ★ 为什么是**宿主本地**的事实而不是请求体字段:
/// 网卡后端决定 guest 能连到谁(`socket` 的对端地址、`tap` 的名字)。
/// 放请求体里 ⇒ 站点端可以让本机的 guest 去连**任意**对端
/// ⇒ SSRF / 流量劫持面。与 `guest_endpoint` 同理。
pub fn with_launch_override(mut self, ov: LaunchOverride) -> Self {
self.launch_override = Some(ov);
self
}
/// 当前配置的启动参数覆盖(`None` = 用框架的默认规格)。
pub fn launch_override(&self) -> Option<&LaunchOverride> {
self.launch_override.as_ref()
}
/// 建一个带落盘的运行时。
pub fn with_state_file(path: impl Into<PathBuf>) -> Self {
let mut s = Self::with_hand_root(default_hand_root());
@@ -583,6 +638,15 @@ impl TeeRuntime {
// ★ 手牌必须在 spawn **之前**备好 ——
// qemu 启动时就要挂 9p 目录,guest 一起来就能读。
let mut argv = spec.args.clone();
// ★★★ 宿主本地的**启动参数覆盖**(真机网卡 / 额外内核参数)。
//
// ★ 必须在 9p 参数追加**之前**做:覆盖会重排 `-device`,
// 而 9p 的 `-device virtio-9p-pci,...` 必须原样保留。
if let Some(ov) = &self.launch_override {
apply_launch_override(&mut argv, ov).map_err(|e| {
RuntimeError::Spawn(format!("启动参数覆盖失败: {e}"))
})?;
}
// 上传令牌(无绑定上下文时为空 —— 那个实例不参与证明门控)。
let mut upload_token = String::new();
// ★ 手牌目录(每实例一个);实例删除时一并清掉。
@@ -1370,6 +1434,190 @@ fn exit_state(code: Option<i32>) -> InstanceState {
}
}
/// ★ 把宿主本地的**启动参数覆盖**应用到 qemu argv。
///
/// # 覆盖两件事
///
/// 1. **网卡参数**:整段替换框架给的 `-netdev user` + 对应 `-device`;
/// 2. **额外内核参数**:并进 `-append` 的值(空格分隔)。
///
/// # ★ 为什么必须**整段替换**而不是「再加一张卡」
///
/// 框架的 `qemu_argv()` 给的是 `-netdev user,id=mpcnet0`(qemu 自带的 slirp)。
/// 海光真机的静态 qemu(kata-static 裁剪版)**没编 slirp** ——
/// `-netdev user` 直接报 `Parameter 'type' expects a netdev backend type`。
///
/// 而真机要**两张卡**:
/// - 跨 guest 密文会话走 `socket`(**二层**点对点,两端只有 10.0.0.1/.2);
/// - 访问宿主 KBS 走 `tap`(**三层**,guest 需要同网段地址)。
///
/// 两者**不能是同一张卡**(合成一张 ⇒「会话连得上但取不到密钥」或反过来)。
/// 框架只给一张 ⇒ 必须整段换掉。
///
/// # ★ 为什么**不**做成请求体字段
///
/// 网卡后端决定 guest 能连到谁(`socket` 的对端地址、`tap` 的名字)。
/// 放请求体里 ⇒ 站点端可以让本机的 guest 去连**任意**对端 ⇒ SSRF。
/// 与 `guest_endpoint` 同理:只允许**宿主自己**配(启动参数)。
///
/// # 负向:不改 argv 的「静默失败」一律不接受
///
/// - 覆盖了网卡但 argv 里**没有** `-netdev` ⇒ **拒**(配错了以为生效了);
/// - `-append` 不存在 ⇒ 额外内核参数**无处可放** ⇒ **拒**。
pub fn apply_launch_override(argv: &mut Vec<String>, ov: &LaunchOverride) -> Result<(), String> {
// ---- 1. 网卡参数 ----
if !ov.netdev_args.is_empty() {
// ★ 先收集框架那张卡的 netdev id(**必须在摘除之前**)——
// 后面要靠它认出「哪张 `-device` 是框架那张卡的」。
let framework_ids = collect_netdev_ids(argv);
// 摘掉框架给的 `-netdev`(**所有** `-netdev`,不只 `user` 那种)——
// 框架那张卡在真机上是多余的,留着会撞 id 或直接起不来。
let mut had_netdev = false;
let mut i = 0usize;
while i < argv.len() {
if argv[i] == "-netdev" {
had_netdev = true;
// `-netdev` + 它的值:两元素一起摘。
argv.drain(i..(i + 2).min(argv.len()));
continue;
}
i += 1;
}
// 摘掉与框架那张卡绑定的 `-device`(`virtio-net-pci,netdev=mpcnet0`)。
//
// ★ 为什么要按 **netdev id** 摘而不是只摘 `virtio-net-pci`:
// 9p 的 `-device virtio-9p-pci,fsdev=...` 也含 `-device`,
// 按前缀盲摘会把 9p 通道一起摘掉 ⇒ guest 拿不到手牌
// ⇒ 证明材料传不回来 ⇒ 判定停在 pending ⇒ 端点不公布。
let mut i = 0usize;
while i < argv.len() {
if argv[i] == "-device" && i + 1 < argv.len() {
let v = &argv[i + 1];
if let Some(id) = netdev_id_of_device(v) {
// 只摘「框架原来那张卡」—— id 在**框架的** id 集合里。
if framework_ids.iter().any(|f| f == &id) {
argv.drain(i..(i + 2).min(argv.len()));
continue;
}
}
}
i += 1;
}
let _ = had_netdev;
// 追加宿主给的网卡参数(**完整 argv 元素**,不按空格拆)。
argv.extend(ov.netdev_args.iter().cloned());
// ★★★ **终检**:宿主注入的每个 netdev id 必须真的进了 argv。
//
// ★ 为什么不能靠「框架原来有没有 -netdev」来判:
// 框架只在**在线 KBC** 时才给 `-netdev user`(`needs_network()`)。
// 离线 KBC 的场景框架根本不给网卡,而宿主**仍然**可能要加一张
// (比如 role=none 但要访问宿主 KBS)⇒ 那种情况下「框架没给网卡」
// 是**正常**的,不是「覆盖规则对不上」。
// 用「有没有 -netdev」当判据会把合法配置判成错。
//
// ★ 真正要防的是「**覆盖没生效**」—— 配了却没进 argv ⇒
// 机器以为网卡是宿主给的,实际是框架那张 `-netdev user`
// ⇒ 海光上直接报 "Parameter 'type' expects a netdev backend type"。
// 症状与「压根没配」一模一样 ⇒ 必须在这里**拒**。
let final_ids = collect_netdev_ids(argv);
for want in collect_netdev_ids(&ov.netdev_args) {
if !final_ids.contains(&want) {
return Err(format!(
"宿主注入的 netdev {want:?} 没有进到最终 argv —— 覆盖没生效"
));
}
}
}
// ---- 2. 额外内核参数 ----
let extra = ov.extra_kernel_params.trim();
if !extra.is_empty() {
// ★★★ `extra_kernel_params` 是**多个内核参数按空格拼接**的整串:
// CLI 侧 `build_launch_override()` 把重复的 `--guest-kernel-param`
// **逐个**校验(单个参数内不得含空白/控制字符)后用单空格 join。
// 所以「整串含空格」是**设计如此**,不是错误。
//
// ★ 早先这里对**整串**判 `any(is_whitespace)` ⇒ 给 ≥2 个参数恒拒,
// 真机症状是 `create 失败: hostd 返回 500: 启动参数覆盖失败:
// 额外内核参数含空白或控制字符`,而排查方向会被带到网卡/脚本上。
// 给 1 个参数能过只是**碰巧**(整串里没空格)。
//
// 真正要防的是**单个参数内部**含控制字符 —— 内核命令行按空格
// 切分,控制字符不会切分但会污染参数值(换行/TAB 还会被 qemu
// 或外层 shell 解释)。空白由 `split_whitespace()` 规范化掉。
let tokens: Vec<&str> = extra.split_whitespace().collect();
for tok in &tokens {
if tok.chars().any(|c| c.is_control()) {
return Err(format!(
"额外内核参数 {tok:?} 含控制字符 —— 内核命令行参数值不允许控制字符"
));
}
}
// ★ 用规范化后的单空格串追加:避免原串里的 TAB/连续空白混进
// 内核命令行(那些字符在 -append 值里是合法的,但会污染日志
// 与后续按空格解析的一方)。
let normalized = tokens.join(" ");
let Some(idx) = argv.iter().position(|a| a == "-append") else {
return Err(String::from(
"配了额外内核参数,但 qemu argv 里没有 -append —— 参数无处可放",
));
};
let v = argv
.get_mut(idx + 1)
.ok_or("qemu argv 里 -append 后面缺值")?;
if !v.is_empty() {
v.push(' ');
}
v.push_str(&normalized);
}
Ok(())
}
/// 从 `-netdev <spec>` 形态的 argv 片段里收集 netdev id。
///
/// 片段形如 `["-netdev", "socket,id=mpcnet0,listen=0.0.0.0:19500", ...]`。
/// 只看**紧跟 `-netdev` 之后**的那个元素。
fn collect_netdev_ids(args: &[String]) -> Vec<String> {
let mut out = Vec::new();
let mut i = 0usize;
while i < args.len() {
if args[i] == "-netdev" {
if let Some(v) = args.get(i + 1) {
if let Some(id) = netdev_id_of_spec(v) {
out.push(id);
}
}
}
i += 1;
}
out
}
/// 从 `-netdev` 的值里取 `id=`。
fn netdev_id_of_spec(spec: &str) -> Option<String> {
for part in spec.split(',') {
if let Some(id) = part.strip_prefix("id=") {
if !id.is_empty() {
return Some(String::from(id));
}
}
}
None
}
/// 从 `-device` 的值里取 `netdev=`。
fn netdev_id_of_device(device: &str) -> Option<String> {
for part in device.split(',') {
if let Some(id) = part.strip_prefix("netdev=") {
if !id.is_empty() {
return Some(String::from(id));
}
}
}
None
}
/// 从 [`JsonObject`] 取回对象。
fn json_from_object(o: JsonObject) -> Json {
// `JsonObject` 的序列化产物就是一个对象;这里只需要能放进数组。
@@ -2281,4 +2529,262 @@ mod tests {
assert!(!r.paused);
let _ = rt.stop(&inst.sandbox_id);
}
// ---- 宿主本地的启动参数覆盖(真机网卡 / 额外内核参数)----
/// 一份**真机形态**的 qemu argv(含框架那张 `-netdev user`)。
///
/// ★ 这份形状取自 `schedule.rs::qemu_argv` 的真实输出 ——
/// 守卫测试必须对着**真形状**写,否则改了框架而测试还绿。
fn framework_qemu_argv() -> Vec<String> {
vec![
String::from("/opt/kata/bin/qemu-system-x86_64"),
String::from("-enable-kvm"),
String::from("-machine"),
String::from("q35,confidential-guest-support=sev0"),
String::from("-append"),
String::from("console=ttyS0 mpc.tee.site=alice"),
String::from("-nographic"),
String::from("-netdev"),
String::from("user,id=mpcnet0"),
String::from("-device"),
String::from("virtio-net-pci,netdev=mpcnet0"),
]
}
/// ★★★ 正向:覆盖后,框架那张 `-netdev user` **必须消失**。
///
/// ★ 这条守的是 2026-11-10 真机联调挖出的真问题:
/// 海光真机的静态 qemu(kata-static 裁剪版)**没编 slirp** ——
/// `-netdev user` 直接报
/// `Parameter 'type' expects a netdev backend type`。
/// 而框架的 `qemu_argv()` 给的是**平台中立**规格,网卡固定是
/// `-netdev user,id=mpcnet0` ⇒ 集群面下发的 guest 在海光上**起不来**。
///
/// ★ 症状极具误导性:「节点活着、自报收到了、create 返回 201」,
/// 但 guest 从来没起来 ⇒ 端点永不公布。
/// 排查方向会被带到「对账器 / 控制面 / 调度器」上,
/// 而真因是**一张网卡的后端类型**。
#[test]
fn launch_override_replaces_framework_slirp_netdev() {
let mut argv = framework_qemu_argv();
let ov = LaunchOverride {
netdev_args: vec![
String::from("-netdev"),
String::from("socket,id=mpcnet0,listen=0.0.0.0:19500"),
String::from("-device"),
String::from("virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01"),
],
extra_kernel_params: String::new(),
};
apply_launch_override(&mut argv, &ov).expect("覆盖必须成功");
let joined = argv.join(" ");
assert!(
!joined.contains("netdev user"),
"★ 框架那张 slirp 网卡必须被摘掉(海光 qemu 没编 slirp): {joined}"
);
assert!(
joined.contains("socket,id=mpcnet0"),
"宿主的网卡参数必须进 argv: {joined}"
);
// ★ 网卡的**数量**必须恰好是一份 `-netdev` —— 多一份就撞 id。
assert_eq!(
argv.iter().filter(|a| a.as_str() == "-netdev").count(),
1,
"最终 argv 里只能有一份 -netdev: {joined}"
);
}
/// ★★★ 正向:两张卡必须**并存**(数据面 socket + KBS 面 tap)。
///
/// ★ 真机要两张卡的原因(2026-11-07 合流时挖出):
/// · 跨 guest 密文会话走 `socket` —— **二层**点对点,两端只有
/// 10.0.0.1/.2,没有网关、不做三层路由;
/// · 访问宿主 KBS 走 `tap` —— **三层**,guest 需要同网段地址。
/// 两者**不能是同一张卡** ⇒ 合成一张的后果是
/// 「会话连得上但取不到密钥」或「取到密钥但会话连不上」,
/// 两种都容易被误判成 KBS 或会话本身的问题。
#[test]
fn launch_override_supports_two_nics() {
let mut argv = framework_qemu_argv();
let ov = LaunchOverride {
netdev_args: vec![
String::from("-netdev"),
String::from("socket,id=mpcnet0,connect=192.168.1.7:19500"),
String::from("-device"),
String::from("virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01"),
String::from("-netdev"),
String::from("tap,id=mpcnet1,ifname=tap0,script=no"),
String::from("-device"),
String::from("virtio-net-pci,netdev=mpcnet1,mac=52:54:00:00:0a:02"),
],
extra_kernel_params: String::new(),
};
apply_launch_override(&mut argv, &ov).expect("覆盖必须成功");
let joined = argv.join(" ");
assert!(joined.contains("socket,id=mpcnet0"), "{joined}");
assert!(joined.contains("tap,id=mpcnet1"), "{joined}");
assert_eq!(
argv.iter().filter(|a| a.as_str() == "-netdev").count(),
2,
"两张卡必须并存: {joined}"
);
}
/// ★★★ **9p 手牌通道绝不能被覆盖误伤**。
///
/// ★ 这条守的是一个**极隐蔽**的失败:9p 的 `-device virtio-9p-pci,...`
/// 与网卡的 `-device virtio-net-pci,...` **长得像**。
/// 若按「前缀是 `-device` 就摘」来摘,9p 会被一起摘掉 ⇒
/// guest 挂不上手牌 ⇒ 拿不到上传令牌 ⇒ 证明材料传不回来
/// ⇒ 宿主判定停在 `pending` ⇒ 端点**永不公布**。
///
/// ★ 而且这个 bug 是**静默**的:qemu 照样起来,guest 照样跑,
/// 只是「判定永远 pending」—— 排查方向会被带到 KBS / 芯片上。
#[test]
fn launch_override_keeps_the_9p_hand_channel() {
let mut argv = framework_qemu_argv();
// 模拟真实 spawn 后的 argv:9p 参数已在里面。
argv.extend(crate::guest_hand::virtfs_args(std::path::Path::new("/tmp/hands/x")));
let ov = LaunchOverride {
netdev_args: vec![
String::from("-netdev"),
String::from("socket,id=mpcnet0,listen=0.0.0.0:19500"),
String::from("-device"),
String::from("virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01"),
],
extra_kernel_params: String::new(),
};
apply_launch_override(&mut argv, &ov).expect("覆盖必须成功");
let joined = argv.join(" ");
assert!(
joined.contains("virtio-9p-pci"),
"★ 9p 手牌通道的 -device 不能被网卡覆盖误伤: {joined}"
);
assert!(
joined.contains("mount_tag=mpchostd"),
"★ 9p 的 mount_tag 不能丢: {joined}"
);
}
/// ★ 负向:**破坏实验** —— 去掉覆盖逻辑后,这条必须红。
///
/// ★ 「负向判据天然可能恒为真」是项目纪律里反复强调的坑:
/// 这里显式构造「**没有**应用覆盖」的 argv,
/// 断言它**仍然**含 `netdev user` ⇒ 证明本条判据不是恒假。
#[test]
fn without_override_the_slirp_netdev_is_still_there() {
// 这是**不做**覆盖的 argv —— 它必须仍然带框架那张 slirp 卡。
let argv = framework_qemu_argv();
let joined = argv.join(" ");
assert!(
joined.contains("netdev user"),
"★ 破坏实验:不做覆盖时框架那张 slirp 卡必须在(否则本判据恒真)"
);
}
/// ★ 正向:额外内核参数并进 `-append`,原有内容保留。
#[test]
fn launch_override_appends_kernel_params() {
let mut argv = framework_qemu_argv();
let ov = LaunchOverride {
netdev_args: Vec::new(),
extra_kernel_params: String::from("mpc.tee.ip=10.99.0.2/24"),
};
apply_launch_override(&mut argv, &ov).expect("覆盖必须成功");
let idx = argv.iter().position(|a| a == "-append").unwrap();
let v = &argv[idx + 1];
assert!(v.contains("console=ttyS0"), "原有内核参数必须保留: {v}");
assert!(v.contains("mpc.tee.ip=10.99.0.2/24"), "新参数必须并入: {v}");
}
/// ★★★ **正向:多个内核参数(整串含空格)必须全部并进 `-append`。**
///
/// ★ 这条守的是 2026-11-10 真机联调挖出的真 bug:CLI 侧把重复的
/// `--guest-kernel-param` 逐个校验后用**空格 join** 成一份字符串,
/// 而 runtime 侧早先对**整串**判「含空白即拒」⇒ 给 ≥2 个参数恒拒,
/// 真机症状是 `create 失败: hostd 返回 500: 启动参数覆盖失败`。
/// ★ 早先甚至有一条测试把「多参数被拒」当成规范钉死 —— 已改掉。
#[test]
fn launch_override_accepts_multiple_kernel_params() {
let mut argv = framework_qemu_argv();
let ov = LaunchOverride {
netdev_args: Vec::new(),
extra_kernel_params: String::from(
"mpc.tee.ip=10.99.0.2/24 mpc.role=root mpc.tee.data_mac=02:00:00:00:0a:01",
),
};
apply_launch_override(&mut argv, &ov).expect("多个内核参数必须被接受");
let idx = argv.iter().position(|a| a == "-append").unwrap();
let v = &argv[idx + 1];
assert!(v.contains("console=ttyS0"), "原有内核参数必须保留: {v}");
assert!(v.contains("mpc.tee.ip=10.99.0.2/24"), "第 1 个参数必须并入: {v}");
assert!(v.contains("mpc.role=root"), "第 2 个参数必须并入: {v}");
assert!(
v.contains("mpc.tee.data_mac=02:00:00:00:0a:01"),
"第 3 个参数必须并入: {v}"
);
}
/// ★ 负向:**单个参数内部**含控制字符 ⇒ 拒。
/// (空白本身是参数分隔符,由 `split_whitespace` 规范化,不算非法。)
#[test]
fn launch_override_rejects_control_char_in_a_single_kernel_param() {
let mut argv = framework_qemu_argv();
let ov = LaunchOverride {
netdev_args: Vec::new(),
extra_kernel_params: String::from("mpc.tee.ip=10.99.0.2/24\u{7}mpc.role=root"),
};
assert!(
apply_launch_override(&mut argv, &ov).is_err(),
"★ 参数值内含控制字符必须被拒"
);
}
/// ★ 负向:配了额外内核参数但 argv 里没有 `-append` ⇒ **拒**。
///
/// ★ 为什么不静默忽略:静默忽略 ⇒ 运维以为「加了内核参数」,
/// 实际 guest 一个都没收到 ⇒ 参数缺失 ⇒ guest `die`。
/// 症状是「配置写了但没生效」,极难查。
#[test]
fn launch_override_without_append_is_rejected() {
let mut argv = vec![String::from("/usr/bin/qemu"), String::from("-nographic")];
let ov = LaunchOverride {
netdev_args: Vec::new(),
extra_kernel_params: String::from("mpc.tee.ip=10.99.0.2/24"),
};
assert!(
apply_launch_override(&mut argv, &ov).is_err(),
"★ 没有 -append 时必须拒(参数无处可放),不能静默忽略"
);
}
/// ★★★ 端到端:`spawn` 出来的实例 argv 里**不得**再有 slirp 卡。
///
/// ★ 这条把覆盖接到了**真实 spawn 路径**上 ——
/// 只测 `apply_launch_override` 本身不够:它可能压根没被调用。
/// 这条真的起一个进程并查它的 argv。
#[test]
fn spawned_instance_argv_has_no_slirp_netdev() {
let rt = TeeRuntime::new().with_launch_override(LaunchOverride {
netdev_args: vec![
String::from("-netdev"),
String::from("socket,id=mpcnet0,listen=0.0.0.0:19500"),
String::from("-device"),
String::from("virtio-net-pci,netdev=mpcnet0,mac=52:54:00:00:0a:01"),
],
extra_kernel_params: String::new(),
});
let mut s = spec("/bin/sleep");
// 真实形态:带 `-append` 与框架那张 slirp 卡。
s.args = framework_qemu_argv()[1..].to_vec();
let inst = rt.spawn(&s).unwrap();
let joined = inst.argv.join(" ");
assert!(
!joined.contains("netdev user"),
"★ 起出来的实例 argv 里不得再有 slirp 卡: {joined}"
);
assert!(joined.contains("socket,id=mpcnet0"), "{joined}");
let _ = rt.stop(&inst.sandbox_id);
}
}
+98 -2
View File
@@ -130,6 +130,22 @@ impl KbcMode {
/// 拿到一个解析不了的地址,取料必然失败,而报错现场完全看不出是
/// scheme 拼重了。
pub fn kernel_param(self, endpoint: Option<&str>) -> String {
format!("agent.aa_kbc_params={}", self.kbc_spec(endpoint))
}
/// ★ KBC 模式的**裸形态**(`cc_kbc::http://host:port` / `offline_fs_kbc::null`)。
///
/// ★ 为什么要有这个「裸形态」:
/// 同一个 KBC 事实要写进**两个**内核参数,而两者要的形状**不同**:
/// · `agent.aa_kbc_params=<裸形态>` —— 给 guest 内的证明代理(qemu 代理参数);
/// · `mpc.tee.kbs=<裸形态>` —— 给 guest 的 init.sh(`case` 分支匹配)。
/// init.sh 的匹配是 `cc_kbc::http://*` ⇒ 传 `agent.aa_kbc_params=cc_kbc::…`
/// **匹配不上** ⇒ guest 直接 `die "未知 KBC 模式"` ⇒ 端点永不公布。
///
/// 早先这里没有裸形态,集群面为了拼 `mpc.tee.kbs` 只能整个复用
/// `kernel_param()` 的输出 —— 于是带上了 `agent.aa_kbc_params=` 前缀,
/// init.sh 匹配失败。那是**框架自己把 guest 判死**。
pub fn kbc_spec(self, endpoint: Option<&str>) -> String {
match self {
Self::Online => {
let raw = endpoint.unwrap_or("http://127.0.0.1:8080").trim();
@@ -143,9 +159,9 @@ impl KbcMode {
} else {
format!("http://{raw}")
};
format!("agent.aa_kbc_params=cc_kbc::{ep}")
format!("cc_kbc::{ep}")
}
Self::Offline => String::from("agent.aa_kbc_params=offline_fs_kbc::null"),
Self::Offline => String::from("offline_fs_kbc::null"),
}
}
@@ -452,4 +468,84 @@ mod tests {
"不指定代际时按实测 CSV2 处理"
);
}
// ---- KBC 的「裸形态」与「内核参数形态」必须分清 ----
/// ★★★ **裸形态**与**内核参数形态**必须分清,且两者**同源**。
///
/// ★ 同一个 KBC 事实要写进**两个**内核参数,而两者要的形状**不同**:
/// · `agent.aa_kbc_params=<裸形态>` —— 给 guest 内的证明代理;
/// · `mpc.tee.kbs=<裸形态>` —— 给 guest 的 init.sh(`case` 分支匹配)。
///
/// ★ 早先没有裸形态,集群面为了拼 `mpc.tee.kbs` 只能整个复用
/// `kernel_param()` 的输出 —— 于是带上了 `agent.aa_kbc_params=` 前缀,
/// init.sh 的 `case "$KBC" in cc_kbc::http://*)` **匹配不上**
/// ⇒ guest 直接 `die "未知 KBC 模式"` ⇒ 端点永不公布。
/// 那是**框架自己把 guest 判死**。
///
/// ★ 这条钉死:裸形态**不带**任何参数名前缀,且 kernel_param 是裸形态的包裹。
#[test]
fn kbc_spec_is_the_bare_form_without_any_param_prefix() {
assert_eq!(
KbcMode::Online.kbc_spec(Some("http://192.168.1.7:8080")),
"cc_kbc::http://192.168.1.7:8080"
);
assert_eq!(KbcMode::Offline.kbc_spec(None), "offline_fs_kbc::null");
// ★ 裸形态里**不得**含任何 `key=` 形态的参数名。
for spec in [
KbcMode::Online.kbc_spec(Some("http://192.168.1.7:8080")),
KbcMode::Offline.kbc_spec(None),
] {
assert!(
!spec.contains("agent.aa_kbc_params"),
"★ 裸形态不得带参数名前缀: {spec}"
);
assert!(
!spec.contains('=') || spec.starts_with("cc_kbc::"),
"★ 裸形态不得含 key=value 形态的参数: {spec}"
);
}
}
/// ★★★ **kernel_param 必须是裸形态的包裹**(两者同源,不许各写一份)。
///
/// ★ 「各写一份」的典型后果就是分叉:改了一处忘了另一处 ⇒
/// init.sh 匹配不上 ⇒ guest die。
#[test]
fn kernel_param_wraps_the_bare_spec() {
for (mode, ep) in [
(KbcMode::Online, Some("http://192.168.1.7:8080")),
(KbcMode::Online, None),
(KbcMode::Offline, None),
] {
let kp = mode.kernel_param(ep);
assert_eq!(
kp,
format!("agent.aa_kbc_params={}", mode.kbc_spec(ep)),
"★ kernel_param 必须与 kbc_spec 同源: {kp}"
);
}
}
/// ★★★ **负向:破坏实验** —— 若有人把裸形态又写成带前缀的形态,
/// 这条必须红。
///
/// ★ 显式构造「错误的形态」(就是那个真 bug 的产物)并断言它
/// **不**等于裸形态 —— 证明本组判据不是恒真。
#[test]
fn the_buggy_prefixed_form_is_detectable() {
// ★ 这就是 2026-11-10 真机联调时集群面实际下发的形态。
let buggy = "agent.aa_kbc_params=cc_kbc::http://192.168.1.7:8080";
let bare = KbcMode::Online.kbc_spec(Some("http://192.168.1.7:8080"));
assert_ne!(
buggy, bare,
"★ 破坏实验:带前缀的形态必须与裸形态不同(否则本组判据恒真)"
);
// 而且带前缀的形态**匹配不上** guest init.sh 的 case 分支。
assert!(
!buggy.starts_with("cc_kbc::http://"),
"★ 带前缀的形态匹配不上 init.sh 的 `cc_kbc::http://*` 分支"
);
assert!(bare.starts_with("cc_kbc::http://"), "{bare}");
}
}
+203
View File
@@ -557,6 +557,39 @@ pub fn admit(
params.push(format!("mpc.tee.platform={}", platform_param_value(req.platform)));
params.push(format!("mpc.tee.site={}", node.site));
// ★★★ 集群面下发的三个**必需**参数(2026-11-10 真机联调挖出)。
//
// guest 的 init.sh(deploy/tee/guest/init.sh)硬性读这三个:
// · `mpc.tee.manifest` —— 镜像 digest。与镜像内
// `/etc/mpc-tee/manifest.digest` 不一致 ⇒ 直接 `die`。
// **缺这个参数 ⇒ guest 一启动就死**(`expect_manifest=none`)。
// · `mpc.tee.session` —— 本轮会话 id(KBS 的 `--session`)。
// 缺 ⇒ KBS 请求头 `MPC-Tee-Session` 为空 ⇒ KBS 403。
// · `mpc.tee.kbs` —— KBC 模式(`cc_kbc::http://…` / `offline_fs_kbc::null`)。
// 缺 ⇒ init.sh 走 `*)` 分支 ⇒ `die "未知 KBC 模式"`。
//
// ★ 为什么这三个**必须由框架产出**(而不是留给部署层追加):
// 部署层追加的那条路(run-guest.py)只存在于「单机演练」形态;
// 集群面(control-plane → hostd → POST /sandboxes)**没有**那条路 ——
// 请求体里只有 `program` + `args`,没有「再追加点什么」的位置。
// ⇒ 集群面不补这三个 ⇒ guest 必die ⇒ 端点永不公布。
// 症状极具误导性:「节点活着、自报收到了、create 也返回 201」,
// 但端点永远不出现 —— 排查方向会被带到「对账器 / 控制面 / 调度器」上,
// 而真因是 guest 的启动参数少了三项。
//
// ★ `mpc.tee.manifest` 取**节点声明的度量**:它就是
// `binding.code_measurement`(admit 已校验二者一致),
// 也是镜像内 `manifest.digest` 的值(部署方按同一份 manifest 构建镜像)。
params.push(format!("mpc.tee.manifest={}", hex(&node.measurement)));
// ★ 会话 id:绑定值的第一段就绑了它 —— 用**绑定材料里的**那份,
// 不是「会话 id」这个字符串(后者是 MPC 层的会话名,格式不保证)。
params.push(format!("mpc.tee.session={}", hex(&binding.session_id)));
// ★ KBC 模式:与 `agent.aa_kbc_params` **同一个**值(裸形态)。
// 两个名字指向同一件事(前者给 init.sh 的 case 分支,后者给 guest 内证明代理),
// 必须同源 —— 否则 init.sh 走在线分支而证明代理走离线分支,
// 症状是「密钥取到了但证明包没有」(或反过来)。
params.push(format!("mpc.tee.kbs={}", node.kbc.kbc_spec(kbs_ep.as_deref())));
Ok(LaunchSpec {
site: node.site.clone(),
host: node.host.clone(),
@@ -989,4 +1022,174 @@ mod tests {
let b = SessionBinding::new([1u8; 32], "alice", [2u8; 32], node.measurement);
assert!(admit(&TeeRequirement::new(PlatformKind::SevSnp, 0), &node, &b).is_err());
}
// ---- 集群面下发的三个必需内核参数(2026-11-10 真机联调挖出)----
/// ★★★ **guest 的 init.sh 硬性读的三个参数必须由框架产出**。
///
/// ★ 这条守的是**集群面**(control-plane → hostd → POST /sandboxes)
/// 的三个必需内核参数。缺任何一个,guest 都会死:
/// · 缺 `mpc.tee.manifest` ⇒ `die "cmdline 的 manifest digest 与镜像不一致 (expect=none)"`;
/// · 缺 `mpc.tee.session` ⇒ KBS 请求头 `MPC-Tee-Session` 为空 ⇒ KBS 403;
/// · 缺 `mpc.tee.kbs` ⇒ init.sh 走 `*)` 分支 ⇒ `die "未知 KBC 模式"`。
///
/// ★ **为什么必须由框架产出**(而不是留给部署层追加):
/// 部署层追加的那条路(`run-guest.py`)只存在于「单机演练」形态;
/// 集群面**没有**那条路 —— 请求体里只有 `program` + `args`,
/// 没有「再追加点什么」的位置。
/// ⇒ 集群面不补这三个 ⇒ guest 必die ⇒ 端点永不公布。
///
/// ★ 症状极具误导性:「节点活着、自报收到了、create 返回 201」,
/// 但端点永远不出现 —— 排查方向会被带到「对账器 / 控制面 / 调度器」上,
/// 而真因是 guest 的启动参数少了三项。
#[test]
fn admit_emits_the_three_params_guest_init_hard_requires() {
let req = TeeRequirement::new(PlatformKind::SevSnp, 3);
let node = amd_node();
let b = binding();
let spec = admit(&req, &node, &b).unwrap();
let kp = &spec.kernel_params;
// ① manifest:必须是**节点声明的度量**(= binding.code_measurement,
// admit 已校验二者一致)。
assert!(
kp.contains(&format!("mpc.tee.manifest={}", hex(&node.measurement))),
"★ 必须下发 mpc.tee.manifest(否则 guest 因 expect=none 直接 die): {kp}"
);
// ② session:必须是**绑定材料里的** session_id(32 字节 hex),
// 不是 MPC 层的会话名字符串。
assert!(
kp.contains(&format!("mpc.tee.session={}", hex(&b.session_id))),
"★ 必须下发 mpc.tee.session(否则 KBS 请求头为空 ⇒ 403): {kp}"
);
// ③ kbs:必须是**裸形态** `cc_kbc::http://…`。
// ⚠️ 不能带 `agent.aa_kbc_params=` 前缀 —— init.sh 的 case
// 匹配的是 `cc_kbc::http://*`,带前缀就匹配不上 ⇒ guest die。
//
// ★ 端点取**节点描述里声明的那个**(现场部署事实),
// 不是平台内置缺省 —— 两者不同时(CSV 的内置缺省是 None,
// AMD 的内置缺省是 192.168.1.7:8080)会导致取错。
let want_kbs = node
.kbs_endpoint
.as_deref()
.or(PlatformProfile::builtin(req.platform, None).and_then(|p| p.kbs_endpoint))
.map(|ep| KbcMode::Online.kbc_spec(Some(ep)))
.unwrap_or_else(|| KbcMode::Online.kbc_spec(None));
assert!(
kp.contains(&format!("mpc.tee.kbs={want_kbs}")),
"★ 必须下发裸形态的 mpc.tee.kbs: {kp}"
);
assert!(
!kp.contains("mpc.tee.kbs=agent.aa_kbc_params="),
"★ mpc.tee.kbs 绝不能带 agent.aa_kbc_params= 前缀(init.sh 匹配不上): {kp}"
);
// ★★ 两个 KBC 参数必须指向**同一个** KBS 端点。
//
// `agent.aa_kbc_params` 给 guest 内的证明代理(它去 KBS 换密钥),
// `mpc.tee.kbs` 给 init.sh(它去 KBS 取资源)。
// 两者不一致 ⇒ 证明代理连的是 KBS-A,取料连的是 KBS-B
// ⇒ 症状是「密钥取到了但证明包没有」(或反过来)——
// 两者各自都「成功」,中间没人报错。
let aa = kp
.split_whitespace()
.find(|t| t.starts_with("agent.aa_kbc_params="))
.unwrap_or_else(|| panic!("★ agent.aa_kbc_params 必须在: {kp}"));
let aa_bare = aa.trim_start_matches("agent.aa_kbc_params=");
assert_eq!(
aa_bare, want_kbs,
"★ 两个 KBC 参数必须同源(同一个 KBS 端点): {kp}"
);
}
/// ★★★ **负向:破坏实验** —— 把三个参数逐个删掉,guest 就会死。
///
/// ★ 「负向判据天然可能恒为真」是项目纪律里反复强调的坑:
/// 这里显式断言「删掉任一个 ⇒ 那条断言会红」,
/// 证明本组判据不是恒假(不是「怎么都过」)。
///
/// ★ 同时钉死一件事:**这三个参数与 guest init.sh 的读法同源** ——
/// init.sh 用 `cmdval 'mpc\.tee\.manifest'` 这类正则读它们,
/// 键名写错一个字 guest 就读不到 ⇒ 与「没给」等价。
#[test]
fn dropping_any_of_the_three_params_is_detectable() {
let req = TeeRequirement::new(PlatformKind::SevSnp, 3);
let node = amd_node();
let spec = admit(&req, &node, &binding()).unwrap();
let full = spec.kernel_params.clone();
for key in ["mpc.tee.manifest=", "mpc.tee.session=", "mpc.tee.kbs="] {
let stripped: String = full
.split_whitespace()
.filter(|t| !t.starts_with(key))
.collect::<Vec<_>>()
.join(" ");
assert!(
!stripped.contains(key),
"★ 破坏实验:删掉 {key} 后不应还含它(否则本组判据恒真)"
);
assert!(
full.contains(key),
"★ 破坏实验:完整的 kernel_params 必须含 {key}"
);
}
}
/// ★★★ guest init.sh 读的键名必须与框架下发的**逐字一致**。
///
/// ★ 这条守的是**跨语言契约**:框架(Rust)写键名,guest(shell)读键名,
/// 两侧各写各的字符串。此前一致性**只靠人眼**。
/// 键名写错一个字 ⇒ guest 读到空值 ⇒ `die`(manifest 不一致)
/// 或 KBS 403(session 为空)⇒ 端点永不公布。
#[test]
fn guest_init_reads_exactly_the_keys_we_emit() {
let init = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../deploy/tee/guest/init.sh");
let text = std::fs::read_to_string(&init)
.unwrap_or_else(|e| panic!("读 guest init.sh 失败: {e}"));
for key in [
"mpc\\.tee\\.manifest",
"mpc\\.tee\\.session",
"mpc\\.tee\\.kbs",
"mpc\\.tee\\.user_data",
"mpc\\.tee\\.site",
"mpc\\.tee\\.platform",
] {
assert!(
text.contains(key),
"★ guest init.sh 必须读 {key}(键名必须与框架下发逐字一致)"
);
}
// ★ init.sh 的 KBC 分支必须匹配**裸形态**。
assert!(
text.contains("cc_kbc::http://*)"),
"★ guest init.sh 的 KBC 分支必须匹配裸形态 cc_kbc::http://*"
);
}
/// ★★★ **跨网段选址时,绑定的 site 与节点的 site 必然不同** ——
/// 这正是 `bind_site` 存在的理由。
///
/// ★ 集群面典型场景:控制面 `site=alice`,跨网段选中一台 `site=bob` 的节点。
/// 早先 `host_dispatch` 不带 `bind_site` ⇒ 宿主用**请求体的 site**
/// 顶替 ⇒ 重算出的 `user_data` 与 guest 采报告时用的那份**必然不同**
/// ⇒ `user_data_ok=false` ⇒ 判定报「可能是重放报告」。
///
/// ★ 这条把「两个 site 不同」这件事**钉成事实**,
/// 让 `bind_site` 的存在有据可依(不是「以防万一」)。
#[test]
fn cross_segment_scheduling_has_different_bind_site_and_node_site() {
let node = csv_node(); // site = bob
let b = SessionBinding::new([1u8; 32], "alice", [2u8; 32], node.measurement);
assert_eq!(b.site, "alice", "绑定的 site 是算绑定的一方(会话发起方)");
assert_eq!(node.site, "bob", "节点的 site 是这台节点自己");
assert_ne!(
b.site, node.site,
"★ 跨网段选址时两者必然不同 —— 这就是 bind_site 必须显式下发的理由"
);
// 且 `user_data` 确实绑了 site —— 换 site 就换绑定值。
let d1 = b.user_data(PlatformKind::HygonCsv, 4);
let b2 = SessionBinding::new([1u8; 32], "bob", [2u8; 32], node.measurement);
let d2 = b2.user_data(PlatformKind::HygonCsv, 4);
assert_ne!(d1, d2, "★ user_data 必须绑住 site(否则 bind_site 就无关紧要了)");
}
}
+939
View File
@@ -0,0 +1,939 @@
#!/usr/bin/env bash
# ★ 真机集群**端点公布门禁**:真 KBS 验签通过后,控制面才公布会话端点。
#
# ── 这条脚本守的是什么 ──
#
# Task #16 的最终目标:
# 「真 KBS 验签后的会话端点」—— 只有**芯片签名验过**的会话,
# 它的端点才允许被集群控制面公布给计算面消费。
#
# 整条链路:
# 控制面选节点 → 下发 create(含绑定材料 + 三个 init.sh 必需参数)
# → 节点 hostd 起 guest(真机双网卡 + 9p 手牌)
# → guest 采芯片报告 → 提交本机 KBS → KBS **芯片验签**
# → guest 回传原始证明包(走 9p 手牌的实例级令牌)
# → 节点 hostd **独立判定**(四布尔 + 三态)
# → 控制面对账 → `proven_endpoints()` → `GET /sessions`
#
# ★ 端点公布的两道门(**都在服务端,不在脚本里**):
# ① `is_verified()` —— 决定**实例去留**(证据不成立 ⇒ 撤回端点 + 回收实例);
# ② `publishable(require_chip_sig)` —— 决定**端点是否外泄**
# (默认 `require_chip_sig=true`:没做芯片验签 ⇒ 端点不公布)。
# ⇒ 脚本**只观察**这两个门的结果,不替它们下结论。
#
# ── 正向 / 负向的分工 ──
#
# ★ 正向:真 KBS 验签通过 ⇒ `GET /sessions` 的 `sessions` 数组**非空**,
# 且端点指向**真实节点地址**。
# ★ 负向:证明不过 ⇒ `GET /sessions` 的端点**零外泄**,
# 且 `GET /report` 的 `failed` **有记录**(带原因)。
#
# ★★★ 负向怎么做到「证明不过」而不需要真的破坏芯片?
# 用**另一个节点**(不满足绑定度量 / 不满足 TCB)去承担同一条期望会话:
# 控制面会选中它 → create → 但**准入**在绑定上就拒了(度量 pin 不符),
# 或者它的证明判定不过 ⇒ 端点**不公布**。
# 这条路走的是**同一份**「端点绝不外泄」逻辑(对账器侧),
# 不是靠脚本自己判断「不该公布」。
#
# ★★ 关键纪律(**否定式判据天然可能恒真**):
# 负向必须**先跑正向**。若正向都不通过(控制面没起 / 没节点 / 没会话),
# 「sessions 数组为空」这件事**恒为真** ⇒ 负向毫无意义。
# ⇒ 脚本里**硬性**要求:正向通过之后才判负向;否则直接失败退出。
#
# 用法:
# set -a; . deploy/tee/real-machine/real-machines.env; set +a
# ./cluster-endpoint-gate-e2e.sh
#
# 环境变量:
# MPC_CLUSTER_SECRET 集群共享密钥(默认**本次运行随机生成**,用完即弃)
# MPC_EPG_WORK 工作目录(默认 /tmp/mpc-cluster-epg)
# MPC_EPG_TIMEOUT 等端点出现的秒数(默认 420 —— 真机芯片验签要联网拉证书链)
set -u
HERE=$(cd "$(dirname "$0")" && pwd)
REPO=$(cd "$HERE/../../.." && pwd)
SSHO="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PreferredAuthentications=password -o PubkeyAuthentication=no -o ConnectTimeout=20 -o LogLevel=ERROR"
AMD_HOST=${MPC_TEE_AMD_HOST:-192.168.1.7}
HYGON_HOST=${MPC_TEE_HYGON_HOST:-192.168.1.102}
AMD_USER_KEY=${MPC_TEE_AMD_USER_KEY:-tee_amd_7_user}
AMD_PASS_KEY=${MPC_TEE_AMD_PASS_KEY:-tee_amd_7_pass}
HYGON_USER_KEY=${MPC_TEE_HYGON_USER_KEY:-tee_hg_102_user}
HYGON_PASS_KEY=${MPC_TEE_HYGON_PASS_KEY:-tee_hg_102_pass}
# ★ 远端集群目录(两台机同名,各自独立)。
CLUSTER_DIR=${MPC_EPG_CLUSTER_DIR:-/tmp/mpc-cluster}
# ★ 物料目录(initrd / 验签器 / KBS 脚本都在这里 —— 由 tee-pair-attest-e2e.sh 分发过)。
REMOTE_DIR=${MPC_TEE_REMOTE_DIR:-/tmp/mpc-tee-run-attestpair}
# ★ 本地工作目录(存期望态 JSON / 判据输出)。
WORK=${MPC_EPG_WORK:-/tmp/mpc-cluster-epg}
# ★ 等端点出现的秒数。★ 必须够长:SNP 验签要联网拉 KDS 证书链(首次可达 90 秒)。
EPG_TIMEOUT=${MPC_EPG_TIMEOUT:-420}
EPG_POLL=${MPC_EPG_POLL:-5}
# ★★ 集群共享密钥:**本地随机生成**,不落盘、不入库、不进 xop。
# 它只需要在**本次运行内**三方一致(控制面 + 两个节点 hostd)。
# ⇒ 每次运行都是新密钥 ⇒ 泄漏面最小。
# (要复现同一组密钥,设 MPC_CLUSTER_SECRET 覆盖它 —— 只在调试时用。)
CLUSTER_SECRET=${MPC_CLUSTER_SECRET:-}
OK_N=0
FAIL_N=0
ok() { OK_N=$((OK_N + 1)); printf 'ok %s\n' "$1"; }
fail() { FAIL_N=$((FAIL_N + 1)); printf 'FAIL %s\n' "$1" >&2; }
# ★ 探 xop 里的键:只看**长度**(长度不会被 FileGuard 掩码)。
#
# ★★ 为什么只探长度、不取值:
# xop 的 FileGuard 会在**打印**时把值替换成掩码(实测 2026-11-09:
# 连 `printf %s "$V"` 都会被替换,而 `${#V}` 正常)。
# ⇒ 「取出来存进 shell 变量」这条路**本来就是死的** ——
# 拿到的不是口令,是掩码。
# ⇒ 正确姿势:值**只在 xop 的子进程里**用(见 remote()),本脚本从不持有明文。
xop_probe() {
local n
# ★ xop 把 Guard 的 WARN 打到 **stdout**(不是 stderr)⇒ `2>/dev/null` 挡不住。
# 只认**纯数字行** ⇒ WARN 行含非数字字符会被过滤掉 ⇒ 拿不到数字就当失败。
n=$(xop run --secret "V=$1" -- sh -c 'printf "%s\n" "${#V}"' \
< /dev/null 2>/dev/null | grep -E '^[0-9]+$' | tail -n 1)
case "$n" in
''|*[!0-9]*) return 1 ;;
0) return 1 ;;
*) return 0 ;;
esac
}
require_env() {
local missing=0
if [ -z "$AMD_USER_KEY" ] || [ -z "$AMD_PASS_KEY" ] \
|| [ -z "$HYGON_USER_KEY" ] || [ -z "$HYGON_PASS_KEY" ]; then
printf '缺少真机凭据的 xop 键名(检查 MPC_TEE_AMD_USER_KEY 等,或 source real-machines.env)\n' >&2
missing=1
fi
if ! command -v xop >/dev/null 2>&1; then
printf '找不到 xop(凭据管理工具)—— 本脚本按项目约定从 xop 取真机口令\n' >&2
missing=1
fi
if ! command -v sshpass >/dev/null 2>&1; then
printf '找不到 sshpass —— 无法做密码认证的 SSH\n' >&2
missing=1
fi
if ! command -v curl >/dev/null 2>&1; then
printf '找不到 curl —— 判据要查控制面的 HTTP 端点\n' >&2
missing=1
fi
[ "$missing" -eq 0 ] || return 1
# ★ 预检:xop 能不能解锁 vault、键名对不对 —— 这里用「只取长度」的方式验。
if ! xop_probe "$AMD_USER_KEY" || ! xop_probe "$AMD_PASS_KEY" \
|| ! xop_probe "$HYGON_USER_KEY" || ! xop_probe "$HYGON_PASS_KEY"; then
printf 'xop 取不到凭据(键名不对或 vault 未解锁)—— 键名:%s / %s / %s / %s\n' \
"$AMD_USER_KEY" "$AMD_PASS_KEY" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" >&2
missing=1
fi
[ "$missing" -eq 0 ] || return 1
# ★ 集群密钥:没给就本地随机生成一份(**不落盘、不入库**)。
if [ -z "$CLUSTER_SECRET" ]; then
if command -v openssl >/dev/null 2>&1; then
CLUSTER_SECRET=$(openssl rand -hex 32)
else
CLUSTER_SECRET=$(od -An -tx1 -N32 /dev/urandom | tr -d ' \n')
fi
printf '集群共享密钥:本次运行随机生成(%d 字节,用完即弃)\n' "${#CLUSTER_SECRET}"
fi
return "$missing"
}
remote() {
# $1=host $2=用户键名 $3=口令键名 $4=script
#
# ★★ 脚本正文走 **stdin**(`ssh ... bash -s`),**不走 argv**。
# argv 会进远端 `ps` 输出 ⇒ 正文里带的密钥就等于公开。
#
# ★★ 凭据**全程不经过本 shell**:ssh 在 xop 的子进程里跑,
# `SSHPASS` 由 xop 注入成环境变量(`sshpass -e` 读它)。
#
# ★★ **xop 自己的 WARN 打在 stdout** ⇒ 用 **fd 3 分流**:
# 远端 stdout → fd3 → 临时文件;xop 自己的 stdout → /dev/null;
# stderr 留给调用方看诊断。
# ★★ **stderr 绝对不能一起收进 fd3**:ssh 客户端的
# `Warning: Permanently added '…'` 打在**客户端 stderr**,
# 一旦 `2>&3` 它照样混进返回值 ⇒ 同一个 bug 换个马甲复现。
# ⇒ 只引 stdout;远端命令需要看 stderr 时自己 `2>&1`。
local _out
_out=$(mktemp "${TMPDIR:-/tmp}/mpc-epg-remote.XXXXXX") || return 1
xop run --secret "SSHPASS=$3" --secret "TEE_USER=$2" -- \
sh -c "sshpass -e ssh ${SSHO} \"\$TEE_USER@$1\" 'bash -s' 1>&3" \
3>"$_out" >/dev/null <<<"$4"
cat "$_out"
rm -f "$_out"
}
remote_put() {
# $1=host $2=用户键名 $3=口令键名 $4=远端路径 —— 内容从**本脚本 stdin** 读
#
# ★★ 只传内容、不传脚本 ⇒ 密钥**不经过 argv**(argv 会进远端 ps)。
# 密钥全文只走 stdin 这条通道。
#
# ★★ **这里绝不能写 `< /dev/null`** ——
# 那会把调用方的**管道内容**丢掉(实测:写出的文件是 0 字节,
# 密钥根本没送达远端 ⇒ 控制面配的密钥与节点用的不是同一份 ⇒ 全 401,
# 且症状极难查)。
# ⇒ 只在 stdin **是 TTY** 时才断开(xop 在 TTY 下会等 Touch ID 超时)。
if [ -t 0 ]; then
xop run --secret "SSHPASS=$3" --secret "TEE_USER=$2" -- \
sh -c "sshpass -e ssh ${SSHO} \"\$TEE_USER@$1\" \"umask 077 && mkdir -p \$(dirname '$4') && cat > '$4'\"" \
< /dev/null 2>&1
else
xop run --secret "SSHPASS=$3" --secret "TEE_USER=$2" -- \
sh -c "sshpass -e ssh ${SSHO} \"\$TEE_USER@$1\" \"umask 077 && mkdir -p \$(dirname '$4') && cat > '$4'\"" \
2>&1
fi
}
if ! require_env; then
exit 2
fi
mkdir -p "$WORK"
printf '=== 真机集群端点公布门禁 ===\n'
printf '控制面 : %s:3020\n' "$HYGON_HOST"
printf '节点 AMD : %s\n' "$AMD_HOST"
printf '节点 CSV : %s\n' "$HYGON_HOST"
printf '共享密钥 : %d 字节\n' "${#CLUSTER_SECRET}"
printf '等端点 : %s 秒\n' "$EPG_TIMEOUT"
printf '\n'
# ── 0. 负向矩阵:端点公布的三道硬闸门 ─────────────────────────────────
#
# ★ 三条负向,每条都必须**真的拒**(不是警告):
# ① 非回环 + 无共享密钥 ⇒ 拒启动(否则等于零保护的公网控制面);
# ② 非回环 + 有密钥但缺 `--allow-remote` ⇒ 拒启动;
# ③ 错密钥 ⇒ 401。
#
# ★ 判据纪律:负向必须**用构造样例逐条破坏过**,且每条都要
# 「带期望拒绝特征」—— 只判「失败」会恒真。
#
# ★ ① ② 是**启动期**负向(不需要控制面已在跑)⇒ 放在起控制面**之前**。
# ③ 是**运行期**负向(要控制面起来)⇒ 放在起控制面**之后**。
neg_gate() {
# $1=标签 $2=远端命令 $3=期望出现在输出里的拒绝特征
local label=$1 cmd=$2 want=$3 o
o=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" "$cmd")
if printf '%s' "$o" | grep -q "$want"; then
ok "负向·${label}:按预期拒绝"
return 0
fi
fail "负向·${label}:没看到拒绝特征 '${want}',实际输出:${o}"
return 1
}
# ★ 格式串以 `---` 开头会被 bash 的 printf 当成选项 ⇒ 用 `%s` 传参。
printf '%s\n' '--- 负向矩阵:端点公布前的硬闸门 ---'
# ★ 密钥**不进 argv**:从**文件**读进环境(文件此时可能还不存在,
# 所以用本机的 secret 内容经 stdin 传给远端 —— 见 remote_put)。
printf '%s' "$CLUSTER_SECRET" | remote_put "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"$CLUSTER_DIR/cluster.secret" >/dev/null
# ★★ **必须校验密钥真的送到了**(不能假设)。
# 实测踩过:`remote_put` 里写了 `< /dev/null` ⇒ 把调用方的**管道内容**
# 整个丢掉 ⇒ 远端文件是 **0 字节** ⇒ 远端读到空密钥 ⇒ 全 401,
# 而症状是「自报收不到」,极难往「密钥没送达」上想。
want_len=${#CLUSTER_SECRET}
got_len=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"wc -c < $CLUSTER_DIR/cluster.secret 2>/dev/null | tr -d ' '")
if [ "${got_len:-0}" = "$want_len" ] && [ "$want_len" -ge 32 ]; then
ok "集群密钥已送达海光机(${got_len} 字节)"
else
fail "集群密钥没送达海光机(期望 ${want_len} 字节,得到 '${got_len:-空}')—— \
密钥通道断了(remote_put 的 stdin 被重定向覆盖?)"
exit 1
fi
neg_gate '非回环无密钥拒启动' \
"cd $CLUSTER_DIR && MPC_HOSTD_SHARED_SECRET= ./mpc control-plane serve --listen 0.0.0.0:3099 --allow-remote 2>&1 | head -3" \
'共享密钥'
neg_gate '有密钥但缺 --allow-remote 拒启动' \
"cd $CLUSTER_DIR && SECRET=\$(cat $CLUSTER_DIR/cluster.secret) && MPC_HOSTD_SHARED_SECRET=\"\$SECRET\" ./mpc control-plane serve --listen 0.0.0.0:3099 2>&1 | head -3" \
'allow-remote'
# ── 1. 起控制面(海光机)────────────────────────────────────────────────
#
# ★ 只杀**自己起的**那个控制面(按 pid 文件),**绝不** pkill 全局 ——
# `pkill -f 'mpc control-plane serve'` 会**匹配到执行它的这个 shell 自身**
# (远端 ssh 的 cmdline 整段含这个串)⇒ **自杀** ⇒ 后面的 nohup 根本没机会跑
# ⇒ cp.log 是**上一轮的残留** ⇒ 判定读到旧日志说「起来了」⇒ **假绿**。
#
# ★★ 控制面的**全局**绑定材料(--session-id / --pubkey / --measurement)
# 这里不给 ⇒ 全局绑定是全零。这**不是**缺陷:本脚本提交的 `/desired`
# 每条会话都自带完整绑定(session_id / session_pubkey /
# code_measurement / site),对账器取的是 `d.binding`
# (`reconciler.rs`:`d.binding.clone().unwrap_or(self.binding)`)——
# 全局绑定**只在会话没自带绑定时**兜底,而这里永远不会走到。
# 钉死这条的测试:`per_session_binding_overrides_the_global_one`。
# ★ 真要给全局绑定,三件必须同时给,且 code_measurement 必须是
# 节点声明的度量(见下面的「物料预检」),否则 admit 直接拒。
printf '\n--- 起控制面 ---\n'
out=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"cd $CLUSTER_DIR
if [ -f $CLUSTER_DIR/cp.pid ]; then
kill \"\$(cat $CLUSTER_DIR/cp.pid)\" 2>/dev/null || true
rm -f $CLUSTER_DIR/cp.pid
fi
sleep 1
SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
export MPC_HOSTD_SHARED_SECRET=\"\$SECRET\"
unset SECRET
nohup ./mpc control-plane serve --listen 0.0.0.0:3020 --hostd-port 3010 --allow-remote > cp.log 2>&1 &
echo \$! > $CLUSTER_DIR/cp.pid
sleep 3
cat cp.log")
printf '%s\n' "$out" | sed 's/^/ /'
if printf '%s\n' "$out" | grep -q 'control-plane: 监听'; then
ok "控制面已起($(printf '%s\n' "$out" | grep -o '监听 [^(]*' | head -1))"
else
fail "控制面没起来"
exit 1
fi
# ★★ 负向(**运行期**):错密钥必须 401。
#
# ★★ 关键:必须有**正向对照**。
# 只判「错密钥不是 200」的话 —— 控制面**没起来**时 curl 连不上,
# 返回码是 `000`,`000 != 200` ⇒ **判通过** ⇒ 假绿。
# ⇒ 先断言「正确密钥拿到 200」,再断言「错密钥拿到 401」。
printf '\n--- 负向矩阵:鉴权 ---\n'
code_ok=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -o /dev/null -w '%{http_code}' -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/nodes")
if [ "$code_ok" = "200" ]; then
ok "正向·正确密钥可查注册表(200)"
else
fail "正向·正确密钥查注册表失败(期望 200,得到 '${code_ok}')—— 控制面没起来?"
exit 1
fi
neg_gate '错密钥 401' \
"curl -s -o /dev/null -w '%{http_code}' -m 8 -H 'Authorization: Bearer wrong-secret-000000000000000000000000000' http://127.0.0.1:3020/nodes" \
'401'
# ── 2. 物料与节点参数 ──────────────────────────────────────────────────
#
# ★★★ 这段是本脚本与「自报脚本」最大的差别:集群面要**真的起 guest**,
# 所以必须给出 guest 侧的**全部**物料:
# · initrd(guest 镜像)
# · 芯片验签器(hostd 的 `--attest-verifier`)—— ★ 没有它就没有
# `chip_sig=true` ⇒ 端点**按策略不公布**(`require_chip_sig=true`)。
# · 真实双网卡(socket 跨 guest + tap 进宿主网段访问 KBS)
# · KBS 端点(节点描述里的 `kbs_endpoint`)—— guest 要靠它取密钥。
#
# ★ 度量必须**非全零**(全零 ⇒ 节点永远选不中,admit 要求 has_measurement)。
# 真值读节点描述里的 `measurement=`(OCI manifest digest),见「物料预检」。
#
# ★★ 网卡参数:**每个 argv 元素一个 flag**(`--guest-netdev -netdev
# --guest-netdev socket,id=...`)—— 不做「一个 flag 吃掉后面所有 token」
# 的解析(值本身可能以 `--` 开头,猜错就是给 qemu 传了错的 argv)。
# 两侧的 KBS 端口与网段(与 tee-pair-attest-e2e.sh 同口径 —— 两侧各一个 KBS,
# 各自做**本机**芯片的验签:共用一个 KBS 意味着「把海光的报告拿到 AMD 机上验」。
AMD_KBS_PORT=${MPC_AMD_KBS_PORT:-18093}
AMD_BR=${MPC_AMD_BR:-mpcbr-pa}
AMD_TAP=${MPC_AMD_TAP:-mpctap-pa}
AMD_BR_IP=${MPC_AMD_BR_IP:-10.93.0.1/24}
AMD_GUEST_IP=${MPC_AMD_GUEST_IP:-10.93.0.2/24}
# ★★★ 网卡 MAC 必须与真机既有口径**逐字一致**(real-machines.env 的 D/E 段)。
# guest 的 init.sh 按 MAC **精确匹配**网卡(`iface_by_mac`)⇒ 匹配不到直接
# `die "找不到数据网卡"`。这里曾用 52:54:00:00:0a:xx(QEMU 惯用前缀),
# 与真机在跑的 02:00:00:00:0a:xx 不一致 ⇒ guest 必die ⇒ 端点永不公布。
AMD_DATA_MAC=${MPC_AMD_DATA_MAC:-02:00:00:00:0a:01}
AMD_KBS_MAC=${MPC_AMD_KBS_MAC:-02:00:00:00:0a:11}
HY_KBS_PORT=${MPC_HY_KBS_PORT:-18094}
HY_BR=${MPC_HY_BR:-mpcbr-pb}
HY_TAP=${MPC_HY_TAP:-mpctap-pb}
HY_BR_IP=${MPC_HY_BR_IP:-10.94.0.1/24}
HY_GUEST_IP=${MPC_HY_GUEST_IP:-10.94.0.2/24}
HY_DATA_MAC=${MPC_HY_DATA_MAC:-02:00:00:00:0a:02}
HY_KBS_MAC=${MPC_HY_KBS_MAC:-02:00:00:00:0a:12}
LINK_PORT=${MPC_TEE_LINK_PORT:-19777}
# ★★★ 会话材料必须与真机 KBS 仓库里**已铺好**的那份一致。
#
# KBS 的资源目录布局是 <res>/<repo>/<kind>/<tag>,tag = 会话 id。
# guest 取 psk/seed/root-key 时用的就是本轮 session id ⇒
# session id 与已铺的资源对不上 ⇒ KBS 404 ⇒ guest die ⇒ 端点永不公布。
# 真机上 tee-pair-attest-e2e.sh 铺的是 MPC_TEE_SESSION_ID(缺省 abab…),
# ⇒ 这里**必须复用同一份**,不能另起一个 e1e1…。
EPG_SESSION_ID=${MPC_EPG_SESSION_ID:-${MPC_TEE_SESSION_ID:-$(printf 'ab%.0s' $(seq 1 32))}}
EPG_PUBKEY=${MPC_EPG_PUBKEY:-${MPC_TEE_PUBKEY:-$(printf 'cd%.0s' $(seq 1 32))}}
# ★ 绑定的 site = **算绑定的一方**(控制面 = alice)。
# 它与「节点自己的 site」(AMD=alice / CSV=bob)**不是同一件事** ——
# 集群面跨网段选址时两者必然不同(这正是 bind_site 存在的理由)。
EPG_SITE=${MPC_EPG_SITE:-alice}
# ── 2'. 物料预检(必须在起 KBS / 起 hostd **之前**)────────────────────
#
# ★★★ 顺序是硬约束:`start_kbs` 的绑定重算要用 `EPG_MEASUREMENT`,
# `start_hostd` 要用 `AMD_TCB` / `HY_TCB`。早先这段放在 KBS 之后,
# `set -u` 下直接 unbound 崩溃(症状还伪装成「KBS 没起来」的假红)。
#
# ★ 度量的**唯一真相源 = 节点描述文件里的 `measurement=`**(OCI manifest
# digest)。`sha256sum initrd.img` 与之完全无关:guest 校验的是镜像内
# `/etc/mpc-tee/manifest.digest`,用 initrd 的 sha 会让
# `mpc.tee.manifest=` 与镜像对不上 ⇒ guest 一启动就 die。
read_node_field() {
# $1=host $2=user $3=pass $4=远端节点描述路径 $5=字段名 $6=匹配正则(BRE)
remote "$1" "$2" "$3" \
"sed -n 's/^$5=\($6\)\$/\1/p' '$4' | head -1"
}
amd_meas=$(read_node_field "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" \
"$REMOTE_DIR/node" measurement '[0-9a-fA-F]\{64\}')
hy_meas=$(read_node_field "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"$REMOTE_DIR/node" measurement '[0-9a-fA-F]\{64\}')
if [ "${#amd_meas}" -ne 64 ] || [ "${#hy_meas}" -ne 64 ]; then
fail "读不出节点描述里的度量(AMD='${amd_meas}' CSV='${hy_meas}')—— \
先跑 tee-pair-attest-e2e.sh 铺物料(它把 OCI manifest digest 写进节点描述)"
exit 1
fi
if [ "$amd_meas" != "$hy_meas" ]; then
fail "两侧镜像度量不一致(AMD=${amd_meas} CSV=${hy_meas})—— \
期望态只能 pin 一份度量,另一侧节点永远选不中"
exit 1
fi
EPG_MEASUREMENT=$amd_meas
printf ' 镜像度量(唯一真相源) = %s\n' "$EPG_MEASUREMENT"
# ★ TCB 也**只读节点描述**,不猜默认值:它参与 `user_data` 的绑定值计算
# (`SessionBinding::user_data(platform, tcb)`),猜错 ⇒ KBS 重算的绑定值
# 与 guest 采报告用的那份不一致 ⇒ 证明永远判不过。
AMD_TCB=$(read_node_field "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" \
"$REMOTE_DIR/node" tcb '[0-9]\{1,\}')
HY_TCB=$(read_node_field "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"$REMOTE_DIR/node" tcb '[0-9]\{1,\}')
case "$AMD_TCB" in ''|*[!0-9]*) fail "读不出 AMD 节点 TCB('${AMD_TCB}')—— 不猜默认值" ; exit 1 ;; esac
case "$HY_TCB" in ''|*[!0-9]*) fail "读不出 CSV 节点 TCB('${HY_TCB}')—— 不猜默认值" ; exit 1 ;; esac
printf ' 节点 TCB = AMD %s / CSV %s\n' "$AMD_TCB" "$HY_TCB"
# ★ hostd 的 `--attest-chain-dir` 与 KBS 的 `--chain-dir` **必须指向已存在的
# 目录**(`build_chip_verifier()` 显式校验:不存在就拒启动 —— 真机常离线,
# 目录不存在会退化成联网取证书 ⇒ `chip_sig` 恒 false)。
# AMD 侧的 SNP 证书链缓存目录由本脚本建;CSV 侧用厂商自带目录。
remote "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" \
"mkdir -p '$REMOTE_DIR/snp-chain'" >/dev/null
if ! remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"test -d /opt/hygon/csv/confidential-containers/scripts"; then
fail "海光机缺 CSV 证书链目录 /opt/hygon/csv/confidential-containers/scripts"
exit 1
fi
start_hostd() {
# $1=label $2=host $3=user $4=pass $5=platform $6=site $7=qemu $8=fw $9=kernel
# $10=initrd $11=meas $12=kbs_ep $13=netdev $14=kparams
# $15=tcb $16=chain_dir $17=role $18=guest_endpoint
#
# ★★★ bash 的 `$10` 是 `${1}0`(第 1 位参数后接字面量 0),**不是**第 10 位!
# 早先这里写 `$10`..`$17` ⇒ `initrd=AMD0` / `meas=AMD1` … 全部错位,
# 症状是 `--node-measurement AMD1`(4 位)被 hostd 拒、脚本却继续跑。
# 必须用 `${10}`..`${18}`。
local label=$1 host=$2 user=$3 pass=$4 platform=$5 site=$6 qemu=$7 fw=$8 kernel=$9
local initrd=${10} meas=${11} kbs_ep=${12} netdev=${13} kparams=${14}
local tcb=${15} chain_dir=${16} role=${17} guest_ep=${18}
local verifier
# ★ 芯片验签器:按平台分派。
# AMD → snp-verify-attestation.sh(KDS / VCEK 链)
# 海光 → csv-verify-attestation.sh(厂商官方验签器)
# ★ 没有验签器 ⇒ `chip_sig=false` ⇒ 端点**按策略不公布**
# (`require_chip_sig=true`)—— 那是**诚实的**失败,不是缺陷。
#
# ★ 证书链目录走**独立选项** `--attest-chain-dir`,**不能**塞进
# `--attest-verifier-arg`:argparse 遇到「以 - 开头的值」会把它
# 当成下一个选项 ⇒ 实测报 "expected one argument"。
local chain_flags=""
case "$platform" in
snp) verifier="$REMOTE_DIR/snp-verify-attestation.sh"
chain_dir=${chain_dir:-$REMOTE_DIR/snp-chain} ;;
csv) verifier="$REMOTE_DIR/csv-verify-attestation.sh"
chain_dir=${chain_dir:-/opt/hygon/csv/confidential-containers/scripts} ;;
*) verifier="" ;;
esac
if [ -n "$verifier" ]; then
if ! remote "$host" "$user" "$pass" "test -x '$verifier'"; then
fail "${label}:验签器不存在或不可执行(${verifier})—— \
没有它就没有 chip_sig=true,端点按策略不会公布"
return 1
fi
if [ -n "$chain_dir" ]; then
chain_flags="--attest-chain-dir $chain_dir"
fi
fi
# ★★ 密钥:先推到远端 0600 文件(内容走 stdin,不进 argv)。
printf '%s' "$CLUSTER_SECRET" | remote_put "$host" "$user" "$pass" \
"$CLUSTER_DIR/cluster.secret" >/dev/null
# ★ 网卡参数:**每个 argv 元素一个 flag**。
# 数据面(socket,二层,跨 guest)+ KBS 面(tap,三层,进宿主网段)。
local netdev_flags=""
local a
for a in $netdev; do
netdev_flags="$netdev_flags --guest-netdev $a"
done
local kparam_flags=""
for a in $kparams; do
kparam_flags="$kparam_flags --guest-kernel-param $a"
done
local script
script=$(cat <<EOS
cd $CLUSTER_DIR
if [ -f $CLUSTER_DIR/hostd.pid ]; then
kill "\$(cat $CLUSTER_DIR/hostd.pid)" 2>/dev/null || true
rm -f $CLUSTER_DIR/hostd.pid
fi
sleep 1
# ★★ 清掉上一轮遗留的 qemu:guest halt 后 qemu **不退出**(项目已知事实:
# Flash device refused suspend),而 socket netdev 的 listen 端口是
# **每机唯一**的 ⇒ 遗留 qemu 会一直占着该端口 ⇒ 本轮 create 起 qemu 时
# 报 can't bind ... Address already in use ⇒ guest 永远起不来 ⇒
# 端点永不公布。症状极具误导性:控制面 / 自报 / KBS 全绿,只有 guest 没起。
# ★ 按**端口**找占用者并 kill,**不用 pkill -f**(会匹配到执行它的 shell)。
OLD_QEMU=\$(ss -ltnp 2>/dev/null | grep -E ':$LINK_PORT[[:space:]]' | sed -n 's/.*pid=\([0-9][0-9]*\).*/\1/p' | sort -u)
for p in \$OLD_QEMU; do kill "\$p" 2>/dev/null || true; done
i=0
while [ \$i -lt 50 ]; do
ss -ltn 2>/dev/null | grep -qE ':$LINK_PORT[[:space:]]' || break
sleep 0.2
i=\$((i+1))
done
if ss -ltn 2>/dev/null | grep -qE ':$LINK_PORT[[:space:]]'; then
echo LINK_PORT_STILL_BUSY
exit 1
fi
echo LINK_PORT_FREE
SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
export MPC_HOSTD_SHARED_SECRET="\$SECRET"
unset SECRET
nohup ./mpc hostd \\
--listen 0.0.0.0:3010 \\
--allow-remote \\
--control-plane $HYGON_HOST:3020 \\
--node-platform $platform \\
--node-site $site \\
--node-host $host \\
--node-tcb $tcb \\
--node-qemu $qemu \\
--node-firmware $fw \\
--node-kernel $kernel \\
--node-initrd $initrd \\
--node-measurement $meas \\
--node-capacity 2 \\
--node-kbc online \\
--node-kbs-endpoint $kbs_ep \\
--report-interval 5 \\
--guest-endpoint $guest_ep \\
--attest-verifier $verifier \\
$chain_flags \\
$netdev_flags \\
$kparam_flags \\
> hostd.log 2>&1 &
echo \$! > $CLUSTER_DIR/hostd.pid
sleep 3
cat hostd.log
EOS
)
local o
o=$(remote "$host" "$user" "$pass" "$script")
printf '%s\n' "$o" | sed 's/^/ /'
if printf '%s\n' "$o" | grep -qi 'hostd: 监听'; then
ok "$label hostd 已起"
return 0
fi
fail "$label hostd 没起来"
return 1
}
# ── 3. 起两台 hostd(带自报 + 验签器 + 真机网卡)────────────────────────
#
# ★ 两侧各起一个 KBS(不共用)—— 见 tee-pair-attest-e2e.sh 的理由。
# KBS 要做**芯片验签**,验签器与证书链都只在**本机**的 /opt 下才有。
# ⇒ 本脚本先把两侧的 KBS 起起来(复用 kbs-net.sh + 已有资源目录)。
start_kbs() {
# $1=label $2=host $3=user $4=pass $5=verifier $6=chain_dir $7=br $8=tap
# $9=br_ip $10=port $11=token_key $12=resources $13=platform $14=site $15=tcb
local label=$1 host=$2 user=$3 pass=$4 verifier=$5 chain=$6 br=$7 tap=$8
local br_ip=$9 port=${10} token_key=${11} resources=${12}
local platform=${13} site=${14} tcb=${15}
local o
o=$(remote "$host" "$user" "$pass" "set -u
export MPC_KBS_BRIDGE=$br
export MPC_KBS_TAP=$tap
export MPC_KBS_BRIDGE_IP=$br_ip
export MPC_KBS_PORT=$port
export MPC_KBS_TOKEN_KEY_FILE=$token_key
export MPC_KBS_RESOURCES=$resources
export MPC_KBS_SESSION=$EPG_SESSION_ID
export MPC_KBS_VERIFIER=$verifier
export MPC_KBS_VERIFIER_ARGS=
export MPC_KBS_CHAIN_DIR=$chain
export MPC_KBS_PIDFILE=$CLUSTER_DIR/kbs.pid
# ★★★ KBS 侧的绑定材料 —— **缺任何一项,KBS 重算出来的绑定值就与
# guest 采报告时用的那份不一致** ⇒ 判定报「报告与本轮会话不匹配」
# ⇒ KBS 403 ⇒ guest 取不到密钥 ⇒ 端点**永不公布**。
# 症状极具误导性:guest 起来了、KBS 在跑、就是端点不出现,
# 而排查方向会被带到「对账器 / 调度器 / 证明链」上,真因是
# **KBS 启动时少给了几个环境变量**。
#
# · MPC_KBS_PLATFORM —— 平台必须显式给。serve.py 的缺省是 csv,
# 于是 AMD 机上那个 KBS 会拿 csv 去判 SNP 证明包 ⇒ 直接拒收。
# · MPC_KBS_SITE / MPC_KBS_PUBKEY / MPC_KBS_MEASUREMENT ——
# 参与绑定值重算的四个要素(session_id 由 --session 给)。
# site 必须是**绑定的 site**(alice),不是节点自己的 site。
# · MPC_KBS_PIN —— 准入批准的镜像度量(与 measurement 同源但语义独立)。
# · MPC_KBS_TCB —— **节点的实际 TCB**(参与绑定值计算);
# MPC_KBS_MIN_TCB 是门槛(只做准入比较)。两者不能混:
# 漏传 --tcb 会让重算的绑定值用 tcb=0 ⇒ 报「报告与本轮会话不匹配」。
# · MPC_KBS_MPC_BIN —— 判定由框架二进制做(mpc tee attest-check),
# Python 只搬运字节。没有它 ⇒ 严格模式下所有证明都被拒。
export MPC_KBS_PLATFORM=$platform
export MPC_KBS_SITE=$site
export MPC_KBS_PUBKEY=$EPG_PUBKEY
export MPC_KBS_MEASUREMENT=$EPG_MEASUREMENT
export MPC_KBS_PIN=$EPG_MEASUREMENT
export MPC_KBS_TCB=$tcb
export MPC_KBS_MIN_TCB=3
export MPC_KBS_MPC_BIN=$CLUSTER_DIR/mpc
bash $REMOTE_DIR/kbs-net.sh up 2>&1 | tail -5
# ★★★ 本轮实例的**正向证据**。
#
# kbs-net.sh 打印 kbs_net_up 只说明「端口在监听」,**不**说明
# 「是本轮参数起的」。旧实例占端口时新实例会 bind 失败退出,
# 而 kbs-net.sh 只看端口 ⇒ 假绿(根因已在 kbs-net.sh 里修:
# 先按端口清旧 + 端口未释放就拒)。这里再钉一层:
# pidfile 里的 pid 必须活着,且它的命令行必须带**本轮**
# --session 与 --mpc 路径 ⇒ 旧参数实例一律不算通过。
#
# ★ 这条同时是**否定式判据的正向锚点**:只判「端口有响应」
# 会恒真(旧实例也会响应),必须验到归属。
PID=\$(cat $CLUSTER_DIR/kbs.pid 2>/dev/null || true)
if [ -z \"\$PID\" ] || ! kill -0 \"\$PID\" 2>/dev/null; then
echo EPG_KBS_NO_PID
exit 1
fi
CMD=\$(tr '\0' ' ' < /proc/\$PID/cmdline 2>/dev/null || true)
# ★ 归属检查用 grep -qF + **单引号**:整段远端脚本嵌在本地的双引号
# 字符串里,普通双引号会提前结束本地字符串(本轮踩过:拼接后引号
# 全丢,printf 的 CMD 被词分割 ⇒ 判据假红),须写成转义的引号;
# 而 case 模式里去掉引号后,空格又把模式拆成多个 word(远端报语法
# 错误、只看到半截)。单引号在本地双引号内只是字面字符,且能包住
# 含空格的匹配串。
if printf '%s' \"\$CMD\" | grep -qF -- '--session $EPG_SESSION_ID' && printf '%s' \"\$CMD\" | grep -qF -- '--mpc $CLUSTER_DIR/mpc'; then
echo EPG_KBS_OWNED_OK
else
echo EPG_KBS_STALE
exit 1
fi")
printf '%s\n' "$o" | sed 's/^/ /'
# ★ 只认**本轮实例**的正向锚点。
# 早先这里用 `grep -Eiq 'kbs_net_up|...'` + 「端口探活」兜底 ——
# 两者都是**恒真型**判据:旧 KBS 占着端口时照样命中,
# 于是拿到的是上一轮参数(session / 绑定材料 / mpc 路径全不对),
# 证明永远判不过 ⇒ 端点永不公布,排查方向被带到证明链上。
if printf '%s\n' "$o" | grep -q 'EPG_KBS_OWNED_OK'; then
ok "$label KBS 已起(本轮实例,端口 ${port})"
return 0
fi
fail "$label KBS 不是本轮实例(输出:${o})"
return 1
}
printf '\n--- 起两侧 KBS ---\n'
start_kbs 'AMD' "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" \
"$REMOTE_DIR/snp-verify-attestation.sh" "$REMOTE_DIR/snp-chain" \
"$AMD_BR" "$AMD_TAP" "$AMD_BR_IP" "$AMD_KBS_PORT" \
"$REMOTE_DIR/kbs-token.key" "$REMOTE_DIR/kbs-res" snp "$EPG_SITE" "$AMD_TCB" || FAIL_N=$((FAIL_N + 1))
start_kbs 'CSV' "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"$REMOTE_DIR/csv-verify-attestation.sh" "/opt/hygon/csv/confidential-containers/scripts" \
"$HY_BR" "$HY_TAP" "$HY_BR_IP" "$HY_KBS_PORT" \
"$REMOTE_DIR/kbs-token.key" "$REMOTE_DIR/kbs-res" csv "$EPG_SITE" "$HY_TCB" || FAIL_N=$((FAIL_N + 1))
# ★ KBS 资源必须在(guest 要凭 token 取 psk/seed/root-key)。
# 缺了就取不到密钥 ⇒ guest 走不到会话 ⇒ 端点不公布(诚实失败)。
for pair in "AMD:$AMD_HOST:$AMD_USER_KEY:$AMD_PASS_KEY" "CSV:$HYGON_HOST:$HYGON_USER_KEY:$HYGON_PASS_KEY"; do
tag=${pair%%:*}; rest=${pair#*:}
host=${rest%%:*}; rest=${rest#*:}
user=${rest%%:*}; pass=${rest#*:}
for kind in psk seed root-key; do
if ! remote "$host" "$user" "$pass" \
"test -s $REMOTE_DIR/kbs-res/mpc/$kind/$EPG_SESSION_ID"; then
fail "${tag}:KBS 资源缺失($kind / ${EPG_SESSION_ID})—— \
guest 取不到密钥,端点不会公布。先跑 tee-pair-attest-e2e.sh 铺资源。"
FAIL_N=$((FAIL_N + 1))
fi
done
done
if [ "$FAIL_N" -eq 0 ]; then
ok "两侧 KBS 资源就位(psk / seed / root-key)"
fi
printf '\n--- 起节点 hostd ---\n'
# ★★★ 网卡参数:
# · 数据面 = socket netdev(跨 guest,二层)
# · KBS 面 = tap netdev(三层,进宿主网段访问本机 KBS)
# 两张卡不能合成(见 kbs-net.sh 的说明)。
#
# ★ MAC 用**真机既有口径**(02:00:00:00:0a:xx),guest 按 MAC 精确认卡。
# ★ tap 必须带 `ifname=` 与 `script=no`:
# · ifname 指到 kbs-net.sh 建好的那个 tap(两边名字必须同源);
# · script=no —— 否则 qemu 去跑 /etc/qemu-ifup,真机上没有该脚本 ⇒
# "network script .../qemu-ifup failed with status 256" ⇒ 直接起不来。
AMD_NETDEV="-netdev socket,id=mpcnet0,listen=0.0.0.0:$LINK_PORT -device virtio-net-pci,netdev=mpcnet0,mac=$AMD_DATA_MAC -netdev tap,id=mpctap0,ifname=$AMD_TAP,script=no -device virtio-net-pci,netdev=mpctap0,mac=$AMD_KBS_MAC"
HY_NETDEV="-netdev socket,id=mpcnet0,listen=0.0.0.0:$LINK_PORT -device virtio-net-pci,netdev=mpcnet0,mac=$HY_DATA_MAC -netdev tap,id=mpctap0,ifname=$HY_TAP,script=no -device virtio-net-pci,netdev=mpctap0,mac=$HY_KBS_MAC"
# ★ 度量 / TCB / 证书链目录都在上面的「物料预检」里取好(顺序硬约束:
# `start_kbs` 的绑定重算要用 `EPG_MEASUREMENT`,必须先于它定义)。
# ★★★ guest 必需的内核参数(**每个参数一个 flag**)。
#
# 框架的 argv 已经带了 mpc.tee.manifest / session / kbs / user_data /
# site / platform(admit 产出的),所以**不重复给**。
# 这里补的是**部署层的事实**(框架不知道的那些):
# · mpc.role —— guest 要靠它决定角色(alice / bob / none)。
# ★ 端点公布这条链路只需要「跑证明门控」,不需要跨 guest 密文会话
# ⇒ 角色用 none ⇒ 不要求数据面网卡(guest 的 init.sh 对 role=none
# 不强制数据面卡)。但 KBS 面那张卡**必须**在(要访问宿主 KBS)。
# · mpc.tee.data_mac / kbs_mac —— guest 按 MAC 精确认卡(不给就认不出)。
# · mpc.tee.ip —— guest 在 tap 网段里的地址(与宿主 KBS 同网段)。
# · mpc.tee.kbs_repo —— KBS 资源仓库名(默认 mpc,与 serve.py 的布局一致)。
AMD_KPARAMS="mpc.role=none mpc.tee.kbs_repo=mpc mpc.tee.data_mac=$AMD_DATA_MAC mpc.tee.kbs_mac=$AMD_KBS_MAC mpc.tee.ip=$AMD_GUEST_IP"
HY_KPARAMS="mpc.role=none mpc.tee.kbs_repo=mpc mpc.tee.data_mac=$HY_DATA_MAC mpc.tee.kbs_mac=$HY_KBS_MAC mpc.tee.ip=$HY_GUEST_IP"
# ★★★ `--guest-endpoint` 必须是 **guest 能路由到的**宿主地址。
#
# 它**不是** `--listen`(`0.0.0.0` 对 guest 没有意义)。
# guest 在 tap 网段里(10.93.0.2 / 10.94.0.2),与管理网(192.168.1.x)
# **不互通** ⇒ 填管理网 IP 时 guest 连不上宿主 ⇒ 传不回证明材料
# ⇒ 宿主判定停在 pending ⇒ 端点永不公布。
# ⇒ 填 **tap 网段里的宿主 bridge 地址**(KBS 绑的那个地址)。
# 代价:hostd 的管理端口只监听 0.0.0.0,tap 网段也能连上 —— 这正是
# 「跨网段暴露」要显式 `--allow-remote` + 共享密钥的原因。
AMD_GUEST_ENDPOINT="${AMD_BR_IP%%/*}:3010"
HY_GUEST_ENDPOINT="${HY_BR_IP%%/*}:3010"
start_hostd 'AMD' "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" snp alice \
/opt/kata/bin/qemu-system-x86_64 \
/opt/kata/share/ovmf/AMDSEV.fd \
/opt/kata/share/kata-containers/vmlinuz-6.12.36-160-confidential \
"$REMOTE_DIR/initrd.img" "$EPG_MEASUREMENT" \
"http://${AMD_BR_IP%%/*}:$AMD_KBS_PORT" "$AMD_NETDEV" \
"$AMD_KPARAMS" "$AMD_TCB" "$REMOTE_DIR/snp-chain" none "$AMD_GUEST_ENDPOINT" \
|| FAIL_N=$((FAIL_N + 1))
start_hostd 'CSV' "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" csv bob \
/opt/confidential-containers/bin/qemu-system-x86_64 \
/opt/confidential-containers/share/ovmf/HYGONCSV.fd \
/opt/confidential-containers/share/kata-containers/vmlinuz-5.10.134-102cc-csv-hygon-gpu \
"$REMOTE_DIR/initrd.img" "$EPG_MEASUREMENT" \
"http://${HY_BR_IP%%/*}:$HY_KBS_PORT" "$HY_NETDEV" \
"$HY_KPARAMS" "$HY_TCB" "/opt/hygon/csv/confidential-containers/scripts" none "$HY_GUEST_ENDPOINT" \
|| FAIL_N=$((FAIL_N + 1))
if [ "$FAIL_N" -ne 0 ]; then
fail "节点 hostd 没全部起来(${FAIL_N} 项失败)—— 后续判据无意义"
exit 1
fi
# ── 4. 设期望态(站点端的产出)─────────────────────────────────────────
#
# ★ 这条 HTTP 请求的**形状**就是站点端 `site_admit` 的产出:
# { "sessions": [ { id, platform, min_tcb, pinned_measurement,
# session_id, session_pubkey, code_measurement, site } ] }
#
# ★ `code_measurement` 必须是**节点声明的度量** —— admit 会校验
# 「绑定度量 == 节点度量」,不一致 ⇒ 准入拒绝(会话永远排不上)。
# ★ `site` 是**绑定方**的 site(alice)—— 它与「节点自己的 site」(bob)**不同**,
# 这正是跨网段暴露场景;`user_data` 的第一段哈希绑的就是它。
printf '\n--- 设期望态 ---\n'
DESIRED="$WORK/desired.json"
cat > "$DESIRED" <<EOF
{"sessions":[{"id":"epg1","platform":"sev-snp","min_tcb":3,"require_attestation":true,"session_id":"$EPG_SESSION_ID","session_pubkey":"$EPG_PUBKEY","code_measurement":"$EPG_MEASUREMENT","site":"$EPG_SITE"}]}
EOF
printf '%s\n' " 期望态:$(cat "$DESIRED")"
# ★ 期望态里写的是 platform=sev-snp ⇒ 选址只会落在 AMD 节点
# (两侧镜像度量同源,度量本身不能区分节点;平台过滤才是决定因素)。
# code_measurement pin 的是**同一份 OCI manifest digest**,
# 不是「指定节点」—— 是绑定的自然结果。
code_desired=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
cat > $CLUSTER_DIR/desired.json <<'JSONEOF'
$(cat "$DESIRED")
JSONEOF
curl -s -o /dev/null -w '%{http_code}' -m 10 -X POST \
-H \"Authorization: Bearer \$SECRET\" -H 'Content-Type: application/json' \
--data-binary @$CLUSTER_DIR/desired.json http://127.0.0.1:3020/desired")
if [ "$code_desired" = "204" ]; then
ok "期望态已提交(204)"
else
fail "期望态提交失败(期望 204,得到 '${code_desired}')"
exit 1
fi
# ── 5. 等端点出现(正向)───────────────────────────────────────────────
#
# ★★ 这是整条链路的**唯一**判据来源:`GET /sessions` 的 `sessions` 数组。
# 控制面内部走的是 `reconciler.proven_endpoints()` ——
# 它只列「证据成立 **且** 按发布策略可公布」的会话。
#
# ★ 轮询而不是一次性查:芯片验签要联网拉证书链(首次可达 90 秒),
# guest 采证明 + KBS 验签 + 回传 + 宿主判定 + 对账,串起来要几分钟。
printf '\n--- 等端点出现(正向) ---\n'
sessions=""
epg_ok=0
elapsed=0
while [ "$elapsed" -lt "$EPG_TIMEOUT" ]; do
sessions=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/sessions")
n_sessions=$(printf '%s' "$sessions" | grep -o '"session_id"' | wc -l | tr -d ' ')
if [ "${n_sessions:-0}" -ge 1 ]; then
epg_ok=1
break
fi
sleep "$EPG_POLL"
elapsed=$((elapsed + EPG_POLL))
printf ' ... 已等 %d 秒(sessions=%s)\n' "$elapsed" "${n_sessions:-0}"
done
printf '%s\n' "$sessions" | sed 's/^/ /'
# ★★ **正向没过 ⇒ 后面一律不判**。
# 「sessions 数组为空」在没有正向对照时是**恒真**的 ——
# 控制面没起、没节点、没会话,它都为空。
if [ "$epg_ok" -ne 1 ]; then
fail "正向:端点没出现(等 ${EPG_TIMEOUT} 秒)—— \
证明链或对账链没走通。**负向判据在此恒真,故不判**。"
printf '\n=== 结果:%d 通过 / %d 失败 ===\n' "$OK_N" "$FAIL_N"
printf '%s\n' "--- 控制面对账结论 ---"
remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/report" | sed 's/^/ /'
printf '\n--- 海光机 hostd 日志尾部 ---\n'
remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"tail -25 $CLUSTER_DIR/hostd.log 2>/dev/null" | sed 's/^/ /'
exit 1
fi
ok "正向·控制面公布了已证明通过的会话端点(${n_sessions} 条)"
# ★ 正向的**内容**判据:端点必须指向**真实节点地址**,且带 session_id。
# 只判「数组非空」不够 —— 一个空壳端点也能让数组非空。
if printf '%s' "$sessions" | grep -q "\"endpoint\":\"$AMD_HOST:3010\""; then
ok "正向·端点指向真实节点($AMD_HOST:3010)"
else
fail "正向·端点不是预期节点(期望 $AMD_HOST:3010):${sessions}"
fi
if printf '%s' "$sessions" | grep -q '"session_id":"epg1"'; then
ok "正向·端点带正确的 session_id(epg1)"
else
fail "正向·端点的 session_id 不对:${sessions}"
fi
# ── 6. 负向:证明不过 ⇒ 端点零外泄 ─────────────────────────────────────
#
# ★★ 怎么造一个「证明不过」的会话?
# 把期望态换成一个**绑定度量对不上**的会话(`code_measurement` 用一个
# 与任何节点都不匹配的度量)⇒ 准入就拒(会话绑定与节点镜像度量不一致)
# ⇒ 不会有任何会话被创建 ⇒ 端点**零外泄**。
#
# ★ 这条路走的是**同一份**「端点绝不外泄」逻辑:
# 控制面侧的 `proven_endpoints()` 只列已落地的会话;
# 准入被拒 ⇒ 没有落地会话 ⇒ 端点不外泄。
# 而**不是**脚本自己判断「不该公布」。
#
# ★★ 判据纪律(**这是本脚本最容易假绿的地方**):
# 1. 先记录**旧的** sessions 集合(正向时它是**非空**的);
# 2. 提交坏的期望态 ⇒ 等对账跑完;
# 3. 断言新的 sessions 集合**不含**那条坏会话
# —— 注意:**只断言「坏会话不在」是不够的**,
# 因为旧的那条可能还在(期望态是**替换**不是叠加);
# 4. ★ 所以判据是:**坏会话 id 一个都不在里面**(按 session_id 精确匹配),
# 同时**至少断言**控制面对账结论里那条坏会话**有失败记录**(带原因)。
# 5. ★★ 「坏会话不在 sessions 里」若没有第 4 步的失败记录做锚点,
# 就可能恒为真(控制面压根没收到这条期望态)。
printf '\n--- 负向:证明不过 ⇒ 端点零外泄 ---\n'
BAD_SESSION_ID=$(printf 'b1%.0s' $(seq 1 32))
BAD_MEAS=$(printf 'ff%.0s' $(seq 1 32))
BAD_DESIRED="$WORK/desired-bad.json"
cat > "$BAD_DESIRED" <<EOF
{"sessions":[{"id":"epg-bad","platform":"sev-snp","min_tcb":3,"require_attestation":true,"session_id":"$BAD_SESSION_ID","session_pubkey":"$EPG_PUBKEY","code_measurement":"$BAD_MEAS","site":"alice"}]}
EOF
code_bad=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
cat > $CLUSTER_DIR/desired-bad.json <<'JSONEOF'
$(cat "$BAD_DESIRED")
JSONEOF
curl -s -o /dev/null -w '%{http_code}' -m 10 -X POST \
-H \"Authorization: Bearer \$SECRET\" -H 'Content-Type: application/json' \
--data-binary @$CLUSTER_DIR/desired-bad.json http://127.0.0.1:3020/desired")
if [ "$code_bad" = "204" ]; then
ok "坏期望态已提交(204)"
else
fail "坏期望态提交失败(期望 204,得到 '${code_bad}')"
exit 1
fi
# 等对账跑完(默认对账周期 10 秒;多等两轮)。
sleep 25
report=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/report")
sessions_bad=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/sessions")
printf ' report : %s\n' "$report"
printf ' sessions : %s\n' "$sessions_bad"
# ① 坏会话**不在**已公布端点里(按 session_id 精确匹配)。
if printf '%s' "$sessions_bad" | grep -q 'epg-bad'; then
fail "负向:证明不过的会话 'epg-bad' 竟然出现在已公布端点里 —— 端点外泄了!"
else
ok "负向·证明不过的会话未出现在已公布端点里"
fi
# ② ★ 失败记录**有**这条会话(带原因)—— 这是否定式判据的**正向锚点**。
# 没有它,「不在 sessions 里」可能只是「期望态没被收到」。
if printf '%s' "$report" | grep -q 'epg-bad'; then
ok "负向·控制面对账结论里有失败记录(带原因)"
else
fail "负向·对账结论里没有 'epg-bad' 的失败记录 —— \
「不在 sessions 里」可能是恒真(期望态压根没被收到)"
fi
# ③ 失败记录必须**带原因**(排查的关键)。
reason=$(printf '%s' "$report" | sed -n 's/.*"id":"epg-bad","reason":"\([^"]*\)".*/\1/p' | head -1)
if [ -n "$reason" ]; then
ok "负向·失败记录带原因:${reason}"
else
fail "负向·失败记录没有原因字段:${report}"
fi
# ── 7. 收尾:把期望态清掉(别把实例留在两台真机上)────────────────────
printf '\n--- 收尾 ---\n'
remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -o /dev/null -m 10 -X POST \
-H \"Authorization: Bearer \$SECRET\" -H 'Content-Type: application/json' \
--data-binary '{\"sessions\":[]}' http://127.0.0.1:3020/desired" >/dev/null
sleep 15
rest=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \
"SECRET=\$(cat $CLUSTER_DIR/cluster.secret)
curl -s -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/sessions")
if printf '%s' "$rest" | grep -q '"endpoint"'; then
fail "期望态清空后仍有端点公布:${rest}"
else
ok "期望态清空后端点已收回(实例被回收)"
fi
printf '\n=== 结果:%d 通过 / %d 失败 ===\n' "$OK_N" "$FAIL_N"
[ "$FAIL_N" -eq 0 ] || exit 1
echo "CLUSTER_ENDPOINT_GATE_OK: 真 KBS 验签后端点才公布;证明不过时端点零外泄"
+36 -14
View File
@@ -80,23 +80,45 @@ do_up() {
# KBS 必须绑在 bridge 地址上:guest 通过 tap 进宿主网段后直连这个 IP。
BR_ADDR=${BR_IP%%/*}
# ★★ 先停掉**任何**占着本轮端口的旧实例,而不只是 pidfile 里那个。
#
# 为什么必须按端口找:上一轮脚本(或手工调试)可能用了**别的
# MPC_KBS_PIDFILE** 起 KBS,此刻 pidfile 里记的 pid 要么不存在、
# 要么根本不是端口占用者。只 kill pidfile 里的 pid ⇒ 端口仍被旧实例
# 占着 ⇒ 新实例 `server_bind()` 抛 "Address already in use" 立刻退出,
# 而下面「端口在监听」的就绪判据**照样绿**(它看到的是旧实例)⇒
# ★ 假绿:拿到的 KBS 是**旧参数**的(session / 绑定材料 / mpc 路径
# 全不是本轮),guest 提交的证明绑定值与 KBS 重算的不一致 ⇒
# 证明永远判不过 ⇒ 端点永不公布,而排查方向会被带到证明链上。
if [ -f "$PIDFILE" ]; then
kill "$(cat "$PIDFILE")" 2>/dev/null || true
rm -f "$PIDFILE"
# ★ 等旧实例**真正退出**再起新的。
# 原来只 `sleep 1`:Python 的 HTTPServer 收到 SIGTERM 后要走到
# serve_forever 的退出点才释放 socket,1 秒常常不够 →
# 新实例 bind 时报 "Address already in use" → 进程直接退出 →
# guest 连过去是 "Connection refused"。
# 症状极具迷惑性:看着像「KBS 没起来」,实际是**端口没释放**。
i=0
while [ "$i" -lt 50 ]; do
if ! ss -ltn 2>/dev/null | grep -q ":$PORT[[:space:]]"; then
break
fi
sleep 0.2
i=$((i + 1))
done
fi
# ss -ltnp 的形态:users:(("python3",pid=4090659,fd=3))
OLD_PIDS=$(ss -ltnp 2>/dev/null \
| grep -E ":${PORT}[[:space:]]" \
| sed -n 's/.*pid=\([0-9][0-9]*\).*/\1/p' | sort -u)
for p in $OLD_PIDS; do
kill "$p" 2>/dev/null || true
done
# ★ 等旧实例**真正退出**再起新的。Python 的 HTTPServer 收到 SIGTERM 后
# 要走到 serve_forever 的退出点才释放 socket,1 秒常常不够 →
# 新实例 bind 时报 "Address already in use" → 进程直接退出 →
# guest 连过去是 "Connection refused"。
# 症状极具迷惑性:看着像「KBS 没起来」,实际是**端口没释放**。
i=0
while [ "$i" -lt 50 ]; do
if ! ss -ltn 2>/dev/null | grep -q ":${PORT}[[:space:]]"; then
break
fi
sleep 0.2
i=$((i + 1))
done
# ★ 硬判据:端口没释放就**拒**,不能带着「可能是旧实例」继续往下走。
if ss -ltn 2>/dev/null | grep -q ":${PORT}[[:space:]]"; then
echo "端口 ${PORT} 仍被占用(10 秒未释放)—— 起 KBS 前必须清干净" >&2
ss -ltnp 2>/dev/null | grep -E ":${PORT}[[:space:]]" >&2
exit 2
fi
# ★ KBS 现在是「先验证明,才给密钥」:判定由 `--mpc` 指定的框架二进制做,
# 芯片签名由 `--verifier` 指定的验签器做。两者缺一,严格模式下所有