feat(tee): KBS 客户端 + 证明结构校验,OCI 打包与真机编排资产入仓

- mpc-tee 新增 kbs.rs(最小 HTTP/1.1 KBS 客户端 + fail-closed 校验 + KbsKeySource 替代内置 PSK)、verify.rs(SNP 报告结构解析 + 可插拔外部芯片验签器 + verify_attestation 显式区分「芯片签名未验证」)。
- mpc-cli 新增 mpc tee verify / mpc tee kbs-get 子命令。
- catalog.rs 补 verify/kbs 模块到 TEE 直接调度段并加回归断言(清单铁律)。
- deploy/tee 新增 oci/(分层镜像构建)、kbs/(serve stub)、guest/(init)、real-machine/(跨机双 guest 编排);docs/TEE_OCI_PATH.md 记录 Kata 实测复核(仅 AMD 有、海光无且不支持 CSV,不引入)与 e2b 远程调度接口参考。
- 影响:密钥经 KBS 注入(不再内置明文 PSK),证明结论如实区分结构与芯片验签;远程调度走 OCI digest + 框架选节点,不引入 Kata/e2b 依赖。
- 测试:./tools/ci.sh 四道全绿;mpc-tee 单测 73→86。
This commit is contained in:
admin committed 2026-11-06 19:33:53 +08:00
1 parent 783761cb26
commit 5dec915185
16 files changed
+2321 -2

No files matched your search

+153
View File
@@ -0,0 +1,153 @@
#!/bin/busybox sh
# ssw-mpc TEE guest 的 PID 1(由 deploy/tee/oci/oci-image.py 放到 /init)。
#
# 启动顺序是 fail-closed 的:
# 1. 挂 /proc /sys /dev
# 2. 校验 OCI 层 digest 链(layers.sha256)
# 3. 校验 cmdline 里的 manifest digest 与镜像内的一致
# 4. 由 KBC/KBS 取回本轮会话的 PSK / seed / 根密钥(不再内置明文)
# 5. 才允许启动 mpc 做跨机密文会话
#
# 任何一步失败就 halt,绝不「先跑起来再说」。
#
# 边界:层 digest 校验防的是分发/拉取过程中的层被替换;能同时改 initrd 里
# /init 与校验清单的宿主不在防御范围内。芯片证明代理与证书链验签由验证方 /
# KBS 负责,这里只消费它的产物(token 文件),不自己验签。
set -u
BB=/bin/busybox
OCI=/etc/mpc-tee/oci
RUN=/run/mpc-tee
MPC=/mpc
$BB mkdir -p /proc /sys /dev "$RUN"
$BB mount -t proc proc /proc 2>/dev/null || true
$BB mount -t sysfs sysfs /sys 2>/dev/null || true
$BB mount -t devtmpfs devtmpfs /dev 2>/dev/null || true
echo "===== MPC TEE GUEST BOOT (OCI layers) ====="
echo "kernel: $($BB uname -r)"
echo "cmdline: $($BB cat /proc/cmdline)"
cmdval() {
$BB sed -n "s/.*$1=\\([^ ]*\\).*/\\1/p" /proc/cmdline | $BB head -n 1
}
USER_DATA=$(cmdval 'mpc\.tee\.user_data')
SITE=$(cmdval 'mpc\.tee\.site')
EXPECT_MANIFEST=$(cmdval 'mpc\.tee\.manifest')
SESSION=$(cmdval 'mpc\.tee\.session')
KBC=$(cmdval 'mpc\.tee\.kbs')
ROLE=$(cmdval 'mpc\.role')
PORT=$(cmdval 'mpc\.tee\.port')
[ -n "${PORT:-}" ] || PORT=19444
echo "site=${SITE:-none} role=${ROLE:-none} session_len=${#SESSION}"
if [ -e /dev/sev-guest ]; then echo "SNP device: present"; else echo "SNP device: absent"; fi
# --- 2. 逐层校验 OCI digest 链 -------------------------------------------------
if [ ! -f "$OCI/layers.sha256" ]; then
echo "FATAL: 镜像缺少 OCI 层校验清单"
$BB halt -f 2>/dev/null || exit 1
fi
if ! ( cd "$OCI" && $BB sha256sum -c layers.sha256 ); then
echo "FATAL: OCI 层或 manifest/config 的 digest 与声明不符"
$BB halt -f 2>/dev/null || exit 1
fi
echo "oci_layers: verified"
# --- 3. 把镜像度量钉到启动参数 ------------------------------------------------
ACTUAL_MANIFEST=$($BB cat /etc/mpc-tee/manifest.digest)
if [ -z "$EXPECT_MANIFEST" ] || [ "$EXPECT_MANIFEST" != "$ACTUAL_MANIFEST" ]; then
echo "FATAL: cmdline 的 manifest digest 与镜像不一致 (expect=${EXPECT_MANIFEST:-none})"
$BB halt -f 2>/dev/null || exit 1
fi
if [ -z "$USER_DATA" ]; then
echo "FATAL: cmdline 没有会话绑定值"
$BB halt -f 2>/dev/null || exit 1
fi
echo "manifest_digest=$ACTUAL_MANIFEST"
echo "user_data=$USER_DATA"
# --- 4. KBC 取密钥 -------------------------------------------------------------
# 在线:cc_kbc::http://HOST:PORT —— 由 mpc 自带的 KBS 客户端取资源
# 离线:offline_fs_kbc::null —— 仅演练,镜像里带固定测试密钥,显式警告
TOKEN=offline-demo
if [ -f "$RUN/attestation.token" ]; then
TOKEN=$($BB cat "$RUN/attestation.token")
echo "attestation_token: from guest agent"
else
echo "WARNING: 未找到证明代理 token,使用离线演练占位值(生产必须提供)"
fi
case "$KBC" in
cc_kbc::http://*)
ENDPOINT=${KBC#cc_kbc::http://}
ENDPOINT=${ENDPOINT%/}
echo "kbs_endpoint=$ENDPOINT"
for kind in psk seed root-key; do
if ! "$MPC" tee kbs-get --endpoint "$ENDPOINT" \
--session "$SESSION" --kind "$kind" --token "$TOKEN" \
--out "$RUN/$kind"; then
echo "FATAL: KBS 资源 $kind 取回失败"
$BB halt -f 2>/dev/null || exit 1
fi
done
PSK_FILE="$RUN/psk"
SEED=$($BB cat "$RUN/seed")
echo "key_source=kbs"
;;
offline_fs_kbc::null)
echo "WARNING: 离线演练密钥,PSK/seed/root-key 内置在镜像里,禁止用于生产"
for kind in psk seed root-key; do
if [ ! -f "/etc/mpc-tee/offline/$kind" ]; then
echo "FATAL: 离线密钥缺失: $kind"
$BB halt -f 2>/dev/null || exit 1
fi
$BB cp "/etc/mpc-tee/offline/$kind" "$RUN/$kind"
done
PSK_FILE="$RUN/psk"
SEED=$($BB cat "$RUN/seed")
echo "key_source=offline-demo"
;;
*)
echo "FATAL: 未知 KBC 模式: ${KBC:-none}"
$BB halt -f 2>/dev/null || exit 1
;;
esac
echo "--- mpc selfcheck / selftest ---"
"$MPC" selfcheck --file "$MPC"
"$MPC" selftest | tail -6
# --- 5. 网络与跨机密文会话 ---------------------------------------------------
IFACE=$($BB ls /sys/class/net | $BB grep -v '^lo$' | $BB head -n 1)
echo "iface=${IFACE:-none}"
case "$ROLE" in
alice) ADDR=10.0.0.1/24 ;;
bob) ADDR=10.0.0.2/24 ;;
*) ADDR= ;;
esac
if [ -n "${IFACE:-}" ] && [ -n "$ADDR" ]; then
$BB ip link set "$IFACE" up 2>/dev/null || true
$BB ip addr add "$ADDR" dev "$IFACE" 2>/dev/null || true
$BB ip addr show "$IFACE" 2>/dev/null | $BB head -n 5 || true
fi
case "$ROLE" in
alice)
"$MPC" node --site alice --sites alice,bob \
--listen 0.0.0.0:"$PORT" --data 1,2,3 \
--seed "$SEED" --psk-file "$PSK_FILE"
;;
bob)
"$MPC" node --site bob --sites alice,bob \
--connect 10.0.0.1:"$PORT" --data 4,5,6 \
--seed "$SEED" --psk-file "$PSK_FILE"
;;
*)
echo "(no role: guest selftest only)"
;;
esac
echo "===== MPC TEE GUEST DONE ====="
$BB halt -f 2>/dev/null || true
+112
View File
@@ -0,0 +1,112 @@
#!/usr/bin/env python3
"""可复现的 KBS 资源下发 stub(仅用于本地 / 真机演练)。
**这不是 Trustee / KBS,也不做芯片证明校验**。它只提供最小的
`GET /kbs/v0/resource/<repo>/<tag>/<kind>` 资源接口,让 guest 内的
`mpc tee kbs-get` 有东西可取,从而把「PSK 内置 initrd」换成
「按会话从 KBS 取」。
生产必须换成带远程证明校验的 KBS:由它验证 SNP/CSV 报告、证书链与
measurement 后才下发密钥。本 stub 只检查请求头里的 session 与 token
是否匹配启动参数,token 是占位字符串时(非 --strict)会放行并告警。
资源目录布局:
<resources>/mpc/<session_id_64hex>/psk
<resources>/mpc/<session_id_64hex>/seed
<resources>/mpc/<session_id_64hex>/root-key
Python 3.6 兼容(海光 Anolis 8.10)。
"""
import argparse
import os
import sys
from http.server import BaseHTTPRequestHandler, HTTPServer
PREFIX = "/kbs/v0/resource/"
DEMO_TOKEN = "offline-demo"
def make_handler(resources, session, strict):
class Handler(BaseHTTPRequestHandler):
server_version = "mpc-tee-kbs-stub/1.0"
def log_message(self, fmt, *args):
sys.stderr.write("[kbs] %s\n" % (fmt % args))
def _deny(self, code, reason):
body = ("denied: %s" % reason).encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", "text/plain; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self):
path = self.path.split("?", 1)[0]
if not path.startswith(PREFIX):
return self._deny(404, "unknown path")
parts = path[len(PREFIX):].split("/")
if len(parts) != 3 or not all(parts):
return self._deny(400, "expected /<repo>/<tag>/<kind>")
repo, tag, kind = parts
allowed = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz0123456789._-")
if any(not set(p) <= allowed for p in parts):
return self._deny(400, "illegal resource component")
got_session = self.headers.get("MPC-Tee-Session", "")
token = self.headers.get("MPC-Tee-Attestation", "")
if got_session != session or tag != session:
return self._deny(403, "session mismatch")
if not token:
return self._deny(403, "missing attestation token")
if strict and token == DEMO_TOKEN:
return self._deny(403, "demo token rejected in strict mode")
if token == DEMO_TOKEN:
sys.stderr.write("[kbs] WARNING: 放行占位证明 token(演练模式)\n")
full = os.path.abspath(os.path.join(resources, repo, tag, kind))
base = os.path.abspath(os.path.join(resources, repo, tag))
if not (full == base or full.startswith(base + os.sep)):
return self._deny(400, "path traversal")
if not os.path.isfile(full):
return self._deny(404, "resource not found")
with open(full, "rb") as f:
body = f.read()
self.send_response(200)
self.send_header("Content-Type", "application/octet-stream")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_POST(self):
self._deny(405, "read-only stub")
return Handler
def main():
ap = argparse.ArgumentParser(description="KBS 资源下发 stub(演练用)")
ap.add_argument("--resources", required=True, help="资源根目录")
ap.add_argument("--session", required=True, help="本轮会话 id(64 位十六进制)")
ap.add_argument("--host", default="127.0.0.1")
ap.add_argument("--port", type=int, default=18080)
ap.add_argument("--strict", action="store_true",
help="拒绝 offline-demo 占位 token(生产应开启)")
args = ap.parse_args()
if not os.path.isdir(args.resources):
sys.exit("资源目录不存在: %s" % args.resources)
srv = HTTPServer((args.host, args.port),
make_handler(args.resources, args.session, args.strict))
sys.stderr.write("[kbs] stub listening %s:%d strict=%s\n" %
(args.host, args.port, args.strict))
sys.stderr.write("[kbs] 提醒:这是演练 stub,生产请用带证明校验的 KBS\n")
try:
srv.serve_forever()
except KeyboardInterrupt:
pass
return 0
if __name__ == "__main__":
sys.exit(main())
+67
View File
@@ -0,0 +1,67 @@
# OCI 分层镜像(无容器运行时依赖)
`oci-image.py` 用 Python 3 标准库直接生成 OCI image layout。真机现场只有
`docker` / `runc`,没有 `buildah` / `podman` / `krunvm`,所以这里不调用任何
容器运行时,也不需要 registry 就能本地构建与校验。
## 三步
```bash
# 0) 准备 base rootfs:现成 alpine rootfs 目录(含 busybox 与 musl loader)
# macOS 上可直接用宿主解出的目录;真机上 /opt/.../kata-alpine-*.initrd
# 用 `gzip -dc | cpio -idm` 解出来即可。
# 1) 构建分层镜像(base / mpc / init)
python3 oci-image.py build \
--base /path/to/alpine-rootfs \
--mpc /path/to/mpc-linux-x86_64 \
--init ../guest/init.sh \
--out ./image
# 2) 校验 digest 链(index → manifest → config → layers,含 diff_id)
python3 oci-image.py verify --image ./image
# 3) 校验通过后按层解包,打成 qemu 直接启动用的 initrd
python3 oci-image.py pack --image ./image --out ./mpc-initrd.img
```
`build` 与 `pack` 都打印:
```text
manifest_digest=<64hex> # 就是 SessionBinding.code_measurement
measurement=<64hex> # 写进节点描述的 measurement=
initrd_sha256=<64hex> # 分发完整性用
```
把 `measurement` 填进 `deploy/tee/nodes/*.node` / `real-machine/nodes/*.node`,
并在启动 guest 时把 `mpc.tee.manifest=<64hex>` 钉进内核参数
(`real-machine/run-guest.py` 从 `MPC_TEE_MANIFEST` 读取,缺失即 fail-closed 拒绝启动)。
## 层契约
| 层 | 内容 | 说明 |
|---|---|---|
| `base` | 整个 rootfs 目录 | 排序 + 固定 uid/gid/mtime,保证可复现 |
| `mpc` | `/mpc` | Linux 静态二进制,0755 |
| `init` | `/init` | `../guest/init.sh`,0755,后层覆盖 base 自带 init |
| `offline`(可选) | `/etc/mpc-tee/offline/{psk,seed,root-key}` | **仅离线演练**,`--offline-dir` 开启时会打印警告,禁止上生产 |
`pack` 会把每层 tar.gz、manifest.json、config.json、`layers.json` 与
`layers.sha256` 一起放进 initrd 的 `/etc/mpc-tee/oci/`。guest init 先
`sha256sum -c layers.sha256`,再核对 cmdline 的 manifest digest,全部通过才启动 `mpc`。
## 为什么 measurement 取 manifest digest
`SessionBinding` 的 `code_measurement` 是 32 字节,正好是 sha256。用 manifest
digest 而不是「mpc 二进制的哈希」,是因为真正决定 guest 行为的是整套层
(rootfs + 二进制 + init),换任何一层都应让旧证明失效。这也让 registry 的
按 digest 拉取与框架的 `--pin` 判定天然对齐。
## 边界
- 层 digest 校验防的是**分发过程被替换**;能同时改 initrd 里 `/init` 与校验清单的
宿主不在防御范围内。硬件级启动度量要靠 SNP/CSV 证明,见 `docs/TEE_OCI_PATH.md`。
- 本工具只产出物料,**不启动任何东西**;执行仍走 `deploy/tee/real-machine/` 或
`deploy/tee/launch.sh` 的 qemu 后端。
- 兼容 Python 3.6(海光 Anolis 8.10):不用 `capture_output`、walrus、
`gzip.compress(mtime=)`。
+472
View File
@@ -0,0 +1,472 @@
#!/usr/bin/env python3
"""ssw-mpc TEE guest 镜像:OCI 分层构建 / 校验 / 打包成 initrd。
现场两台真机只有 docker + runc,没有 buildah / podman / krunvm,所以这里用
Python 标准库直接生成 OCI image layout,不依赖任何容器运行时。
三层(顺序固定,后层覆盖前层):
base 现成 rootfs 目录(alpine + busybox + musl loader)
mpc 静态 mpc 二进制,落在 /mpc
init guest init 脚本,落在 /init
**度量契约**:`SessionBinding.code_measurement` = OCI manifest 的 sha256
(去掉 `sha256:` 前缀的 32 字节)。改一行 guest init、换一个二进制,
manifest digest 就变,证明里的绑定值跟着变,旧报告自然重放不了。
`pack` 会把每层的 tar.gz 连同 manifest/config 一起放进 initrd,并生成
`layers.sha256` 清单;guest init 先逐层校验 digest 才允许启动 mpc。
这道校验防的是「分发/拉取过程中层被替换」,**不替代芯片对启动镜像的
度量** —— 能同时改 initrd 里 /init 与清单的宿主不在防御范围内,见
docs/TEE_OCI_PATH.md 的边界说明。
兼容 Python 3.6(海光 Anolis 8.10 自带 3.6):不用 capture_output、不用
walrus、不用 gzip.compress 的 mtime 参数。
"""
import argparse
import gzip
import hashlib
import io
import json
import os
import shutil
import stat
import sys
import tarfile
import tempfile
LAYER_MEDIA = "application/vnd.oci.image.layer.v1.tar+gzip"
CONFIG_MEDIA = "application/vnd.oci.image.config.v1+json"
MANIFEST_MEDIA = "application/vnd.oci.image.manifest.v1+json"
SCHEME = "mpc-tee/oci-layers/v1"
MAX_LAYER_BYTES = 128 * 1024 * 1024
def sha256_hex(data):
return hashlib.sha256(data).hexdigest()
def jbytes(obj):
return json.dumps(obj, sort_keys=True, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
def gzip_deterministic(data):
"""固定 mtime / filename,保证同样输入产出同样 digest。"""
buf = io.BytesIO()
with gzip.GzipFile(fileobj=buf, mode="wb", compresslevel=9,
mtime=0, filename="") as gz:
gz.write(data)
return buf.getvalue()
def normalize(info):
info.uid = 0
info.gid = 0
info.uname = "root"
info.gname = "root"
info.mtime = 0
return info
def tar_from_dir(root):
"""把目录打成确定性 tar(排序 + 固定元信息)。"""
buf = io.BytesIO()
with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tf:
tf.add(root, arcname=".", recursive=False, filter=normalize)
for cur, dirs, files in os.walk(root):
dirs.sort()
files.sort()
for name in dirs + files:
full = os.path.join(cur, name)
rel = os.path.relpath(full, root)
tf.add(full, arcname=rel, recursive=False, filter=normalize)
return buf.getvalue()
def tar_from_files(entries):
"""entries: [(arcname, 文件绝对路径 or None(目录), 内容 bytes or None, 模式)]。"""
buf = io.BytesIO()
with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tf:
for arc, src, content, mode in entries:
if content is None:
ti = tarfile.TarInfo(arc)
ti.type = tarfile.DIRTYPE
ti.mode = mode
tf.addfile(ti)
continue
if src is not None:
with open(src, "rb") as f:
content = f.read()
ti = tarfile.TarInfo(arc)
ti.size = len(content)
ti.mode = mode
tf.addfile(ti, io.BytesIO(content))
return buf.getvalue()
def blob_path(image, digest):
return os.path.join(image, "blobs", "sha256", digest)
def write_blob(image, data):
digest = sha256_hex(data)
path = blob_path(image, digest)
if not os.path.isdir(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
if not os.path.exists(path):
with open(path, "wb") as f:
f.write(data)
return digest, len(data)
def read_blob(image, descriptor):
digest = descriptor.get("digest", "")
if not digest.startswith("sha256:") or len(digest) != 71:
raise ValueError("descriptor digest 不是 sha256:<64hex>: %s" % digest)
h = digest[7:]
path = blob_path(image, h)
with open(path, "rb") as f:
data = f.read()
if sha256_hex(data) != h:
raise ValueError("blob 内容与 descriptor 不符: %s" % h)
if descriptor.get("size") != len(data):
raise ValueError("blob 大小与 descriptor 不符: %s" % h)
return h, data
def safe_extract(tf, dest):
"""拒绝路径穿越与绝对路径,只解常规文件/目录/符号链接。"""
for m in tf.getmembers():
p = m.name
if p.startswith("/") or ".." in p.split("/"):
raise ValueError("层内路径不安全: %s" % p)
if not (m.isfile() or m.isdir() or m.issym() or m.islnk()):
raise ValueError("层内含不支持的类型: %s (%s)" % (p, m.type))
tf.extractall(dest)
def build(args):
if not os.path.isdir(args.base):
sys.exit("base rootfs 目录不存在: %s" % args.base)
for p in (args.mpc, args.init):
if not os.path.isfile(p):
sys.exit("文件不存在: %s" % p)
image = os.path.abspath(args.out)
if os.path.exists(image):
shutil.rmtree(image)
os.makedirs(os.path.join(image, "blobs", "sha256"))
layer_specs = []
layer_specs.append(("base", tar_from_dir(args.base)))
layer_specs.append(("mpc", tar_from_files([
("mpc", args.mpc, None, 0o755),
])))
layer_specs.append(("init", tar_from_files([
("init", args.init, None, 0o755),
])))
if args.offline_dir:
entries = [("etc/mpc-tee/offline", None, None, 0o700)]
for name in sorted(os.listdir(args.offline_dir)):
src = os.path.join(args.offline_dir, name)
if os.path.isfile(src):
entries.append(("etc/mpc-tee/offline/" + name, src, None, 0o600))
layer_specs.append(("offline", tar_from_files(entries)))
diffs, layers = [], []
for idx, (name, tar_bytes) in enumerate(layer_specs):
if len(tar_bytes) > MAX_LAYER_BYTES:
sys.exit("层 %s 超过 %d 字节" % (name, MAX_LAYER_BYTES))
gz = gzip_deterministic(tar_bytes)
d, size = write_blob(image, gz)
diff = sha256_hex(tar_bytes)
diffs.append("sha256:" + diff)
layers.append({
"index": idx,
"name": name,
"digest": d,
"diff_id": diff,
"size": size,
"media_type": LAYER_MEDIA,
})
config = {
"architecture": "amd64",
"os": "linux",
"created": "1970-01-01T00:00:00Z",
"config": {"Cmd": ["/init"], "Env": ["PATH=/bin:/usr/bin"]},
"rootfs": {"type": "layers", "diff_ids": diffs},
"history": [{"created_by": "mpc-tee oci-image build"}],
}
config_digest, config_size = write_blob(image, jbytes(config))
manifest = {
"schemaVersion": 2,
"mediaType": MANIFEST_MEDIA,
"config": {
"mediaType": CONFIG_MEDIA,
"digest": "sha256:" + config_digest,
"size": config_size,
},
"layers": [{
"mediaType": LAYER_MEDIA,
"digest": "sha256:" + l["digest"],
"size": l["size"],
"annotations": {"mpc.tee.layer": l["name"]},
} for l in layers],
"annotations": {
"mpc.tee.measurement.scheme": "oci-manifest-digest",
"mpc.tee.spec": SCHEME,
},
}
manifest_digest, manifest_size = write_blob(image, jbytes(manifest))
index = {
"schemaVersion": 2,
"mediaType": "application/vnd.oci.image.index.v1+json",
"manifests": [{
"mediaType": MANIFEST_MEDIA,
"digest": "sha256:" + manifest_digest,
"size": manifest_size,
"annotations": {"org.opencontainers.image.ref.name": args.tag},
}],
}
with open(os.path.join(image, "oci-layout"), "wb") as f:
f.write(jbytes({"imageLayoutVersion": "1.0.0"}))
with open(os.path.join(image, "index.json"), "wb") as f:
f.write(jbytes(index))
layers_doc = {
"schema": SCHEME,
"manifest_digest": manifest_digest,
"config_digest": config_digest,
"measurement_scheme": "oci-manifest-digest",
"entrypoint": "/init",
"layers": layers,
}
with open(os.path.join(image, "layers.json"), "wb") as f:
f.write(jbytes(layers_doc))
with open(os.path.join(image, "manifest.digest"), "w") as f:
f.write(manifest_digest + "\n")
print("image=%s" % image)
print("manifest_digest=%s" % manifest_digest)
print("measurement=%s" % manifest_digest)
print("layers=%d" % len(layers))
for l in layers:
print(" [%d] %-8s %s (%d bytes)" %
(l["index"], l["name"], l["digest"], l["size"]))
if args.offline_dir:
print("WARNING: 镜像内含离线演练密钥层,禁止用于生产")
return 0
def verify(image):
"""按 index → manifest → config → layers 逐跳校验 digest 与 diff_id。"""
with open(os.path.join(image, "index.json"), "rb") as f:
index = json.loads(f.read().decode("utf-8"))
if index.get("schemaVersion") != 2 or not index.get("manifests"):
raise ValueError("index.json 不合法")
manifest_digest, manifest_bytes = read_blob(image, index["manifests"][0])
manifest = json.loads(manifest_bytes.decode("utf-8"))
if manifest.get("mediaType") != MANIFEST_MEDIA:
raise ValueError("manifest mediaType 不符")
config_digest, config_bytes = read_blob(image, manifest["config"])
config = json.loads(config_bytes.decode("utf-8"))
diffs = config.get("rootfs", {}).get("diff_ids", [])
layers = manifest.get("layers", [])
if len(diffs) != len(layers) or not layers:
raise ValueError("config.diff_ids 与 manifest.layers 数量不符")
checked = []
for i, desc in enumerate(layers):
digest, gz = read_blob(image, desc)
tar_bytes = gzip.decompress(gz)
diff = sha256_hex(tar_bytes)
if diffs[i] != "sha256:" + diff:
raise ValueError("层 %d 的 diff_id 与 config 不符" % i)
checked.append((digest, desc.get("annotations", {}).get(
"mpc.tee.layer", "layer%d" % i)))
layers_doc_path = os.path.join(image, "layers.json")
if os.path.exists(layers_doc_path):
with open(layers_doc_path, "rb") as f:
doc = json.loads(f.read().decode("utf-8"))
if doc.get("manifest_digest") != manifest_digest:
raise ValueError("layers.json 的 manifest_digest 与实测不符")
if doc.get("config_digest") != config_digest:
raise ValueError("layers.json 的 config_digest 与实测不符")
return manifest_digest, config_digest, checked
def cmd_verify(args):
try:
m, c, layers = verify(os.path.abspath(args.image))
except (ValueError, OSError, IOError) as e:
sys.stderr.write("镜像校验失败: %s\n" % e)
return 1
print("verified=ok")
print("manifest_digest=%s" % m)
print("measurement=%s" % m)
print("config_digest=%s" % c)
for d, name in layers:
print(" %-8s %s" % (name, d))
return 0
def cpio_newc(root):
"""生成 newc 格式 cpio(Linux initrd 可识别)。"""
out = bytearray()
ino = 1
def pad(buf):
while len(buf) % 4:
buf.append(0)
def emit(name, st, data, is_link, is_dir):
mode = stat.S_IMODE(st.st_mode)
if is_dir:
mode |= 0o040000
elif is_link:
mode |= 0o120000
else:
mode |= 0o100000
nlink = 2 if is_dir else 1
fields = [ino, mode, 0, 0, nlink, 0, len(data), 0, 0, 0, 0,
len(name) + 1, 0]
header = "070701" + "".join("%08x" % (v & 0xffffffff) for v in fields)
out.extend(header.encode("ascii"))
out.extend(name.encode("utf-8"))
out.append(0)
pad(out)
if data:
out.extend(data)
pad(out)
emit(".", os.stat(root), b"", False, True)
for cur, dirs, files in os.walk(root):
dirs.sort()
files.sort()
for name in dirs + files:
full = os.path.join(cur, name)
rel = os.path.relpath(full, root).replace(os.sep, "/")
st = os.lstat(full)
if stat.S_ISLNK(st.st_mode):
emit(rel, st, os.readlink(full).encode("utf-8"), True, False)
elif stat.S_ISDIR(st.st_mode):
emit(rel, st, b"", False, True)
elif stat.S_ISREG(st.st_mode):
with open(full, "rb") as f:
emit(rel, st, f.read(), False, False)
else:
raise ValueError("initrd 不支持特殊文件: %s" % rel)
trailer = [0, 0o100000 | 0o755, 0, 0, 1, 0, 0, 0, 0, 0, 0,
len("TRAILER!!!") + 1, 0]
out.extend(("070701" + "".join("%08x" % v for v in trailer)).encode("ascii"))
out.extend(b"TRAILER!!!\0")
pad(out)
return bytes(out)
def cmd_pack(args):
image = os.path.abspath(args.image)
try:
manifest_digest, config_digest, layers = verify(image)
except (ValueError, OSError, IOError) as e:
sys.stderr.write("打包前校验失败: %s\n" % e)
return 1
tmp = tempfile.mkdtemp(prefix="mpc-tee-initrd-")
try:
root = os.path.join(tmp, "root")
os.makedirs(root)
with open(os.path.join(image, "layers.json"), "rb") as f:
doc = json.loads(f.read().decode("utf-8"))
for layer in doc["layers"]:
with open(blob_path(image, layer["digest"]), "rb") as f:
gz = f.read()
tf = tarfile.open(fileobj=io.BytesIO(gzip.decompress(gz)), mode="r:")
safe_extract(tf, root)
tf.close()
oci = os.path.join(root, "etc", "mpc-tee", "oci")
blobs = os.path.join(oci, "blobs")
os.makedirs(blobs)
copies = [("layers.json", os.path.join(image, "layers.json")),
("index.json", os.path.join(image, "index.json"))]
for name, src in copies:
shutil.copyfile(src, os.path.join(oci, name))
with open(os.path.join(oci, "manifest.json"), "wb") as f:
f.write(open(blob_path(image, manifest_digest), "rb").read())
with open(os.path.join(oci, "config.json"), "wb") as f:
f.write(open(blob_path(image, config_digest), "rb").read())
sums = []
for layer in doc["layers"]:
d = layer["digest"]
shutil.copyfile(blob_path(image, d),
os.path.join(blobs, d + ".tar.gz"))
sums.append("%s blobs/%s.tar.gz" % (d, d))
sums.append("%s manifest.json" % manifest_digest)
sums.append("%s config.json" % config_digest)
with open(os.path.join(oci, "layers.sha256"), "w") as f:
f.write("\n".join(sums) + "\n")
with open(os.path.join(root, "etc", "mpc-tee", "manifest.digest"),
"w") as f:
f.write(manifest_digest + "\n")
cpio = cpio_newc(root)
packed = gzip_deterministic(cpio)
out = os.path.abspath(args.out)
with open(out, "wb") as f:
f.write(packed)
print("initrd=%s" % out)
print("initrd_sha256=%s" % sha256_hex(packed))
print("manifest_digest=%s" % manifest_digest)
print("measurement=%s" % manifest_digest)
print("layers=%d" % len(layers))
if not args.quiet:
top = ["init", "mpc", "bin/busybox",
"etc/mpc-tee/manifest.digest", "etc/mpc-tee/oci/layers.sha256"]
for name in top:
print(" %s %s" % ("ok" if os.path.exists(os.path.join(root, name))
else "MISSING", name))
finally:
shutil.rmtree(tmp, ignore_errors=True)
return 0
def main():
ap = argparse.ArgumentParser(
description="OCI 分层镜像构建 / 校验 / 打包 initrd(无容器运行时依赖)")
sub = ap.add_subparsers(dest="cmd")
b = sub.add_parser("build", help="由 rootfs + mpc + init 构建 OCI image layout")
b.add_argument("--base", required=True, help="已解包的 rootfs 目录")
b.add_argument("--mpc", required=True, help="Linux 静态 mpc 二进制")
b.add_argument("--init", required=True, help="guest init 脚本")
b.add_argument("--out", required=True, help="输出 OCI image 目录")
b.add_argument("--tag", default="mpc-tee:local")
b.add_argument("--offline-dir", default=None,
help="离线演练密钥目录(仅测试,会打印警告)")
b.set_defaults(func=lambda a: build(a))
v = sub.add_parser("verify", help="校验 index/manifest/config/layer digest 链")
v.add_argument("--image", required=True)
v.set_defaults(func=cmd_verify)
p = sub.add_parser("pack", help="校验后按层解包并打成 initrd")
p.add_argument("--image", required=True)
p.add_argument("--out", required=True)
p.add_argument("--quiet", action="store_true")
p.set_defaults(func=cmd_pack)
args = ap.parse_args()
if not getattr(args, "func", None):
ap.print_help()
return 2
return args.func(args)
if __name__ == "__main__":
sys.exit(main())
+76
View File
@@ -0,0 +1,76 @@
# 真机复现:AMD SEV-SNP + 海光 CSV 双加密 guest
把 2026-11-06 的临时 `/tmp` 脚本整理成可复现资产。**凭据不入库**:SSH 口令由
xop 键名经环境变量注入,PSK / seed / 根密钥由 KBS 下发(或离线演练层),
仓库里只有占位值与示例节点描述。
## 前置物料
1. **Linux 静态 `mpc`**(macOS 上交叉编译):
```bash
RUSTFLAGS="-C link-self-contained=no" \
CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=x86_64-linux-musl-gcc \
cargo build -p mpc-cli --features secure --target x86_64-unknown-linux-musl
zig objcopy --strip-all \
target/x86_64-unknown-linux-musl/debug/mpc /tmp/mpc-linux-x86_64
```
`-C link-self-contained=no` 是必须的,否则 zig 的 crt 与 Rust 自带 crt 重复定义 `_start`。
2. **base rootfs**:现成 alpine rootfs(含 `/bin/busybox` 与 musl loader)。
3. **OCI 镜像与 initrd**:按 `../oci/README.md` 跑 `build` / `verify` / `pack`,
记下 `measurement=<64hex>`。
4. **节点描述**:复制 `nodes/*.node.example`,把 `measurement` 换成上一步的 digest,
其余路径按真机 `preflight.sh` 结果填写。
5. **KBS(可选,在线模式)**:`../kbs/serve.py` 只是演练 stub;生产请用带证明校验的
Trustee/KBS。离线演练用 `MPC_TEE_KBC=offline_fs_kbc::null`,
并在 `build` 时加 `--offline-dir` 提供 `psk` / `seed` / `root-key`。
## 单 guest 自检
```bash
export MPC_TEE_MPC_BIN=/path/to/mpc
export MPC_TEE_MANIFEST=<64hex>
export MPC_TEE_KBC=offline_fs_kbc::null
python3 run-guest.py nodes/amd-sev-snp.node.example <64hex-session> <64hex-pubkey> none
```
`role=none` 不挂网卡,只验证 guest 内核、`mpc selftest` 与 OCI 层校验。
## 双 guest 跨物理机计算
```bash
export MPC_TEE_MPC_BIN=/path/to/mpc-linux-x86_64
export MPC_TEE_INITRD=/path/to/mpc-initrd.img
export MPC_TEE_AMD_NODE=nodes/amd-sev-snp.node.example
export MPC_TEE_HYGON_NODE=nodes/hygon-csv2.node.example
export MPC_TEE_MANIFEST=<64hex>
export MPC_TEE_KBC=offline_fs_kbc::null
# 可选:MPC_TEE_AMD_HOST / MPC_TEE_HYGON_HOST / *_USER_KEY / *_PASS_KEY
MPC_TEE_DRY_RUN=1 ./pair-run.sh # 先看物料与计划,不连机
./pair-run.sh
```
`pair-run.sh` 会:分发物料到两台宿主 → 后台起 AMD SNP guest(alice,socket 监听)→
只读确认端口 LISTEN → 起海光 CSV guest(bob,socket 连接)→ 输出两侧日志尾部。
判定成功的标志是**两侧都输出 `value | 35.000000`**,且日志里有
`oci_layers: verified`、`manifest_digest=...`、`mpc selftest 全部通过`。
## 分层与职责
| 层 | 文件 | 职责 |
|---|---|---|
| 框架 | `mpc tee plan --argv` | 平台中立的 qemu argv(含 `user_data`、kernel-hashes、pflash、cbitpos) |
| 部署 | `run-guest.py` | 只补串口 / 角色 / manifest / KBC / socket 网卡 / NUMA,**不覆盖框架参数** |
| 编排 | `pair-run.sh` | 分发物料、起两侧 guest、收日志;调度决策在本地,不在集群 |
| guest | `../guest/init.sh` | 校验 OCI 层 → 取密钥 → 启动 `mpc node` |
框架原生 argv 已经过真机校正,**不要**再加 `-machine` / `sev-guest` / 固件 / CPU 的
部署层覆盖;真机上那次 `Platform is already owned` 的根因是缺 `kernel-hashes=on`
与 pflash,已修进 `PlatformProfile`,详见 `docs/TEE_DIRECT_LAUNCH.md`。
## 边界
- 两台真机的静态 qemu 没编 slirp,`-netdev user` 不可用;跨 guest 链路由部署层
注入 `socket` netdev,核心 crate 不写死宿主网络后端。
- 在线 KBS 的 token 目前是占位值 `offline-demo`(stub 非 strict 模式放行并告警)。
生产必须换成证明代理产物 + 带证明校验的 KBS。
- `pair-run.sh` 只起 qemu,不做芯片证明互验;报告验签走 `mpc tee verify` 的外部验签器。
+39
View File
@@ -0,0 +1,39 @@
#!/usr/bin/env bash
# 单个机密 guest 的角色入口(在 TEE 宿主上执行)。
# 由 pair-run.sh 分发到远端后调用;所有敏感值经环境变量注入,仓库内不落密钥。
set -u
ROLE=${1:-none}
BASE=${MPC_TEE_RUN_DIR:-/tmp/mpc-tee-run}
NODE=${MPC_TEE_NODE_FILE:-$BASE/node}
SID=${MPC_TEE_SESSION_ID:-$(printf 'ab%.0s' $(seq 1 32))}
PK=${MPC_TEE_PUBKEY:-$(printf 'cd%.0s' $(seq 1 32))}
VARIANT=${MPC_TEE_VARIANT:-}
AMD_HOST=${MPC_TEE_AMD_HOST:-192.168.1.7}
LINK_PORT=${MPC_TEE_LINK_PORT:-19777}
export MPC_TEE_MPC_BIN=${MPC_TEE_MPC_BIN:-$BASE/mpc}
export MPC_TEE_MANIFEST=${MPC_TEE_MANIFEST:?必须给出 OCI manifest digest}
export MPC_TEE_KBC=${MPC_TEE_KBC:-offline_fs_kbc::null}
export MPC_TEE_MIN_TCB=${MPC_TEE_MIN_TCB:-3}
export MPC_TEE_SESSION_ID=$SID
export MPC_TEE_PUBKEY=$PK
case "$ROLE" in
alice)
export MPC_NETDEV_ARGS="-netdev socket,id=mpcnet0,listen=0.0.0.0:$LINK_PORT -device virtio-net-pci,netdev=mpcnet0"
;;
bob)
export MPC_NETDEV_ARGS="-netdev socket,id=mpcnet0,connect=$AMD_HOST:$LINK_PORT -device virtio-net-pci,netdev=mpcnet0"
;;
none)
;;
*)
echo "未知角色: $ROLE" >&2
exit 2
;;
esac
ARGS=("$NODE" "$SID" "$PK" "$ROLE")
[ -n "$VARIANT" ] && ARGS+=("$VARIANT")
exec python3 "$BASE/run-guest.py" "${ARGS[@]}"
@@ -0,0 +1,19 @@
# AMD SEV-SNP 真机节点描述(2026-11-06 实测 192.168.1.7 / tee-node-01)
# 用 deploy/tee/preflight.sh 产出实际值;measurement 必须换成
# `oci-image.py build` 输出的 manifest digest(64 hex),否则 fail-closed 会拒绝。
# pair-run.sh 分发时会把 initrd= 改写成远端路径,无需手改。
site=alice
host=192.168.1.7
kind=sev-snp
tcb=5
device_present=true
qemu_present=true
firmware_present=true
image_present=true
kbc=online
kbs_reachable=true
measurement=0000000000000000000000000000000000000000000000000000000000000000
qemu=/opt/kata/bin/qemu-system-x86_64
firmware=/opt/kata/share/ovmf/AMDSEV.fd
kernel=/opt/kata/share/kata-containers/vmlinuz-6.12.36-160-confidential
initrd=/tmp/mpc-tee-run/initrd.img
@@ -0,0 +1,20 @@
# 海光 CSV2 真机节点描述(2026-11-06 实测 192.168.1.102)
# CSV2 实测 policy=7;CSV3 需加 `--variant csv3`。
# 固件路径只填文件位置:框架对海光自动用 pflash 加载并带 kernel-hashes=on
# (缺任一都会导致 direct boot 失败,报错 "Platform is already owned" 是误导性的)。
# measurement 必须换成 `oci-image.py build` 输出的 manifest digest。
site=bob
host=192.168.1.102
kind=hygon-csv
tcb=3
device_present=true
qemu_present=true
firmware_present=true
image_present=true
kbc=offline
kbs_reachable=false
measurement=0000000000000000000000000000000000000000000000000000000000000000
qemu=/opt/confidential-containers/bin/qemu-system-x86_64
firmware=/opt/confidential-containers/share/ovmf/HYGONCSV.fd
kernel=/opt/confidential-containers/share/kata-containers/vmlinuz-5.10.134-102cc-csv-hygon-gpu
initrd=/tmp/mpc-tee-run/initrd.img
+137
View File
@@ -0,0 +1,137 @@
#!/usr/bin/env bash
# 跨两台 TEE 真机各起一个加密 guest,跑一次带 PSK 的密文会话。
#
# 凭据只走 xop 键名(环境变量指定),脚本里没有任何明文口令。
# 编排决策在本地,远端只执行 guest-role.sh —— 与「框架直接调度 TEE」一致。
#
# 必需输入(环境变量):
# MPC_TEE_MPC_BIN Linux 静态 mpc 二进制
# MPC_TEE_INITRD oci-image.py pack 产出的 initrd
# MPC_TEE_AMD_NODE AMD 节点描述文件
# MPC_TEE_HYGON_NODE 海光节点描述文件
# MPC_TEE_MANIFEST OCI manifest digest(64 hex)
# 可选:MPC_TEE_KBC(默认 offline_fs_kbc::null)、MPC_TEE_SESSION_ID、
# MPC_TEE_PUBKEY、MPC_TEE_*_HOST、MPC_TEE_*_USER_KEY / *_PASS_KEY、
# MPC_TEE_LOG_DIR、MPC_TEE_DRY_RUN=1
set -u
HERE=$(cd "$(dirname "$0")" && pwd)
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}
REMOTE_DIR=${MPC_TEE_REMOTE_DIR:-/tmp/mpc-tee-run}
LOG_DIR=${MPC_TEE_LOG_DIR:-/tmp/mpc-tee-logs}
LINK_PORT=${MPC_TEE_LINK_PORT:-19777}
MANIFEST=${MPC_TEE_MANIFEST:-}
SID=${MPC_TEE_SESSION_ID:-$(printf 'ab%.0s' $(seq 1 32))}
PK=${MPC_TEE_PUBKEY:-$(printf 'cd%.0s' $(seq 1 32))}
KBC=${MPC_TEE_KBC:-offline_fs_kbc::null}
SSHO="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PreferredAuthentications=password -o PubkeyAuthentication=no -o ConnectTimeout=20"
need() {
if [ ! -f "$1" ]; then echo "缺少文件: $1" >&2; exit 2; fi
}
need "$HERE/run-guest.py"
need "$HERE/guest-role.sh"
need "${MPC_TEE_MPC_BIN:-/nonexistent}"
need "${MPC_TEE_INITRD:-/nonexistent}"
need "${MPC_TEE_AMD_NODE:-/nonexistent}"
need "${MPC_TEE_HYGON_NODE:-/nonexistent}"
case "$MANIFEST" in
[0-9a-fA-F][0-9a-fA-F]*) [ "${#MANIFEST}" -eq 64 ] || { echo "MANIFEST 必须 64 位 hex" >&2; exit 2; } ;;
*) echo "MANIFEST 必须 64 位 hex" >&2; exit 2 ;;
esac
stage() {
local dst=$1 node=$2 variant=$3
mkdir -p "$dst"
cp "${MPC_TEE_MPC_BIN}" "$dst/mpc"
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"
sed "s|^initrd=.*|initrd=$REMOTE_DIR/initrd.img|" "$node" > "$dst/node"
cat > "$dst/env.sh" <<EOF
export MPC_TEE_RUN_DIR=$REMOTE_DIR
export MPC_TEE_NODE_FILE=$REMOTE_DIR/node
export MPC_TEE_MPC_BIN=$REMOTE_DIR/mpc
export MPC_TEE_MANIFEST=$MANIFEST
export MPC_TEE_KBC=$KBC
export MPC_TEE_SESSION_ID=$SID
export MPC_TEE_PUBKEY=$PK
export MPC_TEE_AMD_HOST=$AMD_HOST
export MPC_TEE_LINK_PORT=$LINK_PORT
export MPC_TEE_VARIANT=$variant
EOF
}
scpto() {
local host=$1 user_key=$2 pass_key=$3 src=$4
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/\"" \
< /dev/null
}
remote() {
local host=$1 user_key=$2 pass_key=$3 role=$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'\"" \
< /dev/null
}
STAGE_A=$(mktemp -d /tmp/mpc-tee-stage-a.XXXXXX)
STAGE_B=$(mktemp -d /tmp/mpc-tee-stage-b.XXXXXX)
stage "$STAGE_A" "${MPC_TEE_AMD_NODE}" ""
stage "$STAGE_B" "${MPC_TEE_HYGON_NODE}" "csv2"
mkdir -p "$LOG_DIR"
if [ "${MPC_TEE_DRY_RUN:-0}" = "1" ]; then
echo "=== dry-run(不连机) ==="
echo "AMD $AMD_HOST role=alice node=${MPC_TEE_AMD_NODE}"
echo "HYGON $HYGON_HOST role=bob node=${MPC_TEE_HYGON_NODE} variant=csv2"
echo "manifest=$MANIFEST kbc=$KBC link_port=$LINK_PORT"
echo "staged files (AMD):"; ls -1 "$STAGE_A"
echo "staged files (HYGON):"; ls -1 "$STAGE_B"
echo "env.sh (AMD):"; cat "$STAGE_A/env.sh"
rm -rf "$STAGE_A" "$STAGE_B"
exit 0
fi
echo "=== 分发物料到两台 TEE 宿主 ==="
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"
echo "=== 起 AMD SNP guest (alice) ==="
remote "$AMD_HOST" "$AMD_USER_KEY" "$AMD_PASS_KEY" alice \
> "$LOG_DIR/alice.log" 2>&1 &
P_ALICE=$!
ready=0
for _ in $(seq 1 40); 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
ready=1
break
fi
sleep 0.5
done
echo "snp_socket_listening=$ready ($AMD_HOST:$LINK_PORT)"
echo "=== 起 海光 CSV guest (bob) ==="
remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" bob \
> "$LOG_DIR/bob.log" 2>&1
RC=$?
wait "$P_ALICE" 2>/dev/null || true
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 "bob_guest_rc=$RC"
echo "完整日志: $LOG_DIR/alice.log $LOG_DIR/bob.log"
exit "$RC"
+127
View File
@@ -0,0 +1,127 @@
#!/usr/bin/env python3
"""真机侧启动器:消费框架原生 qemu argv,只补部署层参数。
框架(`mpc tee plan --argv`)负责平台中立且已被真机校正过的启动规格;
这里只补宿主相关的东西:串口、guest 角色、会话/镜像度量/KBC 参数、
socket 网卡、NUMA 内存后端。**不覆盖 -machine / -object / -bios / -cpu / -smp**
—— 那些都是框架能力表的职责,真机差异已经在 2026-11-06 校正过。
环境变量(全部由调用方注入,仓库内不落任何凭据或密钥):
MPC_TEE_MPC_BIN guest 内静态 mpc 二进制在宿主上的路径(默认 mpc)
MPC_TEE_MANIFEST OCI manifest digest,64 位十六进制(必填)
MPC_TEE_KBC guest 内 KBC 模式(默认 offline_fs_kbc::null)
MPC_TEE_MIN_TCB TCB 门槛(默认 3)
MPC_NETDEV_ARGS role != none 时必填,qemu 网卡参数(socket netdev)
用法:run-guest.py NODE_FILE SESSION_ID PUBKEY ROLE [VARIANT]
兼容 Python 3.6(海光 Anolis 8.10)。
"""
import json
import os
import shlex
import subprocess
import sys
HEX = set("0123456789abcdef")
def die(msg):
sys.stderr.write("run-guest: %s\n" % msg)
sys.exit(2)
def drop_pair(argv, flag, pred):
while True:
for i, a in enumerate(argv):
if a == flag and i + 1 < len(argv) and pred(argv[i + 1]):
del argv[i:i + 2]
break
else:
return
def main():
if len(sys.argv) < 5:
die("用法: run-guest.py NODE SESSION PUBKEY ROLE [VARIANT]")
mpc = os.environ.get("MPC_TEE_MPC_BIN", "mpc")
node_path, sid, pk, role = sys.argv[1:5]
variant = sys.argv[5] if len(sys.argv) > 5 else None
manifest = os.environ.get("MPC_TEE_MANIFEST", "").strip().lower()
kbc = os.environ.get("MPC_TEE_KBC", "offline_fs_kbc::null").strip()
min_tcb = os.environ.get("MPC_TEE_MIN_TCB", "3")
if len(manifest) != 64 or not set(manifest) <= HEX:
die("MPC_TEE_MANIFEST 必须是 64 位十六进制(由 oci-image.py build 输出)")
if len(sid) != 64 or not set(sid.lower()) <= HEX:
die("SESSION_ID 必须是 64 位十六进制")
if len(pk) != 64 or not set(pk.lower()) <= HEX:
die("PUBKEY 必须是 64 位十六进制")
if " " in kbc or not kbc:
die("MPC_TEE_KBC 不能含空格或为空")
if role not in ("alice", "bob", "none"):
die("ROLE 只能是 alice / bob / none")
cmd = [mpc, "--report", "json", "tee", "plan", "--node", node_path,
"--session-id", sid, "--pubkey", pk,
"--min-tcb", min_tcb, "--argv"]
if variant:
cmd += ["--variant", variant]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True)
plan_out, plan_err = p.communicate()
if p.returncode != 0:
sys.stderr.write("tee plan 失败 rc=%d\n%s\n%s\n" %
(p.returncode, plan_out, plan_err))
sys.exit(2)
argv = None
for line in plan_out.splitlines():
try:
obj = json.loads(line)
except ValueError:
continue
for k, v in obj.get("rows", []):
if k == "argv_json":
argv = json.loads(v)
if not argv:
sys.stderr.write("没拿到 argv_json\n%s" % plan_out)
sys.exit(2)
print("=== framework argv (%d args) ===" % len(argv))
print(" ".join(argv))
sys.stdout.flush()
# 1) 部署层追加的内核参数:镜像度量与 KBC 由调度侧钉进 guest。
# framework 原有的 mpc.tee.user_data / site / aa_kbc_params 不动。
i = argv.index("-append") + 1
argv[i] += (" console=ttyS0 earlyprintk=serial"
" mpc.role=%s mpc.tee.session=%s"
" mpc.tee.manifest=%s mpc.tee.kbs=%s" %
(role, sid, manifest, kbc))
# 2) 真机自带的静态 qemu 没编 slirp,框架给的 user netdev 用不了;
# 跨 guest 链路改由部署层注入 socket netdev(核心 crate 不写死网络后端)。
drop_pair(argv, "-netdev", lambda v: v.startswith("user,"))
drop_pair(argv, "-device",
lambda v: v.startswith("virtio-net-pci,netdev=mpcnet0"))
if role == "none":
print("=== role=none: 自检 guest 不挂网卡 ===")
else:
extra = os.environ.get("MPC_NETDEV_ARGS")
if not extra:
die("跨 guest 会话需要 MPC_NETDEV_ARGS(部署层注入 socket 网卡)")
argv += shlex.split(extra)
print("=== deploy netdev: %s ===" % extra)
# 3) 机密 guest 需要显式 NUMA 内存后端;关机即退出 qemu。
argv += ["-object", "memory-backend-ram,id=dimm1,size=2048M",
"-numa", "node,memdev=dimm1", "-no-reboot"]
print("=== deployed argv (%d args) ===" % len(argv))
print(" ".join(argv))
sys.stdout.flush()
os.execvp(argv[0], argv)
if __name__ == "__main__":
main()