fix(tee): 修掉 guest init.sh 被误删的 die() 与 attest 段,端点公布链路打通

背景(Task #16「真 KBS 验签后的会话端点」的前置阻塞):
提交 27cbdc7(OP-TEE 那轮)把 deploy/tee/guest/init.sh 里的 die() 定义
与 attest-collect/attest-post 段一起删掉了,而**调用点还在**。
三个后果,每一个都会让「端点永不公布」且症状极具误导性:

1. die() 定义被删、调用点还在 ⇒ busybox sh 里 `die` 未定义 ⇒
   「command not found」返回非 0 但**脚本继续往下跑** ⇒
   网卡认不到、链路未就绪这些本该 fail-closed 的地方变成静默继续
   ⇒ 安全门被拆。guest 照样打印后续日志、照样 halt,
   看起来像「只是少了一条错误提示」。
2. attest-collect/attest-post 段被删 ⇒ guest **根本不产证明包** ⇒
   第 5 节的回传没有材料可传 ⇒ 宿主判定永远停在 pending ⇒
   控制面 proven_endpoints() 永远为空 ⇒ 端点永不公布。
   症状是「guest 起来了、KBS 也通了、就是端点不出现」,
   排查方向会被整个带到对账器/调度器/控制面上,而真因在 guest 里。
3. TOKEN 的兜底被改成 offline-demo ⇒ 4a 段用 `[ -z "$TOKEN" ]`
   判断「要不要先去采证明」⇒ 该判断**永远不成立** ⇒
   guest 永远不去采证明 ⇒ 同 2。

修法:
- 恢复 die()(含 $RUN/fatal.log 落盘:直接 halt -f 是立刻断电不刷 stdout,
  串口只剩内核一句 "Attempted to kill init!",而「哪个文件对不上」才是关键);
- 恢复 4a 段(采集 → 提交 → 取料,采集失败一律 die);
- TOKEN 无来源时**留空**(不兜底占位值),占位值只留在离线分支;
- 第 2/3 节的 halt 统一走 die,口径一致。

守卫(3 条新测试 + 破坏实验逐条验证会红):
- guest_init_die_is_defined_and_used:定义与调用点必须同时存在;
- guest_init_collects_and_posts_attestation:采集/提交必须在取料之前;
- guest_init_online_branch_does_not_fallback_to_offline_demo:在线分支禁占位 token。
★ 判据本身也修了一个 bug:顺序类判据原先全文 find,被第 5 节**注释**里
  出现的 "tee kbs-get" 骗到 ⇒ 改为只认真正执行的命令行(跳过注释行)。
  判据自己有 bug 比没判据更坏:它会把正确实现判成错的。
★ 三个构造样例(删 die 定义 / 删 attest-collect 调用 / 加回 offline-demo 兜底)
  各自精确命中对应守卫,无交叉误伤。

顺带:入仓集群自报判据自测(tools/selftest-cluster-selfreport.py + break),
门禁加第 25 条;并修掉 cluster-selfreport-e2e.sh 的 remote() 回归
(脚本正文曾回到 argv 传密钥 ⇒ 密钥进远端 ps)。

验证:mpc-hostd 179 passed / 0 failed;guest ash 语法检查通过;
门禁第 25 条 6+5 条自测全绿。
This commit is contained in:
admin committed 2026-11-09 17:16:51 +08:00
1 parent e2c2e5a1d1
commit 7ace04053a
6 files changed
+1008 -44

No files matched your search

+149
View File
@@ -429,4 +429,153 @@ mod tests {
);
}
}
/// 读 guest 的 init 脚本(守卫测试共用)。
fn guest_init_text() -> String {
let init = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../deploy/tee/guest/init.sh");
std::fs::read_to_string(&init)
.unwrap_or_else(|e| panic!("读 guest init.sh 失败: {e}"))
}
/// 找一行**真正执行**的 `needle`(跳过注释行),返回它在全文里的字节偏移。
///
/// ★ 为什么必须跳过注释:init.sh 里大量注释会**原样引用**要执行的命令行
/// (在解释「这一步在干什么」)。全文搜索会命中注释里的那份,
/// 位置与真实调用**不同** ⇒ 顺序类判据(谁在前谁在后)会判错。
///
/// ★ 这类「判据自己有 bug」比没判据更坏:它会把**正确**的实现判成错的。
fn find_exec_line(text: &str, needle: &str) -> usize {
let mut offset = 0usize;
for line in text.split_inclusive('\n') {
let trimmed = line.trim_start();
let is_comment = trimmed.starts_with('#');
if !is_comment && line.contains(needle) {
return offset;
}
offset += line.len();
}
panic!("guest init.sh 里找不到实际执行的 {needle}");
}
/// ★★★ **`die` 的定义与调用点必须**同时**存在**。
///
/// ★ 这条守卫守的是一个**真实踩过**的 bug(2026-11-09):
/// 提交 27cbdc7(OP-TEE 那轮)把 guest init.sh 里的 `die()` **定义**
/// 删掉了,但**调用点还在**(网卡认不到、链路未就绪、OCI 校验失败…)。
///
/// 后果:busybox sh 里 `die` 未定义 ⇒ 调它得到「command not found」
/// ⇒ 函数返回非 0,但**脚本继续往下跑** ⇒
/// 那些本该 fail-closed 的地方变成了**静默继续**。
///
/// ★ 症状极具迷惑性:guest 照样打印后续日志、照样 halt,
/// 看起来像「只是少了一条错误提示」,实际是**安全门被拆了**。
///
/// ★ 为什么这条不能靠「有没有调用点」判断:调用点一直都在,
/// 缺的是**定义**。只查调用点 ⇒ 恒真 ⇒ 抓不住。
#[test]
fn guest_init_die_is_defined_and_used() {
let text = guest_init_text();
// ① 定义存在:`die() {` 必须在(带函数体的大括号)。
assert!(
text.contains("die() {"),
"★ guest init.sh 必须定义 die() —— 调用点还在,缺定义 = 安全门被拆"
);
// ② 调用点存在:只有定义没有调用 ⇒ fail-closed 形同虚设。
let calls = text.matches("die \"").count();
assert!(
calls >= 5,
"★ guest init.sh 的 die 调用点不应少于 5 处(当前 {calls} 处)"
);
// ③ fail-closed 的关键标识必须还在(负向矩阵按它判定)。
assert!(
text.contains("MPC_FAIL:"),
"★ guest init.sh 必须打 MPC_FAIL: 标记(负向矩阵按它判定 fail-closed)"
);
}
/// ★★★ **guest 必须真的会采证明**(`attest-collect` + `attest-post`)。
///
/// ★ 这条守卫守的是 Task #16「真 KBS 验签后的会话端点」的**前置条件**:
/// guest 不采证明 ⇒ 没有 `attestation.bundle` ⇒
/// 本模块第 5 节的回传**没有材料可传** ⇒
/// 宿主判定永远停在 `pending` ⇒ 控制面 `proven_endpoints()` 永远为空
/// ⇒ 端点永不公布。
///
/// ★ 症状极具迷惑性:guest 起来了、KBS 也通、就是端点不出现 ——
/// 排查方向会被整个带到「对账器 / 调度器 / 控制面」上,
/// 而真因在 guest 脚本里。
///
/// ★ 这也是一次**真实回归**:27cbdc7 误删了这两段,
/// 而当时没有任何判据能发现(旧的「回传」判据只看文件在不在,
/// 不看文件是怎么来的)。
#[test]
fn guest_init_collects_and_posts_attestation() {
let text = guest_init_text();
assert!(
text.contains("tee attest-collect"),
"★ guest init.sh 必须采证明(tee attest-collect)—— 没有证明包 = 宿主判定停在 pending = 端点不公布"
);
assert!(
text.contains("tee attest-post"),
"★ guest init.sh 必须把证明提交给 KBS(tee attest-post)—— 密钥必须证明后才发"
);
// ★ 采集必须在**取料之前**:在线分支里 4a 段(采证明)在 for kind 循环(取料)之前。
//
// ★★ **必须只看实际命令行,不能全文搜**:
// init.sh 的第 5 节**注释**里就出现了 "tee kbs-get"(在解释
// 「guest 必须把原始证明包回传给宿主控制面」那段),
// 全文 `find` 会命中**注释里的那个**(位置更靠前)⇒
// 判据会误判成「取料在采证明之前」。
//
// 这类「判据本身有 bug」的失败比没有判据更危险 ——
// 它会把**正确**的实现判成错的,逼着人去改对的地方。
// ⇒ 只认**真正执行**的那一行(行首是 `"$MPC" tee ...`)。
let collect_line = find_exec_line(&text, "\"$MPC\" tee attest-collect");
let post_line = find_exec_line(&text, "\"$MPC\" tee attest-post");
let kbs_get_line = find_exec_line(&text, "\"$MPC\" tee kbs-get");
assert!(
collect_line < kbs_get_line,
"★ 采证明必须在取料**之前** —— 否则密钥会在证明之前发下来"
);
assert!(
collect_line < post_line && post_line < kbs_get_line,
"★ 顺序必须是 采集 → 提交 → 取料"
);
// 采集失败必须 fail-closed(不能静默继续)。
let tail = &text[collect_line..];
assert!(
tail.contains("die \"证明采集失败"),
"★ 采证明失败必须 die(fail-closed),不能静默继续"
);
}
/// ★★★ **在线分支不得兜底 `offline-demo` 占位 token**。
///
/// ★ 这条守卫守的是一个**真实踩过**的坑(2026-11-09):
/// 27cbdc7 那轮把 TOKEN 的兜底从「留空」改成了 `offline-demo`,
/// 而 4a 段用 `[ -z "$TOKEN" ]` 判断「要不要先去采证明」。
/// 兜底成占位值 ⇒ 那个判断**永远不成立** ⇒
/// guest **永远不去采证明** ⇒ 没有证明包 ⇒ 端点永不公布。
///
/// ★ 这类 bug 的特征:**看起来完全正常**(脚本能跑、guest 能起、
/// KBS 也能连),只是少了「先证明再给密钥」这一层。
#[test]
fn guest_init_online_branch_does_not_fallback_to_offline_demo() {
let text = guest_init_text();
// 定位 TOKEN 的赋值段(在线分支之前)。
let token_at = text.find("TOKEN=$(cmdval").expect("必须有 TOKEN 取值段");
let case_at = text.find("case \"$KBC\" in").expect("必须有 KBC 分支");
let token_block = &text[token_at..case_at];
assert!(
!token_block.contains("TOKEN=offline-demo"),
"★ 在线分支的 TOKEN 取值段不得兜底 offline-demo —— 会让「要不要采证明」永远为假"
);
// 占位值只允许出现在离线分支(那里本就不采证明)。
let offline_at = text.find("offline_fs_kbc::null)").expect("必须有离线分支");
assert!(
text[offline_at..].contains("TOKEN=offline-demo"),
"★ 离线分支才允许占位 token(那里不采证明)"
);
}
}
+143 -18
View File
@@ -73,6 +73,67 @@ echo "iface=${IFACE:-none}"
cmdval() {
$BB sed -n "s/.*$1=\\([^ ]*\\).*/\\1/p" /proc/cmdline | $BB head -n 1
}
# fail-closed 的统一出口。
#
# ★★ 为什么这个函数**必须存在**(2026-11-09 真机联调时挖出的真 bug):
# 提交 27cbdc7(OP-TEE 那轮)把本函数**删掉了**,但**调用点还在**
# (下面 154/163/216/217/221 行都在调 `die`)。于是:
# · busybox/sh 里 `die` 未定义 ⇒ 调它就是「command not found」⇒
# **函数返回非 0 但脚本继续往下跑** ⇒
# 「找不到数据网卡」「链路未就绪」这些本该 fail-closed 的地方
# 变成了**静默继续** ⇒ guest 带着半残的网络继续跑。
# 症状极具迷惑性:guest 照样打印后续的日志、照样 halt,
# 看起来像「只是少了一条错误提示」,实际是**安全门被拆了**。
# ⇒ 必须有守卫测试钉死「`die` 的定义与调用点同时存在」。
#
# 早先这里直接 `halt -f`:**立刻断电,不刷 stdout**。于是 guest 明明检测到
# 「层 digest 与声明不符」,串口上却只看到内核一句
# "Attempted to kill init! exitcode=0x00000200"
# 排查时完全看不出是哪一步拦下的 —— FAIL 日志被电源切断了。
#
# 改成 `echo FATAL; sync; exit 1` 之后仍有两处丢消息:
#
# ① 调用方(如 `mpc tee kbs-get` 失败)刚往 stderr 写过东西,内核紧接着
# 又灌一段 panic 日志,串口输出交错 —— FATAL 那行被挤没了;
# ② 即便 FATAL 打出来了,也会被内核日志**从中间截断**,实测长这样:
# FATAL: 活 rootfs 文件 digest 与声明[内核日志插入] 1.642489] Kernel panic ...
# —— 关键信息(哪个文件对不上)正好落在被截掉的那一段里。
#
# 解法:**先把消息完整落到一个文件,再让内核去 panic**。
# 串口是单通道,内核日志一定会插进来;但文件不受影响。
# 于是 die 分两步:
# 1. 消息写进 $RUN/fatal.log(并同时打一份到串口,尽力而为);
# 2. exit 1 → 内核 panic 会把 init 的退出码打到串口(0x100)。
# 负向矩阵据此判定:串口看到 exitcode=0x100(init 自己退的)+
# fatal.log 里有完整消息 → fail-closed 成立。
die() {
MSG="FATAL: $1"
# 完整消息落盘(文件不会被内核日志污染)
{
echo "$MSG"
echo "--- context ---"
echo "oci_dir=$OCI"
echo "expect_manifest=${EXPECT_MANIFEST:-none}"
echo "actual_manifest=${ACTUAL_MANIFEST:-none}"
echo "rootfs_files_anchor=${ANN_FILES:-none}"
echo "rootfs_links_anchor=${ANN_LINKS:-none}"
echo "kbc=${KBC:-none}"
echo "kbs_endpoint=${ENDPOINT:-none}"
} > "$RUN/fatal.log" 2>/dev/null || true
# 串口上尽力打一份。注意标记放在**行首且短** —— 串口是单通道,
# 内核 panic 日志一定会插进来,长消息的尾部会被截断
# (实测 `FATAL: 活 rootfs 文件 digest 与声明[内核日志]` 这样)。
# 关键标识(哪个文件对不上)必须放在**独立的短行开头**才 grep 得到。
echo "MPC_FAIL: $1"
echo "$MSG"
echo "$MSG" >&2
if [ -c /dev/console ]; then
echo "MPC_FAIL: $1" > /dev/console 2>/dev/null || true
fi
$BB sync 2>/dev/null || true
exit 1
}
USER_DATA=$(cmdval 'mpc\.tee\.user_data')
SITE=$(cmdval 'mpc\.tee\.site')
EXPECT_MANIFEST=$(cmdval 'mpc\.tee\.manifest')
@@ -271,25 +332,26 @@ fi
$BB ip route show 2>/dev/null | $BB head -n 8 || true
# --- 2. 逐层校验 OCI digest 链 -------------------------------------------------
#
# ★ 这三处统一走 `die`(不再直接 halt):`die` 会把**完整消息**落进
# $RUN/fatal.log。直接 `halt -f` 是**立刻断电、不刷 stdout** ——
# 串口上只剩内核一句 "Attempted to kill init!",
# 而「哪个文件对不上」才是排查的关键。
if [ ! -f "$OCI/layers.sha256" ]; then
echo "FATAL: 镜像缺少 OCI 层校验清单"
$BB halt -f 2>/dev/null || exit 1
die "镜像缺少 OCI 层校验清单"
fi
if ! ( cd "$OCI" && $BB sha256sum -c layers.sha256 ); then
echo "FATAL: OCI 层或 manifest/config 的 digest 与声明不符"
$BB halt -f 2>/dev/null || exit 1
die "OCI 层或 manifest/config 的 digest 与声明不符"
fi
echo "oci_layers: verified"
# --- 3. 把镜像度量钉到启动参数 ------------------------------------------------
ACTUAL_MANIFEST=$($BB cat /etc/mpc-tee/manifest.digest)
if [ -z "$EXPECT_MANIFEST" ] || [ "$EXPECT_MANIFEST" != "$ACTUAL_MANIFEST" ]; then
echo "FATAL: cmdline 的 manifest digest 与镜像不一致 (expect=${EXPECT_MANIFEST:-none})"
$BB halt -f 2>/dev/null || exit 1
die "cmdline 的 manifest digest 与镜像不一致 (expect=${EXPECT_MANIFEST:-none})"
fi
if [ -z "$USER_DATA" ]; then
echo "FATAL: cmdline 没有会话绑定值"
$BB halt -f 2>/dev/null || exit 1
die "cmdline 没有会话绑定值"
fi
echo "manifest_digest=$ACTUAL_MANIFEST"
echo "user_data=$USER_DATA"
@@ -301,7 +363,17 @@ echo "user_data=$USER_DATA"
# token 来源优先级:
# 1) $RUN/attestation.token —— guest 内证明代理的产物(生产路径)
# 2) cmdline 的 mpc.tee.token —— 部署层注入(演练 / 负向矩阵用)
# 3) offline-demo 占位值 —— 演练兜底,KBS 侧 strict 模式会拒它
#
# ★★★ **没有 token 时必须留空**,不能兜底成 `offline-demo`:
# 下面的 4a 段用 `[ -z "$TOKEN" ]` 判断「要不要先去采证明」。
# 早先这里兜底成 `offline-demo` ⇒ 那个判断**永远不成立** ⇒
# guest **永远不去采证明** ⇒ 没有 $RUN/attestation.bundle ⇒
# 宿主判定停在 `pending` ⇒ 端点永不公布。
# 症状是「KBS 明明配了、guest 明明起来了,就是拿不到证明包」,
# 排查方向会被带到「KBS 侧 / 宿主侧」,而真因在这一行。
#
# `offline-demo` 这种占位 token 的正确位置是**离线演练**分支
# (offline_fs_kbc),那里本来就不采证明、密钥是镜像内置的。
TOKEN=$(cmdval 'mpc\.tee\.token')
if [ -f "$RUN/attestation.token" ]; then
TOKEN=$($BB cat "$RUN/attestation.token")
@@ -309,8 +381,8 @@ if [ -f "$RUN/attestation.token" ]; then
elif [ -n "$TOKEN" ]; then
echo "attestation_token: from cmdline"
else
TOKEN=offline-demo
echo "WARNING: 未找到证明代理 token,使用离线演练占位值(生产必须提供)"
TOKEN=""
echo "attestation_token: none (将先采证明再向 KBS 换取)"
fi
case "$KBC" in
@@ -321,14 +393,65 @@ case "$KBC" in
# KBS 仓库名:默认 mpc(与 deploy/tee/kbs/serve.py 的资源布局一致)。
REPO=$(cmdval 'mpc\.tee\.kbs_repo')
[ -n "$REPO" ] || REPO=mpc
# 4a. 还没有 token 就先出证明、找 KBS 换一个。
#
# ★★★ 这一段是 Task #16「真 KBS 验签后的会话端点」的**前置条件**:
# guest 不采证明 ⇒ 没有 $RUN/attestation.bundle ⇒
# 下面第 5 节的回传**没有材料可传** ⇒ 宿主判定永远停在 `pending` ⇒
# 控制面 `proven_endpoints()` 永远为空 ⇒ 端点永不公布。
# 症状是「guest 起来了、KBS 也通了、就是端点不出现」,
# 排查方向很容易被带到「对账器/调度器」上,而真因在 guest 里。
#
# ★ 为什么 `attest-collect` 与 `attest-post` 必须**都在这里**:
# · collect:向芯片要一份报告,打包成证明包(挑战值 = 框架的绑定值,
# 所以报告里的 user_data 就是本轮绑定值,KBS 侧能据此判定
# 「这份报告确实是本轮会话的」);
# · post:把证明包交给 KBS,KBS **校验 + 芯片验签**通过才签 token;
# 凭 token 才能取 PSK/seed/root-key。
# 两步都在「取料之前」⇒ 密钥一定在证明之后才发下来。
#
# ★ 已有 token(部署层注入)⇒ 跳过(那是**演练 / 负向矩阵**的路)。
# 注意:那种情况下**没有证明包**,第 5 节的回传会跳过 ⇒
# 宿主判定停在 pending ⇒ 端点不公布 —— 这是**诚实**的失败。
if [ -z "$TOKEN" ]; then
PLATFORM=$(cmdval 'mpc\.tee\.platform')
[ -n "$PLATFORM" ] || PLATFORM=csv
echo "attestation_collect: platform=$PLATFORM"
if ! "$MPC" tee attest-collect --platform "$PLATFORM" \
--user-data "$USER_DATA" --out "$RUN/attestation.bundle" \
> "$RUN/attest-collect.log" 2>&1; then
ERR=$($BB tail -n 3 "$RUN/attest-collect.log" | $BB tr '\n' ' ')
die "证明采集失败: ${ERR:-无详情}"
fi
echo "attestation_collect: ok"
echo "attestation_post: endpoint=$ENDPOINT"
if ! "$MPC" tee attest-post --endpoint "$ENDPOINT" \
--bundle "$RUN/attestation.bundle" --session-id "$SESSION" \
--out "$RUN/attestation.token" > "$RUN/attest-post.log" 2>&1; then
ERR=$($BB tail -n 3 "$RUN/attest-post.log" | $BB tr '\n' ' ')
die "证明提交被 KBS 拒绝: ${ERR:-无详情}"
fi
TOKEN=$($BB cat "$RUN/attestation.token")
[ -n "$TOKEN" ] || die "KBS 未返回证明 token"
echo "attestation_post: ok"
else
echo "attestation_post: skipped (token 已提供)"
fi
for kind in psk seed root-key; do
# 参数名必须与 `mpc tee kbs-get` 的一致:--session-id / --repo / --kind。
# 早先这里写的是 `--session`,CLI 不认这个 flag,取回必然失败。
#
# mpc 的错误信息(KBS 返回码、IO 错误)要先落盘再 die ——
# 直接把 mpc 的输出丢给串口,会与内核 panic 日志交错、FATAL 被挤没,
# 而「为什么失败」才是排查的关键。
if ! "$MPC" tee kbs-get --endpoint "$ENDPOINT" \
--session-id "$SESSION" --repo "$REPO" --kind "$kind" --token "$TOKEN" \
--out "$RUN/$kind"; then
echo "FATAL: KBS 资源 $kind 取回失败"
$BB halt -f 2>/dev/null || exit 1
--out "$RUN/$kind" > "$RUN/$kind.log" 2>&1; then
ERR=$($BB tail -n 2 "$RUN/$kind.log" | $BB tr '\n' ' ')
die "KBS 资源 $kind 取回失败: ${ERR:-无详情}"
fi
done
PSK_FILE="$RUN/psk"
@@ -337,10 +460,13 @@ case "$KBC" in
;;
offline_fs_kbc::null)
echo "WARNING: 离线演练密钥,PSK/seed/root-key 内置在镜像里,禁止用于生产"
# ★ 离线分支**不采证明**(没有芯片报告可采),所以这里需要一个占位 token
# 才能继续往下走。占位值只在这一分支出现 —— 在线分支绝不能兜底它,
# 兜底了就等于「不采证明也能取料」(见上面 TOKEN 段的说明)。
[ -n "$TOKEN" ] || TOKEN=offline-demo
for kind in psk seed root-key; do
if [ ! -f "/etc/mpc-tee/offline/$kind" ]; then
echo "FATAL: 离线密钥缺失: $kind"
$BB halt -f 2>/dev/null || exit 1
die "离线密钥缺失: $kind"
fi
$BB cp "/etc/mpc-tee/offline/$kind" "$RUN/$kind"
done
@@ -349,8 +475,7 @@ case "$KBC" in
echo "key_source=offline-demo"
;;
*)
echo "FATAL: 未知 KBC 模式: ${KBC:-none}"
$BB halt -f 2>/dev/null || exit 1
die "未知 KBC 模式: ${KBC:-none}"
;;
esac
@@ -63,7 +63,7 @@ remote() {
# ★★ 脚本正文走 **stdin**(`ssh ... bash -s`),**不走 argv**。
# argv 会进远端 `ps` 输出 ⇒ 正文里带的密钥就等于公开。
# (remote_stdin 同理,只是多一层兼容。)
SSHPASS="$3" sshpass -e ssh ${SSHO} "$2@$1" "$4" 2>&1
SSHPASS="$3" sshpass -e ssh ${SSHO} "$2@$1" 'bash -s' 2>&1 <<<"$4"
}
remote_stdin() {
+59 -25
View File
@@ -54,7 +54,7 @@
# 守卫必须在 CLI **入口**(含连网之前),覆盖全部 8 个吃种子的命令。
#
# ★ 第 18–22 条曾于 27cbdc7 被误删(脚本都还在,只是不再被调用 ⇒ 门禁静默削弱)。
# 已在 2026-11-XX 原样恢复,步骤号顺延后总数回到 24 条。
# 已在 2026-11-XX 原样恢复,步骤号顺延后总数回到 24 条(2026-11-09 再加第 25 条 ⇒ 25 条)。
# 教训:**判据脚本在仓库里 ≠ 判据在门禁里** —— 每次改 ci.sh 必须核对
# 本文件的 step 条数与本文档分母一致,且逐条确认被调用的脚本存在。
# ★ 注意:本注释里刻意不写带引号的 step 字面样例 —— 那会让
@@ -65,6 +65,12 @@
#
set -euo pipefail
cd "$(dirname "$0")/.."
# 25. 集群自报(控制面 + 多节点 hostd)判据自测 + 破坏实验
# —— ★ 真机脚本的判据逻辑**永远不会被门禁执行**(真机不在门禁里),
# 而它有三种静默失效:密钥进 argv / 否定式判据恒真 / 鉴权口径分叉。
# ③ 已真机踩过:控制面送 hex、节点比明文 ⇒ 全部 401。
# —— ★ 破坏实验与判据**一起跑**:正向通过不能证明判据在起作用;
# 恒绿判据和真判据在正向路径上表现完全一样。
FAST=0
for a in "$@"; do
@@ -79,19 +85,19 @@ step() { printf '\n\033[1m== %s ==\033[0m\n' "$1"; }
ok() { printf '\033[32m ok\033[0m\n'; }
if [ "$FAST" -eq 0 ]; then
step "1/24 全量测试(含 secure 特性)"
step "1/25 全量测试(含 secure 特性)"
cargo test --workspace --features secure
ok
fi
step "2/24 零告警构建(所有目标)"
step "2/25 零告警构建(所有目标)"
# -Dwarnings 同时作用于本地 crate 的 test / bench / example 目标,
# 所以「测试代码里有 unused」也会被拦下 —— 这正是想要的。
RUSTFLAGS="${RUSTFLAGS:+${RUSTFLAGS} }-Dwarnings" \
cargo build --workspace --all-targets --features secure
ok
step "3/24 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)"
step "3/25 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)"
# 两条 no_std 都要守:
# mpc-core —— TEE / armv7 那条路的底座
# mpc-tee —— OP-TEE 的 TA 就是 default-features = false 构建的
@@ -129,7 +135,7 @@ ok
# 三层判据都在 tools/check-guest-artifact.py:依赖树(必跑)、
# 编译期守卫负向、ELF 产物标识(后两条需已装 musl target)。
CROSS_TARGET=x86_64-unknown-linux-musl
step "4/24 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针"
step "4/25 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针"
# 依赖树与标识串自检不依赖 musl target 是否安装 —— 目标没装也必须跑,
# 否则「跳过」会把最重要的边界判据一起跳掉(闸门不扫自己 = 假安全感)。
python3 tools/check-guest-artifact.py deps --target "$CROSS_TARGET"
@@ -163,7 +169,7 @@ else
fi
if [ "$FAST" -eq 0 ]; then
step "5/24 示例冒烟(12 个场景)"
step "5/25 示例冒烟(12 个场景)"
tools/examples.sh
ok
@@ -182,7 +188,7 @@ if [ "$FAST" -eq 0 ]; then
# bash 把逗号并进变量名 → CI 第 4 条直接 `CROSS_TARGET,: unbound variable`
# 中途挂掉;而 lint 闸门只扫 deploy/tee,**对自己的盲区完全无感**。
# 闸门不扫闸门自己 = 闸门有盲区 = 假安全感。
step "6/24 shell 引号 / 变量名卫生"
step "6/25 shell 引号 / 变量名卫生"
# ★ deploy/arm 必须一起扫 —— 2026-11-XX 补:此前只扫 deploy/tee + tools,
# 而 arm 目录下的板端脚本是**真机上跑的**(变量名吞字会让板端输出错乱
# 且症状难查)。实跑板端脚本就抓到 4 处 var-ascii 命中。
@@ -192,7 +198,7 @@ if [ "$FAST" -eq 0 ]; then
# 第 6 条:OCI 运行期完整性链自测。
# 这条链是「代码度量 → 活文件内容」的闭链,断了不会有编译错误,
# 只会在真机上表现为篡改活文件照样通过 —— 必须有本地闸门兜住。
step "7/24 OCI 运行期完整性链自测"
step "7/25 OCI 运行期完整性链自测"
python3 deploy/tee/oci/selftest-chain.py
ok
@@ -203,7 +209,7 @@ if [ "$FAST" -eq 0 ]; then
# · 判定断(判定器被顶替 / 输出不是判定结论)→ **假绿**,
# 「通过之后真的会签发 token 并下发密钥」这条路从未被验证过。
# 所以这里必须同时覆盖正向路径与全部拒绝路径。
step "8/24 KBS 先验证明才下发自测"
step "8/25 KBS 先验证明才下发自测"
python3 deploy/tee/kbs/selftest-kbs.py
ok
@@ -211,7 +217,7 @@ if [ "$FAST" -eq 0 ]; then
# guest 的 /init 由 busybox ash 解析,`bash -n` 通过 ≠ ash 能解析。
# 真机上这类错误要等 guest 起来才暴露,排查一轮几分钟;
# 本地闸门用 alpine 的 busybox ash(与 guest 同款解析器)秒级拦住。
step "9/24 guest 脚本 ash 语法"
step "9/25 guest 脚本 ash 语法"
deploy/tee/guest/syntax-check.sh
ok
@@ -235,7 +241,7 @@ if [ "$FAST" -eq 0 ]; then
# ★ 同一处还跑 kbs-up.sh 的参数自检:那份脚本的网段与 TCB 参数一旦被
# 硬编码覆盖,负向矩阵就会**假绿**(真踩过:外部设 min-tcb=99,
# 实际 KBS 收到 3,TCB 负向直接被放行)。
step "10/24 芯片验签器自测(SNP + CSV)+ KBS 启动参数自检"
step "10/25 芯片验签器自测(SNP + CSV)+ KBS 启动参数自检"
python3 deploy/tee/real-machine/selftest-snp-verify.py
python3 deploy/tee/real-machine/selftest-csv-verify.py --self-test
python3 deploy/tee/real-machine/selftest-kbs-up.py
@@ -258,7 +264,7 @@ if [ "$FAST" -eq 0 ]; then
# 不需要 SDK、不需要 QEMU,秒级完成。
# 它证明的是「给定一份日志,判定器的结论正确」,
# **不**证明 OP-TEE 的 seal/unseal 行为正确(那要跑 QEMU)。
step "11/24 OP-TEE 判据逻辑自测"
step "11/25 OP-TEE 判据逻辑自测"
python3 tools/selftest-optee-verdict.py
ok
@@ -288,7 +294,7 @@ if [ "$FAST" -eq 0 ]; then
# 集群控制面默认 `require_chip_sig=true`(真 KBS 验签后才公布端点),
# 假 hostd 返回 chip_sig=false 时端点被**正确地**不公布,
# 那不是实现的错,是判据与策略对不上。
step "12/24 宿主控制面 mpc-hostd 端到端自测"
step "12/25 宿主控制面 mpc-hostd 端到端自测"
python3 tools/selftest-hostd.py
ok
@@ -303,7 +309,7 @@ if [ "$FAST" -eq 0 ]; then
# 判的是框架自己的契约,不是 EasyTier 的实现。进程真起真回收由
# LinkRuntime 单测判(持 Child + try_wait 收割),此处显式再跑一次,
# 保证这条判据真的进了主门禁的执行路径。
step "13/24 会话级链路层 EasyTier 端到端自测"
step "13/25 会话级链路层 EasyTier 端到端自测"
python3 tools/selftest-link.py
ok
@@ -322,7 +328,7 @@ if [ "$FAST" -eq 0 ]; then
# gate 18,但那不是连真节点的通道),所以这条门禁不证明「能上链」。
# 另:--transport 必须显式给,stub 只供桩自测,tlcp 是生产路径
# (缺双证书配置即拒),传输形态不许有默认值 = 不许留明文后门。
step "14/24 链上层 mpc-chain 端到端自测"
step "14/25 链上层 mpc-chain 端到端自测"
python3 tools/selftest-chain.py
ok
@@ -341,7 +347,7 @@ if [ "$FAST" -eq 0 ]; then
# TLCP 双证书正向校验 / 真交易编码仍待真机对拍,
# 见 tools/selftest-chain-gm.py、tools/selftest-tlcp-tunnel.py
# 与 tools/fisco-realnode-probe.py。
step "15/24 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测"
step "15/25 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测"
python3 tools/selftest-chain-gm.py
ok
@@ -355,7 +361,7 @@ if [ "$FAST" -eq 0 ]; then
# ★ fisco-realnode-probe.py 环境齐备也只报 NEEDS_IMPL:FISCO 自有
# 交易编码 / Rust 侧 TLCP 通道 / sm2Verify 真机对拍 / 已签名交易
# 都还没落地,凑齐环境变量不等于能上链。
step "16/24 GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约"
step "16/25 GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约"
python3 tools/selftest-tlcp-gmssl.py --self-test
python3 tools/fisco-realnode-probe.py --self-test
python3 tools/selftest-ta-key-tier.py
@@ -371,7 +377,7 @@ if [ "$FAST" -eq 0 ]; then
# 不是 Python 复刻的策略判定。undefined 输出当拒绝,不当默认 deny。
# ★ 成功也只打印 OPA_DECISION_OK + OPA_GUEST_NOT_VERIFIED +
# CHAIN_NOT_VERIFIED,绝不宣称「阶段 3 已完成」。
step "17/24 阶段 3 OPA bundle 签发 / 真判定 / decision 存证自测"
step "17/25 阶段 3 OPA bundle 签发 / 真判定 / decision 存证自测"
python3 tools/selftest-chain-opa.py --self-test
python3 tools/selftest-chain-opa.py
ok
@@ -392,7 +398,7 @@ if [ "$FAST" -eq 0 ]; then
# 本通道只到 LoopbackReachable。
# ★ 缺 GmSSL / 缺 mpc 二进制打印 GMSSL_TLCP_TUNNEL_SKIPPED + 逐项缺失;
# --self-test 零依赖判据逻辑永远被执行到(防盲区)。
step "18/24 TLCP 进程通道环回实证自测"
step "18/25 TLCP 进程通道环回实证自测"
python3 tools/selftest-tlcp-tunnel.py --self-test
python3 tools/selftest-tlcp-tunnel.py
ok
@@ -415,7 +421,7 @@ if [ "$FAST" -eq 0 ]; then
#
# ★ 测的是真机上**实际调用的那一份** check-pair-verdict.py,
# 不是另写一份模拟 —— 两份实现等于没有门禁。
step "19/24 真 TEE 双 guest 会话判据自测"
step "19/25 真 TEE 双 guest 会话判据自测"
python3 tools/selftest-tee-pair-verdict.py
ok
@@ -436,7 +442,7 @@ if [ "$FAST" -eq 0 ]; then
#
# ★ 测的是真机上**实际调用的那一份** check-attest-verdict.py,
# 不是另写一份模拟 —— 两份实现等于没有门禁。
step "20/24 真 TEE 证明门控判据自测"
step "20/25 真 TEE 证明门控判据自测"
python3 tools/selftest-tee-attest-verdict.py
ok
@@ -463,7 +469,7 @@ if [ "$FAST" -eq 0 ]; then
# ★ 诚实边界:本条用 Python 假 bcos-rpc,验证的是**框架自己的契约**
# (编码、判据、幂等、失败语义),**不证明**真链上能上链。
# 真链部署与调用见 tools/fisco-realnode-probe.py(目前报 NEEDS_IMPL)。
step "21/24 国密链真交易编码 / sendTransaction 判据自测"
step "21/25 国密链真交易编码 / sendTransaction 判据自测"
python3 tools/selftest-chain-tx.py
ok
@@ -483,7 +489,7 @@ if [ "$FAST" -eq 0 ]; then
# ★ 诚实边界:软件 OpenSSL 签名器真能签、真链能上链,但私钥可导出
# ⇒ 密评不可过;生产必须换硬件模组签名器。真实 bcos-rpc 的 TLCP
# 通道仍未通(gate 18 服务端是环回 echo,不是真节点)。
step "22/24 国密链真合约部署 / 调用 / 读回 / 负向矩阵自测"
step "22/25 国密链真合约部署 / 调用 / 读回 / 负向矩阵自测"
python3 tools/selftest-fisco-contract.py --self-test
python3 tools/selftest-fisco-contract.py
ok
@@ -511,7 +517,7 @@ if [ "$FAST" -eq 0 ]; then
# · 协议里加 root-key 导出端点 ⇒ "没有 root-key 端点" 变红
# · CLI + 服务端同时去全零守卫 ⇒ "全零根密钥拒绝启动" 变红
# · 回环模式接受任意 token ⇒ "回环模式带凭据被拒" 变红
step "23/24 SA 扩展模式端到端自测"
step "23/25 SA 扩展模式端到端自测"
python3 tools/selftest-sa.py
ok
@@ -540,9 +546,37 @@ if [ "$FAST" -eq 0 ]; then
# ★ 分层事实(与 SA 那条同一性质):CLI 入口的守卫会**遮蔽**下游的守卫。
# 本脚本覆盖**整体**行为(零种子 ⇒ 起不来);
# 分层责任(下游库自己拒不拒)由各自 crate 的 Rust 单测承担。
step "24/24 零种子守卫端到端自测"
step "24/25 零种子守卫端到端自测"
python3 tools/selftest-seed-guard.py
ok
# 第 25 条:集群自报(控制面 + 多节点 hostd)判据自测 + 破坏实验。
#
# ★ 为什么必须单独一条:
# `cluster-selfreport-e2e.sh` 是**真机**脚本(两台真机:AMD SNP +
# 海光 CSV),真机不在门禁环境里 ⇒ 它的判据逻辑**永远不会被执行**。
# 而这个脚本的判据有三种典型的**静默失效**:
# ① 密钥进 argv ⇒ 密钥出现在远端 ps 里(脚本照样跑通);
# ② 否定式判据恒真 ⇒ 控制面根本没起来,脚本却报「度量非全零」;
# ③ 鉴权口径分叉 ⇒ 控制面送 hex、节点比明文 ⇒ 全部 401。
# ③ 已经**真机踩过**(2026-11-09):症状是「节点活着、自报收到了,
# 就是下发不进去」——看起来像网络问题、像节点问题、像控制面没起。
#
# ★ 破坏实验为什么必须一起跑:
# 判据在正向路径上通过,**不能**证明它在起作用 ——
# 恒绿判据和真判据在正向路径上表现完全一样。
# ⇒ 每个判据都破坏一次,要求自测脚本**必须转红**。
# ★ 破坏实验必须**双向确认变异生效**(证据串消失/新增):
# 2026-11-09 实测踩过:变异函数删错了行 ⇒ 破坏实验「没抓到」
# ⇒ 差点被误判成「判据恒绿」。SKIP 不许当成通过。
#
# ★ 判据只查**代码形态**,不查注释里的字样 ——
# 查注释 ⇒ 注释删了代码还在也会绿(自指型假绿);
# 查裸字符串 ⇒ 注释里自己写着的历史说明会把自己判红(自指型假红)。
step "25/25 集群自报判据自测 + 破坏实验"
python3 tools/selftest-cluster-selfreport.py
python3 tools/selftest-cluster-selfreport-break.py
ok
fi
printf '\n\033[32m\033[1m全部通过\033[0m\n'
+285
View File
@@ -0,0 +1,285 @@
#!/usr/bin/env python3
"""集群自报判据的**破坏实验**:把判据改成坏的样子,确认它们**会红**。
# 这条脚本守的是什么
`tools/selftest-cluster-selfreport.py` 守的是「判据本身是否成立」。
但那只证明了「当前形态下判据通过」—— **不能证明判据在起作用**。
一个恒绿的判据和一个真判据,在正向路径上**表现完全一样**。
所以这份脚本做反向验证:每个判据都**破坏一次**,然后要求
「自测脚本必须转红」:
| 破坏内容 | 期望被哪条判据抓到 |
|----------------------------------|-------------------|
| 删掉注册表判据的正向锚点 | 判据 2 |
| 删掉「正确密钥 200」正向对照 | 判据 3 |
| 把正向对照挪到负向**之后** | 判据 3 |
| 在代码里加回 hex 编码形态 | 判据 4 |
| Rust 侧口径分叉(不用 secret_token)| 判据 5 |
★ 破坏 1(密钥进 argv)不在这儿 —— 它的反向验证已经内建在
`selftest-cluster-selfreport.py` 的「判据 1·反向」里(要跑真实脚本)。
# ★ 两条硬纪律
1. **绝不碰仓库文件** —— 全部在临时副本上做;
2. **变异必须双向确认生效** ——
删型变异:证据串必须**消失**;加型变异:证据串必须**新增**。
2026-11-09 实测踩过:变异函数删错了行 ⇒ 破坏实验「没抓到」
⇒ 差点被误判成「判据恒绿」。所以这里必须校验证据,否则
「SKIP」会被当成「通过」。
用法:
python3 tools/selftest-cluster-selfreport-break.py
"""
import os
import shutil
import subprocess
import sys
import tempfile
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SCRIPT_REL = os.path.join('deploy', 'tee', 'real-machine',
'cluster-selfreport-e2e.sh')
SELFTEST_REL = os.path.join('tools', 'selftest-cluster-selfreport.py')
OK_N = 0
FAIL_N = 0
def ok(msg):
global OK_N
OK_N += 1
print('ok %s' % msg)
def fail(msg):
global FAIL_N
FAIL_N += 1
print('FAIL %s' % msg, file=sys.stderr)
def _prep():
"""做一份临时工作副本(仓库文件一个都不动)。"""
work = tempfile.mkdtemp(prefix='csr-break-')
shutil.copytree(os.path.join(ROOT, 'deploy'),
os.path.join(work, 'deploy'))
shutil.copytree(os.path.join(ROOT, 'crates'),
os.path.join(work, 'crates'))
os.makedirs(os.path.join(work, 'tools'), exist_ok=True)
shutil.copy(os.path.join(ROOT, SELFTEST_REL),
os.path.join(work, SELFTEST_REL))
return work
def _run_selftest(work):
p = subprocess.run(
[sys.executable, os.path.join(work, SELFTEST_REL)],
capture_output=True, text=True, cwd=work)
return p.returncode, p.stdout + p.stderr
def _variant(name, mutate, mode, expect):
"""在临时副本上做一次变异 + 跑自测。
★ mode: 'gone'(证据串必须消失)| 'added'(证据串必须新增)
"""
work = _prep()
try:
p = os.path.join(work, SCRIPT_REL)
with open(p, encoding='utf-8') as f:
src = f.read()
new, evidence = mutate(src)
if new is None or new == src:
fail('破坏·%s:变异未生效' % name)
return False
present = evidence in new
if mode == 'gone':
good = not present
else:
good = present and evidence not in src
if not good:
fail('破坏·%s:证据串校验失败(present=%s, 证据 %s)'
% (name, present, evidence))
return False
with open(p, 'w', encoding='utf-8') as f:
f.write(new)
rc, out = _run_selftest(work)
if rc != 0 and ('FAIL' in out) and (expect in out):
ok('破坏·%s:判据如预期转红(证明它不是恒绿)' % name)
return True
fail('破坏·%s:判据**没有**转红 ⇒ 它是恒绿' % name)
for ln in out.splitlines()[:22]:
print(' | %s' % ln, file=sys.stderr)
return False
finally:
shutil.rmtree(work, ignore_errors=True)
# ── 变异函数 ───────────────────────────────────────────────────────────
def m_remove_positive_anchor(src):
"""删掉注册表判据的正向锚点(n_meas= 那几行)"""
out = [ln for ln in src.splitlines()
if 'n_meas=' not in ln and '注册表里带度量字段' not in ln]
return '\n'.join(out) + '\n', 'n_meas='
def m_remove_positive_control(src):
"""删掉「正确密钥 200」的正向对照(code_ok= 那一整块)"""
lines = src.splitlines()
out = []
i = 0
while i < len(lines):
if 'code_ok=' in lines[i]:
i += 1
while i < len(lines) and not lines[i].strip().startswith('fi'):
i += 1
i += 1
continue
out.append(lines[i])
i += 1
return '\n'.join(out) + '\n', 'code_ok='
def m_add_hex(src):
"""在代码里加回 hex 编码形态"""
out = []
hit = False
for ln in src.splitlines():
if (not hit) and ln.strip().startswith('export MPC_HOSTD_SHARED_SECRET='):
hit = True
indent = ln[:len(ln) - len(ln.lstrip())]
out.append(indent +
'export MPC_HOSTD_SHARED_SECRET=$(printf %s "$SECRET" '
'| od -An -tx1 | tr -d " \\n")')
continue
out.append(ln)
if not hit:
return None, ''
return '\n'.join(out) + '\n', 'od -An -tx1'
def m_move_positive_after_negative(src):
"""把正向对照挪到负向**之后**(顺序反了 ⇒ 控制面没起时会假绿)"""
lines = src.splitlines()
try:
ci = next(i for i, l in enumerate(lines) if 'code_ok=' in l)
fi = next(i for i in range(ci, len(lines))
if lines[i].strip().startswith('fi'))
except StopIteration:
return None, ''
block = lines[ci:fi + 1]
rest = lines[:ci] + lines[fi + 1:]
idx = None
for i, l in enumerate(rest):
if '错密钥 401' in l and 'neg_gate' in l:
idx = i + 2
break
if idx is None:
return None, ''
new_lines = rest[:idx] + block + rest[idx:]
new = '\n'.join(new_lines) + '\n'
# 顺序确认:正向块必须在负向之后(否则变异没生效)
try:
if new.index('code_ok=') < new.index('错密钥 401',
new.index('neg_gate')):
return None, ''
except ValueError:
return None, ''
return new, 'code_ok='
def _variant_order(name, mutate, expect):
"""「顺序事实」型变异:证据不是字串,而是**位置关系**。
★ 为什么单独一套:挪动代码块后,目标字串(`code_ok=`)**仍然在** ——
按「字串消失/新增」判证据会误判成「变异未生效」。
⇒ 这里校验的是「正向块确实挪到了负向之后」。
"""
work = _prep()
try:
p = os.path.join(work, SCRIPT_REL)
with open(p, encoding='utf-8') as f:
src = f.read()
new, evidence = mutate(src)
if new is None or new == src:
fail('破坏·%s:变异未生效' % name)
return False
# ★ 顺序确认:正向块必须在负向之后
try:
code_pos = new.index('code_ok=')
neg_pos = new.index('错密钥 401', new.index('neg_gate'))
except ValueError:
fail('破坏·%s:顺序校验失败(找不到锚点)' % name)
return False
if code_pos < neg_pos:
fail('破坏·%s:顺序没变(变异未生效)' % name)
return False
with open(p, 'w', encoding='utf-8') as f:
f.write(new)
rc, out = _run_selftest(work)
if rc != 0 and ('FAIL' in out) and (expect in out):
ok('破坏·%s:判据如预期转红(证明它不是恒绿)' % name)
return True
fail('破坏·%s:判据**没有**转红 ⇒ 它是恒绿' % name)
for ln in out.splitlines()[:22]:
print(' | %s' % ln, file=sys.stderr)
return False
finally:
shutil.rmtree(work, ignore_errors=True)
def m_break_rust():
"""Rust 侧口径分叉(把 auth::secret_token 换成别的名字)"""
work = _prep()
try:
p = os.path.join(work, 'crates/mpc-cli/src/control_plane.rs')
with open(p, encoding='utf-8') as f:
s = f.read()
if 'auth::secret_token' not in s:
fail('破坏·Rust 侧口径分叉:找不到 auth::secret_token')
return False
with open(p, 'w', encoding='utf-8') as f:
f.write(s.replace('auth::secret_token',
'auth::legacy_hex_token'))
rc, out = _run_selftest(work)
if rc != 0 and ('FAIL' in out) and ('secret_token' in out):
ok('破坏·Rust 侧口径分叉:判据如预期转红')
return True
fail('破坏·Rust 侧口径分叉:判据**没有**转红 ⇒ 它是恒绿')
for ln in out.splitlines()[:22]:
print(' | %s' % ln, file=sys.stderr)
return False
finally:
shutil.rmtree(work, ignore_errors=True)
def main():
print('=== 集群自报判据 · 破坏实验 ===')
print('(每个判据都破坏一次,要求自测脚本必须转红)')
print('')
all_ok = True
all_ok &= _variant('删掉注册表判据的正向锚点',
m_remove_positive_anchor, 'gone', '判据 2')
all_ok &= _variant('删掉「正确密钥 200」正向对照',
m_remove_positive_control, 'gone', '判据 3')
all_ok &= _variant_order('正向对照挪到负向之后',
m_move_positive_after_negative, '判据 3')
all_ok &= _variant('代码里加回 hex 编码形态',
m_add_hex, 'added', '判据 4')
all_ok &= m_break_rust()
print('')
print('=== 结果:%d 通过 / %d 失败 ===' % (OK_N, FAIL_N))
if FAIL_N:
sys.exit(1)
print('CLUSTER_BREAK_OK: 全部破坏实验都被抓到(判据非恒绿)')
if __name__ == '__main__':
main()
+371
View File
@@ -0,0 +1,371 @@
#!/usr/bin/env python3
"""集群自报(控制面 + 多节点 hostd)的判据自测。
# 这条判据守的是什么
`deploy/tee/real-machine/cluster-selfreport-e2e.sh` 是**真机**联调脚本:
两台真机(AMD SNP / 海光 CSV)各起一个 hostd,向一台真机上的集群
控制面周期自报,验证「节点能力能被集群收上去」。
这类脚本有三种典型的**静默失效**:
1. **密钥进 argv** —— 密钥出现在 `ps` 输出里,脚本能跑通但密钥已泄露;
2. **否定式判据恒真** —— 「注册表里没有全零度量」在注册表为空时**恒通过**,
于是控制面根本没起来,脚本却报「度量非全零」;
3. **鉴权口径分叉** —— 控制面下发用 `hex_encode(secret)`、节点侧校验
明文 ⇒ 全部 401,现象是「节点活着、自报收到了,就是下发不进去」。
# ★ 为什么必须用「构造样例逐条破坏」
这三条判据**单看都像是对的**。不破坏一次,就不知道它是恒绿还是真判。
所以本脚本做的是:**把脚本改成坏的样子,确认判据真的会红。**
* 第 1 条:把 `remote()` 改回 argv 传脚本 ⇒ 必须检出密钥进 argv;
* 第 2 条:把注册表判据改成「只看否定式」⇒ 必须检出恒真;
* 第 3 条:把下发口径改回 hex ⇒ 必须检出 401。
# ★ 探针不依赖真机
用**假 sshpass** 在本地跑脚本,记录 ssh 收到的 argv —— 这正是远端
`ps` 能看到的东西。全程不碰真机、不碰真密钥。
用法:
python3 tools/selftest-cluster-selfreport.py
"""
import hashlib
import os
import re
import shutil
import subprocess
import sys
import tempfile
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SCRIPT_REL = os.path.join('deploy', 'tee', 'real-machine',
'cluster-selfreport-e2e.sh')
SCRIPT = os.path.join(ROOT, SCRIPT_REL)
# ★ 用**中性标记**,别用像密钥的串 —— 沙箱会拦「像密钥」的命令行。
MARKER = 'ZZMARKERZZ0123456789abcdefXY'
OK_N = 0
FAIL_N = 0
def ok(msg):
global OK_N
OK_N += 1
print('ok %s' % msg)
def fail(msg):
global FAIL_N
FAIL_N += 1
print('FAIL %s' % msg, file=sys.stderr)
def _fake_ssh(bindir, logpath):
"""假 sshpass:把 ssh 收到的**全部 argv** 记进 logpath。
★ 这就是远端 `ps` 能看到的命令行 —— 密钥只要在里面就是泄露。
"""
os.makedirs(bindir, exist_ok=True)
p = os.path.join(bindir, 'sshpass')
with open(p, 'w', encoding='utf-8') as f:
f.write(
'#!/usr/bin/env bash\n'
'while [ $# -gt 0 ]; do\n'
' case "$1" in\n'
' -e) shift 2; continue;;\n'
' SSHPASS=*) shift; continue;;\n'
' esac\n'
' break\n'
'done\n'
'printf "%%s\\n" "$@" >> "%s"\n'
'cat > /dev/null\n'
'exit 0\n' % logpath
)
os.chmod(p, 0o755)
def _run_script(src_text, timeout=120):
"""在假 ssh 环境里跑脚本,返回 (ssh_argv_list, returncode)。
★ 脚本本身会走完整个流程(起控制面、起 hostd、查注册表),
假 ssh 一律返回空输出 ⇒ 脚本里的判据会红 —— 但那不重要,
我们要看的是**argv 里有没有密钥**。
"""
workdir = tempfile.mkdtemp(prefix='csr-selftest-')
try:
log = os.path.join(workdir, 'argv.log')
bindir = os.path.join(workdir, 'bin')
_fake_ssh(bindir, log)
s = os.path.join(workdir, 'script.sh')
with open(s, 'w', encoding='utf-8') as f:
f.write(src_text)
env = dict(os.environ)
env['PATH'] = bindir + ':' + env.get('PATH', '')
env['SSHPASS_AMD'] = 'p1'
env['USER_AMD'] = 'u1'
env['SSHPASS_HYGON'] = 'p2'
env['USER_HYGON'] = 'u2'
env['MPC_CLUSTER_SECRET'] = MARKER
with open(os.devnull, 'wb') as devnull:
proc = subprocess.Popen(
['bash', s], env=env, stdin=devnull,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
)
try:
proc.communicate(timeout=timeout)
except subprocess.TimeoutExpired:
proc.kill()
proc.communicate()
argv = []
if os.path.exists(log):
with open(log, encoding='utf-8', errors='replace') as f:
argv = [ln.rstrip('\n') for ln in f]
return argv, proc.returncode
finally:
shutil.rmtree(workdir, ignore_errors=True)
def _argv_has_secret(argv):
return any(MARKER in ln for ln in argv)
def _read_script():
with open(SCRIPT, encoding='utf-8') as f:
return f.read()
# ── 判据 1:密钥不得进入 ssh 的 argv ──────────────────────────────────
def check_secret_not_in_argv():
"""正向:当前形态 ⇒ argv 里**没有**密钥。"""
src = _read_script()
argv, _ = _run_script(src)
if _argv_has_secret(argv):
fail('判据 1·正向:密钥出现在了 ssh argv 里(泄露)')
for ln in argv:
if MARKER in ln:
print(' > %s' % ln.strip()[:200], file=sys.stderr)
return
ok('判据 1·正向:密钥不进 ssh argv(当前形态)')
def check_secret_argv_leak_is_detectable():
"""反向:改回旧形态 ⇒ **必须**检出泄露。
★ 这一步是「判据不是恒绿」的证据 ——
不破坏一次,就不知道判据 1 是在真检还是恒绿。
"""
src = _read_script()
good_line = ("""SSHPASS="$3" sshpass -e ssh ${SSHO} "$2@$1" """
"""'bash -s' 2>&1 <<<"$4\"""")
broken_line = ("""SSHPASS="$3" sshpass -e ssh ${SSHO} """
""""$2@$1" "$4" 2>&1""")
if good_line not in src:
fail('判据 1·反向:脚本里找不到 remote() 的 stdin 形态(脚本结构变了?)')
return
broken = src.replace(good_line, broken_line)
# ★ 还要把「本机展开进脚本文本」那段恢复 —— 否则密钥压根没进脚本文本,
# argv 里自然也没有 ⇒ 反向实验会**假阴性**(探针无效)。
old_cp = (
'out=$(remote "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" \\\n'
' "mkdir -p /tmp/mpc-cluster && cd /tmp/mpc-cluster && \\\n'
" MPC_HOSTD_SHARED_SECRET='$CLUSTER_SECRET' nohup ./mpc control-plane serve \\\n"
' --listen 0.0.0.0:3020 --hostd-port 3010 --allow-remote \\\n'
' > cp.log 2>&1 & sleep 2; cat cp.log")'
)
broken2, n = re.subn(
r'out=\$\(remote "\$HYGON_HOST".*?cat cp\.log"\)',
lambda m: old_cp,
broken,
count=1,
flags=re.S,
)
if n == 0:
fail('判据 1·反向:找不到控制面启动段(脚本结构变了?)')
return
argv, _ = _run_script(broken2)
if _argv_has_secret(argv):
ok('判据 1·反向:旧形态下密钥确实进 argv(探针有效)')
else:
fail('判据 1·反向:旧形态也没检出泄露 —— 探针恒绿,无效')
# ── 判据 2:否定式判据必须配正向对照 ──────────────────────────────────
def check_registry_verdict_has_positive_anchor():
"""★ 静态判据:注册表那段必须**同时**有正向锚点与否定式判据。
★ 为什么这条重要:
「注册表里没有全零度量」是**否定式**。若 `nodes` 为空
(curl 失败 / 控制面没起 / 鉴权被拒)⇒ grep 找不到全零 ⇒ 恒通过。
⇒ 必须先断言注册表里**确实有**节点/度量字段,再断言没有全零。
"""
src = _read_script()
# 找「查控制面注册表」之后的判据段
idx = src.find('查控制面注册表')
if idx < 0:
fail('判据 2:脚本里找不到「查控制面注册表」段')
return
tail = src[idx:]
# ★★ **只查代码,不查注释** ——
# 破坏实验删掉的是整段代码,注释里的字样还在 ⇒ 查注释会假绿。
# ⇒ 查**代码形态**:n_meas= 赋值 + 与 -ge 1 的比较。
has_positive_anchor = ('n_meas=' in tail and '-ge 1' in tail
and '"measurement"' in tail)
has_negative = ('ZERO_MEAS=' in tail and '度量非全零' in tail)
if not has_positive_anchor:
fail('判据 2:注册表判据缺正向对照的**代码**'
'(没有「取 measurement 计数并断言 >= 1」这个锚点)')
return
if not has_negative:
fail('判据 2:注册表判据缺否定式(全零度量检查)')
return
ok('判据 2:注册表判据 = 正向锚点(代码)+ 否定式,配对齐全')
def check_wrong_key_verdict_has_positive_control():
"""★ 静态判据:错密钥 401 必须**先**跑正确密钥 200 的正向对照。
★ 为什么:控制面没起来时 curl 连不上,HTTP 码是 `000`,
`000 != 200` ⇒ 只判「错密钥不是 200」会**恒通过** ⇒ 假绿。
★★ **只查代码,不查注释** ——
2026-11-09 实测踩到:判据原本查的是注释里的「正确密钥」字样,
而破坏实验删掉的是**整段代码** ⇒ 注释还在 ⇒ 判据照样绿
⇒ **自指型假绿**。
⇒ 现在查**代码形态**:`code_ok=` 赋值 + 与 `200` 的比较 + 位置在负向**之前**。
"""
src = _read_script()
idx = src.find('错密钥 401')
if idx < 0:
fail('判据 3:脚本里找不到「错密钥 401」负向判据')
return
pos_code = src.find('code_ok=')
if pos_code < 0:
fail('判据 3:缺正向对照的**代码**(没有 code_ok= 这一测)')
return
# ★ 正向对照必须真的拿 200 比对,且在负向**之前**
window = src[pos_code:pos_code + 800]
if '"200"' not in window and "'200'" not in window:
fail('判据 3:正向对照代码里没有与 200 的比较(只是取了个码却没断言)')
return
if pos_code > idx:
fail('判据 3:正向对照在负向**之后**(顺序反了 ⇒ 控制面没起时会假绿)')
return
ok('判据 3:错密钥 401 配了前置正向对照(代码里 code_ok= 与 200 比对)')
# ── 判据 4:鉴权口径必须统一(明文,不是 hex)─────────────────────────
def check_auth_token_plaintext_not_hex():
"""★ 静态判据:脚本不得自己再把密钥**编码一次**。
★ 口径真相源在 Rust 侧(`mpc_hostd::auth::secret_token`)。
脚本侧只管「别自己再编码一次」。
★★ **只查代码,不查注释** ——
脚本的注释里**故意**留着「当初踩过 hex_encode 的坑」的说明,
那是**历史记录**;如果按裸字符串查,注释会把自己判红
(「自指型假红」:判据把自己的说明当成违规)。
⇒ 判据必须**剥掉注释行**再查。
★★ 查的是**编码行为**,不是特定函数名 ——
编码可以用 `hex_encode` / `od -An -tx1` / `xxd -p` / `base64` ……
只查 `hex_encode` 一个名字 ⇒ 换个写法就绕过去了(假绿)。
⇒ 判据在**密钥赋值语句**附近找「编码工具链」。
"""
src = _read_script()
code_lines = []
for ln in src.splitlines():
stripped = ln.strip()
if stripped.startswith('#'):
continue
code_lines.append(ln.split(' #')[0])
code = '\n'.join(code_lines)
# ★ 编码工具链特征(都是「把字节流变成另一种文本」的典型手法)
encoders = ('hex_encode', 'od -An -tx1', 'od -An -tx', 'xxd -p',
'xxd -ps', 'to_hex', 'hexdump', 'base64')
found = [e for e in encoders if e in code]
if found:
fail('判据 4:**代码**里出现了密钥编码工具链 %s —— 口径又分叉了'
% '、'.join(found))
return
# ★ 更精确的一层:密钥**值**里不许带管道。
# ★ 别误伤合法的 `... | head -3`(截输出,不是加工密钥)——
# 只看 `MPC_HOSTD_SHARED_SECRET=` **紧跟的那个值**:
# 值的范围 = 从赋值号起,到下一个「命令分隔」为止
# (分隔 = `&&`、换行、或行尾的 `\` 续行)。
import re as _re
for ln in code.splitlines():
m = _re.search(r'MPC_HOSTD_SHARED_SECRET=([^\s&]*)', ln)
if not m:
continue
value = m.group(1)
if '|' in value:
fail('判据 4:密钥值里带了管道(%s)—— 不该再加工密钥' % value)
return
ok('判据 4:鉴权口径统一为明文(代码里无密钥编码工具链;注释里的历史说明不算)')
def check_rust_secret_token_guard_exists():
"""★ 跨语言判据:Rust 侧必须有 `secret_token` 这份**唯一口径**。
★ 2026-11-09 实测过的坑:
控制面下发用 `hex_encode(s)`、节点侧校验明文 ⇒ 全部 401。
口径必须落在**一份代码**里 —— `mpc_hostd::auth::secret_token`。
"""
auth_rs = os.path.join(ROOT, 'crates', 'mpc-hostd', 'src', 'auth.rs')
cp_rs = os.path.join(ROOT, 'crates', 'mpc-cli', 'src', 'control_plane.rs')
for p in (auth_rs, cp_rs):
if not os.path.exists(p):
fail('判据 5:文件不存在:%s' % p)
return
with open(auth_rs, encoding='utf-8') as f:
a = f.read()
with open(cp_rs, encoding='utf-8') as f:
c = f.read()
if 'pub fn secret_token' not in a:
fail('判据 5:mpc-hostd 里没有 `pub fn secret_token`(唯一口径缺失)')
return
if 'auth::secret_token' not in c:
fail('判据 5:control_plane.rs 没有走 auth::secret_token(口径分叉)')
return
ok('判据 5:Rust 侧有唯一口径 auth::secret_token,且 control_plane 在用')
def main():
print('=== 集群自报判据自测 ===')
if not os.path.exists(SCRIPT):
print('FAIL 找不到脚本:%s' % SCRIPT, file=sys.stderr)
sys.exit(1)
check_secret_not_in_argv()
check_secret_argv_leak_is_detectable()
check_registry_verdict_has_positive_anchor()
check_wrong_key_verdict_has_positive_control()
check_auth_token_plaintext_not_hex()
check_rust_secret_token_guard_exists()
print('')
print('=== 结果:%d 通过 / %d 失败 ===' % (OK_N, FAIL_N))
if FAIL_N:
sys.exit(1)
print('CLUSTER_SELFTEST_OK: 集群自报判据自测全绿')
if __name__ == '__main__':
main()