Files
admin e839a972c0 feat(tee): 接入 AMD SEV-SNP 芯片验签,双平台「先验证明才给密钥」全部真机跑通
## 改了什么

- **SNP 芯片签名验签闭环**:新增 `snp_collect.rs`(SNP_GET_EXT_REPORT ioctl
  + GHCB 切分)、`snp-verify-attestation.sh`(VCEK 走 AMD KDS)、
  `selftest-snp-verify.py`(正 1 + 负 8),进主闸门第 10 条。
- **框架侧补 `mpc.tee.platform`**:`tee plan` 现在告诉 guest 用哪个平台采证明。
- **KBS 补独立 `--pin`**:`MPC_KBS_PIN` 与 `--measurement` 解耦,缺省回落,
  既有部署行为不变 —— 这是「度量 pin 那一关」唯一能被单独测到的姿势。
- **guest stdout 修复**:init 开头 mknod 真 `/dev/console` + `exec > ... 2>&1`;
  `run-guest.py` 加 `MPC_TEE_SERIAL_LOG` 换 chardev file 落盘。
- **负向矩阵**:新增 `snp-attest-negative.sh`(6 条),判据全部收紧到该关独有文案。
- **KBS 就绪判据**:`kbs-net.sh` 从「进程存活」改成「端口进 LISTEN」。
- **文档**:`TEE_DIRECT_LAUNCH.md` 新增 SNP 整节 + bug 1~9;
  `TEE_OCI_PATH.md` 补 SNP 侧与负向判据唯一性;新增 `INTEGRATION_ANALYSIS.md`
  与 `OPTEE_VERIF_PLAN.md`;`ci.sh` 加 no_std 双守、TA UUID 对拍、SNP 自测。

## 什么影响

- 真机(海光 CSV `192.168.1.102` + AMD SNP `192.168.1.7`)**双向跑通**,
  两端用同一份 Rust 判定代码。
- SNP 正向 e2e 7/7、负向 6/6 全部真拒在各自关卡;`tools/ci.sh` 十条全绿。
- 三处真 bug 已修:guest stdout 全丢(`/dev/console` 是普通文件 +
  `-nographic`/`-serial stdio` 抢 stdio)、`MPC_KBS_PIN` 接口缺口、
  负向判据不唯一(兜底分支导致假绿)。
- 边界不变:`attest-mkbundle` 仍是合成件,过不了芯片验签(仅自测用)。
2026-11-07 12:47:22 +08:00

627 lines
31 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
"""KBS 资源下发服务 —— **先验证明,才给密钥**。
# 为什么不是「查一下 session 就发」
上一版(`serve.py` 的雏形)只检查请求头里的 session 与 token 匹配,
token 是个占位字符串 `offline-demo`。也就是说:**只要能连到 KBS 并知道
会话 id,就能拿到密钥**,根本没验证「对面真的是这轮会话里跑着这份镜像的
那台机密虚拟机」。这不是密钥服务,是个文件服务器。
这一版把顺序倒过来:
1. guest 先向芯片要一份证明(报告原文 + 证书链 + 期望绑定值),打包成
**证明包**,POST 到 `/kbs/v0/attestation`;
2. KBS 用**与验证方完全同一份** Rust 代码校验(调用 `mpc tee attest-check`):
结构 / 会话绑定 / 代码度量 pin / TCB / 芯片签名;
3. **通过才签发 token**,token 绑定「会话 + 证明包摘要」;
4. 之后取资源必须带这个 token,KBS 核对它确实是自己签发的那一份。
# 为什么判定要调 Rust
证明判定如果 KBS 用 Python 重写一遍,就有了**两份口径**。上一轮踩过的坑
就在这里:生成端自检与审计端判定不一致时,「一致地判不通过」会被误读成
「模型不稳定」,「一致地判通过」则是虚假安全感。
所以 Python 只做**搬运字节 + 看退出码**,判定逻辑全部在
`mpc tee attest-check` 里。KBS 换个语言实现、换个 Python 版本,判定口径
都不变。
# 严格模式
默认就是**严格**(必须提供验签器、必须验签通过)。演练模式要显式
`--allow-demo-token` 且必须同时给 `--demo-token`,且每次放行都写告警日志。
# token 为什么改成无状态
上一版把已签发的 token 放在**进程内 dict** 里。这有两个硬伤:
1. **KBS 重启即失效** —— 一台机器上重启一下 KBS,所有 guest 手里的
token 全部作废,正在跑的会话取不到密钥。
2. **不跨实例** —— 多实例部署时,签发的实例和校验的实例不是同一个,
另一个实例根本不认识这个 token。
所以 token 改成**无状态自校验**:token 里带「会话 + 证明包摘要 + 过期时间 +
HMAC」,KBS 校验时**自己重算 HMAC** 比对,不需要查表。
无状态不等于放弃审计:签发时仍然落一条审计记录(谁、什么时候、哪份证明),
以便事后核对「这轮会话到底发过几次密钥」。
Python 3.6 兼容(海光 Anolis 8.10)。
"""
import argparse
import hashlib
import hmac
import json
import os
import ssl
import subprocess
import sys
import time
from http.server import BaseHTTPRequestHandler, HTTPServer
PREFIX = "/kbs/v0/resource/"
ATTEST_PATH = "/kbs/v0/attestation"
# 演练用的占位 token。生产**永远**不该出现这个值。
DEMO_TOKEN = "offline-demo"
# token 有效期(秒)。证明是「这一轮会话」的事,不是「永久授权」——
# 有效期太长会让一份证明被反复重放。
TOKEN_TTL = 300
# 单个资源 body 上限(与客户端 mpc_tee::kbs::MAX_RESOURCE_BYTES 对齐)。
MAX_RESOURCE_BYTES = 64 * 1024
# 单个证明包上限(与客户端 mpc_tee::bundle::MAX_BUNDLE_BYTES 对齐)。
MAX_BUNDLE_BYTES = 256 * 1024 + 16 * (64 * 1024 + 4) + 64
# 单次判定(attest-check)的超时上限(秒)。
# 判定器卡住不能拖垮整个 KBS —— 最坏情况下这一条请求失败即可,
# 不该让整个服务不可用。
ATTEST_TIMEOUT = 30
# token 的 MAC 长度(十六进制字符数)。32 个十六进制字符 = 128 位。
TOKEN_MAC_LEN = 32
def token_key():
"""取服务端 token 密钥。
★ 缺省**不再退化**。上一版缺省时用「证明包摘要」当密钥 —— 那意味着
任何能算出摘要的人都能伪造 token(摘要本身就在 token 里明文带着)。
这是「看起来有密钥、其实没有」的最坏形态。
现在缺省就是**没有密钥**,由调用方决定是拒绝启动还是走演练路径。
"""
raw = os.environ.get("MPC_KBS_TOKEN_KEY", "")
if not raw:
return None
return raw.encode("utf-8")
def mint_token(key, sess, digest, ttl):
"""签发一个**无状态** token。
token 格式:``v1.<session>.<digest[:32]>.<expires>.<mac[:32]>``
mac = HMAC-SHA256(key, "session|digest|expires")
无状态意味着 KBS 不需要存任何东西就能校验这个 token:自己重算一遍
HMAC 比对即可。这样 KBS 重启不影响已签发的 token,多实例之间也
天然互通(只要共用同一个密钥)。
会话 id **明文放在 token 里**是安全的:它本来就明文出现在每个请求头
里,不是秘密。放进 token 是为了让校验能区分「token 不属于本会话」
与「token 签名不对」两种拒绝原因 —— 排查时这两个的成因完全不同。
"""
expires = int(time.time()) + ttl
# ★ MAC 只覆盖 token 里**实际携带**的字段 —— 否则校验端拿不到
# 完整 digest,重算出来的 MAC 必然对不上(实测踩过:
# 签发用完整 digest、校验用前缀 → 「token 签名不匹配」)。
prefix = digest[:32]
msg = ("%s|%s|%d" % (sess, prefix, expires)).encode("ascii")
mac = hmac.new(key, msg, hashlib.sha256).hexdigest()
return "v1.%s.%s.%d.%s" % (sess, prefix, expires, mac[:TOKEN_MAC_LEN])
def check_token(key, token, sess, now=None):
"""核对 token。返回 (是否通过, 原因)。
校验四件事,**顺序有意义**:
1. 格式:五段、MAC 长度对 —— 格式不对直接拒,不进下一步;
2. 会话匹配;
3. 过期;
4. **重算 HMAC 并常量时间比较** —— 这是真正决定放行与否的那一步。
"""
if not token:
return False, "缺少 attestation token"
parts = token.split(".")
if len(parts) != 5 or parts[0] != "v1":
return False, "token 格式不对"
_, tok_sess, digest_prefix, exp_s, mac = parts
if len(mac) != TOKEN_MAC_LEN:
return False, "token 格式不对"
try:
expires = int(exp_s)
except ValueError:
return False, "token 格式不对"
if tok_sess != sess:
return False, "token 不属于本会话"
if now is None:
now = int(time.time())
if expires < now:
return False, "token 已过期"
if key is None:
return False, "KBS 未配置 token 密钥,无法校验 token"
msg = ("%s|%s|%d" % (sess, digest_prefix, expires)).encode("ascii")
expect = hmac.new(key, msg, hashlib.sha256).hexdigest()[:TOKEN_MAC_LEN]
# ★ 必须用常量时间比较 —— 逐字节比较会在第一个不同处提前返回,
# 泄露 MAC 的前缀信息。
if not hmac.compare_digest(expect, mac):
return False, "token 签名不匹配"
return True, "ok"
def make_handler(resources, session, mpc_bin, verifier_cmd, verifier_args,
demo_token, node_tcb, min_tcb, require_chip, platform,
chain_dir="", token_key=None, audit_path=""):
"""构造请求处理器。
`mpc_bin` 是框架的 `mpc` 二进制路径 —— 判定由
`mpc tee attest-check` 完成(Python 只搬运字节、看退出码)。
`verifier_cmd` 是**芯片验签器**(如海光厂商的 `verify-attestation`),
它会被转交给 `attest-check --verifier <prog>`,由框架去调。
为空表示没有芯片验签器 —— 此时严格模式下一律拒绝。
`token_key` 是签发/校验 token 用的服务端密钥。**None 表示没有密钥**,
此时任何 token 都无法通过校验(fail-closed)。
"""
class Handler(BaseHTTPRequestHandler):
server_version = "mpc-tee-kbs/2.0"
def log_message(self, fmt, *args):
sys.stderr.write("[kbs] %s\n" % (fmt % args))
# stderr 被重定向到文件时是全缓冲的,不 flush 的话日志要等
# 进程退出才出现 —— 真机上排查时看到的是「空日志」,很容易
# 误判成「KBS 什么都没做」。
sys.stderr.flush()
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 _read_body(self):
length = self.headers.get("Content-Length")
if length is None:
return None, "缺少 Content-Length"
try:
n = int(length)
except ValueError:
return None, "Content-Length 不是整数"
if n < 0 or n > MAX_BUNDLE_BYTES:
return None, "请求体过大或非法"
return self.rfile.read(n), None
def _run_attest_check(self, bundle_bytes):
"""调用 `mpc tee attest-check` 判定,返回解析后的 JSON 结论。
判定逻辑全在 Rust 里,Python 只搬运字节、看退出码 ——
这样 KBS 与审计端的判定口径**必然一致**(不存在两份实现)。
"""
# ★ 没有 mpc 二进制时必须直接拒,不能往下拼命令。
# 否则 cmd 会变成 ["tee", "attest-check", ...] —— 也就是去执行
# 系统里的 GNU coreutils `tee`,它会**等 stdin 读完**才退出,
# 表现是 HTTP 请求一直挂到超时(自测里实测到了)。
if not mpc_bin:
return None, "KBS 未配置 mpc 二进制,无法做证明判定"
tmpdir = os.environ.get("TMPDIR", "/tmp")
path = os.path.join(tmpdir, "mpc-kbs-bundle-%d.bin" % os.getpid())
# ★ 判定进程在**独立工作目录**里跑。
# 万一 mpc 指向了某种会吞参数的程序(GNU coreutils 的 tee 就是
# 典型:它把每个非选项参数当文件名创建),副作用被关在这个
# 目录里,不会污染 KBS 的工作目录 —— 本轮自测实测踩中过,
# 仓库根目录被撒了 15 个垃圾文件。
workdir = os.path.join(tmpdir, "mpc-kbs-work-%d" % os.getpid())
try:
with open(path, "wb") as f:
f.write(bundle_bytes)
if not os.path.isdir(workdir):
os.makedirs(workdir)
cmd = [mpc_bin, "tee", "attest-check",
"--bundle", path,
"--platform", platform,
"--session-id", session,
"--site", os.environ.get("MPC_KBS_SITE", "site"),
"--pubkey", os.environ.get("MPC_KBS_PUBKEY", "00" * 32),
"--measurement", os.environ.get("MPC_KBS_MEASUREMENT", "00" * 32),
# ★ --pin 是**独立的**度量 pin,与 --measurement 分开。
#
# --measurement 参与绑定值重算(guest 侧算 user_data 时
# 用的就是它),--pin 才是「准入时批准的那份镜像」。
# 两者不给同一个值时,绑定检查会先过、度量 pin 那一关
# 单独触发 —— 这是「度量 pin 不符」这一关**唯一**能被
# 单独测到的姿势。
# 早先 KBS 只给 --measurement,于是改度量必然先撞
# 「绑定不一致」,那一关永远测不到(假绿)。
"--pin", os.environ.get("MPC_KBS_PIN",
os.environ.get("MPC_KBS_MEASUREMENT", "00" * 32)),
# ★ --tcb 是**节点的实际 TCB**(参与绑定值计算),
# --min-tcb 是**门槛**(只做准入比较)。
# 两者不能混:漏传 --tcb 会让重算的绑定值用 tcb=0,
# 于是「报告里的 user_data 与本次会话绑定不一致」——
# 一个把参数漏填报成重放攻击的误导性结论。
"--tcb", str(node_tcb),
"--min-tcb", str(min_tcb),
"--report", "json"]
if verifier_cmd:
cmd += ["--verifier", verifier_cmd[0]]
for a in verifier_args:
cmd += ["--verifier-arg", a]
# 证书链目录单独走 --chain-dir:
# 它必须**紧跟在 --chain-dir 这个 token 之后**,
# 而 argparse 遇到「以 - 开头的值」会把它当成下一个
# 选项 —— 实测 `--verifier-arg --chain-dir X` 直接报
# "argument --verifier-arg: expected one argument"。
# 所以这类「路径/目录」类参数要有自己的选项名。
if chain_dir:
cmd += ["--chain-dir", chain_dir]
# ★ stdin 必须显式接 DEVNULL。
# 判定器一旦读了 stdin(GNU coreutils 的 tee 就会:它要等
# stdin 读到 EOF 才退出),继承来的 stdin 可能永远不 EOF,
# 于是判定进程挂死 —— 表现是 HTTP 请求一直挂着直到客户端
# 超时(本轮自测实测命中)。接 DEVNULL 的话 EOF 立即到达,
# 判定器立刻退出。
# ★ 同时给判定设上限:判定器卡住不能拖垮整个 KBS。
try:
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.DEVNULL,
cwd=workdir)
out, err = proc.communicate(timeout=ATTEST_TIMEOUT)
except subprocess.TimeoutExpired:
try:
proc.kill()
except OSError:
pass
return None, "attest-check 超时(%d 秒)" % ATTEST_TIMEOUT
text = out.decode("utf-8", "replace").strip()
try:
doc = json.loads(text)
except ValueError:
return None, ("attest-check 输出不是 JSON: %s" % text[:200])
# ★ 必须是**期望的 JSON 结构**,不能是「恰好也能解析的别的东西」。
# 判定结果必须显式带 ok / verdict 两个字段,缺一即拒 ——
# 否则「输出是合法 JSON 但不是判定结论」会被当成通过(假绿)。
if not isinstance(doc, dict) or "ok" not in doc or "verdict" not in doc:
return None, ("attest-check 输出不是判定结论: %s" % text[:200])
if proc.returncode != 0 or not doc.get("ok"):
return doc, doc.get("verdict") or err.decode("utf-8", "replace").strip()
return doc, doc.get("verdict", "通过")
except OSError as e:
return None, "调用 attest-check 失败: %s" % e
finally:
try:
os.remove(path)
except OSError:
pass
# 清掉判定进程的工作目录(含它可能误建的垃圾文件)。
try:
if os.path.isdir(workdir):
for name in os.listdir(workdir):
try:
os.remove(os.path.join(workdir, name))
except OSError:
pass
os.rmdir(workdir)
except OSError:
pass
def do_POST(self):
if self.path.split("?", 1)[0] != ATTEST_PATH:
return self._deny(404, "unknown path")
body, err = self._read_body()
if err:
return self._deny(400, err)
got_session = self.headers.get("MPC-Tee-Session", "")
if got_session != session:
return self._deny(403, "session mismatch")
doc, verdict = self._run_attest_check(body)
# ★ 判定结论必须落日志 —— 「通过」这件事本身要能被事后核对。
# 特别是 chip 字段:只有它写着 verified-by:xxx,才说明芯片
# 签名真的验过,而不是只过了结构与绑定。
# stderr 是行缓冲的,但被重定向到文件时 Python 会改成全缓冲,
# 所以这里显式 flush —— 否则进程还在跑时日志文件是空的
# (真机实测 kbs.log 是 0 字节,看着像「什么都没发生」)。
if doc is None:
sys.stderr.write("[kbs] 证明校验未通过: %s\n" % verdict)
sys.stderr.flush()
return self._deny(403, "attestation rejected: %s" % verdict)
sys.stderr.write(
"[kbs] 判定结论: ok=%s structure_ok=%s bound_ok=%s chip=%s verdict=%s\n"
% (doc.get("ok"), doc.get("structure_ok"), doc.get("bound_ok"),
doc.get("chip"), doc.get("verdict")))
sys.stderr.flush()
if not doc.get("ok"):
return self._deny(403, "attestation rejected: %s" % verdict)
# 芯片签名未验证时,严格模式一律拒绝 —— 「结构对」不等于
# 「芯片签过名」。
chip = doc.get("chip", "")
if require_chip and not chip.startswith("verified-by"):
sys.stderr.write("[kbs] 证明未经芯片验签(chip=%s),严格模式拒绝\n"
% chip)
return self._deny(403, "attestation 未经芯片验签,严格模式拒绝")
digest = hashlib.sha256(body).hexdigest()
token = self._mint_token(session, digest)
self._audit("attest-ok", session, digest, token)
payload = json.dumps({
"token": token,
"session": session,
"bundle_digest": digest,
"expires_in": TOKEN_TTL,
"verdict": verdict,
"chip": chip,
}).encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(payload)))
self.end_headers()
self.wfile.write(payload)
def _audit(self, event, sess, digest, token=""):
"""落一条审计记录。
token 改成无状态之后,KBS 不再需要「查表」来验证它 ——
但**审计不能跟着一起消失**。这一轮会话到底发过几次密钥、
凭的是哪份证明,事后必须查得到。
落盘失败只告警不阻断:审计写不进去不该让服务不可用
(但也不能装作没事,所以必须打日志)。
"""
if not audit_path:
return
rec = {
"ts": int(time.time()),
"event": event,
"session": sess,
"bundle_digest": digest,
"token_prefix": token[:32] if token else "",
}
try:
with open(audit_path, "a") as f:
f.write(json.dumps(rec, sort_keys=True) + "\n")
f.flush()
except OSError as e:
sys.stderr.write("[kbs] WARNING: 审计记录写入失败 %s: %s\n"
% (audit_path, e))
sys.stderr.flush()
def _mint_token(self, sess, digest):
"""签发 token:绑定会话与证明包摘要。
无状态:token 自带过期时间与 HMAC,KBS 校验时自己重算比对,
不需要查表 → KBS 重启不影响已签发的 token,多实例也互通。
"""
if token_key is None:
# 没有密钥就**签不出**可用 token —— 与其签一个必然被拒的
# token,不如在这里直接失败(fail-closed)。
raise ValueError("KBS 未配置 token 密钥,无法签发 token")
return mint_token(token_key, sess, digest, TOKEN_TTL)
def _check_token(self, token, sess):
"""核对 token 是自己签发的、没过期、且属于本会话。"""
if demo_token and token == demo_token:
sys.stderr.write("[kbs] WARNING: 放行占位证明 token(演练模式)\n")
sys.stderr.flush()
return True, "demo token(演练)"
ok, why = check_token(token_key, token, sess)
if ok:
self._audit("resource-served", sess, token[:32], token)
return ok, why
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("/")
# 路径三段的顺序必须与客户端 `mpc_tee::kbs::ResourcePath::path()`
# 完全一致:<repo>/<kind>/<tag>。曾经这里写的是 <repo>/<tag>/<kind>,
# 而客户端发的是 <repo>/<kind>/<tag> —— 真机上直接 403,
# 且报的是「session mismatch」,把一个路径顺序 bug 报成了会话问题。
if len(parts) != 3 or not all(parts):
return self._deny(400, "expected /<repo>/<kind>/<tag>")
repo, kind, tag = parts
allowed = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz0123456789._-")
if any(not set(p) <= allowed for p in parts):
return self._deny(400, "illegal resource component")
# kind 是固定的三类物料,不接受任意名字(避免拿别的资源当密钥用)。
if kind not in ("psk", "seed", "root-key"):
return self._deny(400, "unknown resource kind: %s" % kind)
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")
ok, why = self._check_token(token, session)
if not ok:
return self._deny(403, why)
full = os.path.abspath(os.path.join(resources, repo, kind, tag))
base = os.path.abspath(os.path.join(resources, repo, kind))
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()
if len(body) > MAX_RESOURCE_BYTES:
return self._deny(500, "resource too large")
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)
return Handler
def main():
ap = argparse.ArgumentParser(description="KBS 资源下发服务(先验证明)")
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("--mpc", default=os.environ.get("MPC_KBS_MPC", ""),
help="框架 mpc 二进制路径(判定由它做)")
ap.add_argument("--verifier", default=os.environ.get("MPC_KBS_VERIFIER", ""),
help="芯片验签器程序路径(留空 = 无法验签)")
ap.add_argument("--verifier-arg", action="append", default=[],
help="验签器附加参数(可重复)")
ap.add_argument("--chain-dir", default=os.environ.get("MPC_KBS_CHAIN_DIR", ""),
help="芯片证书链目录(转交给验签器,如海光的 scripts/ 目录)")
ap.add_argument("--tcb", type=int,
default=int(os.environ.get("MPC_KBS_TCB", "0")),
help="节点实际 TCB(参与绑定值计算,必须与启动同源)")
ap.add_argument("--min-tcb", type=int,
default=int(os.environ.get("MPC_KBS_MIN_TCB", "0")),
help="TCB 门槛(只做准入比较)")
ap.add_argument("--platform", default=os.environ.get("MPC_KBS_PLATFORM", "csv"),
help="平台(csv/snp)")
ap.add_argument("--allow-demo-token", action="store_true",
help="允许占位 token(演练用,必须同时给 --demo-token)")
ap.add_argument("--demo-token", default=os.environ.get("MPC_KBS_DEMO_TOKEN", ""),
help="演练占位 token(配合 --allow-demo-token)")
ap.add_argument("--no-require-chip", action="store_true",
help="不要求芯片验签通过(仅本地开发,生产禁止)")
ap.add_argument("--audit-log", default=os.environ.get("MPC_KBS_AUDIT_LOG", ""),
help="审计日志路径(每条签发/下发记一行 JSONL)")
ap.add_argument("--token-key", default="",
help="token 签名密钥(也可给环境变量 MPC_KBS_TOKEN_KEY)")
ap.add_argument("--tls-cert", default=os.environ.get("MPC_KBS_TLS_CERT", ""),
help="TLS 服务端证书(PEM)")
ap.add_argument("--tls-key", default=os.environ.get("MPC_KBS_TLS_KEY", ""),
help="TLS 服务端私钥(PEM)")
ap.add_argument("--require-tls", action="store_true",
help="要求 TLS 已启用(未配证书则拒绝启动)")
args = ap.parse_args()
if not os.path.isdir(args.resources):
sys.exit("资源目录不存在: %s" % args.resources)
if args.allow_demo_token and not args.demo_token:
sys.exit("--allow-demo-token 必须同时给 --demo-token")
verifier_cmd = [args.verifier] if args.verifier else []
require_chip = not args.no_require_chip
chain_dir = args.chain_dir
# ★ token 密钥缺省 = **拒绝启动**。
# 上一版缺省时退化成「用证明包摘要当密钥」—— 而摘要就明文写在
# token 里,任何人都能自己算出来。于是「有 HMAC」是假象,谁都能
# 造出合法 token。那是「看起来有密钥、其实没有」的最坏形态。
# 现在没有密钥就是没有密钥:要么给密钥,要么明确走演练路径。
key = token_key()
if args.token_key:
key = args.token_key.encode("utf-8")
if key is None:
if not args.allow_demo_token:
sys.exit(
"未配置 token 密钥(MPC_KBS_TOKEN_KEY 或 --token-key)\n"
" token 用 HMAC 签名,缺密钥时无法签发也无法校验。\n"
" 生产必须给一个真随机密钥;仅本地演练可加 --allow-demo-token "
"并同时给 --demo-token。")
sys.stderr.write("[kbs] ★ 演练模式:无 token 密钥,token 校验必然失败\n")
sys.stderr.flush()
elif len(key) < 16:
sys.exit("token 密钥太短(至少 16 字节,当前 %d)" % len(key))
# ★ --mpc 必须是一个**真实存在的可执行文件**。
#
# 为什么要卡这一步:判定命令拼成
# `[mpc, "tee", "attest-check", "--bundle", ...]`。如果 mpc 为空或
# 拼错,`tee` 会落到 argv[0] 上,于是执行的是系统里的 **GNU coreutils
# tee** —— 它把**每一个非选项参数都当文件名创建出来**(实测:
# `tee attest-check --bundle x --platform csv` 会生成
# attest-check / --bundle / x / --platform / csv 五个空文件)。
#
# 后果有两层:
# ① 副作用:往当前工作目录里撒一堆垃圾文件;
# ② **假绿风险**:tee 成功退出、stdout 却是空的或非 JSON,
# 若判定逻辑退化成「只要不报错就算过」就会误放行。
# (本轮自测实测踩中:仓库根目录被撒了 15 个垃圾文件。)
if not args.mpc:
sys.stderr.write("[kbs] WARNING: 未配置 --mpc,所有证明都会被拒(无法判定)\n")
elif not os.path.isfile(args.mpc):
sys.exit("--mpc 指向的文件不存在: %s" % args.mpc)
elif not os.access(args.mpc, os.X_OK):
sys.exit("--mpc 指向的文件不可执行: %s" % args.mpc)
if not verifier_cmd and require_chip:
sys.stderr.write("[kbs] WARNING: 未配置芯片验签器,严格模式下所有证明都会被拒\n")
# ★ TLS:密钥服务走明文 HTTP 等于把会话密钥在网线上裸奔。
# KBS 自带 TLS(Python 标准库 ssl,不引依赖),也可以放在反向代理
# 后面 —— 但那样 KBS 进程本身仍然监听明文端口,代理漏配就裸奔。
# 所以这里提供 --require-tls:**要求本进程自己**启用 TLS,
# 没配证书就拒绝启动,而不是「打个警告继续跑」。
tls_ctx = None
if args.tls_cert or args.tls_key:
if not (args.tls_cert and args.tls_key):
sys.exit("--tls-cert 与 --tls-key 必须同时给")
for p in (args.tls_cert, args.tls_key):
if not os.path.isfile(p):
sys.exit("TLS 文件不存在: %s" % p)
tls_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
try:
tls_ctx.load_cert_chain(args.tls_cert, args.tls_key)
except (ssl.SSLError, OSError) as e:
sys.exit("TLS 证书加载失败: %s" % e)
# TLS 1.2 起,不允许更老的协议。
try:
tls_ctx.minimum_version = ssl.TLSVersion.TLSv1_2
except AttributeError:
pass
elif args.require_tls:
sys.exit("--require-tls 但未给 --tls-cert/--tls-key")
srv = HTTPServer((args.host, args.port),
make_handler(args.resources, args.session, args.mpc,
verifier_cmd, args.verifier_arg, args.demo_token,
args.tcb, args.min_tcb, require_chip, args.platform,
chain_dir, token_key=key,
audit_path=args.audit_log))
scheme = "http"
if tls_ctx is not None:
srv.socket = tls_ctx.wrap_socket(srv.socket, server_side=True)
scheme = "https"
sys.stderr.write(
"[kbs] listening %s://%s:%d strict=%s demo_token=%s mpc=%s "
"token_key=%s tls=%s audit=%s\n" %
(scheme, args.host, args.port, require_chip,
bool(args.allow_demo_token), args.mpc or "(未配置)",
"yes" if key else "no", "yes" if tls_ctx else "no",
args.audit_log or "(未配置)"))
if args.allow_demo_token:
sys.stderr.write("[kbs] ★ 演练模式:占位 token 会被放行,禁止用于生产\n")
sys.stderr.flush()
try:
srv.serve_forever()
except KeyboardInterrupt:
pass
return 0
if __name__ == "__main__":
sys.exit(main())