交付两件此前欠着的事,并在真机(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 完整性链自测。
886 lines
37 KiB
Python
886 lines
37 KiB
Python
#!/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())
|