diff --git a/crates/mpc-hostd/src/guest_hand.rs b/crates/mpc-hostd/src/guest_hand.rs index 5d574cd..eaa3c98 100644 --- a/crates/mpc-hostd/src/guest_hand.rs +++ b/crates/mpc-hostd/src/guest_hand.rs @@ -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(那里不采证明)" + ); + } } diff --git a/deploy/tee/guest/init.sh b/deploy/tee/guest/init.sh index 2758deb..229e575 100644 --- a/deploy/tee/guest/init.sh +++ b/deploy/tee/guest/init.sh @@ -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 diff --git a/deploy/tee/real-machine/cluster-selfreport-e2e.sh b/deploy/tee/real-machine/cluster-selfreport-e2e.sh index bee1b4e..4986a1c 100755 --- a/deploy/tee/real-machine/cluster-selfreport-e2e.sh +++ b/deploy/tee/real-machine/cluster-selfreport-e2e.sh @@ -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() { diff --git a/tools/ci.sh b/tools/ci.sh index c9a5aec..cb59b0c 100755 --- a/tools/ci.sh +++ b/tools/ci.sh @@ -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' diff --git a/tools/selftest-cluster-selfreport-break.py b/tools/selftest-cluster-selfreport-break.py new file mode 100644 index 0000000..614bb77 --- /dev/null +++ b/tools/selftest-cluster-selfreport-break.py @@ -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() diff --git a/tools/selftest-cluster-selfreport.py b/tools/selftest-cluster-selfreport.py new file mode 100644 index 0000000..75ed969 --- /dev/null +++ b/tools/selftest-cluster-selfreport.py @@ -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()