feat(tee): 真 TEE 跨物理机双 guest 密文会话跑通,挖出并修掉四个真缺口

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  一键复现(编译→OCI→分发→双机→判定)
- deploy/tee/real-machine/guest-watch.sh   后台起 guest + 轮询完成标记 + 收尾
- deploy/tee/real-machine/check-pair-verdict.py  唯一判定实现
- tools/selftest-tee-pair-verdict.py        判据自测(主门禁第 19 条)

修掉的四个真缺口:
1. guest halt 后 qemu 不退出 ⇒ 前台 ssh 永久挂死(会话已成功但判据没跑到 ⇒ 假红)
2. 判据字符串写错("mpc selftest 全部通过" vs 真实 "全部通过")⇒ 假红
3. 串口没落盘 ⇒ guest stdout 全丢,判据无从采集
4. 采集日志被 xop 掩码(rootfs_files → ro****fs_files)⇒ 判据只认稳定后缀

判据纪律:判定只有一份实现(编排与门禁自测共用同一份),每条判据都用构造样例
逐条破坏过(13/13),证明能真的把结论推翻。

另修 tools/selftest-chain-opa.py 的门禁计数守卫:不再硬编码 "18/18",
改为从 ci.sh 实际解析条目编号(连续 + 分母一致),避免加条即假红。

诚实边界:本轮跑的是离线演练密钥,不宣称密钥分发链路;
pair-run.sh 不做芯片证明互验,不宣称两端互验过对方芯片报告。
This commit is contained in:
admin committed 2026-11-07 23:06:32 +08:00
1 parent 7451b5b55d
commit 5a0e6e389e
10 files changed
+860 -41

No files matched your search

+29 -4
View File
@@ -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 参考实现(只读)
+53 -4
View File
@@ -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 补齐)
+128
View File
@@ -0,0 +1,128 @@
#!/usr/bin/env python3
"""真 TEE 双 guest 跨物理机会话的**判据判定器**。
`pair-run.sh` 采集两侧串口日志后,把判定交给本脚本 ——
判定逻辑只有这一份实现,主门禁的自测也测它(避免「脚本里一份、
门禁里另一份」这种双份真相源)。
用法:
check-pair-verdict.py --manifest <64hex> \
--alice <alice.serial> --bob <bob.serial>
输出:逐项判定(每条独立标注),最后给总结论。退出码:
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())
+83
View File
@@ -0,0 +1,83 @@
#!/usr/bin/env bash
# 在 TEE 宿主上**后台**起一个机密 guest,并轮询串口日志里的完成标记。
#
# ★ 为什么不能直接前台 `bash guest-role.sh <role>`(这是本文件存在的理由):
#
# 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 <role> <timeout_seconds>
# 环境: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
+116 -11
View File
@@ -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" <<EOF
export MPC_TEE_RUN_DIR=$REMOTE_DIR
@@ -64,22 +66,57 @@ export MPC_TEE_PUBKEY=$PK
export MPC_TEE_AMD_HOST=$AMD_HOST
export MPC_TEE_LINK_PORT=$LINK_PORT
export MPC_TEE_VARIANT=$variant
# ★ 串口必须落盘:guest 的 stdout 默认会丢。
#
# 框架 argv 里是 "-nographic" + "-serial stdio",两个前端抢同一个 stdio,
# AMD 真机上 guest init 的输出**一行都收不到**。run-guest.py 支持
# MPC_TEE_SERIAL_LOG,把串口换成 chardev file 后端,内容直接落文件。
# 没有这一行,判据「两侧都输出 value | 35.000000」根本无从采集 ——
# 采集不到不等于没发生,但**也不能当成发生了**。
export MPC_TEE_SERIAL_LOG=$REMOTE_DIR/serial.log
EOF
}
scpto() {
local host=$1 user_key=$2 pass_key=$3 src=$4
# ★ `scp -O` 不能省:新版 scp 默认走 SFTP 子系统,而两台真机的 sshd
# 没开 SFTP ⇒ 报 "Permission denied"(但同一台机的 `ssh` 一切正常,
# 极易误判成密码错了)。`-O` 强制走传统 scp 协议。
xop run --secret "SSHPASS=$pass_key" --secret "TEE_USER=$user_key" -- \
sh -c "sshpass -e ssh $SSHO \"\$TEE_USER@$host\" \"mkdir -p $REMOTE_DIR\" && \
sshpass -e scp $SSHO $src/* \"\$TEE_USER@$host:$REMOTE_DIR/\"" \
sshpass -e scp -O $SSHO $src/* \"\$TEE_USER@$host:$REMOTE_DIR/\"" \
< /dev/null
}
remote() {
local host=$1 user_key=$2 pass_key=$3 role=$4
# 取回远端串口日志。
#
# ★ 必须单独取:**guest 的 stdout 只能从串口文件里拿**。远端命令的
# stdout 只含 qemu 自身的启动/退出信息,不含 guest 内部日志。
#
# ★ 采集链路上有一层**掩码**:xop 的密钥泄漏防护会把 `root` 这类疑似
# 密钥片段的子串替换成 `ro****【xop禁止将密钥泄漏】`。真机实测:
# guest init 打的 `rootfs_files: verified` 变成
# `ro****【xop禁止将密钥泄漏】fs_files: verified`。
# 所以判定器只认稳定后缀(`fs_files` / `fs_links`),不认会被掩码的词。
fetch_log() {
local host=$1 user_key=$2 pass_key=$3 dst=$4
xop run --secret "SSHPASS=$pass_key" --secret "TEE_USER=$user_key" -- \
sh -c "sshpass -e ssh $SSHO \"\$TEE_USER@$host\" \
\"bash -c 'source $REMOTE_DIR/env.sh && bash $REMOTE_DIR/guest-role.sh $role'\"" \
\"cat $REMOTE_DIR/serial.log 2>/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
+135
View File
@@ -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"
+70
View File
@@ -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` 边界)。
+40 -18
View File
@@ -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'
+19 -4
View File
@@ -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:
+187
View File
@@ -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())