diff --git a/CLAUDE.md b/CLAUDE.md index c34f726..7c898e8 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -40,10 +40,10 @@ cargo check --workspace --target armv7-unknown-linux-gnueabihf # 交叉编译 cargo build --release -p mpc-cli && ./target/release/mpc selftest # ★ guest 静态产物:musl 目标必须显式 --no-default-features cargo build --release -p mpc-cli --target x86_64-unknown-linux-musl --no-default-features -./tools/ci.sh # CI 与本地同一份闸门(18 条) +./tools/ci.sh # CI 与本地同一份闸门(19 条) ``` -主门禁 `./tools/ci.sh` 共 18 条:全量测试(**必须带 `--features secure`**)、 +主门禁 `./tools/ci.sh` 共 19 条:全量测试(**必须带 `--features secure`**)、 `-Dwarnings` 零告警(作用于 test/bench/example 目标)、`mpc-core` / `mpc-tee` no_std 双守 + TA UUID 对拍、**musl 跨目标零告警 + guest 边界探针**、12 示例冒烟、 shell 卫生、OCI 链、KBS、ash 语法、SNP 验签器、OP-TEE 判据逻辑、 @@ -53,7 +53,9 @@ hostd / 链路层 / 链上层端到端桩自测、国密签名与治理形状自 缺环境一律显式 `*_SKIPPED` + 逐项缺失,绝不静默通过)、 **TLCP 进程通道环回实证**(第 18 条;Rust 侧 spawn `gmssl tlcp_client` 经 TLCP 收发真实 JSON-RPC 给环回 echo 服务端,断言往返一致; -`realChainVerified` 恒 false,输出 `BCOS_RPC_NOT_VERIFIED`)。 +`realChainVerified` 恒 false,输出 `BCOS_RPC_NOT_VERIFIED`)、 +**真 TEE 双 guest 会话判据自测**(第 19 条;测的是真机上**实际调用的那一份** +`check-pair-verdict.py`,每条判据用构造样例逐条破坏,验证它能真的把结论推翻)。 明细以脚本自身为准(**闸门不扫自己就是盲区**)。 ## crate 分层 @@ -355,6 +357,28 @@ SM2 签名走系统 OpenSSL 的 EVP 接口(`openssl` crate 链接系统库, - ★ 沙箱驱动的实例**不是真 TEE enclave**(起的是真机上的普通进程)⇒ 四布尔必然全 false。 这验证的是**控制面编排**,不是 TEE 证明链 —— 别混淆。 +**★ 真 TEE 全流程:跨物理机双 guest 密文会话(2026-11-07 首次跑通)**: +AMD SEV-SNP(`192.168.1.7`,alice)与海光 CSV(`192.168.1.102`,bob)跨两台物理机, +各自在**真加密 VM 内**完成 PSK 双向认证 + ChaCha20-Poly1305 密文会话, +**两侧都还原出 `value | 35.000000`**,判据 `TEE_PAIR_OK`。 +一键复现:`deploy/tee/real-machine/tee-pair-e2e.sh`。 +- ★ **guest halt 之后 qemu 不退出** ⇒ 前台 `ssh` 起 guest 会**永久挂死** + (会话其实已成功、判据一行没跑到 ⇒ **假红**)。起 guest 一律走 + `guest-watch.sh`:后台起 + 轮询串口里的 `MPC TEE GUEST DONE` + 显式 kill qemu。 +- ★ **guest 的 stdout 默认会丢**(框架 argv 是 `-nographic` + `-serial stdio`, + 两个前端抢同一个 stdio)⇒ `env.sh` 必须注入 `MPC_TEE_SERIAL_LOG`, + `run-guest.py` 把串口换成 chardev file 后端。 +- ★ **采集回来的日志会被掩码**:xop 的密钥泄漏防护把 `root` 误判成密钥片段, + `rootfs_files: verified` → `ro****【xop禁止将密钥泄漏】fs_files: verified` + ⇒ 判据只认稳定后缀 `fs_files` / `fs_links`。 +- ★ **判定只有一份实现**:`deploy/tee/real-machine/check-pair-verdict.py` + (`pair-run.sh` 与主门禁第 19 条自测调的是同一份;两份实现等于没有门禁)。 + 每条判据都被 `tools/selftest-tee-pair-verdict.py` **逐条破坏**过 + (验证它能真的把结论推翻)—— 负向判据自指是常态,不是意外。 +- ★ 本轮跑的是**离线演练密钥**(`key_source=offline-demo`)⇒ 不宣称密钥分发链路; + `pair-run.sh` **不做芯片证明互验** ⇒ 不宣称两端互验过对方芯片报告。 + 详见 `docs/REAL_MACHINE_FINDINGS.md` 第 9 节。 + **链路层不引任何 EasyTier crate**:`mpc_hostd::link` 只 `Command::spawn` 外部二进制 (独立程序 + CLI/RPC 是 LGPL 明确许可的用法),`mpc_tee::link` 是 no_std 协议层。 静态链接 `easytier-*` 会把整个 `mpc` 二进制拖进 LGPL —— 这是**唯一不能碰的一档**。 @@ -369,5 +393,6 @@ SM2 签名走系统 OpenSSL 的 EVP 接口(`openssl` crate 链接系统库, - `docs/ZYNQ.md` — Zynq-7015 性能预算、交叉编译、部署形态 - `docs/REAL_MACHINE_FINDINGS.md` — **两台真机实测的硬事实**(海光 CSV / AMD SNP): MAC 不在签名覆盖内、官方验签器联网补链、五关闭环与负向矩阵、 - **异地站点端(沙箱)→ 真机 hostd 的控制面闭环**、踩坑清单 + **异地站点端(沙箱)→ 真机 hostd 的控制面闭环**、 + **真 TEE 跨物理机双 guest 密文会话(两侧都 35.000000)**、踩坑清单 - `refs/nax/` — Python 参考实现(只读) diff --git a/deploy/tee/real-machine/README.md b/deploy/tee/real-machine/README.md index f26607d..2da5dec 100644 --- a/deploy/tee/real-machine/README.md +++ b/deploy/tee/real-machine/README.md @@ -62,10 +62,56 @@ MPC_TEE_DRY_RUN=1 ./pair-run.sh # 先看物料与计划,不连机 ./pair-run.sh ``` +### ★ 一键复现(推荐) + +```bash +./tee-pair-e2e.sh # 全流程:编译 → OCI → 分发 → 双 guest → 判定 +MPC_TEE_DRY_RUN=1 ./tee-pair-e2e.sh # 只跑到 dry-run,不连机 +``` + +它把散落的步骤串成一条命令:交叉编译 musl 静态 `mpc` → 导 alpine base +rootfs → `oci-image.py build/verify/pack` → 用**真实** manifest digest 生成 +节点描述(替换示例里的 `000…0` 占位)→ `pair-run.sh` → 判定。 +manifest digest 是从工具输出里**解析**出来的,不是手抄。 + +2026-11-07 真机实测:AMD SEV-SNP(`192.168.1.7`)与海光 CSV(`192.168.1.102`) +跨两台物理机,各自真加密 VM 内完成密文会话,**两侧都还原出 +`value | 35.000000`**,判据 `TEE_PAIR_OK`。详见 +`docs/REAL_MACHINE_FINDINGS.md` 第 9 节。 + +### ★ 判定逻辑只有一份 + +`check-pair-verdict.py` 是唯一的判定实现,`pair-run.sh` 与主门禁自测 +(`tools/selftest-tee-pair-verdict.py`,主门禁第 19 条)**调的是同一份**。 +两份实现等于没有门禁。 + +每条判据都被自测**逐条破坏**过(验证它能真的把结论推翻): + +| 判据 | 说明 | +|---|---| +| `value \| 35.000000` | 密文会话还原结果(写死具体数值,比「任意数字」更严) | +| `oci_layers: verified` | OCI 运行期完整性链 | +| `fs_files: verified` / `fs_links: verified` | 活 rootfs 文件 / 符号链接清单 | +| `manifest_digest=<64hex>` | 与本轮 MANIFEST **逐字符比对**(不是「有没有这一行」) | +| `全部通过` | guest 内 `mpc selftest` | +| `MPC TEE GUEST DONE` | guest 完成标记 | +| 无 `MPC_FAIL:` | fail-closed:guest 明确报错时一律判失败 | + `pair-run.sh` 会:分发物料到两台宿主 → 后台起 AMD SNP guest(alice,socket 监听)→ -只读确认端口 LISTEN → 起海光 CSV guest(bob,socket 连接)→ 输出两侧日志尾部。 -判定成功的标志是**两侧都输出 `value | 35.000000`**,且日志里有 -`oci_layers: verified`、`manifest_digest=...`、`mpc selftest 全部通过`。 +只读确认端口 LISTEN → 起海光 CSV guest(bob,socket 连接)→ 回传两侧**串口**日志 → +逐项判定。判定成功的标志是 `TEE_PAIR_OK`。 + +### ★ 三个必须知道的坑 + +1. **guest halt 之后 qemu 不退出** —— 前台 `ssh` 起 guest 会**永久挂住**。 + 所以起 guest 一律走 `guest-watch.sh`(后台 + 轮询 `MPC TEE GUEST DONE`, + 命中即显式 kill qemu)。详见 `guest-watch.sh` 的文件头。 +2. **guest 的 stdout 默认会丢** —— 框架 argv 是 `-nographic` + `-serial stdio`, + 两个前端抢同一个 stdio。`env.sh` 必须注入 `MPC_TEE_SERIAL_LOG`, + `run-guest.py` 会把串口换成 chardev file 后端。 +3. **采集回来的日志会被掩码** —— xop 的密钥泄漏防护把 `root` 误判成密钥片段, + `rootfs_files: verified` 变成 `ro****【xop禁止将密钥泄漏】fs_files: verified`。 + 所以判据只认稳定后缀 `fs_files` / `fs_links`。 ## 分层与职责 @@ -73,7 +119,10 @@ MPC_TEE_DRY_RUN=1 ./pair-run.sh # 先看物料与计划,不连机 |---|---|---| | 框架 | `mpc tee plan --argv` | 平台中立的 qemu argv(含 `user_data`、kernel-hashes、pflash、cbitpos) | | 部署 | `run-guest.py` | 只补串口 / 角色 / manifest / KBC / socket 网卡 / NUMA,**不覆盖框架参数** | -| 编排 | `pair-run.sh` | 分发物料、起两侧 guest、收日志;调度决策在本地,不在集群 | +| 编排 | `pair-run.sh` | 分发物料、起两侧 guest、收串口日志、判定 | +| 看护 | `guest-watch.sh` | 远端后台起 guest + 轮询完成标记 + 收尾(防 qemu 不退出挂死) | +| 判定 | `check-pair-verdict.py` | **唯一的判定实现**(编排与门禁自测共用) | +| 一键 | `tee-pair-e2e.sh` | 编译 → OCI → 分发 → 双 guest → 判定 | | guest | `../guest/init.sh` | 校验 OCI 层 → 取密钥 → 启动 `mpc node` | ## 证明链路自测(SNP,2026-11-07 补齐) diff --git a/deploy/tee/real-machine/check-pair-verdict.py b/deploy/tee/real-machine/check-pair-verdict.py new file mode 100755 index 0000000..3442b7e --- /dev/null +++ b/deploy/tee/real-machine/check-pair-verdict.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""真 TEE 双 guest 跨物理机会话的**判据判定器**。 + +`pair-run.sh` 采集两侧串口日志后,把判定交给本脚本 —— +判定逻辑只有这一份实现,主门禁的自测也测它(避免「脚本里一份、 +门禁里另一份」这种双份真相源)。 + +用法: + check-pair-verdict.py --manifest <64hex> \ + --alice --bob + +输出:逐项判定(每条独立标注),最后给总结论。退出码: + 0 两侧全部通过 + 1 至少一项不通过 + 2 用法错误 / 文件缺失 + +★ 判定必须**逐项可定位**,不能只给一个总结果: + 实测踩过的坑是「事实成功、判据假红」—— + 两侧明明都还原出 35.000000,判据却因为写错了字符串 + ("mpc selftest 全部通过" vs 真实的 "全部通过")而全红。 + 逐项输出让「哪一条不对」一眼可见。 + +★ 每条判据都必须**可测**(不是恒为真 / 恒为假): + `tools/selftest-tee-pair-verdict.py` 用构造样例逐条破坏,验证 + 每一条判据都能真的把结论推翻。 +""" +import argparse +import os +import re +import sys + +# 判定项:(标识, 说明, 命中即通过的正则, 是��"存在即失败"的禁止项) +# +# `value | 35.000000` —— 两方各 3 个数(1,2,3 与 4,5,6)的乘积和。 +# 数字是 pair-run.sh 固定输入下的确定值,写死它比「任意数字」更严: +# 若计算逻辑变了导致结果不对,这条判据会立刻红,而不是悄悄放过。 +CHECKS = ( + ("value", "密文会话还原结果", r"value \| 35\.000000"), + ("oci_layers", "OCI 运行期完整性链", r"oci_layers: verified"), + # ★ 「活 rootfs 文件清单校验」这一行的标识是 `rootfs_files: verified`, + # 但采集链路上会被**掩码**:`root` 被 xop 的密钥泄漏防护误判成密钥 + # 片段,整行变成 `ro****【xop禁止将密钥泄漏】fs_files: verified` + # (2026-11-07 真机实跑实测)。所以这里只认**稳定后缀** `fs_files` + # 与 `fs_links` —— 它们不是密钥片段,不会被掩码。 + # ★ 代价:这两条判据在「日志被掩码」的环境里仍能成立, + # 所以它们**不能**单独当作「根文件系统完整性链已验证」的证据; + # 真正把这条链钉死的是 guest init 自己的 fail-closed 行为 + # (digest 不符就 MPC_FAIL + halt,见 deploy/tee/real-machine/tamper-initrd.py)。 + ("rootfs_files", "活 rootfs 文件清单校验", r"fs_files: verified"), + ("rootfs_links", "活 rootfs 符号链接清单校验", r"fs_links: verified"), + ("manifest", "镜像度量与本轮一致", r"manifest_digest=([0-9a-f]{64})"), + ("selftest", "guest 内自检全绿", r"全部通过"), + ("done", "guest 完成标记", r"MPC TEE GUEST DONE"), +) + +# 出现即判失败的禁止项(fail-closed): +# guest init 的 die() 会打 `MPC_FAIL: <原因>`。哪怕日志里**碰巧**还留着 +# 上一轮的 35.000000,出现 MPC_FAIL 也必须判失败。 +FORBIDDEN = ("MPC_FAIL:",) + + +def read(path): + if not path or not os.path.isfile(path): + return None + with open(path, "r", encoding="utf-8", errors="replace") as f: + return f.read() + + +def check_side(tag, text, manifest, out): + """对一侧日志做逐项判定,返回 True 表示全过。""" + if text is None: + out.append("判定[%s]: 串口日志缺失 —— 采集失败,不能当成没发生" % tag) + return False + if not text.strip(): + out.append("判定[%s]: 串口日志为空 —— 采集失败,不能当成没发生" % tag) + return False + + ok = True + for name, desc, pattern in CHECKS: + if name == "manifest": + # 这一条要**比对值**,不是「有没有 manifest_digest 这一行」。 + m = re.search(pattern, text) + if not m: + out.append("判定[%s]: 缺 %s(%s)" % (tag, desc, name)) + ok = False + elif m.group(1).lower() != manifest.lower(): + out.append("判定[%s]: %s 不匹配(期望 %s,实得 %s)" + % (tag, desc, manifest, m.group(1))) + ok = False + continue + if not re.search(pattern, text): + out.append("判定[%s]: 缺 %s(%s)" % (tag, desc, name)) + ok = False + + for bad in FORBIDDEN: + if bad in text: + out.append("判定[%s]: guest 报了 %s(fail-closed)" % (tag, bad)) + ok = False + return ok + + +def main(): + ap = argparse.ArgumentParser(description="真 TEE 双 guest 会话判据判定") + ap.add_argument("--manifest", required=True, help="本轮 OCI manifest digest(64 hex)") + ap.add_argument("--alice", required=True, help="alice 侧串口日志") + ap.add_argument("--bob", required=True, help="bob 侧串口日志") + args = ap.parse_args() + + manifest = args.manifest.strip().lower() + if len(manifest) != 64 or not all(c in "0123456789abcdef" for c in manifest): + sys.stderr.write("manifest 必须是 64 位 hex\n") + return 2 + + out = [] + a_ok = check_side("alice", read(args.alice), manifest, out) + b_ok = check_side("bob", read(args.bob), manifest, out) + + for line in out: + print(line) + if a_ok and b_ok: + print("TEE_PAIR_OK: 两侧均在真 TEE 内完成密文会话并还原出 35.000000") + return 0 + print("TEE_PAIR_FAIL: 见上面的逐项判定") + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/deploy/tee/real-machine/guest-watch.sh b/deploy/tee/real-machine/guest-watch.sh new file mode 100755 index 0000000..10a30ee --- /dev/null +++ b/deploy/tee/real-machine/guest-watch.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash +# 在 TEE 宿主上**后台**起一个机密 guest,并轮询串口日志里的完成标记。 +# +# ★ 为什么不能直接前台 `bash guest-role.sh `(这是本文件存在的理由): +# +# guest init 的结尾是 `halt -f`(guest 内核停机)。但 **qemu 进程不会退出** +# —— 2026-11-07 两台真机实测: +# · guest 串口早已打出 "MPC TEE GUEST DONE" 与 "reboot: System halted"; +# · qemu 仍然占着 CPU 与 socket 端口(AMD 上 19777 仍在 LISTEN)。 +# 前台 ssh 于是永远等不到返回 ⇒ 编排脚本挂死。 +# +# 早先那版 pair-run.sh 正是这么挂的:会话其实**已经成功**(两侧都还原出 +# 35.000000),但脚本卡在等 ssh 返回,判据根本没跑到 —— 一次典型的 +# 「事实成功、判据假红」。本文件把「等 guest 做完」从「等 qemu 退出」 +# 改成「等串口里出现完成标记」,并给一个有界超时。 +# +# 完成标记用 guest init 自己打的 `MPC TEE GUEST DONE`,**不用** qemu 的退出码: +# guest 里 halt 之后的退出码与「计算是否成功」无关(成功也可能非 0)。 +# +# 用法:guest-watch.sh +# 环境:MPC_TEE_RUN_DIR(默认 /tmp/mpc-tee-run) +# 输出(stdout):GUEST_DONE_MARK_SEEN / GUEST_FAIL_MARK_SEEN / +# GUEST_PROC_EXITED / GUEST_TIMEOUT +set -u + +ROLE=${1:-none} +TIMEOUT=${2:-300} +BASE=${MPC_TEE_RUN_DIR:-/tmp/mpc-tee-run} +SERIAL="$BASE/serial.log" + +cd "$BASE" || exit 2 +rm -f "$SERIAL" + +# ★ 必须 source env.sh —— guest-role.sh 依赖 MPC_TEE_MANIFEST 等注入值, +# 缺了就直接以「必须给出 OCI manifest digest」退出(guest 进程秒退, +# watch 只看得到 GUEST_PROC_EXITED,串口日志一片空白 —— 症状极具误导性: +# 看起来像「guest 起不来」,真因只是环境变量没灌进去)。 +if [ -f "$BASE/env.sh" ]; then + # shellcheck disable=SC1091 + . "$BASE/env.sh" +fi + +bash "$BASE/guest-role.sh" "$ROLE" > "$BASE/qemu.stdout" 2>&1 & +GPID=$! + +i=0 +MARK="" +while [ "$i" -lt "$TIMEOUT" ]; do + if grep -q "MPC TEE GUEST DONE" "$SERIAL" 2>/dev/null; then + MARK=GUEST_DONE_MARK_SEEN + break + fi + # ★ fail-closed 标记:guest init 的 die() 会打 `MPC_FAIL: <原因>`。 + # 这条必须单独判 —— guest 挂掉时不会有 DONE 标记,若只等 DONE, + # 就会一直等到超时,把「明确失败」拖成「不明所以的超时」。 + if grep -q "MPC_FAIL:" "$SERIAL" 2>/dev/null; then + MARK=GUEST_FAIL_MARK_SEEN + break + fi + kill -0 "$GPID" 2>/dev/null || { MARK=GUEST_PROC_EXITED; break; } + sleep 1 + i=$((i + 1)) +done + +[ -z "$MARK" ] && MARK=GUEST_TIMEOUT +echo "$MARK" + +# ★ 把 qemu 自己的 stdout 一并带出来 —— 否则 watch 只报 +# GUEST_PROC_EXITED,看不出「是 guest-role.sh 因缺 MPC_TEE_MANIFEST +# 秒退」还是「guest 真跑挂了」。两者处置完全不同。 +if [ "$MARK" = "GUEST_PROC_EXITED" ] && [ -s "$BASE/qemu.stdout" ]; then + echo "--- qemu.stdout (tail) ---" + tail -15 "$BASE/qemu.stdout" + echo "--- end qemu.stdout ---" +fi + +# 收尾:qemu 不会自己退出,必须显式杀 —— 否则端口一直被占, +# 下一轮起 guest 会撞 "Device or resource busy" / 端口占用。 +kill "$GPID" 2>/dev/null || true +sleep 1 +kill -9 "$GPID" 2>/dev/null || true +wait "$GPID" 2>/dev/null || true +exit 0 diff --git a/deploy/tee/real-machine/pair-run.sh b/deploy/tee/real-machine/pair-run.sh index 619aec3..3180dce 100755 --- a/deploy/tee/real-machine/pair-run.sh +++ b/deploy/tee/real-machine/pair-run.sh @@ -36,6 +36,7 @@ need() { } need "$HERE/run-guest.py" need "$HERE/guest-role.sh" +need "$HERE/guest-watch.sh" need "${MPC_TEE_MPC_BIN:-/nonexistent}" need "${MPC_TEE_INITRD:-/nonexistent}" need "${MPC_TEE_AMD_NODE:-/nonexistent}" @@ -52,6 +53,7 @@ stage() { cp "${MPC_TEE_INITRD}" "$dst/initrd.img" cp "$HERE/run-guest.py" "$dst/run-guest.py" cp "$HERE/guest-role.sh" "$dst/guest-role.sh" + cp "$HERE/guest-watch.sh" "$dst/guest-watch.sh" sed "s|^initrd=.*|initrd=$REMOTE_DIR/initrd.img|" "$node" > "$dst/node" cat > "$dst/env.sh" </dev/null || true\"" \ + < /dev/null > "$dst" 2>/dev/null || true +} + +# ★ 不要在这里加「前台 ssh 起 guest」的函数。 +# guest 里 halt 之后 qemu 不退出,前台 ssh 会永久挂住 —— +# 2026-11-07 实测踩过:会话已成功(两侧都 35.000000), +# 脚本却卡在等 ssh 返回,判据一行没跑到(假红)。 +# 要起 guest 一律走 remote_bg → guest-watch.sh。 + +remote_bg() { + local host=$1 user_key=$2 pass_key=$3 role=$4 timeout_s=$5 + xop run --secret "SSHPASS=$pass_key" --secret "TEE_USER=$user_key" -- \ + sh -c "sshpass -e ssh $SSHO \"\$TEE_USER@$host\" \ + \"MPC_TEE_RUN_DIR=$REMOTE_DIR bash $REMOTE_DIR/guest-watch.sh $role $timeout_s\"" \ < /dev/null } @@ -106,13 +143,33 @@ scpto "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" "$STAGE_A" || exit 2 scpto "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" "$STAGE_B" || exit 2 rm -rf "$STAGE_A" "$STAGE_B" +# 清掉上一轮的串口日志 —— 否则判据会读到**旧**日志里的 35.000000, +# 把「这次没跑成」误判成「跑成了」。这是判据自指的经典坑。 +# +# 两台机各自用自己的凭据键名,不能拿 AMD 的去清海光的。 +clean_remote_log() { + local host=$1 user_key=$2 pass_key=$3 + xop run --secret "SSHPASS=$pass_key" --secret "TEE_USER=$user_key" -- \ + sh -c "sshpass -e ssh $SSHO \"\$TEE_USER@$host\" \ + \"rm -f $REMOTE_DIR/serial.log\"" < /dev/null >/dev/null 2>&1 || true +} +clean_remote_log "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" +clean_remote_log "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" + +GUEST_TIMEOUT_S=${MPC_TEE_GUEST_TIMEOUT:-300} + echo "=== 起 AMD SNP guest (alice) ===" -remote "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" alice \ +# ★ 用 guest-watch.sh(后台 + 轮询完成标记),不用前台 ssh。 +# 原因见 guest-watch.sh 的文件头:guest halt 之后 qemu 不退出, +# 前台 ssh 会永久挂住 —— 上一版就是「事实成功、判据假红」。 +remote_bg "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" alice "$GUEST_TIMEOUT_S" \ > "$LOG_DIR/alice.log" 2>&1 & P_ALICE=$! +# 等 AMD 的 socket 端口进 LISTEN —— 这是「bob 有地方可连」的唯一依据。 +# ★ 只看第一行 / 只看进程存活都是不够的。 ready=0 -for _ in $(seq 1 40); do +for _ in $(seq 1 60); do if xop run --secret "SSHPASS=$AMD_PASS_KEY" --secret "TEE_USER=$AMD_USER_KEY" -- \ sh -c "sshpass -e ssh $SSHO \"\$TEE_USER@$AMD_HOST\" \"ss -ltn | grep -q ':$LINK_PORT '\"" \ < /dev/null > /dev/null 2>&1; then @@ -124,14 +181,62 @@ done echo "snp_socket_listening=$ready ($AMD_HOST:$LINK_PORT)" echo "=== 起 海光 CSV guest (bob) ===" -remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" bob \ +remote_bg "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" bob "$GUEST_TIMEOUT_S" \ > "$LOG_DIR/bob.log" 2>&1 RC=$? wait "$P_ALICE" 2>/dev/null || true +# ★ 取回两侧**串口**日志。远端命令的 stdout 只有 qemu 自身信息, +# guest 内部日志只在串口文件里。 +fetch_log "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" "$LOG_DIR/alice.serial" +fetch_log "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" "$LOG_DIR/bob.serial" + clean() { grep -v "WARN NetworkGuard\|WARN FileGuard\|Permanently added" "$1" | tail -45; } -echo "=== AMD SNP guest ==="; clean "$LOG_DIR/alice.log" -echo "=== 海光 CSV guest ==="; clean "$LOG_DIR/bob.log" +echo "=== AMD SNP guest (watch) ==="; clean "$LOG_DIR/alice.log" +echo "=== 海光 CSV guest (watch) ==="; clean "$LOG_DIR/bob.log" echo "bob_guest_rc=$RC" -echo "完整日志: $LOG_DIR/alice.log $LOG_DIR/bob.log" -exit "$RC" + +# --- 判据 ------------------------------------------------------------------ +# +# ★ 判定逻辑只有一份实现:check-pair-verdict.py。 +# 主门禁的自测(tools/selftest-tee-pair-verdict.py)测的是**同一个脚本**, +# 避免「编排脚本里一份、门禁里另一份」这种双份真相源 —— +# 那种情况下门禁全绿也不代表真机上的判定是对的。 +# +# 判定项(每项独立输出,便于定位): +# 1) 两侧都有 `value | 35.000000`(两方各 3 个数的乘积和) +# 2) 两侧都有 `oci_layers: verified`(运行期完整性链通过) +# 3) 两侧都有 `rootfs_files: verified`(活 rootfs 文件清单校验) +# 4) 两侧都有 `manifest_digest=<64hex>` 且**与本轮的 MANIFEST 一致** +# 5) 两侧都有 selftest 的「全部通过」 +# 6) 两侧都有 guest 完成标记 `MPC TEE GUEST DONE` +# 7) 两侧都**没有** `MPC_FAIL:`(fail-closed) +# +# 只判第 1 项不够:分片交换可能在一个没校验镜像完整性的 guest 里发生。 +# 只判「进程退出码 0」更不够 —— guest 里 halt -f 之后的退出码与成功无关。 +python3 "$HERE/check-pair-verdict.py" \ + --manifest "$MANIFEST" \ + --alice "$LOG_DIR/alice.serial" \ + --bob "$LOG_DIR/bob.serial" +VERDICT_RC=$? + +# watch 层的完成标记也要看:串口日志可能是**旧**的(采集失败), +# 而 watch 的标记能证明这一轮真的跑到了结束。 +FAIL=0 +for pair in "alice:$LOG_DIR/alice.log" "bob:$LOG_DIR/bob.log"; do + tag=${pair%%:*}; f=${pair#*:} + grep -q "GUEST_DONE_MARK_SEEN" "$f" || { + echo "判定[$tag]: watch 未见 GUEST_DONE_MARK_SEEN"; FAIL=1; } +done + +echo "--- alice 串口尾部 ---"; tail -25 "$LOG_DIR/alice.serial" 2>/dev/null +echo "--- bob 串口尾部 ---"; tail -25 "$LOG_DIR/bob.serial" 2>/dev/null + +if [ "$FAIL" -eq 0 ] && [ "$VERDICT_RC" -eq 0 ]; then + echo "TEE_PAIR_OK: 两侧均在真 TEE 内完成密文会话并还原出 35.000000" +else + echo "TEE_PAIR_FAIL: 见上面的逐项判定" +fi +echo "完整日志: $LOG_DIR/alice.log $LOG_DIR/bob.log $LOG_DIR/alice.serial $LOG_DIR/bob.serial" +[ "$FAIL" -eq 0 ] && [ "$VERDICT_RC" -eq 0 ] && [ "$RC" -eq 0 ] && exit 0 +exit 1 diff --git a/deploy/tee/real-machine/tee-pair-e2e.sh b/deploy/tee/real-machine/tee-pair-e2e.sh new file mode 100755 index 0000000..9a3cb06 --- /dev/null +++ b/deploy/tee/real-machine/tee-pair-e2e.sh @@ -0,0 +1,135 @@ +#!/usr/bin/env bash +# 真 TEE 双 guest 跨物理机全流程**一键复现**。 +# +# 把散落的步骤串成一条命令: +# 1. 交叉编译 musl 静态 mpc(guest 产物) +# 2. 导出 alpine base rootfs(本地 docker) +# 3. oci-image.py build → verify → pack,产出**真 initrd** + 真实 manifest digest +# 4. 用真实 digest 生成两份节点描述(替换示例里的 000…0 占位) +# 5. pair-run.sh 分发物料 → 起双 guest → 收日志 → 判定 +# +# 凭据只走 xop 键名(脚本里没有任何明文口令)。 +# +# 用法: +# ./tee-pair-e2e.sh # 完整流程 +# MPC_TEE_DRY_RUN=1 ./tee-pair-e2e.sh # 只跑到 dry-run(不连机) +# +# 环境变量(可选): +# MPC_TEE_AMD_HOST / MPC_TEE_HYGON_HOST 默认 192.168.1.7 / 192.168.1.102 +# MPC_TEE_AMD_USER_KEY / _PASS_KEY 默认 tee_amd_7_user / tee_amd_7_pass +# MPC_TEE_HYGON_USER_KEY / _PASS_KEY 默认 tee_hg_102_user / tee_hg_102_pass +# MPC_TEE_GUEST_TIMEOUT 每侧 guest 等待秒数,默认 300 +# MPC_TEE_WORK 工作目录,默认 /tmp/mpc-tee-e2e +set -u + +HERE=$(cd "$(dirname "$0")" && pwd) +REPO=$(cd "$HERE/../../.." && pwd) +WORK=${MPC_TEE_WORK:-/tmp/mpc-tee-e2e} +CROSS_TARGET=x86_64-unknown-linux-musl +ALPINE_IMAGE=${MPC_TEE_ALPINE_IMAGE:-alpine:3.18} + +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} +GUEST_TIMEOUT=${MPC_TEE_GUEST_TIMEOUT:-300} + +say() { printf '\n=== %s ===\n' "$1"; } +fail() { printf 'FAIL: %s\n' "$1" >&2; exit 2; } + +command -v docker >/dev/null 2>&1 || fail "需要 docker(导出 alpine base rootfs)" +command -v cargo >/dev/null 2>&1 || fail "需要 cargo" +command -v python3 >/dev/null 2>&1 || fail "需要 python3" + +mkdir -p "$WORK" + +# --- 1. musl 静态 mpc(guest 产物)--------------------------------------- +say "1/5 交叉编译 musl 静态 mpc(guest 产物)" +# ★ --no-default-features 不能省:默认 feature 会把宿主控制面 +# (axum/tokio/reqwest/OpenSSL)编进 guest 静态产物。 +cargo build --release -p mpc-cli --target "$CROSS_TARGET" --no-default-features \ + --manifest-path "$REPO/Cargo.toml" || fail "musl 交叉编译失败" +MPC_BIN="$REPO/target/$CROSS_TARGET/release/mpc" +[ -x "$MPC_BIN" ] || fail "产物不存在: $MPC_BIN" +shasum -a 256 "$MPC_BIN" 2>/dev/null || sha256sum "$MPC_BIN" + +# --- 2. alpine base rootfs ------------------------------------------------- +say "2/5 导出 alpine base rootfs" +BASE="$WORK/alpine-root" +if [ ! -x "$BASE/bin/busybox" ]; then + rm -rf "$BASE" + mkdir -p "$BASE" + CID=$(docker create "$ALPINE_IMAGE") || fail "docker create 失败" + docker export "$CID" | tar x -C "$BASE" || { docker rm "$CID" >/dev/null; fail "docker export 失败"; } + docker rm "$CID" >/dev/null +else + echo "(已有,复用)" +fi +[ -x "$BASE/bin/busybox" ] || fail "base rootfs 里没有 busybox" + +# --- 3. 离线演练密钥(只在离线 KBC 模式用;禁止上生产)--------------------- +say "3/5 生成离线演练密钥(仅演练)" +KEYS="$WORK/offline-keys" +mkdir -p "$KEYS" +[ -f "$KEYS/psk" ] || printf '00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff\n' > "$KEYS/psk" +[ -f "$KEYS/seed" ] || printf 'ffeeddccbbaa99887766554433221100ffeeddccbbaa99887766554433221100\n' > "$KEYS/seed" +[ -f "$KEYS/root-key" ] || printf 'a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90\n' > "$KEYS/root-key" +chmod 600 "$KEYS"/* 2>/dev/null || true + +# --- 4. OCI build → verify → pack ----------------------------------------- +say "4/5 OCI 构建 / 校验 / 打包 initrd" +OCI="$WORK/image" +rm -rf "$OCI" +python3 "$REPO/deploy/tee/oci/oci-image.py" build \ + --base "$BASE" --mpc "$MPC_BIN" \ + --init "$REPO/deploy/tee/guest/init.sh" \ + --offline-dir "$KEYS" --out "$OCI" || fail "OCI build 失败" +python3 "$REPO/deploy/tee/oci/oci-image.py" verify --image "$OCI" || fail "OCI verify 失败" +python3 "$REPO/deploy/tee/oci/oci-image.py" pack --image "$OCI" \ + --out "$WORK/initrd.img" || fail "OCI pack 失败" + +# 从 pack 输出里取 manifest digest(唯一真相源是工具自己的输出, +# 不是手抄 —— 手抄过一次错位,判据就会永远不匹配)。 +MANIFEST=$(python3 "$REPO/deploy/tee/oci/oci-image.py" verify --image "$OCI" \ + | sed -n 's/^manifest_digest=//p' | head -1) +[ "${#MANIFEST}" -eq 64 ] || fail "取不到 manifest digest(拿到 ${#MANIFEST} 字符)" +echo "manifest=$MANIFEST" + +# --- 5. 节点描述(用真实 digest 替换 000…0 占位)--------------------------- +say "5/5 生成节点描述 + 跑双 guest" +NODES="$WORK/nodes" +mkdir -p "$NODES" +for pair in "amd:$HERE/nodes/amd-sev-snp.node.example" \ + "hygon:$HERE/nodes/hygon-csv2.node.example"; do + tag=${pair%%:*}; src=${pair#*:} + python3 - "$src" "$NODES/$tag.node" "$MANIFEST" <<'PY' +import re, sys +src, dst, manifest = sys.argv[1], sys.argv[2], sys.argv[3] +with open(src, encoding="utf-8") as f: + s = f.read() +s = re.sub(r"(?m)^measurement=.*$", "measurement=" + manifest, s) +with open(dst, "w", encoding="utf-8") as f: + f.write(s) +PY +done +grep -h '^measurement=' "$NODES"/*.node + +export MPC_TEE_MPC_BIN="$MPC_BIN" +export MPC_TEE_INITRD="$WORK/initrd.img" +export MPC_TEE_AMD_NODE="$NODES/amd.node" +export MPC_TEE_HYGON_NODE="$NODES/hygon.node" +export MPC_TEE_MANIFEST="$MANIFEST" +export MPC_TEE_AMD_HOST="$AMD_HOST" +export MPC_TEE_HYGON_HOST="$HYGON_HOST" +export MPC_TEE_AMD_USER_KEY="$AMD_USER_KEY" +export MPC_TEE_AMD_PASS_KEY="$AMD_PASS_KEY" +export MPC_TEE_HYGON_USER_KEY="$HYGON_USER_KEY" +export MPC_TEE_HYGON_PASS_KEY="$HYGON_PASS_KEY" +export MPC_TEE_GUEST_TIMEOUT="$GUEST_TIMEOUT" +export MPC_TEE_LOG_DIR="$WORK/logs" + +# MPC_TEE_DRY_RUN=1 时 pair-run.sh 只打印物料与计划、不连机 —— +# 这是**唯一**不碰真机的验证路径(物料齐不齐、digest 对不对)。 +exec "$HERE/pair-run.sh" diff --git a/docs/REAL_MACHINE_FINDINGS.md b/docs/REAL_MACHINE_FINDINGS.md index 63b52f0..2caabe1 100644 --- a/docs/REAL_MACHINE_FINDINGS.md +++ b/docs/REAL_MACHINE_FINDINGS.md @@ -348,3 +348,73 @@ DELETE /sandboxes/{id} → 204,且 ps 回到 [] - SNP 侧:`deploy/tee/real-machine/selftest-snp-verify.py`(进主门禁第 10 条) - 部署层真机脚本:`deploy/tee/real-machine/`(`run-guest.py` / `guest-role.sh` / `kbs-net.sh` / `snp-verify-attestation.sh` / `csv-verify-attestation.sh` …) + +## 9. ★ 真 TEE 全流程(2026-11-07 后续):跨物理机双 guest 密文会话跑通 + +**这是本项目第一次在**真加密 VM**(不是普通进程)里跑通 mpc 全流程。** + +### 9.1 跑通了什么 + +AMD SEV-SNP guest(`192.168.1.7`,alice)与海光 CSV guest(`192.168.1.102`,bob) +**跨两台物理机**,各自在自己的机密 VM 内: + +1. 校验 OCI 运行期完整性链(`oci_layers: verified` + 活 rootfs 文件/符号链接清单); +2. 核对 cmdline 里的 manifest digest 与镜像内的一致(`manifest_digest=<64hex>`); +3. 取会话密钥(离线演练模式); +4. 跑 `mpc selftest`(全绿); +5. 经 **PSK 双向认证 + ChaCha20-Poly1305** 的密文会话完成分片交换与 Beaver 乘法; +6. **两侧都还原出 `value | 35.000000`**。 + +两侧的 guest 内 `user_data` 与框架算出的 `SessionBinding` 一致(AMD +`24b70c66…6dbcef5`,海光 `4c84440c…88731fc59`),且 AMD 的 +`/proc/cmdline` 里能看到 `/dev/sev-guest` 存在(`SNP device: present`)。 + +一键复现:`deploy/tee/real-machine/tee-pair-e2e.sh` +(交叉编译 → 导 alpine rootfs → OCI build/verify/pack → 生成节点描述 → 双机跑 → 判定)。 + +### 9.2 这次修掉的四个真缺口 + +| 缺口 | 症状 | 根因 | 处置 | +|---|---|---|---| +| **guest halt 后 qemu 不退出** | 编排脚本永久挂死,**会话其实已成功**(两侧都 35.000000)但判据一行没跑到 ⇒ **假红** | guest init 结尾 `halt -f` 只停 guest 内核,qemu 进程照旧占着 CPU 与端口 | 新增 `guest-watch.sh`:后台起 guest + 轮询串口里的 `MPC TEE GUEST DONE`,命中即收工并显式 kill qemu | +| **判据字符串写错** | 同样是真跑通却判失败 | 判据写 `mpc selftest 全部通过`,guest 实际输出是 `全部通过` | 判据与真实输出逐条对齐,并写自测钉死 | +| **串口没落盘 ⇒ guest stdout 全丢** | 采集端根本拿不到 guest 输出 | 框架 argv 是 `-nographic` + `-serial stdio`,两个前端抢同一个 stdio | `env.sh` 注入 `MPC_TEE_SERIAL_LOG`,`run-guest.py` 把串口换成 chardev file | +| **日志被掩码** | `rootfs_files: verified` 变成 `ro****【xop禁止将密钥泄漏】fs_files: verified`,判据报「缺失」 | xop 的密钥泄漏防护把 `root` 误判成密钥片段 | 判据只认稳定后缀 `fs_files` / `fs_links`;自测里加了「被掩码日志仍判过」这条 | + +### 9.3 ★ 判据必须可测(负向判据自指的又一次现形) + +判据只有一份实现:`deploy/tee/real-machine/check-pair-verdict.py` +(`pair-run.sh` 与主门禁自测**调的是同一份**,不是两份实现)。 + +`tools/selftest-tee-pair-verdict.py`(主门禁第 19 条,零依赖)用构造样例 +**逐条破坏**每条判据,验证它能真的把结论推翻: + +| 判据 | 破坏方式 | 必须红 | +|---|---|---| +| `value \| 35.000000` | 改成 `34.999999` | ✓ | +| `oci_layers: verified` | 改成 `(skipped)` | ✓ | +| `fs_files: verified` | 改成 `(skipped)` | ✓ | +| `manifest_digest` | 换成另一个 64 hex | ✓ | +| `全部通过` | 改成 `部分失败` | ✓ | +| `MPC TEE GUEST DONE` | 删掉 | ✓ | +| 无 `MPC_FAIL:` | **加上** `MPC_FAIL:`(即使结果行还在) | ✓ | +| 日志为空 / 缺失 | 采集失败 | ✓(不得当成「没发生」就放过) | +| 仅一侧坏 | 只坏 bob | ✓(不得取其一) | + +正向也覆盖了「日志被掩码」的真实形态 ⇒ 13/13 通过。 + +### 9.4 诚实边界(本节新增的不宣称项) + +- ★ 本次跑的是**离线演练密钥**(PSK/seed/root-key 内置在镜像里, + `key_source=offline-demo`)⇒ **不宣称**密钥分发链路被验证过。 +- ★ `pair-run.sh` **不做芯片证明互验** —— 本次跑的是「在真 TEE 里完成密文会话」, + 不是「两端互相验证了对方的芯片报告」。芯片证明链仍走第 3 节(SNP 五关)与 + CSV 的报告验签链;两者**尚未在同一次会话里合流**。 +- ★ 两台机的 **guest 内核不是同一套**:AMD 是 `6.12.36`,海光是 + `5.10.134-102cc-csv-hygon-gpu`;海光侧 CSV 的 MAC 完整性仍**无保护**(第 7 节)。 +- ★ AMD 机跑的仍是 SNP **guest 虚机**,裸机侧(固件 TCB 等)未触及。 +- ★ 海光 CSV 侧的 **KBS「先验证明才给密钥」仍未接**(本轮离线模式绕过了它)。 +- ★ 跨 guest 链路走的是 qemu `socket` netdev(宿主二层直连), + **不经真实网络**,因此不涉及 EasyTier/中继路径。 +- ★ OCI 完整性链验证的是**分发过程未被替换**;能同时改 initrd 里 `/init` + 与校验清单的宿主**不在防御范围内**(见 `deploy/tee/oci/README.md` 边界)。 diff --git a/tools/ci.sh b/tools/ci.sh index 781c7a9..1aafb19 100755 --- a/tools/ci.sh +++ b/tools/ci.sh @@ -95,19 +95,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/18 全量测试(含 secure 特性)" + step "1/19 全量测试(含 secure 特性)" cargo test --workspace --features secure ok fi -step "2/18 零告警构建(所有目标)" +step "2/19 零告警构建(所有目标)" # -Dwarnings 同时作用于本地 crate 的 test / bench / example 目标, # 所以「测试代码里有 unused」也会被拦下 —— 这正是想要的。 RUSTFLAGS="${RUSTFLAGS:+${RUSTFLAGS} }-Dwarnings" \ cargo build --workspace --all-targets --features secure ok -step "3/18 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)" +step "3/19 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)" # 两条 no_std 都要守: # mpc-core —— TEE / armv7 那条路的底座 # mpc-tee —— OP-TEE 的 TA 就是 default-features = false 构建的 @@ -145,7 +145,7 @@ ok # 三层判据都在 tools/check-guest-artifact.py:依赖树(必跑)、 # 编译期守卫负向、ELF 产物标识(后两条需已装 musl target)。 CROSS_TARGET=x86_64-unknown-linux-musl -step "4/18 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针" +step "4/19 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针" # 依赖树与标识串自检不依赖 musl target 是否安装 —— 目标没装也必须跑, # 否则「跳过」会把最重要的边界判据一起跳掉(闸门不扫自己 = 假安全感)。 python3 tools/check-guest-artifact.py deps --target "$CROSS_TARGET" @@ -179,7 +179,7 @@ else fi if [ "$FAST" -eq 0 ]; then - step "5/18 示例冒烟(12 个场景)" + step "5/19 示例冒烟(12 个场景)" tools/examples.sh ok @@ -198,14 +198,14 @@ if [ "$FAST" -eq 0 ]; then # bash 把逗号并进变量名 → CI 第 4 条直接 `CROSS_TARGET,: unbound variable` # 中途挂掉;而 lint 闸门只扫 deploy/tee,**对自己的盲区完全无感**。 # 闸门不扫闸门自己 = 闸门有盲区 = 假安全感。 - step "6/18 shell 引号 / 变量名卫生" + step "6/19 shell 引号 / 变量名卫生" python3 deploy/tee/real-machine/lint-shell-vars.py deploy/tee tools ok # 第 6 条:OCI 运行期完整性链自测。 # 这条链是「代码度量 → 活文件内容」的闭链,断了不会有编译错误, # 只会在真机上表现为篡改活文件照样通过 —— 必须有本地闸门兜住。 - step "7/18 OCI 运行期完整性链自测" + step "7/19 OCI 运行期完整性链自测" python3 deploy/tee/oci/selftest-chain.py ok @@ -216,7 +216,7 @@ if [ "$FAST" -eq 0 ]; then # · 判定断(判定器被顶替 / 输出不是判定结论)→ **假绿**, # 「通过之后真的会签发 token 并下发密钥」这条路从未被验证过。 # 所以这里必须同时覆盖正向路径与全部拒绝路径。 - step "8/18 KBS 先验证明才下发自测" + step "8/19 KBS 先验证明才下发自测" python3 deploy/tee/kbs/selftest-kbs.py ok @@ -224,7 +224,7 @@ if [ "$FAST" -eq 0 ]; then # guest 的 /init 由 busybox ash 解析,`bash -n` 通过 ≠ ash 能解析。 # 真机上这类错误要等 guest 起来才暴露,排查一轮几分钟; # 本地闸门用 alpine 的 busybox ash(与 guest 同款解析器)秒级拦住。 - step "9/18 guest 脚本 ash 语法" + step "9/19 guest 脚本 ash 语法" deploy/tee/guest/syntax-check.sh ok @@ -248,7 +248,7 @@ if [ "$FAST" -eq 0 ]; then # ★ 同一处还跑 kbs-up.sh 的参数自检:那份脚本的网段与 TCB 参数一旦被 # 硬编码覆盖,负向矩阵就会**假绿**(真踩过:外部设 min-tcb=99, # 实际 KBS 收到 3,TCB 负向直接被放行)。 - step "10/18 芯片验签器自测(SNP + CSV)+ KBS 启动参数自检" + step "10/19 芯片验签器自测(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 @@ -271,7 +271,7 @@ if [ "$FAST" -eq 0 ]; then # 不需要 SDK、不需要 QEMU,秒级完成。 # 它证明的是「给定一份日志,判定器的结论正确」, # **不**证明 OP-TEE 的 seal/unseal 行为正确(那要跑 QEMU)。 - step "11/18 OP-TEE 判据逻辑自测" + step "11/19 OP-TEE 判据逻辑自测" python3 tools/selftest-optee-verdict.py ok @@ -287,7 +287,7 @@ if [ "$FAST" -eq 0 ]; then # 跑不跑得通。实例回收那条用**心跳文件**判据(实例自己 touch 一个文件, # 停掉后心跳停止)—— 不依赖 ps / /proc,因为受限环境里 ps 常被禁、 # macOS 也没有 /proc,那时这条判据会被跳过,而它恰恰是最重要的一条。 - step "12/18 宿主控制面 mpc-hostd 端到端自测" + step "12/19 宿主控制面 mpc-hostd 端到端自测" python3 tools/selftest-hostd.py ok @@ -302,7 +302,7 @@ if [ "$FAST" -eq 0 ]; then # 判的是框架自己的契约,不是 EasyTier 的实现。进程真起真回收由 # LinkRuntime 单测判(持 Child + try_wait 收割),此处显式再跑一次, # 保证这条判据真的进了主门禁的执行路径。 - step "13/18 会话级链路层 EasyTier 端到端自测" + step "13/19 会话级链路层 EasyTier 端到端自测" python3 tools/selftest-link.py ok @@ -321,7 +321,7 @@ if [ "$FAST" -eq 0 ]; then # gate 18,但那不是连真节点的通道),所以这条门禁不证明「能上链」。 # 另:--transport 必须显式给,stub 只供桩自测,tlcp 是生产路径 # (缺双证书配置即拒),传输形态不许有默认值 = 不许留明文后门。 - step "14/18 链上层 mpc-chain 端到端自测" + step "14/19 链上层 mpc-chain 端到端自测" python3 tools/selftest-chain.py ok @@ -340,7 +340,7 @@ if [ "$FAST" -eq 0 ]; then # TLCP 双证书正向校验 / 真交易编码仍待真机对拍, # 见 tools/selftest-chain-gm.py、tools/selftest-tlcp-tunnel.py # 与 tools/fisco-realnode-probe.py。 - step "15/18 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测" + step "15/19 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测" python3 tools/selftest-chain-gm.py ok @@ -354,7 +354,7 @@ if [ "$FAST" -eq 0 ]; then # ★ fisco-realnode-probe.py 环境齐备也只报 NEEDS_IMPL:FISCO 自有 # 交易编码 / Rust 侧 TLCP 通道 / sm2Verify 真机对拍 / 已签名交易 # 都还没落地,凑齐环境变量不等于能上链。 - step "16/18 GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约" + step "16/19 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 @@ -373,7 +373,7 @@ if [ "$FAST" -eq 0 ]; then # ★ 撤销来源二选一:本地桩 或 --revocation chain(链读后端未接入 ⇒ # 必须 fail-closed 拒,期望特征 REVOCATION_CHAIN_UNVERIFIED, # 绝不默认 revoked=false 放行)。 - step "17/18 阶段 3 OPA bundle 签发 / 真判定 / decision 存证自测" + step "17/19 阶段 3 OPA bundle 签发 / 真判定 / decision 存证自测" python3 tools/selftest-chain-opa.py --self-test python3 tools/selftest-chain-opa.py ok @@ -394,10 +394,32 @@ if [ "$FAST" -eq 0 ]; then # 本通道只到 LoopbackReachable。 # ★ 缺 GmSSL / 缺 mpc 二进制打印 GMSSL_TLCP_TUNNEL_SKIPPED + 逐项缺失; # --self-test 零依赖判据逻辑永远被执行到(防盲区)。 - step "18/18 TLCP 进程通道环回实证自测" + step "18/19 TLCP 进程通道环回实证自测" python3 tools/selftest-tlcp-tunnel.py --self-test python3 tools/selftest-tlcp-tunnel.py ok + + # 第 19 条:真 TEE 双 guest 跨物理机会话的**判据**自测。 + # + # ★ 这条测的是「判定逻辑」,不是「真机」。真机实跑见 + # deploy/tee/real-machine/pair-run.sh(2026-11-07 两台真机实测通过: + # AMD SEV-SNP + 海光 CSV,双方都还原出 value | 35.000000)。 + # 本条零依赖、每次 CI 都跑,保证「判定逻辑没写错」—— + # 真机跑一次的成本高且不连续,判据写错了真机也测不出来。 + # + # ★ 判据自指必须被证伪:负向判据天然有「恒为真 / 恒为假」的风险。 + # 实测踩过两个真坑: + # ① 判据字符串写错("mpc selftest 全部通过" vs 真实的 "全部通过") + # → 恒为假 → 真机跑通了却报失败(假红); + # ② 只判 qemu 退出码 → guest 里 halt 之后的退出码与成功无关 + # → 恒为真 → 什么都没发生也报成功(假绿)。 + # 所以每条判据都要用构造样例逐条破坏,验证它能真的把结论推翻。 + # + # ★ 测的是真机上**实际调用的那一份** check-pair-verdict.py, + # 不是另写一份模拟 —— 两份实现等于没有门禁。 + step "19/19 真 TEE 双 guest 会话判据自测" + python3 tools/selftest-tee-pair-verdict.py + ok fi printf '\n\033[32m\033[1m全部通过\033[0m\n' diff --git a/tools/selftest-chain-opa.py b/tools/selftest-chain-opa.py index 0703fec..ce4f963 100644 --- a/tools/selftest-chain-opa.py +++ b/tools/selftest-chain-opa.py @@ -205,10 +205,25 @@ def self_test(): check("domain.rs 有阶段 3 两个独立域分隔常量", "TEE_OPA_SIGNED_BUNDLE" in domain and "TEE_OPA_DECISION" in domain) ci = (REPO / "tools/ci.sh").read_text() - # 闸门不扫自己 = 盲区:本 selftest(gate 17)必须真的被 ci.sh 调用; - # 同时要求末步标签升到 18/18,防止「加了 gate 18 却没把计数顶上去」。 - check("★ 主门禁含第 17 条且计数已升到 18(闸门不扫自己 = 盲区)", - "selftest-chain-opa.py" in ci and "18/18" in ci) + # 闸门不扫自己 = 盲区:本 selftest(gate 17)必须真的被 ci.sh 调用。 + # + # ★ 计数**不要硬编码**:早先写死 "18/18 in ci",结果第 19 条一加, + # 这条判据立刻假红 —— 而它要防的其实是「加了新条却没把计数顶上去」。 + # 改成从 ci.sh 实际解析条目编号:① 编号必须从 1 连续到 N; + # ② 每条的标签必须都写成 "k/N"(N 一致);③ 本 selftest 必须在其中。 + # 这样加条只要改 ci.sh 的编号就自动过,不用回头改别处的魔法数字。 + import re as _re + labels = _re.findall(r'step\s+"(\d+)/(\d+)\s', ci) + check("★ 主门禁含第 17 条(闸门不扫自己 = 盲区)", + "selftest-chain-opa.py" in ci) + check("★ 主门禁条目编号从 1 连续、无缺号", + bool(labels) + and sorted(int(a) for a, _ in labels) == list(range(1, len(labels) + 1)), + "实际编号: %s" % sorted(int(a) for a, _ in labels)) + check("★ 主门禁条目的分母一致(末步计数 = 条目总数)", + bool(labels) and len(set(b for _, b in labels)) == 1 + and all(b == str(len(labels)) for _, b in labels), + "分母集合: %s,条目数: %d" % (sorted(set(b for _, b in labels)), len(labels))) print(f"\n判据逻辑自测 {PASS_N + FAIL_N} 条:通过 {PASS_N},失败 {FAIL_N}") if FAIL_N: diff --git a/tools/selftest-tee-pair-verdict.py b/tools/selftest-tee-pair-verdict.py new file mode 100755 index 0000000..d714efe --- /dev/null +++ b/tools/selftest-tee-pair-verdict.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +"""真 TEE 双 guest 会话**判据**的自测(零外部依赖)。 + +测的是 `deploy/tee/real-machine/check-pair-verdict.py` —— 也就是真机上 +`pair-run.sh` 实际调用的那一份判定逻辑,不是另写一份模拟。 + +★ 为什么必须有这个自测:负向判据天然有「恒为真 / 恒为假」的风险。 + 实测踩过的两个真坑: + ① 判据字符串写错("mpc selftest 全部通过" vs 真实的 "全部通过") + → 判据恒为假 → 真机跑通了却报失败(假红)。 + ② 只判「进程退出码 0」→ guest 里 halt 之后的退出码与成功无关 + → 判据恒为真 → 什么都没发生也报成功(假绿)。 + 所以每条判据都要用构造样例**逐条破坏**,验证它能真的把结论推翻。 + +用法:selftest-tee-pair-verdict.py +退出码:0 全过;1 有判据失效。 +""" +import os +import subprocess +import sys +import tempfile + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(HERE) +VERDICT = os.path.join(ROOT, "deploy", "tee", "real-machine", "check-pair-verdict.py") + +MANIFEST = "c7344bee31544371e4459abe28db9dd008067b72e18b60c18f20158bdde63aa3" + +# 一份「全绿」的 guest 串口日志(形状取自 2026-11-07 两台真机的真实输出)。 +GOOD = """\ +===== MPC TEE GUEST BOOT (OCI layers) ===== +kernel: 6.12.36 +SNP device: present +manifest_digest={manifest} +oci_layers: verified +fs_files: verified +fs_links: verified +user_data=24b70c66 +WARNING: 离线演练密钥,PSK/seed/root-key 内置在镜像里,禁止用于生产 +key_source=offline-demo +--- mpc selfcheck / selftest --- +mpc selfcheck +5 | 明文域 / 密态域一致性 | true | 两域逐位一致 sum=433.5 +全部通过 + 已连接 +mpc node · site=alice · 2 方 · 3 个元素 · fxp=18 + 分片交换完成(2 方) + 密文乘法完成(1 次) + 还原完成: [9175040] +会话结果 +key | value +------+---------- +site | alice +value | 35.000000 +===== MPC TEE GUEST DONE ===== +[ 1.363258] reboot: System halted +""".format(manifest=MANIFEST) + + +def run(alice_text, bob_text, manifest=MANIFEST): + """跑判定器,返回 (rc, stdout)。""" + d = tempfile.mkdtemp(prefix="tee-verdict-") + a = os.path.join(d, "alice.serial") + b = os.path.join(d, "bob.serial") + with open(a, "w", encoding="utf-8") as f: + f.write(alice_text) + with open(b, "w", encoding="utf-8") as f: + f.write(bob_text) + p = subprocess.run( + [sys.executable, VERDICT, "--manifest", manifest, "--alice", a, "--bob", b], + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) + for path in (a, b): + try: + os.unlink(path) + except OSError: + pass + try: + os.rmdir(d) + except OSError: + pass + return p.returncode, p.stdout + + +def main(): + if not os.path.isfile(VERDICT): + print("FAIL: 找不到判定器 %s" % VERDICT) + return 1 + + cases = [] + + # --- 正向:两侧全绿必须通过 --- + rc, out = run(GOOD, GOOD) + cases.append(("正向:两侧全绿 → 通过", rc == 0 and "TEE_PAIR_OK" in out, + out.strip().splitlines()[-1] if out.strip() else "")) + + # --- 正向:日志被 xop 掩码后仍必须能判过 --- + # + # ★ 这条对应 2026-11-07 真机实跑的实测形态:采集链路上的密钥泄漏 + # 防护把 `rootfs_files` 里的 `root` 误判成密钥片段,整行变成 + # `ro****【xop禁止将密钥泄漏】fs_files: verified`。 + # 判据只认稳定后缀 `fs_files` / `fs_links`,就是为了在这种日志下 + # 仍能正确判定(而不是把「被掩码」误判成「校验失败」)。 + MASK = "ro****\u3010xop\u7981\u6b62\u5c06\u5bc6\u94a5\u6cc4\u9732\u3011fs_files: verified" + rc, out = run(GOOD.replace("fs_files: verified", MASK), GOOD) + cases.append(("正向:日志被掩码(rootfs_files → ro****fs_files)→ 仍判通过", + rc == 0 and "TEE_PAIR_OK" in out, + out.strip().splitlines()[-1] if out.strip() else "")) + + # --- 负向:逐条破坏,每一条都必须把结论推翻 --- + # 每条破坏都**只**破坏一样,别的地方保持完整 —— + # 否则「红」可能来自别的原因,这条判据的效力就测不出来。 + breaks = [ + ("负向:缺 value | 35.000000", + GOOD.replace("value | 35.000000", "value | 34.999999")), + ("负向:缺 oci_layers: verified", + GOOD.replace("oci_layers: verified", "oci_layers: (skipped)")), + ("负向:缺 fs_files: verified", + GOOD.replace("fs_files: verified", "rootfs_files: (skipped)")), + ("负向:manifest_digest 不匹配", + GOOD.replace(MANIFEST, "0" * 64)), + ("负向:缺 selftest 全部通过", + GOOD.replace("全部通过", "部分失败")), + ("负向:缺 guest 完成标记", + GOOD.replace("===== MPC TEE GUEST DONE =====", "(guest 未完成)")), + ("负向:guest 报 MPC_FAIL(即使结果行还在)", + GOOD.replace("===== MPC TEE GUEST DONE =====", + "MPC_FAIL: 活 rootfs 文件 digest 与声明不符")), + ("负向:日志为空(采集失败)", + ""), + ("负向:日志缺失(采集失败)", + None), + ] + for name, broken in breaks: + if broken is None: + # 「文件缺失」要单独造:run() 会写文件,所以这里用空路径触发。 + d = tempfile.mkdtemp(prefix="tee-verdict-") + a = os.path.join(d, "missing.serial") + b = os.path.join(d, "bob.serial") + with open(b, "w", encoding="utf-8") as f: + f.write(GOOD) + p = subprocess.run( + [sys.executable, VERDICT, "--manifest", MANIFEST, "--alice", a, "--bob", b], + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) + rc, out = p.returncode, p.stdout + os.unlink(b) + os.rmdir(d) + else: + rc, out = run(broken, GOOD) + expect_fail = rc != 0 and "TEE_PAIR_FAIL" in out + cases.append((name, expect_fail, + (out.strip().splitlines()[-1] if out.strip() else ""))) + + # --- 单侧坏:只坏一侧也必须红(防止「两侧取其一」)--- + rc, out = run(GOOD, GOOD.replace("value | 35.000000", "value | 0.0")) + cases.append(("负向:仅 bob 侧坏 → 仍判失败", + rc != 0 and "TEE_PAIR_FAIL" in out, + (out.strip().splitlines()[-1] if out.strip() else ""))) + + # --- manifest 参数非法必须被拒(不能默默按「无 manifest」处理)--- + d = tempfile.mkdtemp(prefix="tee-verdict-") + a = os.path.join(d, "a") + b = os.path.join(d, "b") + for p_ in (a, b): + with open(p_, "w", encoding="utf-8") as f: + f.write(GOOD) + p = subprocess.run( + [sys.executable, VERDICT, "--manifest", "zz", "--alice", a, "--bob", b], + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) + cases.append(("负向:非法 manifest → 退出码 2", + p.returncode == 2, (p.stdout.strip() or ""))) + os.unlink(a) + os.unlink(b) + os.rmdir(d) + + failed = 0 + for name, ok, detail in cases: + if ok: + print(" ok %s" % name) + else: + failed += 1 + print(" FAIL %s %s" % (name, detail)) + print("判定器自测: %d/%d 通过" % (len(cases) - failed, len(cases))) + return 1 if failed else 0 + + +if __name__ == "__main__": + sys.exit(main())