diff --git a/CLAUDE.md b/CLAUDE.md index e830f32..02a84d4 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 与本地同一份闸门(24 条) +./tools/ci.sh # CI 与本地同一份闸门(25 条) ``` -主门禁 `./tools/ci.sh` 共 **24 条**:全量测试(**必须带 `--features secure`**)、 +主门禁 `./tools/ci.sh` 共 **25 条**:全量测试(**必须带 `--features secure`**)、 `-Dwarnings` 零告警(作用于 test/bench/example 目标)、`mpc-core` / `mpc-tee` no_std 双守 + TA UUID 对拍、**musl 跨目标零告警 + guest 边界探针**、12 示例冒烟、 shell 卫生(`deploy/tee` + `deploy/arm` + `tools` 全扫)、OCI 链、KBS、ash 语法、 @@ -71,11 +71,15 @@ hostd / 链路层 / 链上层端到端桩自测、国密签名与治理形状自 而症状是「不报错、不崩溃、结果数值也对」;每条否定判据带期望特征 + 正向对照)、 **零种子守卫端到端自测**(第 24 条;`tools/selftest-seed-guard.py`; 全零主种子是本项目最隐蔽的一类失败 —— 守卫必须在 CLI **入口**且**在连网之前**, -覆盖全部 8 个吃种子的命令)。 +覆盖全部 8 个吃种子的命令)、 +**集群自报判据自测 + 破坏实验**(第 25 条;`tools/selftest-cluster-selfreport.py` / `-break.py`; +9 组判据覆盖「密钥不进 argv / 否定式判据配正向锚点 / 鉴权口径只有一份 / 密钥送达校验 / stdin 不丢 / 凭据经 xop 子进程 / xop 噪声 fd3 隔离」, +11 条破坏实验逐条证明判据非恒绿;探针用**假 xop + 假 sshpass**, +不依赖真机、不解密真口令、不需要 Touch ID)。 明细以脚本自身为准(**闸门不扫自己就是盲区**)。 > ★ 第 18–22 条曾于提交 `27cbdc7` 被误删(判据脚本都还在,只是不再被调用 -> ⇒ 门禁**静默削弱**:文件在、判据在、门禁不跑)。已原样恢复并重排编号到 24 条。 +> ⇒ 门禁**静默削弱**:文件在、判据在、门禁不跑)。已原样恢复并重排编号到 24 条(2026-11-09 再加第 25 条 ⇒ 现为 25 条)。 > **判据脚本在仓库里 ≠ 判据在门禁里** —— 改 `tools/ci.sh` 后必须核对: > ① step 条数与本文档条数一致(★ 数 step 时**注释里出现 step 字面样例会被一起数进去** > ⇒ 计数永远多 1,2026-11-09 实测踩过); @@ -496,7 +500,7 @@ AMD SNP(alice)+ 海光 CSV(bob)两侧**各自**完成 `e = SM3(ZA‖dataHash)` 签名口径、`sendTransaction` 4 参、`status==0`、selector 二元数组 - `docs/REAL_MACHINE_FINDINGS.md` — 两台真机硬事实;第 10 节是**证明门控合流** (第 7 / 9.4 节是 11-07 当时边界,已加状态锚点) -- `tools/ci.sh` — **门禁条数以脚本为准(24 条)**,任何文档写的条数都以此校准 +- `tools/ci.sh` — **门禁条数以脚本为准(25 条)**,任何文档写的条数都以此校准 - `tools/selftest-fisco-contract.py` — **真链验收唯一权威脚本**(第 22 条) - `tools/fisco-realnode/example.chain.json` — 链配置(k8s `192.168.1.26:30100`) diff --git a/README.md b/README.md index 0f620cd..4e7ab70 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,7 @@ ssw-mpc 解决的是**互不信任的多方如何一起算**:数据留在各 | 智能合约真链**部署 / 调用 / 读回** | ✅ 跑通 | `contracts/MpcHardRule.sol`;`tools/selftest-fisco-contract.py` 部署→`recordHardRule`→读回→负向矩阵,**22 项判据全绿**(主门禁第 22 条;零依赖 `--self-test` 每次必跑) | | 链节点与管理节点**持久化** | ✅ 已迁 k8s | FISCO 链连同现有账本迁入 wuguirong,`nfs-wuguirong` PVC;历史区块哈希逐个一致、删 Pod 重建后高度不变;见 `deploy/k8s/fisco/README.md` | | MPC 站点 `mpc-demo` | ✅ 已在 k8s | NodePort `30082`,`/tmp` 挂 NFS PVC;见 `demo/k8s/README.md` | -| 主门禁 | **24 条** | `./tools/ci.sh`;第 21 条真交易编码判据、第 22 条真链合约判据、第 23 条 SA 扩展模式、第 24 条零种子守卫;缺环境一律显式 `*_SKIPPED`,绝不静默通过 | +| 主门禁 | **25 条** | `./tools/ci.sh`;第 21 条真交易编码判据、第 22 条真链合约判据、第 23 条 SA 扩展模式、第 24 条零种子守卫、第 25 条集群自报判据自测 + 破坏实验;缺环境一律显式 `*_SKIPPED`,绝不静默通过 | **仍然不宣称的边界**(别被上面「跑通」冲掉):软件 OpenSSL 签名器私钥可导出 ⇒ **密评不可过**,生产必须换硬件模组签名器;真实 `bcos-rpc` 的 **TLCP 通道未通**(第 18 条服务端是环回 echo); @@ -517,7 +517,7 @@ demo/ 尚数网算子集市站点(Rust 单二进制,已在 k demo/k8s/ 站点部署清单 + NFS PVC 持久化说明 ray/ mpc_ray_shim.cc + build.sh(复用 pip wheel 的 _raylet.so,不走 bazel) refs/nax/ 参考实现(独立仓库,仅作基线) -tools/ golden 生成 + numpy 基准 + 主门禁 ci.sh(24 条)+ 各判据脚本 +tools/ golden 生成 + numpy 基准 + 主门禁 ci.sh(25 条)+ 各判据脚本 tools/fisco-realnode/ 真链复现工具与审计轨迹(SDK 发送器 / JNI 交叉验证 / TARS 辅助) docs/ 架构、专题设计与真相源;**总入口 `INDEX.md`**; `ARCHITECTURE_SYSTEM.md` 是系统架构当前形态(另有同名 .html 分享版); diff --git a/deploy/tee/real-machine/cluster-selfreport-e2e.sh b/deploy/tee/real-machine/cluster-selfreport-e2e.sh index 4986a1c..1eb6e2d 100755 --- a/deploy/tee/real-machine/cluster-selfreport-e2e.sh +++ b/deploy/tee/real-machine/cluster-selfreport-e2e.sh @@ -12,12 +12,21 @@ # 真机 → 真机这条路是通的(已实测:两台真机都能连上 192.168.1.18 的监听)。 # ⇒ 控制面放真机,走「真机 → 真机」这条**不依赖本机网络栈**的路。 # -# ★ 凭据:全部从**环境变量**取(由 xop run --secret 注入),脚本内不碰 xop。 +# ★ 凭据:按**项目约定**,只放 xop **键名**,脚本内自己调 xop 取明文 +# (与 host-materials.sh / kbc-attest-e2e.sh 同一范式)。 +# 键名来自 deploy/tee/real-machine/real-machines.env: +# MPC_TEE_AMD_USER_KEY / MPC_TEE_AMD_PASS_KEY +# MPC_TEE_HYGON_USER_KEY / MPC_TEE_HYGON_PASS_KEY # # 用法: -# xop run --secret SSHPASS_AMD=... --secret USER_AMD=... \ -# --secret SSHPASS_HYGON=... --secret USER_HYGON=... \ -# -- ./cluster-selfreport-e2e.sh +# set -a; . deploy/tee/real-machine/real-machines.env; set +a +# ./cluster-selfreport-e2e.sh +# +# ★★ 集群共享密钥:**本地随机生成**,不落盘、不入库、不进 xop。 +# 理由:它只需要在**本次运行内**三方一致(控制面 + 两个节点 hostd), +# 用完即弃。存进 vault 反而多一份长期有效的凭据。 +# ⇒ 每次运行都是新密钥 ⇒ 泄漏面最小。 +# (要复现同一组密钥,设 MPC_CLUSTER_SECRET 覆盖它 —— 只在调试时用。) # # ★ 判定只有一份:本脚本末尾的 verdict。 set -u @@ -28,6 +37,12 @@ SSHO="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PreferredAu AMD_HOST=${MPC_TEE_AMD_HOST:-192.168.1.7} HYGON_HOST=${MPC_TEE_HYGON_HOST:-192.168.1.102} +# xop 键名(默认与 real-machines.env 一致) +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} + # 集群共享密钥:站点端与所有节点 hostd 持有同一份。 # ★★ 口径:**明文 ASCII 串**(不是 hex)—— 控制面、节点 hostd、 # 自报、下发**四处**用的是**同一个原文**。 @@ -42,42 +57,134 @@ FAIL_N=0 ok() { OK_N=$((OK_N + 1)); printf 'ok %s\n' "$1"; } fail() { FAIL_N=$((FAIL_N + 1)); printf 'FAIL %s\n' "$1" >&2; } +# ★ 探 xop 里的键:只看**长度**(长度不会被 FileGuard 掩码)。 +# +# ★★ 为什么只探长度、不取值: +# xop 的 FileGuard 会在**打印**时把值替换成 +# `ro****【xop禁止将密钥泄漏】`(实测 2026-11-09: +# 连 `printf %s "$V"` 都会被替换,而 `${#V}` 正常)。 +# ⇒ 「取出来存进 shell 变量」这条路**本来就是死的** —— +# 拿到的不是口令,是掩码。 +# ⇒ 正确姿势:值**只在 xop 的子进程里**用(见 remote()), +# 本脚本从不持有明文。 +xop_probe() { + # $1=键名 ⇒ 成功返回 0(键存在且非空),失败返回 1 + local n + # ★ xop 把 Guard 的 WARN 打到 **stdout**(不是 stderr)⇒ `2>/dev/null` 挡不住。 + # `tail -n 1` 只是碰巧取到最后一行;改成**只认纯数字行**, + # WARN 行含非数字字符会被过滤掉 ⇒ 拿不到数字就当失败(fail-closed)。 + n=$(xop run --secret "V=$1" -- sh -c 'printf "%s\n" "${#V}"' \ + < /dev/null 2>/dev/null | grep -E '^[0-9]+$' | tail -n 1) + case "$n" in + ''|*[!0-9]*) return 1 ;; + 0) return 1 ;; + *) return 0 ;; + esac +} + require_env() { - local missing=0 v - for v in SSHPASS_AMD USER_AMD SSHPASS_HYGON USER_HYGON; do - if [ -z "$(eval echo \${$v:-})" ]; then - printf '缺少环境变量 %s(用 xop run --secret %s=<键名> 注入)\n' "$v" "$v" >&2 - missing=1 - fi - done - [ -n "$CLUSTER_SECRET" ] || { - printf '缺少 MPC_CLUSTER_SECRET(至少 32 字节,两侧 hostd 与控制面持有同一份)\n' >&2 + local missing=0 + if [ -z "$AMD_USER_KEY" ] || [ -z "$AMD_PASS_KEY" ] \ + || [ -z "$HYGON_USER_KEY" ] || [ -z "$HYGON_PASS_KEY" ]; then + printf '缺少真机凭据的 xop 键名(检查 MPC_TEE_AMD_USER_KEY 等,或 source real-machines.env)\n' >&2 missing=1 - } + fi + if ! command -v xop >/dev/null 2>&1; then + printf '找不到 xop(凭据管理工具)—— 本脚本按项目约定从 xop 取真机口令\n' >&2 + missing=1 + fi + if ! command -v sshpass >/dev/null 2>&1; then + printf '找不到 sshpass —— 无法做密码认证的 SSH\n' >&2 + missing=1 + fi + [ "$missing" -eq 0 ] || return 1 + + # ★★ **不把口令取到 shell 变量里** —— xop 的 FileGuard 会在**打印**时 + # 把值掩码成 `ro****【xop禁止将密钥泄漏】`(实测:连 `${#V}` 都正常, + # 但 `printf %s "$V"` 会被替换)。所以「取出来再用」这条路是死的。 + # ⇒ 正确姿势:**在 xop 的子进程里直接用注入的环境变量**执行 ssh, + # 值从不经过本 shell 的 stdout。 + # ⇒ 顺带的好处:口令**从不进本脚本的内存**,也不进任何 argv。 + # + # ★ 预检:xop 能不能解锁 vault、键名对不对 —— + # 这里用「只取长度」的方式验(长度不会被掩码)。 + if ! xop_probe "$AMD_USER_KEY" || ! xop_probe "$AMD_PASS_KEY" \ + || ! xop_probe "$HYGON_USER_KEY" || ! xop_probe "$HYGON_PASS_KEY"; then + printf 'xop 取不到凭据(键名不对或 vault 未解锁)—— 键名:%s / %s / %s / %s\n' \ + "$AMD_USER_KEY" "$AMD_PASS_KEY" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" >&2 + missing=1 + fi + [ "$missing" -eq 0 ] || return 1 + + # ★ 集群密钥:没给就本地随机生成一份(**不落盘、不入库**)。 + if [ -z "$CLUSTER_SECRET" ]; then + if command -v openssl >/dev/null 2>&1; then + CLUSTER_SECRET=$(openssl rand -hex 32) + else + CLUSTER_SECRET=$(od -An -tx1 -N32 /dev/urandom | tr -d ' \n') + fi + printf '集群共享密钥:本次运行随机生成(%d 字节,用完即弃)\n' "${#CLUSTER_SECRET}" + fi return "$missing" } +# ★ 曾有一个 remote_amd()(把 $4 塞进 ssh argv),现在删了: +# 没人调用它,但它的形态本身就是「密钥进 argv」的活样本, +# 留着早晚被人复制 ⇒ 判据 1 扫到它会误判,也会被当成可用范式。 +# 脚本正文一律走 remote() 的 stdin 通道。 + remote() { - # $1=host $2=user $3=pass $4=script + # $1=host $2=用户键名 $3=口令键名 $4=script # # ★★ 脚本正文走 **stdin**(`ssh ... bash -s`),**不走 argv**。 # argv 会进远端 `ps` 输出 ⇒ 正文里带的密钥就等于公开。 - # (remote_stdin 同理,只是多一层兼容。) - SSHPASS="$3" sshpass -e ssh ${SSHO} "$2@$1" 'bash -s' 2>&1 <<<"$4" -} - -remote_stdin() { - # $1=host $2=user $3=pass $4=script(脚本从 stdin 读) - SSHPASS="$3" sshpass -e ssh ${SSHO} "$2@$1" 'bash -s' 2>&1 + # + # ★★ 凭据**全程不经过本 shell**:ssh 在 xop 的子进程里跑, + # `SSHPASS` 由 xop 注入成环境变量(`sshpass -e` 读它)。 + # ⇒ 口令不进本脚本内存、不进任何 argv、也不被 FileGuard 掩码。 + # + # ★★ **xop 自己的 WARN 打在 stdout**(`xop -h` 没写,实测 2026-11-09: + # `NetworkGuard/FileGuard.setup() is STUBBED` 两行)。原来 `2>&1` 把 + # 这些行混进 `$(remote ...)` 的返回值 ⇒ `wc -c` 拿到的是 WARN 文本 + # ⇒ 密钥送达长度校验必然失败;`sha256sum` 也拿不到 64 字节度量。 + # ⇒ 用 **fd 3 分流**:远端 stdout/stderr → fd3 → 临时文件; + # xop 自己的 stdout → /dev/null;xop 的 stderr 留给调用方看。 + # ⇒ 返回值只剩远端脚本的真实输出。 + # + # ★ 别再写 `< /dev/null`:`<<<"$4"` 是**后出现**的重定向, + # bash 里会覆盖前面的 `< /dev/null`(实测 `cat < /dev/null <<&3 2>&3" \ + 3>"$_out" >/dev/null <<<"$4" + cat "$_out" + rm -f "$_out" } remote_put() { - # $1=host $2=user $3=pass $4=远端路径 —— 内容从**本脚本 stdin** 读 + # $1=host $2=用户键名 $3=口令键名 $4=远端路径 —— 内容从**本脚本 stdin** 读 # # ★★ 只传内容、不传脚本 ⇒ 密钥**不经过 argv**(argv 会进远端 ps)。 # 密钥全文只走 stdin 这条通道。 - SSHPASS="$3" sshpass -e ssh ${SSHO} "$2@$1" \ - "umask 077 && mkdir -p \$(dirname '$4') && cat > '$4'" 2>&1 + # + # ★★ **这里绝不能写 `< /dev/null`** —— + # 那会把调用方的**管道内容丢掉**(实测:写出的文件是 0 字节, + # 密钥根本没送达远端 ⇒ 远端读到的密钥是空的 ⇒ 控制面配的密钥与 + # 节点用的不是同一份 ⇒ 全 401,且症状极难查)。 + # ⇒ 只在 stdin **是 TTY** 时才断开(xop 在 TTY 下会等 Touch ID 超时); + # 管道场景 stdin 本来就不是 TTY,xop 走无头分支,不需要断开。 + if [ -t 0 ]; then + xop run --secret "SSHPASS=$3" --secret "TEE_USER=$2" -- \ + sh -c "sshpass -e ssh ${SSHO} \"\$TEE_USER@$1\" \"umask 077 && mkdir -p \$(dirname '$4') && cat > '$4'\"" \ + < /dev/null 2>&1 + else + xop run --secret "SSHPASS=$3" --secret "TEE_USER=$2" -- \ + sh -c "sshpass -e ssh ${SSHO} \"\$TEE_USER@$1\" \"umask 077 && mkdir -p \$(dirname '$4') && cat > '$4'\"" \ + 2>&1 + fi } if ! require_env; then @@ -103,7 +210,7 @@ printf '\n' neg_gate() { # $1=标签 $2=远端命令 $3=期望出现在输出里的拒绝特征 local label=$1 cmd=$2 want=$3 o - o=$(remote "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" "$cmd") + o=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" "$cmd") if printf '%s' "$o" | grep -q "$want"; then ok "负向·${label}:按预期拒绝" return 0 @@ -112,14 +219,34 @@ neg_gate() { return 1 } -printf '--- 负向矩阵:跨网段暴露的硬闸门 ---\n' +# ★ 格式串以 `---` 开头会被 bash 的 printf 当成选项(`printf: --: invalid option`) +# ⇒ 用 `%s` 传参,别让格式串直接以 `-` 打头。 +printf '%s\n' '--- 负向矩阵:跨网段暴露的硬闸门 ---' # ★★ 这两条**启动期**负向(不需要控制面已在跑)⇒ 放在起控制面**之前**。 # # ★ 密钥**不进 argv**:从**文件**读进环境(文件此时可能还不存在, # 所以用本机的 secret 内容经 stdin 传给远端 —— 见 remote_put)。 -printf '%s' "$CLUSTER_SECRET" | remote_put "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" \ +printf '%s' "$CLUSTER_SECRET" | remote_put "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \ /tmp/mpc-cluster/cluster.secret >/dev/null +# ★★ **必须校验密钥真的送到了**(不能假设)。 +# +# ★ 实测踩过:`remote_put` 里写了 `< /dev/null` ⇒ 把调用方的**管道内容** +# 整个丢掉 ⇒ 远端文件是 **0 字节** ⇒ 远端读到空密钥 ⇒ 控制面配的 +# 密钥与节点用的不是同一份 ⇒ 全 401,而症状是「自报收不到」, +# 极难往「密钥没送达」上想。 +# ⇒ 这里**当场量长度**:不符就**立刻失败**,别让它流到后面。 +want_len=${#CLUSTER_SECRET} +got_len=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \ + "wc -c < /tmp/mpc-cluster/cluster.secret 2>/dev/null | tr -d ' '") +if [ "${got_len:-0}" = "$want_len" ] && [ "$want_len" -ge 32 ]; then + ok "集群密钥已送达海光机(${got_len} 字节)" +else + fail "集群密钥没送达海光机(期望 ${want_len} 字节,得到 '${got_len:-空}')—— \ +密钥通道断了(remote_put 的 stdin 被重定向覆盖?)" + exit 1 +fi + neg_gate '非回环无密钥拒启动' \ "cd /tmp/mpc-cluster && MPC_HOSTD_SHARED_SECRET= ./mpc control-plane serve --listen 0.0.0.0:3099 --allow-remote 2>&1 | head -3" \ '共享密钥' @@ -143,7 +270,7 @@ neg_gate '有密钥但缺 --allow-remote 拒启动' \ # ⇒ 下面把「后台起服务」和「读日志」拆成**两条独立命令**。 # (密钥文件已在上面的负向矩阵段推过去了,这里不重复推。) printf '\n--- 起控制面 ---\n' -out=$(remote "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" \ +out=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \ "cd /tmp/mpc-cluster pkill -f 'mpc control-plane serve' 2>/dev/null || true sleep 1 @@ -169,7 +296,7 @@ fi # ⇒ 先断言「正确密钥拿到 200」,再断言「错密钥拿到 401」。 # ⇒ 顺序不能反:先跑正向,正向不过就不必跑负向。 printf '\n--- 负向矩阵:鉴权 ---\n' -code_ok=$(remote "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" \ +code_ok=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \ "SECRET=\$(cat /tmp/mpc-cluster/cluster.secret) curl -s -o /dev/null -w '%{http_code}' -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/nodes") if [ "$code_ok" = "200" ]; then @@ -260,12 +387,12 @@ EOS } printf '\n--- 起节点 hostd ---\n' -start_hostd 'AMD' "$AMD_HOST" "$USER_AMD" "$SSHPASS_AMD" snp alice \ +start_hostd 'AMD' "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" snp alice \ /opt/kata/bin/qemu-system-x86_64 \ /opt/kata/share/ovmf/AMDSEV.fd \ /opt/kata/share/kata-containers/vmlinuz-6.12.36-160-confidential || FAIL_N=$((FAIL_N + 1)) -start_hostd 'CSV' "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" csv bob \ +start_hostd 'CSV' "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" csv bob \ /opt/confidential-containers/bin/qemu-system-x86_64 \ /opt/confidential-containers/share/ovmf/HYGONCSV.fd \ /opt/confidential-containers/share/kata-containers/vmlinuz-5.10.134-102cc-csv-hygon-gpu || FAIL_N=$((FAIL_N + 1)) @@ -274,7 +401,7 @@ start_hostd 'CSV' "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" csv bob \ printf '\n--- 查控制面注册表 ---\n' sleep 8 # ★ 密钥从**文件**读进环境,**不进 curl 的 argv**(argv 会进远端 ps)。 -nodes=$(remote "$HYGON_HOST" "$USER_HYGON" "$SSHPASS_HYGON" \ +nodes=$(remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" \ "SECRET=\$(cat /tmp/mpc-cluster/cluster.secret) curl -s -m 8 -H \"Authorization: Bearer \$SECRET\" http://127.0.0.1:3020/nodes") printf '%s\n' "$nodes" | sed 's/^/ /' diff --git a/docs/ARCHITECTURE_SYSTEM.md b/docs/ARCHITECTURE_SYSTEM.md index 71ba1fd..cc974cd 100644 --- a/docs/ARCHITECTURE_SYSTEM.md +++ b/docs/ARCHITECTURE_SYSTEM.md @@ -170,10 +170,16 @@ fail-closed 口径,解析失败拒收、不写半条记录)→ `NodeRegistry 控制面全局绑定。绑定值写进芯片报告 `user_data`,两个会话共用一份绑定等于 两份报告可互相冒用(重放)。 -**状态**:[桩验] 真 socket 端到端门禁已跑通完整闭环,且用**假 hostd** 给 +**状态**:[桩验 + 真机自报] 真 socket 端到端门禁已跑通完整闭环,且用**假 hostd** 给 「端点不外泄」补了正向对照(证明通过 ⇒ 端点真的出现;证明不齐 ⇒ 端点被收回), -避免否定式判据因 `create` 恒失败而恒真(空集通过)。但节点是本机假 hostd / -不可达节点,**不等于真机集群调度已跑通** —— 见 §8。 +避免否定式判据因 `create` 恒失败而恒真(空集通过)。 +**真机两节点自报已实证**(2026-11-09):AMD SNP(`192.168.1.7`,site=alice) +与海光 CSV(`192.168.1.102`,site=bob)各起 hostd 向真机控制面自报, +`/nodes` 注册表里确实有两个节点、`measurement` 非全零。 +但**选址 → 下发 → 证明门控 → 公布端点**的真机闭环仍未做完 —— 见 §8。 +★ 本轮又用离线探针查出联调脚本里 3 个会让真机必挂的缺陷(xop 把 WARN 打在 +**stdout** 污染返回值、`printf` 前导 `---` 被当选项、`remote()` 里被覆盖的 +`< /dev/null` 假防护),修完后**只过了离线判据门禁,尚未在真机复跑**。 ### 1.7 SA 扩展模式(安全锚点供能力、算力挂外部 VM) @@ -360,7 +366,7 @@ TA 是所有 CA 共享的,没有「这个 TA 属于哪个租户」的进程语 | 事项 | 唯一实现 | 纪律 | |---|---|---| -| 主门禁 | `tools/ci.sh`,**24 条** | 缺环境显式 `*_SKIPPED`;闸门不扫自己 = 盲区,lint 含 `tools/` | +| 主门禁 | `tools/ci.sh`,**25 条** | 缺环境显式 `*_SKIPPED`;闸门不扫自己 = 盲区,lint 含 `tools/` | | 真链验收 | `tools/selftest-fisco-contract.py`(第 22 条) | 部署→写→读→负向矩阵,`--self-test` 零依赖 22/22 | | 生成端 / 审计端判定 | 同一份 `security_audit::semantic_review()` | 仅 High/Critical 阻断,不得为通过设豁免 | | SM2 口径 | `docs/FISCO_UPSTREAM_TRUTH.md` §3.1 | `e = SM3(ZA‖dataHash)`,distid 唯一值 `1234567812345678` | @@ -389,11 +395,16 @@ TA 是所有 CA 共享的,没有「这个 TA 属于哪个租户」的进程语 - OP-TEE **QEMU 实跑已做**(2026-11-09,`docs/OPTEE_VERIF_PLAN.md` 有完整证据表):全流程 selftest、第 5 条跨设备解封被拒、第 4 条跨重启 unseal 成功三条**都真跑通了**。但那是 **QEMU 模拟**(`dna` = 编译期 sha256 种子,HUK = 模拟值)⇒ **不是**真板的设备绑定证据,**不能**替代真板一次性验收;`CryptoPrecompiled.sm2Verify` 真机对拍未做;`tools/fisco-realnode-probe.py` 的 4 处 `IMPL_GAPS` 未销账。 - 本租户 SA 无 `create secret` 权限;链客户端私钥 `MPC_FISCO_KEY` 保持仓库外,不进镜像 / ConfigMap / git。 - 站点端控制面是 [设计] 决策角色,不是已实现的独立服务;别把 §2 的职责矩阵当成已部署清单。 -- **集群控制面只在假 hostd / 不可达节点上验过框架契约**:`mpc control-plane` - 的「收自报 → 注册表 → 期望态 → 选址 → 下发 → 证明门控 → 公布端点」闭环 - 在真 socket 门禁里全绿,但节点是本机假 hostd(证明结论可控)或不可达节点; - 真机多节点自报、跨网段暴露、真 KBS 验签后的会话端点交付**未做**。 - 别把 §1.6 当成已部署的集群清单。 +- **真机多节点自报已实证,但「调度闭环」仍未做完**:`mpc control-plane` 的 + 「收自报 → 注册表」这一步 2026-11-09 已在 AMD SNP + 海光 CSV 两台真机上跑通 + (`/nodes` 里两个节点、度量非全零)。但「期望态 → 选址 → 下发 → 证明门控 → + 公布端点」仍只在真 socket 门禁里用**假 hostd**(结论可控)或不可达节点验过; + 跨网段暴露、真 KBS 验签后的会话端点交付**未做**。别把 §1.6 当成已部署清单。 +- ★ **本轮修完的联调脚本尚未在真机复跑**:`deploy/tee/real-machine/cluster-selfreport-e2e.sh` + 的 3 个必挂缺陷(xop WARN 走 stdout ⇒ `wc -c` / `sha256sum` 返回值被污染、 + `printf '--- …'` 前导破折号被当选项、`remote()` 的 `< /dev/null` 被 here-string + 覆盖成假防护)是**离线探针**发现并修掉的;第 25 条门禁证明的是「判据本身 + 不是恒绿」,**不是**「真机端到端已复跑通过」。复跑前别把脚本标成 [实证]。 - **SA 扩展模式只证明了「接口与边界形状成立」,不是「`K_root` 硬件隔离成立」**(§1.7): 板端 SA 的 `K_root` 是**软件**生成与持有的(板子无硬件密钥槽),SA 自曝 `platform=none` / `hardware_protected=false`。⇒ **阶段一不能进密评**。 @@ -413,7 +424,7 @@ TA 是所有 CA 共享的,没有「这个 TA 属于哪个租户」的进程语 想搞懂「计算层为什么这样分」 → ARCHITECTURE.md 想看「当时为什么这么决策」 → INTEGRATION_ANALYSIS.md(先看文首状态提示) 想核对「链上逐字节事实」 → FISCO_UPSTREAM_TRUTH.md -想真跑一遍 → tools/ci.sh(24 条)/ deploy/k8s/fisco/README.md +想真跑一遍 → tools/ci.sh(25 条)/ deploy/k8s/fisco/README.md / deploy/tee/real-machine/README.md ``` diff --git a/docs/INDEX.md b/docs/INDEX.md index 98f7f1a..cac55e0 100644 --- a/docs/INDEX.md +++ b/docs/INDEX.md @@ -33,13 +33,14 @@ | FISCO 国密链真交易 | [实证] TARS 编码(非 RLP)、`sendTransaction` 4 参、`r‖s‖pub` 128B 签名 | `FISCO_UPSTREAM_TRUTH.md`、`crates/mpc-chain/src/fisco_tx.rs` | | ★ SM2 签名口径 | [实证] **`e = SM3(ZA‖dataHash)`**,distid `1234567812345678`;**不是**签裸 `dataHash` | `FISCO_UPSTREAM_TRUTH.md` §3.1、`tools/sm2_verify.py`;这是 `10008 InvalidSignature` 的真根因 | | 智能合约真链部署 / 调用 / 读回 | [实证] `MpcHardRule.sol` 部署 → `recordHardRule` → 读回 → 负向矩阵,**22 项判据全绿** | `tools/selftest-fisco-contract.py`(主门禁第 22 条;零依赖 `--self-test` 每次必跑,真链批缺环境显式 `FISCO_REALNODE_SKIPPED`) | -| 主门禁 | [实证] **24 条**(`tools/ci.sh` 的 `step "N/24"` 是唯一计数) | `tools/ci.sh`;缺环境显式 `*_SKIPPED`,绝不静默通过 | +| 主门禁 | [实证] **25 条**(`tools/ci.sh` 的 `step "N/25"` 是唯一计数) | `tools/ci.sh`;缺环境显式 `*_SKIPPED`,绝不静默通过 | | FISCO 链节点 + 账本持久化 | [实证] 迁入 wuguirong k8s,`nfs-wuguirong` PVC;历史区块哈希逐个一致,删 Pod 重建后高度不变 | `deploy/k8s/fisco/README.md` | | MPC 站点 `mpc-demo` | [实证] 已在 k8s(NodePort `30082`),`/tmp` 挂 NFS PVC | `demo/k8s/README.md` | | ARM 边缘板(Zynq-7015) | [实证] `mpc` 二进制上板:selftest 5/5、两进程会话 `35.000000`、sha256 与本机一致;selftest 单次 **≈4 ms**、峰值 RSS 3.5 MB | `docs/ZYNQ.md` §4 | | ★ Zynq 真板 OP-TEE | [设计] 产物已能交叉编译;**板端未部署**——当前内核 `CONFIG_TEE is not set`、`BOOT.BIN` 无 EL3 承载 ⇒ 须换启动链 | `docs/ZYNQ.md` §4.3、`build/build_optee_zynq7k.sh` | | ★ SA 扩展模式 | [实证] **板端 SA 服务端 ↔ OrbStack 外挂 VM 端到端跑通**,判据 26/26;seal/unseal/attest/sign + 会话物料全部可用;**VM 侧拿不到 `K_root`**(site 名骗不出、协议无导出端点、VM 侧无根密钥文件) | `docs/SA_EXTENDED_MODE.md`、`deploy/arm/zynq7015/sa-pair-e2e.sh` | | ★ 零种子守卫 | [实证] CLI 入口(连网前)+ `Vault::new` 双层拒绝全零主种子;判据 18 条;破坏实验证明非恒绿 | `tools/selftest-seed-guard.py`(主门禁第 24 条) | +| ★ 集群自报判据链 | [实证] **离线自测 10 条 + 破坏实验 11 条全绿**,每条判据都被构造样例逐条破坏过;不依赖真机 / xop 保险库 | `tools/selftest-cluster-selfreport.py`(主门禁第 25 条) | --- @@ -83,9 +84,9 @@ | `docs/ARCHITECTURE_SYSTEM.html` + `tools/render-share-html.py` | 上者的**可分享单文件 HTML** 与生成器;HTML 是派生产物勿手改,`--check` 校验与 md 同步 | | `docs/FISCO_UPSTREAM_TRUTH.md` | 国密链上游逐字节核对的唯一真相源(TARS / ZA / `status==0` / selector) | | `docs/REAL_MACHINE_FINDINGS.md` | 两台真机实测硬事实;第 10 节是最新合流结论 | -| `tools/ci.sh` | 主门禁(24 条)唯一实现 | +| `tools/ci.sh` | 主门禁(25 条)唯一实现 | | `tools/selftest-fisco-contract.py` | 真链验收唯一权威脚本(★ **独立于主门禁**:它要连真链,故不在 `ci.sh` 里) | -| `tools/selftest-sa.py` / `tools/selftest-seed-guard.py` | SA 契约(52 条)/ 零种子守卫(18 条)—— 主门禁第 23 / 24 条 | +| `tools/selftest-sa.py` / `tools/selftest-seed-guard.py` | SA 契约(52 条)/ 零种子守卫(18 条)—— 主门禁第 23 / 25 条 | ### B 专题设计(结论稳定,不含进度) @@ -136,7 +137,7 @@ | 旧文档写过的 | 当前事实 | 权威入口 | |---|---|---| -| 「主门禁共 18 条 / 20 条 / 22 条」 | **24 条** | `tools/ci.sh` | +| 「主门禁共 18 条 / 20 条 / 22 条」 | **25 条** | `tools/ci.sh` | | 「`selftest-fisco-contract.py` 不在主门禁里」 | ★ **已回到主门禁第 22 条**(`27cbdc7` 误删过,现已恢复) | `tools/ci.sh`、`tools/fisco-realnode/README.md` | | 「`flush` 只发规范字节,不是已签名交易」 | `flush --mode signed-tx` 发**完整已签名 FISCO 交易**(TARS + 128B 签名),且走 `Outbox::flush_with` 状态机 | `crates/mpc-cli/src/chain.rs`、`fisco_tx.rs` | | 「不宣称能上链」「合约部署未做」 | 真链部署 / 调用 / 读回已实证,22/22 全绿 | `selftest-fisco-contract.py` | @@ -177,7 +178,7 @@ ## 6. 更新纪律(下次改文档照这个走) -1. **门禁条数只认 `tools/ci.sh`**:脚本里 `step "N/24 ..."` 是唯一计数;文档写死的 +1. **门禁条数只认 `tools/ci.sh`**:脚本里 `step "N/25 ..."` 是唯一计数;文档写死的 数字必须同步,改完用 python 扫全仓 `*.md` 复核(macOS 的 grep 对中文匹配不稳)。 ★ 另:**判据脚本在仓库里 ≠ 判据在门禁里** —— 提交 `27cbdc7` 曾删掉 `tools/ci.sh` 里 5 个 step(第 18–22 条),脚本都还在,只是不再被调用 ⇒ @@ -199,7 +200,7 @@ 8. 改完做校验:**纯文档改动**至少跑 `python3 tools/selftest-fisco-contract.py --self-test` + `bash -n tools/ci.sh` + `git diff --check`(不必跑全量门禁,避免真链判据往链上 写新块 / 部署新合约,那是文档校验不需要的副作用);**涉及代码 / 判据 / 门禁的改动** - 才按 `tools/ci.sh` 跑全量 24 条。确认没有把活文档改坏。 + 才按 `tools/ci.sh` 跑全量 25 条。确认没有把活文档改坏。 9. **★ 帮助文本 / 文档里的参数必须与实现对齐**:2026-11-09 实测踩过两次 —— 改 `mpc tee` 帮助文本时漏掉了 `attest-upload` 的 `--upload-path-file` (实现里**必填**),以及 SA 客户端的 `--plaintext-hex` / `--blob-hex` / diff --git a/docs/INTEGRATION_ANALYSIS.md b/docs/INTEGRATION_ANALYSIS.md index d73ae85..214ae02 100644 --- a/docs/INTEGRATION_ANALYSIS.md +++ b/docs/INTEGRATION_ANALYSIS.md @@ -14,7 +14,7 @@ | 本文当时写的 | 当前事实(2026-11-08) | 权威入口 | |---|---|---| -| 主门禁共 **18 条**(§6、附录) | **24 条** | `tools/ci.sh` | +| 主门禁共 **18 条**(§6、附录) | **25 条** | `tools/ci.sh` | | 「`flush` 只发规范字节,不是已签名交易」 | FISCO **TARS 编码 + 128B `r‖s‖pub` 签名**已落地,`flush --mode signed-tx` 发完整已签名交易并走 `Outbox::flush_with` 状态机 | `crates/mpc-chain/src/fisco_tx.rs`、`crates/mpc-cli/src/chain.rs` | | 「**不宣称能上链**」「合约部署仍未做」 | 真链**合约部署 / 调用 / 读回 + 负向矩阵**已实证,22 项判据全绿 | `tools/selftest-fisco-contract.py`(主门禁第 22 条)、`contracts/MpcHardRule.sol` | | 「FISCO 自有交易编码待真机对拍」 | 已逐字节核对落地;★ 签名口径是 **`e = SM3(ZA‖dataHash)`**(节点 3.17.1 只编译了 `fast_sm2_*`,用 distid `1234567812345678`),**不是**签裸 `dataHash` | `docs/FISCO_UPSTREAM_TRUTH.md` §3.1、`tools/sm2_verify.py` | @@ -758,7 +758,7 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交 **阶段状态(2026-11-08 追加 TLCP 进程通道后,历史快照)**:**0a 已完成**(第 12 条)、**1 已完成**(第 13 条)、**2 形状层 + OpenSSL 国密签名 + GmSSL 本机 TLCP 真握手 + Rust 侧 TLCP 进程通道环回实证已完成**(第 14 / 15 / 16 / 18 条);**3 第一段已完成**(第 17 条:真 OPA bundle 签发 / 真判定 / decision 幂等存证);0b 的编排与判据已实现、**QEMU 实跑待有 SDK 的机器**。主门禁共 **18 条(当时)**。 > **[当前状态 2026-11-08]** 上段与紧随其后的「两段诚实边界」都是**当时的阶段结论**, -> 不是现状。现在:主门禁 **24 条**(第 21 条真交易编码、第 22 条真链合约、第 23 条 SA 扩展模式、第 24 条零种子守卫); +> 不是现状。现在:主门禁 **25 条**(第 21 条真交易编码、第 22 条真链合约、第 23 条 SA 扩展模式、第 24 条零种子守卫、第 25 条集群自报判据自测 + 破坏实验); > 阶段 2 的 **FISCO TARS 编码与已签名交易已落地并在真链实证**;阶段 3 的 > **合约部署已实证**(`MpcHardRule.sol`)。但「OPA 在 guest 内执行 / bundle > 分发 / 链上撤销状态位读取后端 / decision 签名上链」**仍未做**,QEMU 实跑仍待 SDK。 @@ -769,7 +769,7 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交 暴露的是「宿主控制面被编进 guest」而不是环境缺包。现按 feature + target 切分, `tools/check-guest-artifact.py` 三层探针(依赖树 / 编译期守卫 / ELF 标识)进主门禁; `deps` 不依赖 musl target 是否安装,避免「跳过目标」把边界判据一起跳掉。 -本轮(2026-11-07 当时)`./tools/ci.sh` **18 条全绿**(现为 **24 条**):第 4 条 guest 探针 22(deps)/ 3(guard)/ 15(binary)、 +本轮(2026-11-07 当时)`./tools/ci.sh` **18 条全绿**(现为 **25 条**):第 4 条 guest 探针 22(deps)/ 3(guard)/ 15(binary)、 第 14 条 50、第 15 条 36、第 16 条真握手 19 + TA 密钥 16 + 两份零依赖契约判据 11 / 12、第 17 条真 OPA 闭环 41 + 零依赖判据 22、第 18 条 TLCP 进程通道环回实证 15 + 零依赖判据; 第 10 条芯片验签器自测现含 SNP + CSV 两平台(CSV 零依赖 18 条); @@ -982,7 +982,7 @@ decision 只是 outbox 存证(**未签名、未上链**),软件签名器 - `crates/mpc-tee/src/optee/{mod,core,proto}.rs`(CA↔TA 三层范式、seal 格式、命令协议;`ta/`、`ca/` 需 OP-TEE SDK 交叉编译,`build/build_optee.sh` 驱动) - `build/build_optee.sh`(需要 `OPTEE_OS` + `SDK_DIR` + `arm-linux-gnueabihf-`;`UUID` 硬编码 `a1b2c3d4-…`;**`--check-only` 在 SDK 检查之前解析 TA 签名密钥三级**:dev 必须显式 `MPC_TA_ALLOW_DEV_KEY=1` / `MPC_SIM_DEV`,staging 必须 `MPC_TA_SIGN_KEY`,prod 必须 `SIGN_KEY` 且绝不回落 `default_ta.pem`,违规以 `MPC_TA_KEY_FAIL:` 独立短行拒绝;`MPC_SIM_DEV` A/B 跨设备解封失败的机制已串进 `tools/optee-cross-device.sh`,但**QEMU 未实跑**) - `crates/mpc-tee/Cargo.toml`(**没有 `optee` feature**;TA 走 `default-features = false`,所以 `mpc-tee` 的 no_std 是 OP-TEE 的硬前置) -- `tools/ci.sh`(**本文写作时 18 条,现为 24 条**;以下条目编号按当时,新增第 21 条真交易编码判据、第 22 条真链合约判据,见文首状态提示与 `docs/INDEX.md`;第 3 条 = mpc-core + mpc-tee no_std + TA UUID 对拍;第 4 条 = musl 跨目标零告警 + guest 产物三层探针;**第 11 条 = OP-TEE 判据逻辑自测**(零 SDK);第 12 / 13 / 14 条 = hostd / 链路层 / 链上层端到端自测;**第 15 条 = 国密签名 / distid / TLCP 准入 / 治理形状**;**第 16 条 = GmSSL TLCP 真握手 + TA 密钥分级 + FISCO 真机对拍契约**,其中两份 `--self-test` 与 TA 探针零外部依赖;**第 17 条 = 阶段 3 OPA bundle 签发 / 真判定 / decision 存证**,零依赖判据 18 + 真闭环 40;**第 18 条 = TLCP 进程通道环回实证**(`TlcpTunnel` spawn `gmssl tlcp_client` 经 TLCP 收发真实 JSON-RPC 给环回 echo,断言往返一致;`realChainVerified` 恒 false、`BCOS_RPC_NOT_VERIFIED`);缺环境一律显式 `*_SKIPPED` + 逐项缺失) +- `tools/ci.sh`(**本文写作时 18 条,现为 25 条**;以下条目编号按当时,新增第 21 条真交易编码判据、第 22 条真链合约判据,见文首状态提示与 `docs/INDEX.md`;第 3 条 = mpc-core + mpc-tee no_std + TA UUID 对拍;第 4 条 = musl 跨目标零告警 + guest 产物三层探针;**第 11 条 = OP-TEE 判据逻辑自测**(零 SDK);第 12 / 13 / 14 条 = hostd / 链路层 / 链上层端到端自测;**第 15 条 = 国密签名 / distid / TLCP 准入 / 治理形状**;**第 16 条 = GmSSL TLCP 真握手 + TA 密钥分级 + FISCO 真机对拍契约**,其中两份 `--self-test` 与 TA 探针零外部依赖;**第 17 条 = 阶段 3 OPA bundle 签发 / 真判定 / decision 存证**,零依赖判据 18 + 真闭环 40;**第 18 条 = TLCP 进程通道环回实证**(`TlcpTunnel` spawn `gmssl tlcp_client` 经 TLCP 收发真实 JSON-RPC 给环回 echo,断言往返一致;`realChainVerified` 恒 false、`BCOS_RPC_NOT_VERIFIED`);缺环境一律显式 `*_SKIPPED` + 逐项缺失) - `tools/check-optee-uuid.py`(五处 UUID 对拍,不写死期望值;已做探针回归——改一个字符即 `OPTE_UUID_FAIL` 并指出差异行) - `tools/ci-optee.sh`(段二独立通道。skip 分支已实测,构建分支待真 SDK;新增 `--cross-device` / `--restart` 两个互斥模式) - `build/optee-verdict.py`(**判据的唯一真相源**:按 mode / expect / provisioned / require-9p 判定串口日志,兼带 blob 抠取。判据散落多处 = 迟早分叉且分叉了没人知道) diff --git a/tools/fisco-realnode/README.md b/tools/fisco-realnode/README.md index 6544c70..831d3b0 100644 --- a/tools/fisco-realnode/README.md +++ b/tools/fisco-realnode/README.md @@ -16,7 +16,7 @@ |---|---|---| | `tools/selftest-fisco-contract.py` | **真链判据主脚本**(主门禁第 22 条) | 连真链跑完整流程:部署→写→读→负向矩阵。**这是唯一权威验收脚本**。 | | `tools/sm2_verify.py` | SM2 签名口径自检 | 交叉验证 `ZA‖digest` 口径,附 ZA 值锚点。 | -| `tools/ci.sh` | 门禁(24 条) | 第 22 条即本真链判据;全绿才放行。 | +| `tools/ci.sh` | 门禁(25 条) | 第 22 条即本真链判据;全绿才放行。 | | `contracts/MpcHardRule.sol` | 合约源码 | `recordHardRule(summary)` 写接口 + `isRecorded`/`hardRuleSummary` 读接口,`require(summary!=0)`。 | | `build/contracts/combined.json` | solc 产物 | 含 `abi` 与 `bin`(部署字节码),selftest 的 `MPC_FISCO_ABI` 指向这里。 | | `docs/FISCO_UPSTREAM_TRUTH.md` | **上游事实真相** | 签名口径(`fast_sm2_verify` → `e=SM3(ZA‖dataHash)`)、TARS 编码、端点、selector 二元数组等,全部以真链实测为准。 | diff --git a/tools/selftest-cluster-selfreport-break.py b/tools/selftest-cluster-selfreport-break.py index 614bb77..0e3f228 100644 --- a/tools/selftest-cluster-selfreport-break.py +++ b/tools/selftest-cluster-selfreport-break.py @@ -1,28 +1,28 @@ #!/usr/bin/env python3 -"""集群自报判据的**破坏实验**:把判据改成坏的样子,确认它们**会红**。 +"""集群自报判据的**破坏实验**:把每条判据改成坏的样子,确认它们**会红**。 # 这条脚本守的是什么 -`tools/selftest-cluster-selfreport.py` 守的是「判据本身是否成立」。 -但那只证明了「当前形态下判据通过」—— **不能证明判据在起作用**。 +`tools/selftest-cluster-selfreport.py` 有 9 组判据。但「当前形态下判据通过」 +**不能证明判据在起作用** —— 恒绿判据和真判据在正向路径上表现完全一样。 -一个恒绿的判据和一个真判据,在正向路径上**表现完全一样**。 +所以这份脚本把每条判据都**破坏一次**,要求「自测脚本必须转红」: -所以这份脚本做反向验证:每个判据都**破坏一次**,然后要求 -「自测脚本必须转红」: +| 破坏内容 | 期望被哪条判据抓到 | +|----------------------------------------|-------------------| +| 探针不写 argv 日志(fired 断言失效) | 判据 1 | +| 把历史坏形态改成不泄露 | 判据 1·反向 | +| 删掉注册表判据的正向锚点 | 判据 2 | +| 删掉「正确密钥 200」正向对照 | 判据 3 | +| 把正向对照挪到负向**之后** | 判据 3 | +| 在密钥流经语句里加回 hex 编码 | 判据 4 | +| Rust 侧口径分叉(不用 secret_token) | 判据 5 | +| 密钥送达长度改成写死(不真量远端) | 判据 6 | +| `remote_put` 无条件 `< /dev/null` | 判据 7 | +| 把 xop 明文取进 shell 变量 | 判据 8 | +| 拆掉 remote() 的 fd3 隔离 | 判据 9 | -| 破坏内容 | 期望被哪条判据抓到 | -|----------------------------------|-------------------| -| 删掉注册表判据的正向锚点 | 判据 2 | -| 删掉「正确密钥 200」正向对照 | 判据 3 | -| 把正向对照挪到负向**之后** | 判据 3 | -| 在代码里加回 hex 编码形态 | 判据 4 | -| Rust 侧口径分叉(不用 secret_token)| 判据 5 | - -★ 破坏 1(密钥进 argv)不在这儿 —— 它的反向验证已经内建在 - `selftest-cluster-selfreport.py` 的「判据 1·反向」里(要跑真实脚本)。 - -# ★ 两条硬纪律 +# ★ 三条硬纪律 1. **绝不碰仓库文件** —— 全部在临时副本上做; 2. **变异必须双向确认生效** —— @@ -30,6 +30,13 @@ 2026-11-09 实测踩过:变异函数删错了行 ⇒ 破坏实验「没抓到」 ⇒ 差点被误判成「判据恒绿」。所以这里必须校验证据,否则 「SKIP」会被当成「通过」。 +3. **顺序事实型变异单独一套** —— 挪动代码块后目标字串仍在, + 按「字串消失」判证据会误判成「变异未生效」。 + +# ★ 只复制自测脚本真正读的文件 + +自测脚本只读三个文件(e2e 脚本 + 两个 Rust 源文件), +复制整个 `crates/` 又慢又容易把 `target/` 带进来。 用法: python3 tools/selftest-cluster-selfreport-break.py @@ -46,6 +53,10 @@ 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') +RUST_FILES = ( + os.path.join('crates', 'mpc-hostd', 'src', 'auth.rs'), + os.path.join('crates', 'mpc-cli', 'src', 'control_plane.rs'), +) OK_N = 0 FAIL_N = 0 @@ -66,48 +77,108 @@ def fail(msg): 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)) + for rel in (SCRIPT_REL, SELFTEST_REL) + RUST_FILES: + dst = os.path.join(work, rel) + os.makedirs(os.path.dirname(dst), exist_ok=True) + shutil.copy(os.path.join(ROOT, rel), dst) return work def _run_selftest(work): p = subprocess.run( [sys.executable, os.path.join(work, SELFTEST_REL)], - capture_output=True, text=True, cwd=work) + capture_output=True, text=True, cwd=work, timeout=120) return p.returncode, p.stdout + p.stderr -def _variant(name, mutate, mode, expect): +def _write(work, rel, text): + with open(os.path.join(work, rel), 'w', encoding='utf-8') as f: + f.write(text) + + +def _read(work, rel): + with open(os.path.join(work, rel), encoding='utf-8') as f: + return f.read() + + +def _variant(name, mutate, mode, expect, rel=SCRIPT_REL): """在临时副本上做一次变异 + 跑自测。 ★ mode: 'gone'(证据串必须消失)| 'added'(证据串必须新增) """ work = _prep() try: - p = os.path.join(work, SCRIPT_REL) - with open(p, encoding='utf-8') as f: - src = f.read() + src = _read(work, rel) 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 + good = not present and evidence in src else: good = present and evidence not in src if not good: - fail('破坏·%s:证据串校验失败(present=%s, 证据 %s)' - % (name, present, evidence)) + fail('破坏·%s:证据串校验失败(present=%s, 证据 %r)' + % (name, present, evidence[:60])) return False - with open(p, 'w', encoding='utf-8') as f: - f.write(new) + _write(work, rel, 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 _variant_order(name, mutate, expect): + """「顺序事实」型变异:证据不是字串,而是**位置关系**。""" + work = _prep() + try: + src = _read(work, SCRIPT_REL) + new, evidence = mutate(src) + if new is None or new == src: + fail('破坏·%s:变异未生效' % name) + return False + try: + code_pos = new.index(evidence) + 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 + _write(work, SCRIPT_REL, 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 _variant_named(name, rel, mutate, expect): + """对**非默认文件**做变异(Rust 侧)。""" + work = _prep() + try: + src = _read(work, rel) + new, evidence = mutate(src) + if new is None or new == src or evidence not in src: + fail('破坏·%s:变异未生效' % name) + return False + if evidence in new: + fail('破坏·%s:证据串没被破坏掉' % name) + return False + _write(work, rel, new) rc, out = _run_selftest(work) if rc != 0 and ('FAIL' in out) and (expect in out): ok('破坏·%s:判据如预期转红(证明它不是恒绿)' % name) @@ -121,6 +192,28 @@ def _variant(name, mutate, mode, expect): # ── 变异函数 ─────────────────────────────────────────────────────────── +def m_break_probe_fired(src): + """让假 sshpass **不写 argv 日志** ⇒ 探针没 fired,判据 1 必须拒。 + + ★ 这里匹配的是**自测脚本的源码文本**(不是它生成出来的脚本), + 所以反斜杠要按源码里的层数写 ⇒ 用 raw string,别数错。 + """ + token = r'printf "%%s\\n" "$@" >> "' + if token not in src: + return None, '' + new = src.replace(token, r'printf "%%s\\n" "$@" > /dev/null # "', 1) + return new, token + + +def m_neutralize_broken_sample(src): + """把构造样例里的密钥换掉 ⇒ 探针对「没泄露」的样本必须报恒绿。""" + evidence = "MPC_HOSTD_SHARED_SECRET='$CLUSTER_SECRET'" + if evidence not in src: + return None, '' + new = src.replace(evidence, "MPC_HOSTD_SHARED_SECRET='NO_SECRET_HERE'", 1) + return new, evidence + + def m_remove_positive_anchor(src): """删掉注册表判据的正向锚点(n_meas= 那几行)""" out = [ln for ln in src.splitlines() @@ -146,7 +239,7 @@ def m_remove_positive_control(src): def m_add_hex(src): - """在代码里加回 hex 编码形态""" + """在**密钥流经语句**里加回编码形态(用 xxd -p,避开脚本里已有的熵源 od)""" out = [] hit = False for ln in src.splitlines(): @@ -155,12 +248,68 @@ def m_add_hex(src): indent = ln[:len(ln) - len(ln.lstrip())] out.append(indent + 'export MPC_HOSTD_SHARED_SECRET=$(printf %s "$SECRET" ' - '| od -An -tx1 | tr -d " \\n")') + '| xxd -p | tr -d " \\n")') continue out.append(ln) if not hit: return None, '' - return '\n'.join(out) + '\n', 'od -An -tx1' + return '\n'.join(out) + '\n', 'xxd -p' + + +def m_fake_key_delivery(src): + """把「远端量长度」改成写死 ⇒ 判据 6 必须拒(不真量就是没校验)""" + lines = src.splitlines() + out = [] + i = 0 + while i < len(lines): + if 'got_len=$(remote ' in lines[i]: + out.append('got_len="$want_len"') + while i < len(lines) and lines[i].rstrip().endswith('\\'): + i += 1 + i += 1 + continue + out.append(lines[i]) + i += 1 + return '\n'.join(out) + '\n', 'wc -c <' + + +def m_unconditional_devnull(src): + """把 remote_put 的 TTY 守卫去掉 ⇒ `< /dev/null` 变成无条件 ⇒ 判据 7 拒""" + i = src.find('remote_put()') + if i < 0: + return None, '' + j = src.find('\n}', i) + body = src[i:j if j > 0 else i + 1200] + if 'if [ -t 0 ]; then' not in body: + return None, '' + broken_body = body.replace('if [ -t 0 ]; then', 'if true; then', 1) + new = src[:i] + broken_body + src[j if j > 0 else i + 1200:] + return new, '-t 0' + + +def m_take_xop_plaintext(src): + """在 remote() 里把 xop 的明文取进变量 ⇒ 判据 8 拒""" + needle = ' xop run --secret "SSHPASS=$3" --secret "TEE_USER=$2" -- \\\n' + if needle not in src: + return None, '' + new = src.replace(needle, + ' SSHPASS=$(xop get -v "$3")\n' + needle, 1) + return new, 'xop get -v' + + +def m_break_fd3(src): + """拆掉 remote() 的 fd3 隔离 ⇒ xop WARN 又混进返回值 ⇒ 判据 9 拒""" + i = src.find('remote() {') + if i < 0: + return None, '' + j = src.find('\n}', i) + body = src[i:j if j > 0 else i + 1200] + if '1>&3' not in body: + return None, '' + broken = (body.replace(' 1>&3 2>&3', ' 2>&1') + .replace('3>"$_out" >/dev/null', '2>&1')) + new = src[:i] + broken + src[j if j > 0 else i + 1200:] + return new, '1>&3' def m_move_positive_after_negative(src): @@ -181,9 +330,7 @@ def m_move_positive_after_negative(src): break if idx is None: return None, '' - new_lines = rest[:idx] + block + rest[idx:] - new = '\n'.join(new_lines) + '\n' - # 顺序确认:正向块必须在负向之后(否则变异没生效) + new = '\n'.join(rest[:idx] + block + rest[idx:]) + '\n' try: if new.index('code_ok=') < new.index('错密钥 401', new.index('neg_gate')): @@ -193,86 +340,47 @@ def m_move_positive_after_negative(src): 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('(每条判据都破坏一次,要求自测脚本必须转红)') print('') all_ok = True + # 判据 1:探针 fired 的正向锚点 + 反向构造样例(改的是自测脚本自身) + all_ok &= _variant('探针不写 argv 日志(fired 断言失效)', + m_break_probe_fired, 'gone', '判据 1', + rel=SELFTEST_REL) + all_ok &= _variant('把历史坏形态改成不泄露', + m_neutralize_broken_sample, 'gone', '判据 1', + rel=SELFTEST_REL) + # 判据 2 / 3 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 编码形态', + # 判据 4 / 6 / 7 / 8 / 9 + all_ok &= _variant('密钥流经语句里加回编码形态', m_add_hex, 'added', '判据 4') - all_ok &= m_break_rust() + all_ok &= _variant('密钥送达长度改成写死', + m_fake_key_delivery, 'gone', '判据 6') + all_ok &= _variant('remote_put 无条件断开 stdin', + m_unconditional_devnull, 'gone', '判据 7') + all_ok &= _variant('把 xop 明文取进 shell 变量', + m_take_xop_plaintext, 'added', '判据 8') + all_ok &= _variant('拆掉 remote() 的 fd3 隔离', + m_break_fd3, 'gone', '判据 9') + # 判据 5:Rust 侧口径分叉 + all_ok &= _variant_named( + 'Rust 侧口径分叉', + os.path.join('crates', 'mpc-cli', 'src', 'control_plane.rs'), + # ★ 全量替换:control_plane.rs 里 `auth::secret_token` 出现 5 次 + # (注释 3 处 + 代码 2 处)。只换第一处 ⇒ 换的是注释, + # 判据 5 照样绿 ⇒ 破坏实验会被误判成「判据恒绿」。 + lambda s: (s.replace('auth::secret_token', 'auth::legacy_hex_token'), + 'auth::secret_token'), + 'secret_token') print('') print('=== 结果:%d 通过 / %d 失败 ===' % (OK_N, FAIL_N)) diff --git a/tools/selftest-cluster-selfreport.py b/tools/selftest-cluster-selfreport.py index 75ed969..3c81c81 100644 --- a/tools/selftest-cluster-selfreport.py +++ b/tools/selftest-cluster-selfreport.py @@ -7,34 +7,39 @@ 两台真机(AMD SNP / 海光 CSV)各起一个 hostd,向一台真机上的集群 控制面周期自报,验证「节点能力能被集群收上去」。 -这类脚本有三种典型的**静默失效**: +这类脚本有几种典型的**静默失效**: 1. **密钥进 argv** —— 密钥出现在 `ps` 输出里,脚本能跑通但密钥已泄露; -2. **否定式判据恒真** —— 「注册表里没有全零度量」在注册表为空时**恒通过**, - 于是控制面根本没起来,脚本却报「度量非全零」; -3. **鉴权口径分叉** —— 控制面下发用 `hex_encode(secret)`、节点侧校验 - 明文 ⇒ 全部 401,现象是「节点活着、自报收到了,就是下发不进去」。 +2. **否定式判据恒真** —— 「注册表里没有全零度量」在注册表为空时**恒通过**; +3. **鉴权口径分叉** —— 下发用 `hex_encode(secret)`、节点校验明文 ⇒ 全部 401; +4. **密钥根本没送达** —— `remote_put` 把 stdin 丢了 ⇒ 远端拿到空密钥 ⇒ 全 401; +5. **xop 噪声污染返回值** —— xop 把 WARN 打在 **stdout**(不是 stderr), + `2>&1` 一合并,`$(remote ...)` 拿到的就不是 `wc -c` 的数字而是两行 WARN + ⇒ 密钥送达校验、度量长度校验全废,而症状看起来像「远端没收到密钥」。 # ★ 为什么必须用「构造样例逐条破坏」 -这三条判据**单看都像是对的**。不破坏一次,就不知道它是恒绿还是真判。 +判据在正向路径上通过,**不能**证明它在起作用 —— +恒绿判据和真判据在正向路径上表现完全一样。 +所以 `selftest-cluster-selfreport-break.py` 会把每条判据**破坏一次**, +要求本脚本**必须转红**,并且**双向确认变异真的生效**(证据串消失/新增)。 -所以本脚本做的是:**把脚本改成坏的样子,确认判据真的会红。** +# ★ 探针不依赖真机、也不依赖 xop 保险库 -* 第 1 条:把 `remote()` 改回 argv 传脚本 ⇒ 必须检出密钥进 argv; -* 第 2 条:把注册表判据改成「只看否定式」⇒ 必须检出恒真; -* 第 3 条:把下发口径改回 hex ⇒ 必须检出 401。 +判据 1 用**假 xop + 假 sshpass**:假 xop 只负责跳过 `--secret` 并 `exec` +后续命令,假 sshpass 记录 ssh 收到的**全部 argv**(这正是远端 `ps` +能看到的东西)。全程不碰真机、不解密任何真口令、不需要 Touch ID。 -# ★ 探针不依赖真机 +# ★ 探针必须自证「真的 fired」(否则判据 1 是恒绿) -用**假 sshpass** 在本地跑脚本,记录 ssh 收到的 argv —— 这正是远端 -`ps` 能看到的东西。全程不碰真机、不碰真密钥。 +「argv 里没有密钥」在 **argv 日志为空** 时恒为真。 +⇒ 判据 1 先断言 argv 日志非空且含目标主机(探针确实被调用过), + 再断言里面没有密钥。这是**正向锚点**,不是可有可无的检查。 用法: python3 tools/selftest-cluster-selfreport.py """ -import hashlib import os import re import shutil @@ -48,8 +53,9 @@ SCRIPT_REL = os.path.join('deploy', 'tee', 'real-machine', 'cluster-selfreport-e2e.sh') SCRIPT = os.path.join(ROOT, SCRIPT_REL) -# ★ 用**中性标记**,别用像密钥的串 —— 沙箱会拦「像密钥」的命令行。 -MARKER = 'ZZMARKERZZ0123456789abcdefXY' +# ★ 中性标记,长度 >= 32(脚本要求共享密钥至少 32 字节),别用像真密钥的串。 +MARKER = 'ZZMARKERZZ0123456789abcdefXY0123456789' +HOST = '192.168.1.102' OK_N = 0 FAIL_N = 0 @@ -67,19 +73,65 @@ def fail(msg): print('FAIL %s' % msg, file=sys.stderr) -def _fake_ssh(bindir, logpath): - """假 sshpass:把 ssh 收到的**全部 argv** 记进 logpath。 +def _read_script(): + with open(SCRIPT, encoding='utf-8') as f: + return f.read() - ★ 这就是远端 `ps` 能看到的命令行 —— 密钥只要在里面就是泄露。 + +def _strip_comments(src): + """剥掉注释行 + 行内注释 ⇒ 只看**代码**。 + + ★ 判据查注释会「自指型假绿」(删了代码注释还在照样绿); + 查裸字符串会「自指型假红」(注释里的历史说明把自己判红)。 """ + return '\n'.join(ln.split(' #')[0] for ln in src.splitlines() + if not ln.strip().startswith('#')) + + +def _extract_fn(src, name): + """从脚本里抽出 `name() { ... }` 的完整源码(按行首 `}` 收尾)。""" + start = src.find('\n%s() {' % name) + if start < 0: + return None + start += 1 + end = src.find('\n}', start) + if end < 0: + return None + return src[start:end + 2] + + +# ── 假 xop / 假 sshpass ──────────────────────────────────────────────── +def _fake_bin(bindir, logpath): + """造两个假命令,让 remote() 在**完全离线**的环境里跑起来。""" os.makedirs(bindir, exist_ok=True) - p = os.path.join(bindir, 'sshpass') - with open(p, 'w', encoding='utf-8') as f: + + # 假 xop:跳过 `run` 子命令、`--secret K=V` / `--`,注入哑变量, + # 然后 exec 剩余命令。★ 不解密任何真实口令 ⇒ 门禁不依赖保险库是否解锁。 + with open(os.path.join(bindir, 'xop'), 'w', encoding='utf-8') as f: + f.write( + '#!/usr/bin/env bash\n' + '[ "${1:-}" = run ] && shift\n' + 'while [ $# -gt 0 ]; do\n' + ' case "$1" in\n' + ' --secret) shift 2;;\n' + ' --) shift; break;;\n' + ' *) break;;\n' + ' esac\n' + 'done\n' + 'export SSHPASS=selftest-dummy\n' + 'export TEE_USER=selftest-dummy-user\n' + 'exec "$@"\n' + ) + os.chmod(os.path.join(bindir, 'xop'), 0o755) + + # 假 sshpass:把 ssh 收到的**全部 argv** 记下来(= 远端 ps 能看到的), + # 然后消费掉 stdin(模拟远端脚本被读走),不产生任何 stdout。 + with open(os.path.join(bindir, 'sshpass'), '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' + ' -e) shift; continue;;\n' ' SSHPASS=*) shift; continue;;\n' ' esac\n' ' break\n' @@ -88,37 +140,38 @@ def _fake_ssh(bindir, logpath): 'cat > /dev/null\n' 'exit 0\n' % logpath ) - os.chmod(p, 0o755) + os.chmod(os.path.join(bindir, 'sshpass'), 0o755) -def _run_script(src_text, timeout=120): - """在假 ssh 环境里跑脚本,返回 (ssh_argv_list, returncode)。 +def _run_remote_probe(remote_text, body, timeout=30): + """把 `remote()` 单独跑起来,返回 argv 列表。 - ★ 脚本本身会走完整个流程(起控制面、起 hostd、查注册表), - 假 ssh 一律返回空输出 ⇒ 脚本里的判据会红 —— 但那不重要, - 我们要看的是**argv 里有没有密钥**。 + ★ 只跑函数,不跑整份脚本 —— 整份脚本会被「控制面没起来」之类的 + 业务判据提前 `exit`,探针根本走不到后面的调用点 ⇒ 假绿。 + ★ `body` 里**故意放 `$CLUSTER_SECRET`**,模拟「本机把密钥展开进 + 脚本文本」这个历史坏形态。当前正确形态下正文走 stdin ⇒ argv 无密钥。 """ - workdir = tempfile.mkdtemp(prefix='csr-selftest-') + workdir = tempfile.mkdtemp(prefix='csr-probe-') try: - log = os.path.join(workdir, 'argv.log') bindir = os.path.join(workdir, 'bin') - _fake_ssh(bindir, log) + log = os.path.join(workdir, 'argv.log') + _fake_bin(bindir, log) - s = os.path.join(workdir, 'script.sh') - with open(s, 'w', encoding='utf-8') as f: - f.write(src_text) + harness = os.path.join(workdir, 'harness.sh') + with open(harness, 'w', encoding='utf-8') as f: + f.write('set -u\n') + f.write('SSHO="-o StrictHostKeyChecking=no"\n') + f.write('CLUSTER_SECRET="%s"\n' % MARKER) + f.write(remote_text + '\n') + # 双引号 ⇒ `$CLUSTER_SECRET` 在本机展开 ⇒ 密钥进了脚本文本。 + f.write('remote "%s" userkey passkey "%s"\n' + % (HOST, body.replace('"', '\\"'))) 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, + ['bash', harness], env=env, stdin=devnull, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, ) try: @@ -131,7 +184,7 @@ def _run_script(src_text, timeout=120): 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 + return argv finally: shutil.rmtree(workdir, ignore_errors=True) @@ -140,94 +193,82 @@ 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() +def _probe_really_fired(argv): + """★ 正向锚点:argv 日志非空且含目标主机 ⇒ 假 sshpass 真的被调起来了。""" + return bool(argv) and any(HOST in ln for ln in argv) + + +# ★ 2026-11-09 之前的**历史坏形态**:脚本正文(含本机展开的密钥)作为 +# ssh 的命令参数 ⇒ 进远端 ps。用它做「探针有效性」的构造样例: +# 探针必须能检出它,否则判据 1 等于恒绿。 +BROKEN_REMOTE = '''remote() { + sshpass -e ssh ${SSHO} "u@$1" "$4" +}''' +BROKEN_BODY = "MPC_HOSTD_SHARED_SECRET='$CLUSTER_SECRET' ./mpc control-plane serve" +GOOD_BODY = BROKEN_BODY # ── 判据 1:密钥不得进入 ssh 的 argv ────────────────────────────────── def check_secret_not_in_argv(): - """正向:当前形态 ⇒ argv 里**没有**密钥。""" + """正向:当前形态 ⇒ argv 里**没有**密钥(且探针确实 fired)。""" src = _read_script() - argv, _ = _run_script(src) + fn = _extract_fn(src, 'remote') + if fn is None: + fail('判据 1·正向:脚本里找不到 remote() 函数') + return + argv = _run_remote_probe(fn, GOOD_BODY) + if not _probe_really_fired(argv): + fail('判据 1·正向:探针没 fired(argv 日志为空/无主机)—— ' + '此时「没有密钥」是恒真,不能算通过') + return 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(当前形态)') + ok('判据 1·正向:探针已 fired,且密钥不进 ssh argv(当前形态)') def check_secret_argv_leak_is_detectable(): - """反向:改回旧形态 ⇒ **必须**检出泄露。 + """反向:用**历史坏形态**构造样例 ⇒ **必须**检出泄露(证明探针不是恒绿)。 - ★ 这一步是「判据不是恒绿」的证据 —— - 不破坏一次,就不知道判据 1 是在真检还是恒绿。 + ★ 为什么用构造样例而不是「变异当前实现」:当前实现的结构会随 + fd 分流/TTY 分支调整而变,按字面量变异会让探针本身失效(假阴性)。 + 构造样例是**已知会泄露**的独立样本,正反两侧都稳定。 """ - 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 形态(脚本结构变了?)') + if 'sshpass -e ssh' not in BROKEN_REMOTE or '"$4"' not in BROKEN_REMOTE: + fail('判据 1·反向:构造样例本身不含 argv 形态(样本写坏了)') 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·反向:找不到控制面启动段(脚本结构变了?)') + argv = _run_remote_probe(BROKEN_REMOTE, BROKEN_BODY) + if not _probe_really_fired(argv): + fail('判据 1·反向:构造样例的探针没 fired —— 无法判定') return - - argv, _ = _run_script(broken2) if _argv_has_secret(argv): - ok('判据 1·反向:旧形态下密钥确实进 argv(探针有效)') + ok('判据 1·反向:argv 形态下密钥确实进 argv(探针有效)') else: - fail('判据 1·反向:旧形态也没检出泄露 —— 探针恒绿,无效') + fail('判据 1·反向:argv 形态也没检出泄露 —— 探针恒绿,无效') # ── 判据 2:否定式判据必须配正向对照 ────────────────────────────────── def check_registry_verdict_has_positive_anchor(): """★ 静态判据:注册表那段必须**同时**有正向锚点与否定式判据。 - ★ 为什么这条重要: - 「注册表里没有全零度量」是**否定式**。若 `nodes` 为空 - (curl 失败 / 控制面没起 / 鉴权被拒)⇒ grep 找不到全零 ⇒ 恒通过。 - ⇒ 必须先断言注册表里**确实有**节点/度量字段,再断言没有全零。 + 「注册表里没有全零度量」是**否定式**。若 `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」这个锚点)') + fail('判据 2:注册表判据缺正向对照的**代码**(没有取 measurement 计数并断言 >= 1)') return if not has_negative: fail('判据 2:注册表判据缺否定式(全零度量检查)') @@ -235,18 +276,9 @@ def check_registry_verdict_has_positive_anchor(): ok('判据 2:注册表判据 = 正向锚点(代码)+ 否定式,配对齐全') +# ── 判据 3:错密钥 401 必须前置正向对照 ────────────────────────────── def check_wrong_key_verdict_has_positive_control(): - """★ 静态判据:错密钥 401 必须**先**跑正确密钥 200 的正向对照。 - - ★ 为什么:控制面没起来时 curl 连不上,HTTP 码是 `000`, - `000 != 200` ⇒ 只判「错密钥不是 200」会**恒通过** ⇒ 假绿。 - - ★★ **只查代码,不查注释** —— - 2026-11-09 实测踩到:判据原本查的是注释里的「正确密钥」字样, - 而破坏实验删掉的是**整段代码** ⇒ 注释还在 ⇒ 判据照样绿 - ⇒ **自指型假绿**。 - ⇒ 现在查**代码形态**:`code_ok=` 赋值 + 与 `200` 的比较 + 位置在负向**之前**。 - """ + """★ 控制面没起来时 curl 返回 `000`,`000 != 200` ⇒ 只判「不是 200」恒通过。""" src = _read_script() idx = src.find('错密钥 401') if idx < 0: @@ -256,10 +288,9 @@ def check_wrong_key_verdict_has_positive_control(): 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 的比较(只是取了个码却没断言)') + fail('判据 3:正向对照代码里没有与 200 的比较') return if pos_code > idx: fail('判据 3:正向对照在负向**之后**(顺序反了 ⇒ 控制面没起时会假绿)') @@ -269,64 +300,54 @@ def check_wrong_key_verdict_has_positive_control(): # ── 判据 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` 一个名字 ⇒ 换个写法就绕过去了(假绿)。 - ⇒ 判据在**密钥赋值语句**附近找「编码工具链」。 + ★★ 作用域铁律(2026-11-09 踩过):全文扫 `od -An -tx1` 会误伤 + **本地熵源** `CLUSTER_SECRET=$(od -An -tx1 -N32 /dev/urandom | ...)` —— + 那是从内核随机数**生成**密钥,不是把密钥**编码**成另一种形态。 + ⇒ 只扫「密钥流经的语句」:提到密钥变量名、且**不含熵源特征**的行。 """ 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) - - # ★ 编码工具链特征(都是「把字节流变成另一种文本」的典型手法) + code = _strip_comments(src) 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)) + entropy = ('/dev/urandom', '/dev/random', 'openssl rand', 'rand -hex') + secret_names = ('MPC_HOSTD_SHARED_SECRET', 'CLUSTER_SECRET', + 'MPC_CLUSTER_SECRET', 'SECRET=', 'cluster.secret') + + bad = [] + for ln in code.splitlines(): + if not any(n in ln for n in secret_names): + continue + if any(e in ln for e in entropy): + continue # ★ 熵源不是编码,放行 + for e in encoders: + if e in ln: + bad.append((e, ln.strip()[:120])) + break + if bad: + fail('判据 4:**密钥流经的语句**里出现了编码工具链 %s —— 口径又分叉了' + % '、'.join(e for e, _ in bad)) + for e, ln in bad[:3]: + print(' > [%s] %s' % (e, ln), file=sys.stderr) return - # ★ 更精确的一层:密钥**值**里不许带管道。 - # ★ 别误伤合法的 `... | head -3`(截输出,不是加工密钥)—— - # 只看 `MPC_HOSTD_SHARED_SECRET=` **紧跟的那个值**: - # 值的范围 = 从赋值号起,到下一个「命令分隔」为止 - # (分隔 = `&&`、换行、或行尾的 `\` 续行)。 - import re as _re + # ★ 更精确的一层:`MPC_HOSTD_SHARED_SECRET=` **紧跟的值**里不许带管道。 + # 别误伤合法的 `... | head -3`(截输出,不是加工密钥)。 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) + m = re.search(r'MPC_HOSTD_SHARED_SECRET=([^\s&]*)', ln) + if m and '|' in m.group(1): + fail('判据 4:密钥值里带了管道(%s)—— 不该再加工密钥' % m.group(1)) return - - ok('判据 4:鉴权口径统一为明文(代码里无密钥编码工具链;注释里的历史说明不算)') + ok('判据 4:鉴权口径统一为明文(密钥流经语句无编码链;熵源不算)') +# ── 判据 5:Rust 侧唯一口径 ─────────────────────────────────────────── def check_rust_secret_token_guard_exists(): """★ 跨语言判据:Rust 侧必须有 `secret_token` 这份**唯一口径**。 - ★ 2026-11-09 实测过的坑: - 控制面下发用 `hex_encode(s)`、节点侧校验明文 ⇒ 全部 401。 - 口径必须落在**一份代码**里 —— `mpc_hostd::auth::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') @@ -347,6 +368,98 @@ def check_rust_secret_token_guard_exists(): ok('判据 5:Rust 侧有唯一口径 auth::secret_token,且 control_plane 在用') +# ── 判据 6:密钥送达必须当场校验 ────────────────────────────────────── +def check_key_delivery_is_verified(): + """★ `remote_put` 丢了 stdin ⇒ 远端文件 0 字节 ⇒ 远端读空密钥 ⇒ 全 401, + 症状却是「自报收不到」,极难往「密钥没送达」上想 ⇒ 必须当场量长度。 + """ + src = _read_script() + has_len_check = ('wc -c <' in src and 'got_len' in src + and 'want_len' in src) + if not has_len_check: + fail('判据 6:没有「密钥送达长度校验」的代码 —— 密钥可能根本没送到远端') + return + seg = src[src.find('got_len'):src.find('got_len') + 800] + if 'exit 1' not in seg: + fail('判据 6:密钥长度不符时没有「立刻失败」(exit 1)—— 空密钥会流到后面') + return + ok('判据 6:密钥送达有长度校验且不符即失败') + + +# ── 判据 7:remote_put 不得无条件断开 stdin ─────────────────────────── +def check_remote_put_keeps_stdin(): + """★ 无条件 `< /dev/null` 会把**管道内容**整个丢掉(真机实测 0 字节)。""" + src = _read_script() + i = src.find('remote_put()') + if i < 0: + fail('判据 7:脚本里找不到 remote_put()') + return + j = src.find('\n}', i) + body = src[i:j if j > 0 else i + 1200] + code = _strip_comments(body) + if '< /dev/null' not in code: + ok('判据 7:remote_put 不重定向 stdin(管道内容不会丢)') + return + if '-t 0' in code: + ok('判据 7:remote_put 仅在 stdin 是 TTY 时才断开(管道场景安全)') + return + fail('判据 7:remote_put 无条件 `< /dev/null` ⇒ 管道内容会被丢掉') + + +# ── 判据 8:凭据必须经 xop 子进程使用 ───────────────────────────────── +def check_xop_subprocess_credential_path(): + """★ xop 的 FileGuard 在**打印**时把值掩码 ⇒ 「先取到 shell 变量再用」是死路。 + 正确形态:ssh 跑在 xop 子进程里,`SSHPASS` 由 xop 注入(`xop -h` 的 `--secret`)。 + + 注意 `xop_probe` 把 `${#V}`(**长度**)取进变量是**合法**的 —— + 长度不是口令,且经过 `grep -E '^[0-9]+$'` 过滤。判据只禁「把明文取出」。 + """ + src = _read_script() + bad = [] + for ln in src.splitlines(): + if 'xop get -v' in ln: + bad.append(ln.strip()) + # 把 xop 输出直接赋给口令/密钥类变量 + if re.search(r'\b(SSHPASS|PASS|PASSWORD|SECRET|TOKEN)=\$\(xop\b', ln): + bad.append(ln.strip()) + if bad: + fail('判据 8:脚本把 xop 的明文输出取进 shell 变量 —— FileGuard 会掩码它') + for b in bad[:3]: + print(' > %s' % b[:140], file=sys.stderr) + return + if 'xop run --secret' in src and 'sshpass -e' in src: + ok('判据 8:凭据经 xop 子进程使用(sshpass -e 读注入的环境变量)') + return + fail('判据 8:找不到「xop 子进程内跑 ssh」的形态 —— 凭据路径不确定') + + +# ── 判据 9:xop 噪声必须与远端输出隔离 ──────────────────────────────── +def check_remote_output_is_isolated_from_xop_noise(): + """★ xop 把 `WARN ...setup() is STUBBED` 打在 **stdout**(实测 2026-11-09)。 + + 若 remote() 直接 `2>&1` 合并返回,`$(remote ... "wc -c < ...")` 拿到的 + 是两行 WARN 而不是字节数 ⇒ 密钥送达校验必然失败;`sha256sum` 度量也 + 拿不到 64 字节 ⇒ 两个节点都起不来。症状却完全不像「输出被污染」。 + ⇒ 必须有 fd3 分流(远端 stdout/stderr → fd3,xop stdout → /dev/null)。 + """ + src = _read_script() + fn = _extract_fn(src, 'remote') + if fn is None: + fail('判据 9:脚本里找不到 remote() 函数') + return + code = _strip_comments(fn) + if '1>&3' not in code or '3>"' not in code: + fail('判据 9:remote() 没有 fd3 分流 ⇒ xop 的 WARN 会污染返回值') + return + if '>/dev/null' not in code: + fail('判据 9:remote() 没有把 xop 自己的 stdout 丢掉 ⇒ WARN 仍会混进来') + return + if 'cat "$_out"' not in code or 'rm -f "$_out"' not in code: + fail('判据 9:remote() 没有「回读 + 清理」临时文件 ⇒ 返回值不确定/会留垃圾') + return + ok('判据 9:remote() 用 fd3 隔离 xop 噪声,返回值只剩远端输出') + + def main(): print('=== 集群自报判据自测 ===') if not os.path.exists(SCRIPT): @@ -359,6 +472,10 @@ def main(): check_wrong_key_verdict_has_positive_control() check_auth_token_plaintext_not_hex() check_rust_secret_token_guard_exists() + check_key_delivery_is_verified() + check_remote_put_keeps_stdin() + check_xop_subprocess_credential_path() + check_remote_output_is_isolated_from_xop_noise() print('') print('=== 结果:%d 通过 / %d 失败 ===' % (OK_N, FAIL_N))