- 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。
473 lines
17 KiB
Python
473 lines
17 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 的边界说明。
|
||
|
||
兼容 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())
|