Files
admin 5c68564b6c feat(tee): 打通 OCI 镜像流水线与在线 KBC 密钥下发,补齐运行期完整性链
交付两件此前欠着的事,并在真机(192.168.1.102 海光 CSV)端到端跑通:
1. OCI 镜像流水线 build → verify → pack 三步在真机跑通,manifest digest
   作 SessionBinding.code_measurement 钉进会话绑定值。
2. PSK / seed / root-key 不再内置 initrd,改由 guest 内 mpc tee kbs-get
   按会话从宿主 KBS 取回(key_source=kbs)。

★ 修掉两个框架级缺陷(都是「校验通过 ≠ 校验的是对的东西」):
- guest 侧活文件链:旧 layers.sha256 只覆盖 blobs/ 下的惰性证据副本,
  真正执行的 /init、/mpc 不在范围内 —— 真机改 /mpc 一个字节照样打印
  oci_layers: verified。现改为从 cmdline 的 PIN 逐跳推导到活文件逐个校验,
  失败时点名具体文件。
- 流水线侧自证:pack 打完 initrd 必须回读核对内嵌 digest / 清单 /
  manifest.json,不符即失败。缺前者不能保证「送进 guest 的是这个镜像」,
  缺后者不能保证「guest 跑的是这个镜像里的活内容」,两者缺一不可。

新增真机可复现资产(deploy/tee/):
- oci/oci-image.py:rootfs_state_from_layers() 直接从各层 tar 字节算活
  rootfs 状态,不解包(免 mknod 权限,build 与 pack 共用同一函数防分叉);
  build 扫 base rootfs 里的密钥物料,命中即退出码 3。
- oci/selftest-chain.py:完整性链本地回归,含「旧口径对 /mpc 篡改完全
  无感」的反向断言。
- real-machine/kbc-e2e.sh / kbc-negative.sh / kbs-net.sh:正向全链路与
  5 条 fail-closed 负向矩阵、tap + bridge 出网链路。
- real-machine/tamper-initrd.py:精确解析 newc cpio 改目标文件数据区。
- real-machine/guest-syntax-check.sh:解包 initrd 后用解出来的 musl loader
  跑解出来的 busybox,完全模拟 guest 内 ash 解析环境。
- real-machine/lint-shell-vars.py:shell 引号与变量名三类陷阱闸门。

框架侧:PlatformProfile.kbc 拆成 allowed_kbc(支持哪些)与 kbc(缺省);
kbs_endpoint 改由节点描述给出,现场部署事实与代码分离。

真机实测:正向 KBC_E2E_OK(key_source=kbs),负向 5/5 全 fail-closed。
闸门扩到六条:ci.sh 新增 shell 引号/变量名卫生与 OCI 完整性链自测。
2026-11-07 02:07:28 +08:00

886 lines
37 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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 的边界说明。
**⚠ 运行期完整性链(2026-11-07 补)**
只校验 `blobs/` 下的**惰性证据副本**是不够的:真正被执行的 `/init`、
`/mpc` 是解层之后合成出来的**活内容**,根本不在 `layers.sha256` 的覆盖
范围内。真机上把 initrd 里的 `/init` 改掉一个字节,guest 照样打印
`oci_layers: verified` —— 被换掉的是**正在执行的文件**,证据副本却完好
无损。这条链必须一路落到活文件上。
因此 build 阶段额外产出**活 rootfs 的文件级清单**(`rootfs.sha256` /
`rootfs.links`),并把它们的 digest 写进 config.json。guest 侧的信任
链是单一根、逐跳推导:
cmdline 的 mpc.tee.manifest (PIN)
→ sha256(/etc/mpc-tee/oci/manifest.json)
→ manifest.config.digest
→ sha256(/etc/mpc-tee/oci/config.json)
→ config.mpc_tee.rootfs_files_digest
→ sha256(/etc/mpc-tee/oci/rootfs.sha256)
→ sha256sum -c → /init /mpc /bin/... 逐个校验
PIN 由宿主框架算出(就是 OCI manifest digest),并被绑定进芯片报告的
`user_data` —— 于是这条链的信任根与芯片证明是同一个。
兼容 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
# 运行期不参与「活 rootfs 文件级清单」的部分。
#
# 前三类是**运行期才出现/才被替换**的目录:guest 起来后会把 devtmpfs 挂到
# /dev、procfs 挂到 /proc、sysfs 挂到 /sys,并把运行时产物写进 /run —— 这些
# 路径在构建期与运行期内容必然不同,不能进清单。
ROOTFS_EXCLUDE_TOP = ("proc", "sys", "dev", "run", "tmp")
# pack 阶段才写进去的证据文件(构建期还不存在)。
ROOTFS_EXCLUDE_FILES = ("etc/mpc-tee/manifest.digest",)
ROOTFS_EXCLUDE_PREFIXES = ("etc/mpc-tee/oci",)
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(排序 + 固定元信息)。
设备节点(/dev/console、/dev/null 等)必须显式处理:`tarfile.add` 对
字符/块设备只在 root 且能 mknod 时才写设备类型,否则会静默退化成普通
文件。真机上表现为 initrd 里 `/dev/console` 是 0600 的普通文件,
guest 起来后没有控制台。
"""
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)
st = os.lstat(full)
if stat.S_ISCHR(st.st_mode) or stat.S_ISBLK(st.st_mode):
ti = tarfile.TarInfo(rel)
ti.type = tarfile.CHRTYPE if stat.S_ISCHR(st.st_mode) else tarfile.BLKTYPE
ti.mode = stat.S_IMODE(st.st_mode)
ti.devmajor = os.major(st.st_rdev)
ti.devminor = os.minor(st.st_rdev)
ti.mtime = 0
ti.uid = ti.gid = 0
ti.uname = ti.gname = "root"
tf.addfile(ti)
continue
if stat.S_ISFIFO(st.st_mode):
ti = tarfile.TarInfo(rel)
ti.type = tarfile.FIFOTYPE
ti.mode = stat.S_IMODE(st.st_mode)
ti.mtime = 0
ti.uid = ti.gid = 0
ti.uname = ti.gname = "root"
tf.addfile(ti)
continue
tf.add(full, arcname=rel, recursive=False, filter=normalize)
return buf.getvalue()
def tar_from_files(entries):
"""entries: [(arcname, 目录标记 or 文件绝对路径, 内容 bytes or None, 模式)]。
约定:**src 为 None 表示目录**(content 忽略);src 非 None 表示普通文件,
内容从文件读或直接用 content。
早先这里判断的是 `content is None` → 当目录,于是
`("init", args.init, None, 0o755)`(src 是 init.sh 的路径、content 是
None)被打成了**目录**。真机上表现为内核
`Run /init as init process` → `Failed to execute /init (error -13)`
—— EACCES,因为 /init 是个 0755 的目录,不是脚本。
"""
buf = io.BytesIO()
with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tf:
for arc, src, content, mode in entries:
if src is None:
ti = tarfile.TarInfo(arc)
ti.type = tarfile.DIRTYPE
ti.mode = mode
tf.addfile(ti)
continue
if content is 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 scan_rootfs_files(root):
"""列出 rootfs 里应当被逐文件校验的活内容。
返回 (files, links):
files [(relpath, sha256hex)] 普通文件
links [(relpath, linktarget)] 符号链接(校验目标字符串,而不是跟随)
刻意**只收普通文件与符号链接**:设备节点的内容无从校验(内核按
major/minor 还原),FIFO 与 socket 是运行期产物。目录靠文件的路径
隐含,不需要单独列。
排除项见 ROOTFS_EXCLUDE_TOP / ROOTFS_EXCLUDE_FILES / ROOTFS_EXCLUDE_PREFIXES。
"""
files, links = [], []
for cur, dirs, names in os.walk(root):
dirs.sort()
# 运行期目录不进清单;同时也不要走进它们(里面全是运行期产物)。
kept = []
for d in dirs:
rel = os.path.relpath(os.path.join(cur, d), root).replace(os.sep, "/")
top = rel.split("/")[0]
if top in ROOTFS_EXCLUDE_TOP:
continue
kept.append(d)
dirs[:] = kept
for name in sorted(names):
full = os.path.join(cur, name)
rel = os.path.relpath(full, root).replace(os.sep, "/")
top = rel.split("/")[0]
if top in ROOTFS_EXCLUDE_TOP:
continue
if rel in ROOTFS_EXCLUDE_FILES:
continue
if any(rel.startswith(p) for p in ROOTFS_EXCLUDE_PREFIXES):
continue
st = os.lstat(full)
if stat.S_ISLNK(st.st_mode):
links.append((rel, os.readlink(full)))
elif stat.S_ISREG(st.st_mode):
with open(full, "rb") as f:
files.append((rel, sha256_hex(f.read())))
files.sort()
links.sort()
return files, links
def rootfs_state_from_layers(layer_tars):
"""从各层的 tar 字节直接算出「合并后的活 rootfs」文件级状态。
为什么不解包再扫:
- 解包要在宿主上 mknod 设备节点(要 root),本地 macOS 上跑不了;
- 更要紧的是**解包再扫 = 两份实现**(build 一份、pack 一份),一旦
过滤规则或覆盖顺序不一致,清单就与实际产物对不上 —— 而这种不一致
只会在真机上表现为「校验莫名失败」。直接从层内容算,两边共用同一
函数,天然一致。
覆盖语义与 OCI 一致:后层覆盖前层(同名文件以最后一个为准)。
目录、设备节点、FIFO 不进清单(见 scan_rootfs_files 的说明)。
"""
state = {}
for tar_bytes in layer_tars:
tf = tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:")
try:
members = sorted(tf.getmembers(), key=lambda m: m.name)
for m in members:
rel = m.name.replace(os.sep, "/")
while rel.startswith("./"):
rel = rel[2:]
if not rel or rel == ".":
continue
top = rel.split("/")[0]
if top in ROOTFS_EXCLUDE_TOP:
continue
if rel in ROOTFS_EXCLUDE_FILES:
continue
if any(rel.startswith(p) for p in ROOTFS_EXCLUDE_PREFIXES):
continue
if m.issym():
state[rel] = ("link", m.linkname)
elif m.isfile():
data = tf.extractfile(m).read()
state[rel] = ("file", sha256_hex(data))
finally:
tf.close()
files, links = [], []
for rel in sorted(state):
kind, val = state[rel]
if kind == "file":
files.append((rel, val))
else:
links.append((rel, val))
return files, links
def rootfs_manifest_bytes(files, links):
"""生成活 rootfs 清单的字节内容,返回 (files_bytes, links_bytes)。
`rootfs.sha256` 是 busybox `sha256sum -c` 认得的格式(`摘要␣␣路径`),
guest 直接 `sha256sum -c` 即可,不需要自己解析。
`rootfs.links` 是符号链接清单(`路径␣␣目标`),busybox 没有
「校验符号链接」的能力,所以单独列出来给 guest 比对。
"""
lines = ["%s %s" % (d, rel) for rel, d in files]
files_bytes = ("\n".join(lines) + ("\n" if lines else "")).encode("utf-8")
link_lines = ["%s %s" % (rel, t) for rel, t in links]
links_bytes = ("\n".join(link_lines) + ("\n" if link_lines else "")).encode("utf-8")
return files_bytes, links_bytes
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):
"""拒绝路径穿越与绝对路径。
允许常规文件 / 目录 / 符号链接 / 硬链接,以及**字符设备、块设备、FIFO**。
后三类是真实 rootfs 的必备部分(`/dev/console`、`/dev/null` 等)——
早先只放行前四类,导致在真机上 `pack` 直接失败
(`层内含不支持的类型: dev/console`)。
设备节点**显式重建**:`tarfile.extractall` 对 CHRTYPE/BLKTYPE 的处理
在不同 Python 版本上不一致(3.6 上常常静默落成普通空文件),真机上
的表现是 initrd 里 `/dev/console` 是 0600 的普通文件 —— guest 起来后
没有控制台,init 的 echo 全丢。重建需要 root(打包在宿主上做)。
"""
members = []
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()
or m.ischr() or m.isblk() or m.isfifo()):
raise ValueError("层内含不支持的类型: %s (%s)" % (p, m.type))
members.append(m)
devices = []
for m in members:
if m.ischr() or m.isblk():
devices.append(m)
continue
tf.extract(m, dest)
# 设备节点单独处理:先确保父目录存在,再 mknod。
for m in devices:
target = os.path.join(dest, m.name)
parent = os.path.dirname(target)
if parent and not os.path.isdir(parent):
os.makedirs(parent)
if os.path.exists(target):
os.remove(target)
dev = os.makedev(m.devmajor, m.devminor)
if m.ischr():
os.mknod(target, stat.S_IFCHR | (m.mode & 0o7777), dev)
else:
os.mknod(target, stat.S_IFBLK | (m.mode & 0o7777), dev)
os.chmod(target, m.mode & 0o7777)
def merge_layer_tars(layer_tars, dest):
"""把若干层的 tar 依次解到 dest(后层覆盖前层)。
build 阶段用它算出「合并后的活 rootfs」,pack 阶段用同一套逻辑解包 ——
两边结果必须逐字节一致,否则 rootfs.sha256 的校验会失败。
"""
if not os.path.isdir(dest):
os.makedirs(dest)
for tar_bytes in layer_tars:
tf = tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:")
try:
safe_extract(tf, dest)
finally:
tf.close()
def scan_base_for_secrets(root):
"""在 base rootfs 里找疑似内置密钥物料,发现即报错退出。
「PSK 不该内置在 initrd 里」是本项目的铁律:密钥必须由 KBS 按会话下发,
内置的密钥等于所有 guest 共享同一把 PSK,一旦任一 guest 被攻破,
所有会话的机密性一起失守。
真机上这个坑是真实踩过的:复用旧的 alpine initrd 当 base 层时,
根目录下的 `psk` / `seed` 被原样打进 base 层 —— 镜像构建成功、
digest 校验也通过,但密钥已经明文躺在分发介质里。
因此这里**宁可误报也不放过**:命中即 `sys.exit`,不做「先打个警告继续」。
"""
# 常见的密钥物料文件名(大小写都查)。
names = ("psk", "seed", "root-key", "root_key", "psk.txt", "seed.txt")
hits = []
for cur, dirs, files in os.walk(root):
dirs.sort()
for name in sorted(files):
low = name.lower()
if low in names:
full = os.path.join(cur, name)
hits.append(os.path.relpath(full, root))
if hits:
sys.stderr.write(
"FATAL: base rootfs 里含疑似密钥物料 %s\n"
" 密钥必须由 KBS 按会话下发,不能内置进镜像层。\n"
" 请换一个干净的 base rootfs,或把这些文件移出后再构建。\n"
% (", ".join(hits)))
sys.exit(3)
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)
# base 层必须是干净的 rootfs —— 内置密钥直接否掉,不给「先构建再说」。
scan_base_for_secrets(args.base)
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))
# 活 rootfs 的文件级清单(运行期完整性链的最后一环)。
# 必须在 config/manifest 之前算出来 —— 它的 digest 要写进 manifest 的
# annotations,guest 才能从 cmdline 的 PIN 一路推到这里。
files, links = rootfs_state_from_layers([t for _, t in layer_specs])
files_bytes, links_bytes = rootfs_manifest_bytes(files, links)
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,
# 运行期完整性链的两个锚点。guest 侧的推导顺序是:
# cmdline PIN → sha256(manifest.json) → 本文件里的这两个 digest
# → sha256(rootfs.sha256) / sha256(rootfs.links)
# → 逐个校验**正在执行**的活文件
# 放在 annotations 里是 OCI manifest 的标准自由字段,不破坏规范。
"mpc.tee.rootfs-files-digest": sha256_hex(files_bytes),
"mpc.tee.rootfs-links-digest": sha256_hex(links_bytes),
},
}
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。
返回 (manifest_digest, config_digest, checked_layers, manifest_annotations)。
最后一个是 manifest 的 annotations 字典:运行期完整性链的锚点
(活 rootfs 清单的 digest)就写在里面,pack 阶段要用它做交叉核对。
"""
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 与实测不符")
annotations = manifest.get("annotations", {}) or {}
return manifest_digest, config_digest, checked, annotations
def cmd_verify(args):
try:
m, c, layers, ann = 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))
if ann.get("mpc.tee.rootfs-files-digest"):
print("rootfs_files_digest=%s" % ann["mpc.tee.rootfs-files-digest"])
print("rootfs_links_digest=%s" % ann.get("mpc.tee.rootfs-links-digest", ""))
return 0
def cpio_newc(root):
"""生成 newc 格式 cpio(Linux initrd 可识别)。
newc 头有专门的 rdev 字段(主/次设备号),字符设备与块设备靠它还原。
真实 rootfs 的 `/dev/console`、`/dev/null` 等都是字符设备 —— 早先遇到
特殊文件直接报错,导致带 `/dev` 的 rootfs 根本打不成 initrd。
"""
out = bytearray()
ino = 1
def pad(buf):
while len(buf) % 4:
buf.append(0)
def emit(name, st, data, kind, rdev_major=0, rdev_minor=0):
"""写一条 newc 记录。
kind: "dir" / "link" / "file" / "chr" / "blk" / "fifo"。
早先这里有个致命 bug:设备节点和普通文件走同一个分支,mode 一律
加 `0o100000`(S_IFREG)—— 于是 initrd 里的 `/dev/console` 是
**0600 的普通文件**,guest 起来后没有控制台,init 的所有输出全丢,
只看到内核那句 `Run /init as init process` 之后直接 halt。
newc 的设备号字段序是
devmajor devminor rdevmajor rdevminor
前两个是「持有设备的文件系统」的主/次号(对 initramfs 恒为 0),
后两个才是设备自身的 rdev —— 早先把同一个 rdev 填了两遍,内核
拿到的是错的设备号。
"""
mode = stat.S_IMODE(st.st_mode)
if kind == "dir":
mode |= 0o040000
elif kind == "link":
mode |= 0o120000
elif kind == "chr":
mode |= 0o020000
elif kind == "blk":
mode |= 0o060000
elif kind == "fifo":
mode |= 0o010000
else:
mode |= 0o100000
nlink = 2 if kind == "dir" else 1
fields = [ino, mode, 0, 0, nlink, 0, len(data), 0, 0,
rdev_major, rdev_minor, 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"", "dir")
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"), "link")
elif stat.S_ISDIR(st.st_mode):
emit(rel, st, b"", "dir")
elif stat.S_ISREG(st.st_mode):
with open(full, "rb") as f:
emit(rel, st, f.read(), "file")
elif stat.S_ISCHR(st.st_mode):
emit(rel, st, b"", "chr",
os.major(st.st_rdev), os.minor(st.st_rdev))
elif stat.S_ISBLK(st.st_mode):
emit(rel, st, b"", "blk",
os.major(st.st_rdev), os.minor(st.st_rdev))
elif stat.S_ISFIFO(st.st_mode):
emit(rel, st, b"", "fifo")
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 cpio_read_file(raw, want_name):
"""从 newc cpio 字节流里取出一个文件的内容(找不到返回 None)。
打包后**自证**用:不能只信「我刚写进去的」,要把 initrd 真的读回来,
确认里面嵌的 digest / 清单就是这次镜像的。
早先踩过的坑:`pack` 的失败被外层管道的退出码吞掉(`pack ... | grep` 取的是
grep 的 rc),于是**旧 initrd** 被当成新产物继续用 —— guest 侧表现为
「cmdline 的 manifest digest 与镜像不一致」,而镜像本身完全正常。
"""
i = raw.find(b"070701")
while i != -1:
if len(raw) < i + 110:
break
hdr = raw[i:i + 110]
namesize = int(hdr[94:102], 16)
filesize = int(hdr[54:62], 16)
name = raw[i + 110:i + 110 + namesize - 1].decode("utf-8", "replace")
dstart = (i + 110 + namesize + 3) & ~3
if name == want_name:
return raw[dstart:dstart + filesize]
adv = (110 + namesize + 3) & ~3
adv += filesize
adv = (adv + 3) & ~3
i = raw.find(b"070701", i + adv)
return None
def cmd_pack(args):
image = os.path.abspath(args.image)
try:
manifest_digest, config_digest, layers, manifest_annotations = 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"))
# 各层的原始 tar(未压缩):既用于解包,也用于重算活 rootfs 清单。
layer_tars = []
for layer in doc["layers"]:
with open(blob_path(image, layer["digest"]), "rb") as f:
gz = f.read()
layer_tars.append(gzip.decompress(gz))
for tar_bytes in layer_tars:
tf = tarfile.open(fileobj=io.BytesIO(tar_bytes), 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")
# 活 rootfs 的文件级清单:build 阶段算过一次,这里**用同一个函数**
# 从层内容重算,并核对 digest 与 manifest.annotations 里写的一致。
# 两边不一致 = 构建期与打包期的理解已经分叉,必须拒绝打包。
files, links = rootfs_state_from_layers(layer_tars)
files_bytes, links_bytes = rootfs_manifest_bytes(files, links)
expect_files = manifest_annotations.get("mpc.tee.rootfs-files-digest")
expect_links = manifest_annotations.get("mpc.tee.rootfs-links-digest")
if expect_files and expect_files != sha256_hex(files_bytes):
sys.stderr.write("打包前校验失败: 活 rootfs 文件清单与 manifest 声明不符\n")
return 1
if expect_links and expect_links != sha256_hex(links_bytes):
sys.stderr.write("打包前校验失败: 活 rootfs 链接清单与 manifest 声明不符\n")
return 1
with open(os.path.join(oci, "rootfs.sha256"), "wb") as f:
f.write(files_bytes)
with open(os.path.join(oci, "rootfs.links"), "wb") as f:
f.write(links_bytes)
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)
# ── 打包后自证 ──────────────────────────────────────────────
# 把刚写出的 initrd **真的读回来**,确认里面嵌的确实是这次镜像的
# digest 与活 rootfs 清单。
#
# 为什么必须自证:早先 `pack` 被外层管道吞掉了失败退出码
# (`pack ... | grep -v RuntimeWarning` 取的是 grep 的 rc),
# 于是旧 initrd 被当成新产物继续用;更隐蔽的是多个并发实例共用
# 同一个远端目录,image/ 与 initrd.img 来自不同轮次 —— 流水线
# **自己不会发现**这种错配,只有自证能拦下。
raw = gzip.decompress(packed) if packed[:2] == b"\x1f\x8b" else packed
embedded = cpio_read_file(raw, "etc/mpc-tee/manifest.digest")
if embedded is None:
sys.stderr.write("打包失败: initrd 里找不到 etc/mpc-tee/manifest.digest\n")
return 1
embedded_digest = embedded.decode("utf-8", "replace").strip()
if embedded_digest != manifest_digest:
sys.stderr.write(
"打包失败: initrd 内嵌 digest 与镜像 manifest 不符\n"
" initrd=%s\n manifest=%s\n" % (embedded_digest, manifest_digest))
return 1
embedded_files = cpio_read_file(raw, "etc/mpc-tee/oci/rootfs.sha256")
embedded_links = cpio_read_file(raw, "etc/mpc-tee/oci/rootfs.links")
if embedded_files != files_bytes or embedded_links != links_bytes:
sys.stderr.write(
"打包失败: initrd 内嵌的活 rootfs 清单与本次计算结果不符\n")
return 1
embedded_manifest = cpio_read_file(raw, "etc/mpc-tee/oci/manifest.json")
if embedded_manifest is None:
sys.stderr.write("打包失败: initrd 里找不到 etc/mpc-tee/oci/manifest.json\n")
return 1
if sha256_hex(embedded_manifest) != manifest_digest:
sys.stderr.write(
"打包失败: initrd 内 manifest.json 的 sha256 与 PIN 不符\n")
return 1
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))
print("rootfs_files=%d rootfs_links=%d" % (len(files), len(links)))
print("selfcheck=ok (initrd 内嵌 digest / 清单 / manifest 均已回读核对)")
if not args.quiet:
top = ["init", "mpc", "bin/busybox",
"etc/mpc-tee/manifest.digest", "etc/mpc-tee/oci/layers.sha256",
"etc/mpc-tee/oci/rootfs.sha256",
"etc/mpc-tee/oci/rootfs.links"]
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())