Files
ssw-mpc/crates/mpc-hostd/src/api.rs
T
admin 393359ef35 fix(tee): 修掉 3199d16 遗留的编译破损,并让上传路由归位到宿主控制面
3199d16「TEE 远程调度面与节点自报」把 control_plane.rs 进了仓,但
reconciler.rs 没跟着改;main.rs 那边整块重复粘贴了 15 个顶层 fn。
后续两个提交只改文档没碰代码,破损一直潜伏 —— HEAD 编译直接失败:

  error[E0599]: no method named `set_require_chip_sig`
  error[E0063]: missing field `chip_sig_failed` in initializer
  error[E0308]: expected `NodeRegistry`, found `Arc<NodeRegistry>`
  error[E0428]: the name `cmd_tee` is defined multiple times(15 组)

上传路由归位(guest 边界 + 路由漂移):

- 路由形状只有一份,在 hostd 侧:api::attestation_upload_path(id)。
- 宿主经 9p 手牌把完整上传路径注入 guest(手牌第 4 份文件 upload_path)。
- mpc-tee 不再持有 "/sandboxes" 字面量,guest 产物里不再出现该路由。
- CLI 新增 --upload-path-file;guest init.sh 读手牌并传下去。
- 三道防线:源码层 Rust 单测 + 源码层 CI 脚本 + 产物层 ELF 探针。
  产物层判据有盲区(字面量进死代码会被 LTO 裁掉 ⇒ 假绿),
  已用三形态破坏实验验证源码层两道能转红。

对账器三态语义(证据成立 ≠ 可公布):

- is_verified() 决定实例去留;publishable(require_chip_sig) 决定端点外泄。
- chip_sig_failed 区分「没验」与「验了没过」:前者判 verified 但按策略
  不公布,后者硬拒绝判 rejected 并回收实例。
- 证明漂移先从 placed 移除旧记录再回收实例,否则 proven_endpoints()
  会继续公布证明已不通过的旧端点(真 fail-open)。

验证:暂存区快照独立编译 exit 0;mpc-tee 230 passed / mpc-hostd 171
passed / mpc-cli 69 passed;tools/ci.sh --fast exit 0(binary 判据 39/39,
含「/sandboxes 不得出现在 guest 产物」)。

真机 9p 探针修掉三个真 bug:init_b64 取的是 stdout(空)而非文件内容
⇒ 远端 /init 0 字节 ⇒ 内核 ENOEXEC;qemu 参数用 \ 续行被 ssh 管道吃掉;
本地 90 轮轮询每轮走 xop 触摸验证 ⇒ 改为远端轮询一次取回。
2026-11-09 15:34:26 +08:00

1960 lines
80 KiB
Rust
Raw 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.
//! e2b 兼容的宿主控制面 API。
//!
//! # 兼容的是什么
//!
//! 对齐 cbox 的 `boxe2b`(见 `~/Documents/x/cbox/boxe2b/src/api.rs`):
//! 同一套路由、同一套 `SandboxView` 字段名(`templateID` / `sandboxID` /
//! `clientID` / `envdVersion` / `envdAccessToken` / `domain` / `alias` /
//! `timeout` / `memory`)、同一套错误体(`{"code": ..., "message": ...}`)。
//!
//! v1 与 v2 路径共用同一批 handler(E2B SDK 走 `/v2/...`)。
//!
//! # 与 e2b 的三处**故意**不同
//!
//! 1. **template 的语义升级**:e2b 里 template = 镜像;对 TEE,template 必须是
//! **度量集合**(kernel hash + initramfs hash + cmdline + OVMF 版本 + 平台类型)。
//! API 形状不变,但存储内容从 `docker image` 变成一条 `MeasurementProfile`。
//! 2. **证明不塞进 `SandboxView`**:e2b 返回体里没有这个字段,硬塞会破坏 SDK 兼容。
//! 所以证明走独立端点 `GET /sandboxes/{id}/attestation`。
//! 3. **pause / resume 的语义**:e2b 的 pause 是"停止 box",resume 是"再启动";
//! TEE 侧对应 SIGSTOP / SIGCONT guest 进程(qemu 没有 box 那种 stop/start)。
//!
//! # ★ 「验证通过」必须拆成四句话
//!
//! `/attestation` 的返回体里,四个结论**分开报**,不许合并成一个 `ok=1`:
//!
//! ```text
//! user_data_ok=1 meas_ok=1 tcb_ok=1 chip_sig=0
//! ```
//!
//! `chip_sig=0` 的含义是「**绑定关系成立,但没做芯片验签**」。
//! 运维看到 `ok=1` 就以为安全,是最容易出的事故。
//! 这是 `fold_semantic_risks()` 那条「判定口径只有一份」的纪律在 API 层的体现。
use crate::protocol::{Request, Response, Status};
use crate::json::{Json, JsonObject};
use crate::runtime::{Instance, InstanceState, TeeRuntime};
use crate::registry_api::node_report_to_json;
use mpc_tee::dispatch::AttestationStatus;
use mpc_tee::session::SessionBinding;
use mpc_tee::PlatformKind;
/// e2b 兼容层返回的沙箱视图。
///
/// **字段名必须与 e2b 完全一致** —— 同一套 e2b 客户端库要能直接用。
#[derive(Debug, Clone)]
pub struct SandboxView {
/// template ID(对 TEE 是度量集合标识)。
pub template_id: String,
/// 沙箱 ID。
pub sandbox_id: String,
/// 客户端标识。
pub client_id: String,
/// envd 版本(TEE 场景无 envd,给固定值以满足 SDK 解析)。
pub envd_version: String,
/// 数据面访问令牌(TEE 场景不用)。
pub envd_access_token: Option<String>,
/// 域名(TEE 场景不用)。
pub domain: Option<String>,
/// 别名。
pub alias: Option<String>,
/// 超时秒数。
pub timeout: u64,
/// 内存(MiB)。
pub memory: u64,
// --- 扩展字段(e2b 语义之外)-----------------------------------------
/// 本轮会话标识。
pub session_id: String,
/// 站点名。
pub site: String,
/// TEE 平台。
pub platform: PlatformKind,
/// 实例状态。
pub state: String,
/// 实际执行的命令行(argv 数组)。
pub argv: Vec<String>,
/// 创建时刻(Unix 秒)。
pub created_at: u64,
}
impl SandboxView {
/// 从运行时实例生成视图。
pub fn of(inst: &Instance) -> Self {
Self {
template_id: inst.template.clone(),
sandbox_id: inst.sandbox_id.clone(),
client_id: String::from("mpc-hostd"),
envd_version: String::from("0.5.13"),
envd_access_token: None,
domain: None,
alias: Some(format!("mpc-{}", &inst.sandbox_id[..6.min(inst.sandbox_id.len())])),
timeout: inst.timeout_secs,
memory: 0,
session_id: inst.session_id.clone(),
site: inst.site.clone(),
platform: inst.platform,
state: inst.state.as_str().to_string(),
argv: inst.argv.clone(),
created_at: inst.created_at,
}
}
/// 序列化成 e2b 形状的 JSON。
pub fn to_json(&self) -> Json {
let mut o = JsonObject::new();
o.push_str("templateID", &self.template_id);
o.push_str("sandboxID", &self.sandbox_id);
o.push_str("clientID", &self.client_id);
o.push_str("envdVersion", &self.envd_version);
if let Some(t) = &self.envd_access_token {
o.push_str("envdAccessToken", t);
}
if let Some(d) = &self.domain {
o.push_str("domain", d);
}
if let Some(a) = &self.alias {
o.push_str("alias", a);
}
o.push_int("timeout", self.timeout as i64);
o.push_int("memory", self.memory as i64);
// 扩展字段:e2b 语义里没有「这轮会话是谁」「跑的是什么程序」。
// 放在同一层(不嵌套)—— serde 一系的 SDK 默认忽略未知字段,
// 嵌套一层反而会让老 SDK 反序列化失败。
o.push_str("sessionID", &self.session_id);
o.push_str("site", &self.site);
o.push_str("platform", &self.platform.to_string());
o.push_str("state", &self.state);
o.push_arr(
"argv",
self.argv.iter().map(|a| Json::Str(a.clone())).collect(),
);
o.push_int("createdAt", self.created_at as i64);
match crate::json::parse(&o.to_string()) {
Ok(v) => v,
Err(_) => Json::Null,
}
}
/// 从 JSON 解析视图(客户端侧用)。
///
/// **缺字段不报错**:缺的是扩展字段就留空,e2b 字段也留空 ——
/// 客户端只是展示,拿不到就显示空,而不是整条命令失败。
pub fn from_json(v: &Json) -> Self {
Self {
template_id: v.get_str("templateID").unwrap_or("").to_string(),
sandbox_id: v.get_str("sandboxID").unwrap_or("").to_string(),
client_id: v.get_str("clientID").unwrap_or("").to_string(),
envd_version: v.get_str("envdVersion").unwrap_or("").to_string(),
envd_access_token: v.get_str("envdAccessToken").map(String::from),
domain: v.get_str("domain").map(String::from),
alias: v.get_str("alias").map(String::from),
timeout: v.get_int("timeout").unwrap_or(0).max(0) as u64,
memory: v.get_int("memory").unwrap_or(0).max(0) as u64,
session_id: v.get_str("sessionID").unwrap_or("").to_string(),
site: v.get_str("site").unwrap_or("").to_string(),
platform: parse_platform(v.get_str("platform").unwrap_or("")).unwrap_or(PlatformKind::None),
state: v.get_str("state").unwrap_or("").to_string(),
argv: v
.get_arr("argv")
.map(|a| {
a.iter()
.map(|x| match x {
Json::Str(s) => s.clone(),
other => other.to_json_string(),
})
.collect()
})
.unwrap_or_default(),
created_at: v.get_int("createdAt").unwrap_or(0).max(0) as u64,
}
}
}
/// 证明判定的四句话结果。
///
/// **字段必须分开** —— 合并成一个 `ok` 会把「没做芯片验签」说成「验证通过」。
#[derive(Debug, Clone)]
pub struct AttestationVerdict {
/// 会话 ID。
pub session_id: String,
/// 平台。
pub platform: PlatformKind,
/// 节点 TCB。
pub tcb: u32,
/// 门槛 TCB。
pub min_tcb: u32,
/// 会话绑定值是否一致。
pub user_data_ok: bool,
/// 代码度量是否 pin 且一致。
pub meas_ok: bool,
/// TCB 是否达到门槛。
pub tcb_ok: bool,
/// 芯片签名是否已验证。
///
/// `false` **不等于失败** —— 它可能是「没配验签器所以没验」。
/// 这两者的区别由 `chip_sig_note` 说明。
pub chip_sig: bool,
/// ★ 芯片验签器**明确拒绝**了报告签名。
///
/// 与 `chip_sig = false` 分开:
/// - `chip_sig=false, chip_sig_failed=false` ⇒ **没验**;
/// - `chip_sig=false, chip_sig_failed=true` ⇒ **验了没过**(签名是假的)。
///
/// 「没验」与「验了没过」在处置上完全不同,混为一谈会让
/// 「宿主没配验签器」被当成「签名是假的」。
pub chip_sig_failed: bool,
/// ★ 证明状态:`pending` / `verified` / `rejected`。
///
/// ★ **为什么必须有它**:四布尔表达不了「证据还没到」。
/// guest 采证明要几十秒,那段时间里「没拿到」与「没通过」
/// 在四布尔上长得一模一样(都全 false)—— 于是对账器会把
/// 刚起来的 guest 当场销毁,形成「建一个、查一次、扔掉、再建一个」
/// 的死循环,表现为「会话永远起不来」。
pub status: AttestationStatus,
/// 芯片签名的补充说明(谁验的 / 为什么没验)。
pub chip_sig_note: String,
/// 结论一行。
pub verdict: String,
/// 采集时刻。
pub collected_at: u64,
}
impl AttestationVerdict {
/// 序列化成 JSON。
pub fn to_json(&self) -> Json {
let mut o = JsonObject::new();
o.push_str("session_id", &self.session_id);
o.push_str("platform", &self.platform.to_string());
o.push_int("tcb", self.tcb as i64);
o.push_int("min_tcb", self.min_tcb as i64);
// ★ 四个布尔分开。
o.push_bool("user_data_ok", self.user_data_ok);
o.push_bool("meas_ok", self.meas_ok);
o.push_bool("tcb_ok", self.tcb_ok);
o.push_bool("chip_sig", self.chip_sig);
o.push_bool("chip_sig_failed", self.chip_sig_failed);
// ★ 三态单独一个字段(`pending` / `verified` / `rejected`)。
o.push_str("status", self.status.as_str());
o.push_str("chip_sig_note", &self.chip_sig_note);
o.push_str("verdict", &self.verdict);
o.push_int("collected_at", self.collected_at as i64);
match crate::json::parse(&o.to_string()) {
Ok(v) => v,
Err(_) => Json::Null,
}
}
/// 从 JSON 解析判定结论(客户端侧用)。
///
/// **布尔字段缺失一律当作 `false`** —— 「没拿到」与「不成立」在
/// 安全语义上必须同向:缺失不能被读成通过。
///
/// ★ `status` 缺失 ⇒ `pending`(不是 `verified`)——
/// 读不出状态时绝不能当成「已通过」。
pub fn from_json(v: &Json) -> Self {
Self {
session_id: v.get_str("session_id").unwrap_or("").to_string(),
platform: parse_platform(v.get_str("platform").unwrap_or("")).unwrap_or(PlatformKind::None),
tcb: v.get_int("tcb").unwrap_or(0).max(0) as u32,
min_tcb: v.get_int("min_tcb").unwrap_or(0).max(0) as u32,
user_data_ok: v.get_bool("user_data_ok").unwrap_or(false),
meas_ok: v.get_bool("meas_ok").unwrap_or(false),
tcb_ok: v.get_bool("tcb_ok").unwrap_or(false),
chip_sig: v.get_bool("chip_sig").unwrap_or(false),
chip_sig_failed: v.get_bool("chip_sig_failed").unwrap_or(false),
status: AttestationStatus::from_str(v.get_str("status").unwrap_or("")),
chip_sig_note: v.get_str("chip_sig_note").unwrap_or("").to_string(),
verdict: v.get_str("verdict").unwrap_or("").to_string(),
collected_at: v.get_int("collected_at").unwrap_or(0).max(0) as u64,
}
}
}
/// 站点端下发的创建请求。
#[derive(Debug, Clone)]
pub struct CreateRequest {
/// 会话 ID(**人类可读**的会话标识,不是绑定材料里的 32 字节)。
pub session_id: String,
/// 站点名。
pub site: String,
/// 平台。
pub platform: PlatformKind,
/// template(度量集合标识)。
pub template: String,
/// 可执行文件。
pub program: String,
/// 参数。
pub args: Vec<String>,
/// 超时秒数。
pub timeout_secs: u64,
/// OP-TEE 会话(attach 场景)。
pub optee_session: Option<String>,
/// ★ 会话绑定的**原始材料**(会话 id / site / 公钥 / 度量)。
///
/// ★ 为什么必须由站点端下发、而不是宿主自己填:
/// 宿主要做的是**独立判定** —— 拿 guest 上传的原始证明包,
/// 用**创建时保存的**绑定材料重算一遍 `user_data`,再与报告里的比对。
/// 绑定材料必须与「当初发给 guest 的那一份」**逐字节相同**,
/// 否则重算出来的值必然对不上 —— 而这与 guest 有没有作弊无关。
///
/// 早先只下发 64 字节摘要,宿主**没有重算能力**,
/// 只能复述提交者的结论 ⇒ 判定权交回给了提交证明的那一方。
pub binding: Option<SessionBinding>,
/// ★ 节点实际 TCB(参与绑定值重算)。
pub tcb: u32,
/// ★ TCB 门槛(判定 TCB 是否达标)。
pub min_tcb: u32,
/// ★ 度量 pin(十六进制;不给 = 不额外 pin)。
pub pinned_measurement: Option<[u8; 32]>,
}
/// 解析创建请求体。
///
/// **缺字段即拒绝** —— 站点端少给一个字段,宿主不该「猜一个默认值」,
/// 因为猜出来的进程可能根本不是站点端想要的那个。
pub fn parse_create_request(body: &str) -> Result<CreateRequest, String> {
let v = crate::json::parse(body).map_err(|e| e.to_string())?;
if !v.is_object() {
return Err(String::from("请求体必须是对象"));
}
let session_id = v
.get_str("session_id")
.ok_or_else(|| String::from("缺 session_id"))?
.to_string();
if session_id.is_empty() {
return Err(String::from("session_id 不能为空"));
}
let site = v
.get_str("site")
.ok_or_else(|| String::from("缺 site"))?
.to_string();
let platform_raw = v
.get_str("platform")
.ok_or_else(|| String::from("缺 platform"))?;
let platform = parse_platform(platform_raw)
.ok_or_else(|| format!("platform 不认识的值: {platform_raw}"))?;
let template = v.get_str("template").unwrap_or_default().to_string();
let program = v
.get_str("program")
.ok_or_else(|| String::from("缺 program"))?
.to_string();
if program.is_empty() {
return Err(String::from("program 不能为空"));
}
let mut args = Vec::new();
if let Some(arr) = v.get_arr("args") {
for it in arr {
match it {
Json::Str(s) => args.push(s.clone()),
_ => return Err(String::from("args 必须是字符串数组")),
}
}
}
let timeout_secs = v.get_int("timeout").unwrap_or(0).max(0) as u64;
let optee_session = v.get_str("optee_session").map(String::from);
// --- ★ 绑定材料(可选;给了才参与证明门控)------------------------------
//
// 绑定材料的四个字段**要么都给,要么都不给** ——
// 给一半意味着「一部分绑定参与重算,另一部分不参与」,
// 而那等于「绑了一半」,比完全不绑更危险(看起来像有绑定)。
let session_id_bytes = v.get_str("bind_session_id");
let session_pubkey = v.get_str("bind_session_pubkey");
let code_measurement = v.get_str("bind_code_measurement");
let binding = match (session_id_bytes, session_pubkey, code_measurement) {
(None, None, None) => None,
(Some(a), Some(b), Some(c)) => {
let sid = parse_hex32(a).ok_or_else(|| {
String::from("bind_session_id 必须是 64 位十六进制(32 字节)")
})?;
let pk = parse_hex32(b).ok_or_else(|| {
String::from("bind_session_pubkey 必须是 64 位十六进制(32 字节)")
})?;
let meas = parse_hex32(c).ok_or_else(|| {
String::from("bind_code_measurement 必须是 64 位十六进制(32 字节)")
})?;
Some(SessionBinding::new(sid, site.clone(), pk, meas))
}
_ => {
return Err(String::from(
"绑定材料必须成套给全:bind_session_id / bind_session_pubkey / bind_code_measurement",
))
}
};
let tcb = v.get_int("tcb").unwrap_or(0).max(0) as u32;
let min_tcb = v.get_int("min_tcb").unwrap_or(0).max(0) as u32;
let pinned_measurement = match v.get_str("pinned_measurement") {
Some(s) => Some(
parse_hex32(s)
.ok_or_else(|| String::from("pinned_measurement 必须是 64 位十六进制"))?,
),
None => None,
};
// ★ guest 可达地址**不在请求体里** ——
// 它是**宿主自己的配置**(`HostConfig::guest_endpoint`):
// 「guest 从哪个地址能访问到我」是这台宿主的事实,
// 不是每次创建时站点端能随意指定的东西。
// 放请求体里会允许站点端把 guest 的回传地址指向任意主机 ——
// 那是把 guest 变成 SSRF 跳板。
Ok(CreateRequest {
session_id,
site,
platform,
template,
program,
args,
timeout_secs,
optee_session,
binding,
tcb,
min_tcb,
pinned_measurement,
})
}
/// 解析 64 位十六进制为 32 字节。
///
/// 严格:只接受**恰好** 64 个十六进制字符(不多不少),
/// 且不接受 `0x` 前缀 —— 混用两种写法是「同一个字段两种解释」的开始。
fn parse_hex32(s: &str) -> Option<[u8; 32]> {
if s.len() != 64 {
return None;
}
let mut out = [0u8; 32];
let b = s.as_bytes();
for i in 0..32 {
let hi = hex_nibble(b[i * 2])?;
let lo = hex_nibble(b[i * 2 + 1])?;
out[i] = (hi << 4) | lo;
}
Some(out)
}
/// 单个十六进制字符的数值(`None` = 非法)。
fn hex_nibble(c: u8) -> Option<u8> {
match c {
b'0'..=b'9' => Some(c - b'0'),
b'a'..=b'f' => Some(c - b'a' + 10),
b'A'..=b'F' => Some(c - b'A' + 10),
_ => None,
}
}
/// 解析平台名。
pub fn parse_platform(raw: &str) -> Option<PlatformKind> {
match raw {
"sev-snp" | "snp" | "amd" => Some(PlatformKind::SevSnp),
"hygon-csv" | "csv" | "hygon" => Some(PlatformKind::HygonCsv),
"tdx" => Some(PlatformKind::Tdx),
"optee" => Some(PlatformKind::Optee),
"none" => Some(PlatformKind::None),
_ => None,
}
}
/// ★ ★ **宿主控制面的路由形状只有一份,在这里。**
///
/// # 为什么宿主控制面要**拥有**这份路由
///
/// guest(enclave 内)要把证明材料回传给宿主,就**必须知道上传端点的路径**。
/// 早先这个路径在 `mpc-tee::attest_upload` 里写死(`/sandboxes/{id}/attestation`)——
/// 那有两个问题:
///
/// 1. ★ **路由漂移**:hostd 改路由,guest 侧不会跟着改
/// ⇒ guest 静默 POST 到不存在的端点
/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。
/// 症状链是「guest 报 404 / 宿主报 pending / 集群面不公布端点」,
/// 极难定位到「路由变了」这一层。
/// 2. guest 静态产物里带上了宿主控制面的路由痕迹
/// ⇒ 破坏 guest 边界(主门禁第 4 条的负向判据会红)。
///
/// # 所以:路由归宿主,guest 从宿主那里**拿**路径
///
/// 宿主在建实例时把完整上传路径写进 9p 手牌,
/// guest 从 `/run/mpc-tee/hostd/upload_path` 读到后原样使用。
/// hostd 改路由 ⇒ 手牌里的路径跟着改 ⇒ guest 不用动。
///
/// ★ 守卫:`route_literal_must_not_live_in_mpc_tee`
/// (本文件底部的测试)跨 crate 扫 `mpc-tee` 源码,
/// 保证这份路由**不会**又被抄回 guest 侧。
pub const ROUTE_SANDBOXES: &str = "sandboxes";
/// 证明材料上传端点的末段名。
pub const ROUTE_ATTESTATION: &str = "attestation";
/// ★ 某个实例的证明材料上传端点的**完整路径**。
///
/// 宿主写进 9p 手牌、guest 原样使用。路径由**宿主**决定(见上面的说明)。
pub fn attestation_upload_path(sandbox_id: &str) -> String {
format!("/{ROUTE_SANDBOXES}/{sandbox_id}/{ROUTE_ATTESTATION}")
}
/// 路由分发。
///
/// `req.path` 的形状由 e2b 兼容面决定:
/// `/sandboxes`、`/sandboxes/{id}`、`/sandboxes/{id}/attestation` 等。
///
/// ★ **鉴权在路由之前** —— 任何端点(包括 `/health`)都要先过凭证判定。
/// 放一个免鉴权的 `/health` 在前面,等于给攻击者一个不受限的探测口。
pub fn dispatch(rt: &TeeRuntime, req: &Request) -> Response {
dispatch_with_auth(rt, req, &crate::auth::Authenticator::unconfigured())
}
/// 带鉴权的路由分发。
///
/// `auth` 为「未配置」的鉴权器时 = 回环信任模式(不带凭据放行)。
pub fn dispatch_with_auth(
rt: &TeeRuntime,
req: &Request,
auth: &crate::auth::Authenticator,
) -> Response {
let segs = req.segments();
// ★ 鉴权先于一切业务判定。失败一律 401。
// 对外只给「缺少或无效的凭据」—— 不区分「没带」与「带错了」
// (那等于告诉攻击者差多少)。
//
// ★ **唯一例外**:guest 回传证明材料的那条**精确**路径
// (`POST /sandboxes/{id}/attestation`)额外接受**实例级令牌**。
// 理由:全局共享密钥的权限是「起/删任意 guest、读远程证明」,
// 把它交给 guest 等于把主权限交给 guest 里跑的代码。
// 而 guest 必须能把自己那一份证明材料传回来 —— 那份材料
// 只能配**每实例一个**的令牌(只能往这一个实例上传,
// 实例删除即失效)。
//
// ★ 这个例外**只放宽凭据的种类**,不放宽**凭据的必需性**:
// 这条路径上**必须**带上一种有效凭据(共享密钥 或 本实例令牌),
// 一个都不带 ⇒ 401。
// 否则回环信任模式「不带凭据即放行」会顺带把上传端点也放行 ——
// 那等于「谁能连上就能往任意实例写证据」,
// 证据表是判定输入,写它就是改判定结论。
//
// ★ 这个例外也**不是**「带凭据就放行」:它严格按 method + 路径形状
// 匹配,且令牌必须与**该实例**的 upload_token 逐字节相同。
// 匹配不上就退回全局判定(该拒还是拒)。
if is_attestation_upload(req, &segs) {
// 上传端点:两种凭据都接受 —— 共享密钥(站点端/运维)或本实例令牌(guest)。
// 两种都不对 ⇒ 401。
let global_authorized = shared_secret_ok(req, auth);
if !global_authorized && !instance_token_ok(rt, req, segs[1]) {
eprintln!("hostd: 鉴权拒绝(attestation-upload)");
return Response::error(Status::Unauthorized, "缺少或无效的凭据");
}
// 走独立的分支:上传端点要知道自己是被**哪一种**凭据放行的
// (共享密钥 ⇒ 可作用于任何实例;实例级令牌 ⇒ 只能本实例)。
return dispatch_sandboxes(rt, req, &segs, Some(global_authorized));
} else {
let decision = auth.decide(crate::auth::authorization_header(req));
if !decision.is_allowed() {
eprintln!("hostd: 鉴权拒绝({})", decision.internal_reason());
return Response::error(Status::Unauthorized, decision.public_reason());
}
}
if segs.is_empty() {
return Response::text(Status::Ok, "mpc-hostd");
}
// 健康检查
if segs.len() == 1 && segs[0] == "health" {
return Response::text(Status::Ok, "ok");
}
// 沙箱集合
if segs[0] == ROUTE_SANDBOXES {
return dispatch_sandboxes(rt, req, &segs, None);
}
// 宿主自描述:本宿主探测出的 TEE 能力自报(Cubelet 自描述,pull 接口)。
if segs[0] == "node" {
return get_self_node(rt);
}
Response::error(Status::NotFound, "没有这个端点")
}
/// ★ 请求带的凭据**是不是**有效的共享密钥。
///
/// ★ 与 [`crate::auth::Authenticator::decide`] 的区别:
/// `decide(None)` 在**回环信任模式**下返回 `Allow`(信任边界在网络层)。
/// 但上传端点**不能**沿用这条 —— 它在回环模式下也必须真的带凭据,
/// 否则「谁能连上」就等于「谁能往证据表里写」。
/// 所以这里额外要求请求**真的带了**非空 `Authorization` 头。
fn shared_secret_ok(req: &Request, auth: &crate::auth::Authenticator) -> bool {
let raw = match crate::auth::authorization_header(req) {
Some(v) if !v.trim().is_empty() => v,
_ => return false,
};
auth.decide(Some(raw)).is_allowed()
}
fn dispatch_sandboxes(
rt: &TeeRuntime,
req: &Request,
segs: &[&str],
upload_global_authorized: Option<bool>,
) -> Response {
match (req.method.as_str(), segs.len()) {
// POST /sandboxes
("POST", 1) => create_sandbox(rt, req),
// GET /sandboxes
("GET", 1) => list_sandboxes(rt),
// GET /sandboxes/{id}
("GET", 2) => get_sandbox(rt, segs[1]),
// DELETE /sandboxes/{id}
("DELETE", 2) => delete_sandbox(rt, segs[1]),
// GET /sandboxes/{id}/attestation
("GET", 3) if segs[2] == ROUTE_ATTESTATION => get_attestation(rt, segs[1]),
// POST /sandboxes/{id}/attestation —— guest 回传**原始证明包字节**。
// 鉴权走**两种凭据任一**:共享密钥 或 本实例令牌
// (判定见 `attestation_upload_authorized`)。
("POST", 3) if segs[2] == ROUTE_ATTESTATION => {
post_attestation(rt, req, segs[1], upload_global_authorized.unwrap_or(false))
}
// POST /sandboxes/{id}/connect
("POST", 3) if segs[2] == "connect" => connect_sandbox(rt, segs[1]),
// POST|PATCH /sandboxes/{id}/timeout
("POST", 3) | ("PATCH", 3) if segs[2] == "timeout" => set_timeout(rt, req, segs[1]),
// POST /sandboxes/{id}/pause
("POST", 3) if segs[2] == "pause" => pause_sandbox(rt, segs[1]),
// POST /sandboxes/{id}/resume
("POST", 3) if segs[2] == "resume" => resume_sandbox(rt, segs[1]),
_ => Response::error(Status::NotFound, "没有这个端点"),
}
}
/// 宿主自描述(Cubelet 自报的 pull 接口)。
///
/// 返回本宿主探测出的 [`NodeReport`] JSON;未配置能力则返回 404
/// (hostd 不对外宣告自己是 TEE 宿主)。
fn get_self_node(rt: &TeeRuntime) -> Response {
match rt.self_report() {
Some(report) => {
let j = node_report_to_json(&report);
Response::json(Status::Ok, &j.to_json_string())
}
None => Response::error(Status::NotFound, "本宿主未配置 TEE 能力,不对外自报"),
}
}
fn create_sandbox(rt: &TeeRuntime, req: &Request) -> Response {
let body = match crate::protocol::body_str(req) {
Ok(s) => s,
Err(e) => return Response::error(Status::BadRequest, &e),
};
let cr = match parse_create_request(body) {
Ok(v) => v,
Err(e) => return Response::error(Status::BadRequest, &e),
};
let mut spec = crate::runtime::SpawnSpec::new(
cr.session_id.clone(),
cr.site.clone(),
cr.platform,
cr.program.clone(),
);
spec.template = cr.template.clone();
spec.args = cr.args.clone();
spec.timeout_secs = cr.timeout_secs;
// ★ 绑定材料原样交给运行时:宿主要用**这一份**重算 `user_data`,
// 而不是采信 guest 上传的包里自称的值。
if let Some(b) = cr.binding.clone() {
spec = spec.with_binding(b, cr.tcb, cr.min_tcb, cr.pinned_measurement);
}
// ★ guest 可达地址来自**宿主自己的配置**(`HostConfig::guest_endpoint`),
// 不是请求体 —— 见 `parse_create_request` 里的说明。
if let Some(e) = &rt.guest_endpoint() {
spec = spec.with_guest_endpoint(e.clone());
}
let inst = if cr.platform == PlatformKind::Optee {
// OP-TEE 是 attach 语义:分配 TA 会话,不起进程。
let sess = match &cr.optee_session {
Some(s) => s.clone(),
None => {
return Response::error(
Status::BadRequest,
"OP-TEE 需要 optee_session(attach 语义,不起进程)",
)
}
};
rt.attach(&spec, &sess)
} else {
rt.spawn(&spec)
};
match inst {
Ok(i) => {
// ★ 返回**同一个** SandboxView 形状 —— 客户端只有一条解析路径。
// 早先这里返回的是另一套字段名(session_id / sandbox_id),
// 于是 `GET` 与 `POST` 两种响应的形状不一致,客户端得写两套解析。
let v = SandboxView::of(&i).to_json();
Response::json(Status::Created, &v.to_json_string())
}
Err(e) => Response::error(Status::Internal, &e.to_string()),
}
}
fn list_sandboxes(rt: &TeeRuntime) -> Response {
let items: Vec<Json> = rt
.list()
.iter()
.map(SandboxView::of)
.map(|v| v.to_json())
.collect();
// e2b 的 GET /sandboxes 返回**裸数组**,不是包在对象里。
// 必须是裸数组:SDK 直接反序列化成 Vec<SandboxView>。
let arr = Json::Arr(items);
Response::json(Status::Ok, &arr.to_json_string())
}
fn get_sandbox(rt: &TeeRuntime, id: &str) -> Response {
match rt.get(id) {
Some(i) => {
let v = SandboxView::of(&i).to_json();
Response::json(Status::Ok, &v.to_json_string())
}
None => Response::error(Status::NotFound, &format!("sandbox {id} 不存在")),
}
}
fn delete_sandbox(rt: &TeeRuntime, id: &str) -> Response {
// ★ 必须是**真删除**:e2b 的 DELETE /sandboxes/{id} 删完之后,
// GET /sandboxes 不应再返回它。
// 2026-11-07 真机联调实测发现的缺口:这里原来只调 `stop()`
// (停进程 + 标终态,记录还在表里),实例仍留在列表里。
match rt.remove(id) {
// ★ 必须是 204 空体 —— e2b 的 DELETE 就是这个形状,
// 同一套 e2b 客户端库要能直接用,不能改成 200 + JSON。
// 「停完是什么状态」由客户端在 DELETE 后补一次 GET 拿。
Ok(()) => Response::empty(Status::NoContent),
Err(e) => match e {
crate::runtime::RuntimeError::NotFound(_) => {
Response::error(Status::NotFound, &format!("sandbox {id} 不存在"))
}
other => Response::error(Status::Internal, &other.to_string()),
},
}
}
fn connect_sandbox(rt: &TeeRuntime, id: &str) -> Response {
match rt.get(id) {
Some(i) => {
let v = SandboxView::of(&i).to_json();
Response::json(Status::Ok, &v.to_json_string())
}
None => Response::error(Status::NotFound, &format!("sandbox {id} 不存在")),
}
}
fn set_timeout(rt: &TeeRuntime, req: &Request, id: &str) -> Response {
let body = crate::protocol::body_str(req).unwrap_or("{}");
let secs = match crate::json::parse(body) {
Ok(v) => v.get_int("timeout").unwrap_or(0).max(0) as u64,
Err(e) => return Response::error(Status::BadRequest, &e.to_string()),
};
match rt.set_timeout(id, secs) {
Ok(_) => {
let mut o = JsonObject::new();
o.push_int("timeout", secs as i64);
Response::json(Status::Ok, &o.to_string())
}
Err(e) => Response::error(Status::NotFound, &e.to_string()),
}
}
fn pause_sandbox(rt: &TeeRuntime, id: &str) -> Response {
match rt.pause(id) {
Ok(_) => {
let mut o = JsonObject::new();
o.push_bool("paused", true);
Response::json(Status::Ok, &o.to_string())
}
Err(e) => Response::error(Status::NotFound, &e.to_string()),
}
}
fn resume_sandbox(rt: &TeeRuntime, id: &str) -> Response {
match rt.resume(id) {
Ok(_) => {
let mut o = JsonObject::new();
o.push_bool("paused", false);
Response::json(Status::Ok, &o.to_string())
}
Err(e) => Response::error(Status::NotFound, &e.to_string()),
}
}
/// 取运行实例的证明结论。
///
/// # 它是怎么判的
///
/// ★ **不是**复述 KBS 的结论,也**不是**复述 guest 自报的结果:
/// 宿主拿 guest 上传的**原始证明包**,用**创建时保存**的绑定材料
/// 重算 `user_data`,再走同一份 [`mpc_tee::bundle::verify_bundle`] 判定。
///
/// ```text
/// guest ──原始证明包──▶ hostd ──verify_bundle + 外部验签器──▶ 四布尔 + 三态
/// ▲
/// └── 创建时保存的绑定材料(不是 guest 自报的)
/// ```
///
/// ★ 三态([`AttestationStatus`]):
/// - `pending`:证据**尚未到达**(guest 还在采证明)—— 不是失败;
/// - `verified`:证据到达且判定通过;
/// - `rejected`:证据到达但判定被拒。
///
/// ⚠️ 这里**不能**报 `chip_sig=true` 除非确实验过签。
/// 没有验签器时 `chip_sig=false` 且 note 写明「未提供验签器」——
/// 这是「没验」与「验了没过」的区别。
fn get_attestation(rt: &TeeRuntime, id: &str) -> Response {
let inst = match rt.get(id) {
Some(i) => i,
None => return Response::error(Status::NotFound, &format!("sandbox {id} 不存在")),
};
if inst.state == InstanceState::Exited || inst.state == InstanceState::Failed {
return Response::error(
Status::Conflict,
&format!("实例已结束(状态 {}),无法采样证明", inst.state.as_str()),
);
}
let v = conclude_for(rt, &inst);
let j = v.to_json();
Response::json(Status::Ok, &j.to_json_string())
}
/// ★ 用宿主保存的绑定材料独立判定一个实例的证明。
///
/// 三条路径:
/// 1. **没有绑定上下文** ⇒ 不参与证明门控 ⇒ 全 false + `pending`
/// (这个实例压根没被要求证明;报「不通过」是误导)。
/// 2. **有绑定上下文、但证据还没到** ⇒ 全 false + `pending`。
/// 3. **有证据** ⇒ `conclude()` 判定 ⇒ 四布尔 + 三态。
fn conclude_for(rt: &TeeRuntime, inst: &Instance) -> AttestationVerdict {
let ctx = match rt.binding(&inst.sandbox_id) {
Some(c) => c,
None => {
return AttestationVerdict {
session_id: inst.session_id.clone(),
platform: inst.platform,
tcb: 0,
min_tcb: 0,
user_data_ok: false,
meas_ok: false,
tcb_ok: false,
chip_sig: false,
chip_sig_failed: false,
status: AttestationStatus::Pending,
chip_sig_note: String::from("本实例未配置会话绑定,不参与证明门控"),
verdict: String::from("本实例未配置会话绑定,不参与证明门控;不得据此认为验证通过"),
collected_at: crate::runtime::now_secs(),
}
}
};
let evidence = rt.evidence(&inst.sandbox_id);
let conclusion = match &evidence {
Some(ev) => {
let verifier = rt.chip_verifier();
mpc_tee::attest_link::conclude(ev, inst.platform, verifier.as_ref().map(|v| v as &dyn mpc_tee::verify::ChipVerifier))
}
None => mpc_tee::attest_link::AttestationConclusion::absent(),
};
let status = mpc_tee::attest_link::status_of(evidence.as_ref(), &conclusion);
AttestationVerdict {
session_id: inst.session_id.clone(),
platform: inst.platform,
tcb: ctx.tcb,
min_tcb: ctx.min_tcb,
user_data_ok: conclusion.user_data_ok,
meas_ok: conclusion.meas_ok,
tcb_ok: conclusion.tcb_ok,
chip_sig: conclusion.chip_sig,
chip_sig_failed: conclusion.chip_sig_failed,
status,
chip_sig_note: conclusion.chip_sig_note,
verdict: conclusion.verdict,
collected_at: crate::runtime::now_secs(),
}
}
/// ★ 接收 guest 上传的**原始证明包**。
///
/// # 鉴权:实例级令牌
///
/// 用**每实例一个**的随机令牌([`crate::runtime::BindingContext::upload_token`]),
/// 而不是 hostd 的全局共享密钥 ——
///
/// 全局密钥的权限是「起 guest / 删实例 / 读远程证明」,全量。
/// 交给 guest 等于把「起/删任意 guest」的主权限交给了 guest 里跑的代码。
/// 实例级令牌只能往**这一个**实例上传,且实例删除后即失效。
///
/// # 权限边界
///
/// ★ **不接受** guest 自报的绑定材料 ——
/// 绑定材料必须来自**创建时**站点端下发的那一份(存在
/// [`crate::runtime::BindingContext`] 里)。
/// 若采信 guest 自报的绑定,guest 就能「自造一个绑定、自己算一份
/// user_data、自己造一份报告」—— 那是**自己给自己背书**。
///
/// # 请求体
///
/// 原始证明包字节(`AttestationBundle::to_bytes` 的产物),**不是** JSON。
/// 用二进制是因为它要被 KBS / 宿主**逐字节**比对;中间过一次 JSON
/// 编码解码就可能改变字节(base64 padding、空白、编码差异)。
/// 所以这个端点用 `application/octet-stream`。
fn post_attestation(
rt: &TeeRuntime,
req: &Request,
id: &str,
global_authorized: bool,
) -> Response {
// ★ 鉴权先于「实例存不存在」的判定 ——
// 否则未授权的人可以用 404/400 的差异**枚举**出哪些 id 是真实例。
// 所以顺序是:凭据 → 绑定上下文 → 实例 → 状态 → 字节。
//
// 两种凭据任一成立即可(判定见 `attestation_upload_authorized`):
// - `global_authorized`:站点端/运维用共享密钥;
// - 本实例的上传令牌:guest 用。
let ctx = match rt.binding(id) {
Some(c) => c,
// 没有绑定上下文 ⇒ 判定所需的宿主侧事实不存在 ⇒ 不能收证据。
// ★ 但注意:这里**不能**因为「没绑定上下文」就回 401 ——
// 那会把「这个 id 不是真实例」和「这个 id 没有绑定」混成同一个码,
// 反而给枚举提供信息。共享密钥持有者应当看到明确的 400。
// 实例级令牌路径根本到不了这里(没有绑定上下文就没有令牌可比,
// `attestation_upload_authorized` 已经先拒了)。
None => {
return Response::error(
Status::BadRequest,
"本实例未配置会话绑定,不接受证明材料(请由站点端在 create 时下发绑定材料)",
)
}
};
// 实例级令牌校验(常量时间)。
// 共享密钥路径已由 `attestation_upload_authorized` 判过,不重复要求。
if !global_authorized {
let token = bearer_token(req).unwrap_or_default();
if !token_matches(&token, &ctx.upload_token) {
return Response::error(Status::Unauthorized, "缺少或无效的凭据");
}
}
// 过了鉴权,才谈实例存不存在。
let inst = match rt.get(id) {
Some(i) => i,
None => return Response::error(Status::NotFound, &format!("sandbox {id} 不存在")),
};
if inst.state == InstanceState::Exited || inst.state == InstanceState::Failed {
return Response::error(
Status::Conflict,
&format!("实例已结束(状态 {}),不能再上传证明材料", inst.state.as_str()),
);
}
let body = &req.body;
if body.is_empty() {
return Response::error(Status::BadRequest, "请求体为空(应是原始证明包字节)");
}
// 结构合法性在**判定时**查(`verify_bundle` 会核对长度字段),
// 这里先粗查一眼,避免把明显不是证明包的东西存进证据表。
if mpc_tee::bundle::AttestationBundle::from_bytes(body).is_err() {
return Response::error(
Status::BadRequest,
"请求体不是合法的证明包(长度字段与实际字节数不符)",
);
}
rt.put_evidence(
id,
mpc_tee::attest_link::AttestationEvidence {
bundle_bytes: body.clone(),
binding: ctx.binding,
tcb: ctx.tcb,
min_tcb: ctx.min_tcb,
pinned_measurement: ctx.pinned_measurement,
},
);
let mut o = JsonObject::new();
o.push_str("sandbox_id", id);
o.push_int("bytes", body.len() as i64);
o.push_str("status", "received");
Response::json(Status::Ok, &o.to_string())
}
/// 从请求头取 `Bearer <token>` 的 token 部分。
fn bearer_token(req: &Request) -> Option<String> {
let raw = crate::auth::authorization_header(req)?;
let mut parts = raw.splitn(2, ' ');
let scheme = parts.next().unwrap_or("");
let token = parts.next().unwrap_or("").trim();
if !scheme.eq_ignore_ascii_case("bearer") || token.is_empty() {
return None;
}
Some(token.to_string())
}
/// ★ 这条请求**是不是**「guest 回传证明材料」的那条精确路径。
///
/// 形状必须严格是:`POST /sandboxes/{id}/attestation`。
/// - method 必须是 `POST` —— `GET` 同路径是「读判定结论」,走全局鉴权;
/// - 段数必须是 3 —— `/sandboxes/{id}/attestation/extra` 不是它;
/// - 末段必须是 `attestation`。
///
/// ★ **不能放宽成「带凭据就走实例级判定」** ——
/// 那样等于让「带任何 Authorization 头」绕过全局鉴权,
/// 正好把回环信任模式「带了凭据一律拒」这条纪律拆了。
fn is_attestation_upload(req: &Request, segs: &[&str]) -> bool {
req.method.eq_ignore_ascii_case("POST")
&& segs.len() == 3
&& segs[0] == ROUTE_SANDBOXES
&& segs[2] == ROUTE_ATTESTATION
}
/// ★ 这条请求带的令牌**是不是**该实例的上传令牌。
///
/// 失败一律 `false` —— 调用方会退回全局鉴权判定(该拒还是拒)。
fn instance_token_ok(rt: &TeeRuntime, req: &Request, id: &str) -> bool {
let ctx = match rt.binding(id) {
Some(c) => c,
None => return false,
};
let token = bearer_token(req).unwrap_or_default();
token_matches(&token, &ctx.upload_token)
}
/// 常量时间比较两个令牌(都比 SHA-256 摘要)。
fn token_matches(candidate: &str, expected: &str) -> bool {
if candidate.is_empty() || expected.is_empty() {
return false;
}
let a = mpc_core::hash::sha256(candidate.as_bytes());
let b = mpc_core::hash::sha256(expected.as_bytes());
mpc_core::hmac::ct_eq(&a, &b)
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
/// ★ ★ **宿主控制面的路由字面量不得出现在 `mpc-tee` 里。**
///
/// # 这条守卫在钉什么
///
/// 路由形状**只有一份**,就在本文件(`ROUTE_SANDBOXES` / `ROUTE_ATTESTATION`)。
/// guest 从 9p 手牌里**拿**宿主下发的完整路径(见 `attestation_upload_path`)。
///
/// 早先 `mpc-tee::attest_upload` 里写死了 `/sandboxes/{id}/attestation`,
/// 造成两个问题:
/// 1. **路由漂移** —— hostd 改路由,guest 不会跟着改
/// ⇒ guest 静默 POST 到不存在的端点
/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。
/// 2. guest 静态产物里带上了宿主控制面的路由痕迹 ⇒ 破坏 guest 边界
/// (主门禁第 4 条的负向判据会红)。
///
/// ★ 为什么守卫放在**这里**(hostd)而不是 mpc-tee:
/// 被检查方自己检查自己等于没检查。
/// hostd 是路由的**真正归属方** —— 路由归谁管,谁就负责看住它。
///
/// ★ 只扫**非测试代码**:`#[cfg(test)]` 里的夹具不进二进制,
/// 且它们本来就要构造「各种形状的路径」来验证校验逻辑。
#[test]
fn route_literal_must_not_live_in_mpc_tee() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../mpc-tee/src");
let mut offenders: Vec<String> = Vec::new();
let mut entries: Vec<std::path::PathBuf> = std::fs::read_dir(&dir)
.unwrap_or_else(|e| panic!("读 {} 失败: {e}", dir.display()))
.filter_map(|e| e.ok().map(|e| e.path()))
.collect();
entries.sort();
for p in entries {
if p.extension().and_then(|x| x.to_str()) != Some("rs") {
continue;
}
let text = std::fs::read_to_string(&p).unwrap();
// ★ `#[cfg(test)]` 之后是测试代码(不进二进制)—— 只扫它之前。
let test_start = text
.lines()
.position(|l| l.trim() == "#[cfg(test)]")
.unwrap_or(usize::MAX);
for (i, line) in text.lines().enumerate() {
if i >= test_start {
break;
}
let l = line.trim();
// 跳过注释行与文档行(它们不进二进制,也不构成「持有路由」)。
if l.starts_with("//") {
continue;
}
// 路由前缀只在这两处形态下算「持有」:
// · 字符串字面量 "/sandboxes...
// · 常量赋值里的 "sandboxes"
if l.contains("\"/sandboxes") || l.contains("= \"sandboxes\"") {
offenders.push(format!("{}:{}: {}", p.display(), i + 1, l));
}
}
}
assert!(
offenders.is_empty(),
"★ 宿主控制面的路由字面量不得留在 mpc-tee(会进 guest 产物,且会造成路由漂移):\n{}",
offenders.join("\n")
);
}
/// ★ 正向:上传路径由宿主生成,形状正确。
#[test]
fn upload_path_is_produced_by_the_host() {
assert_eq!(
attestation_upload_path("sbx-abc"),
"/sandboxes/sbx-abc/attestation"
);
}
fn req(method: &str, path: &str, body: &str) -> Request {
let mut headers = HashMap::new();
headers.insert(String::from("content-type"), String::from("application/json"));
Request {
method: String::from(method),
path: String::from(path),
query: String::new(),
headers,
body: body.as_bytes().to_vec(),
}
}
fn body_of(resp: &Response) -> String {
String::from_utf8_lossy(&resp.body).to_string()
}
#[test]
fn sandbox_view_uses_e2b_field_names() {
// 字段名错一个,e2b SDK 就解析失败 —— 而症状是"连上了但读不到"。
let inst = Instance {
sandbox_id: String::from("abcdef0123456789abcd"),
session_id: String::from("s1"),
site: String::from("alice"),
platform: PlatformKind::SevSnp,
template: String::from("tpl-1"),
argv: vec![],
pid: Some(1),
start_key: Some(String::from("proc:1")),
created_at: 0,
state: InstanceState::Running,
exit_code: None,
timeout_secs: 300,
paused: false,
optee_session: None,
};
let v = SandboxView::of(&inst);
assert_eq!(v.client_id, "mpc-hostd");
assert_eq!(v.envd_version, "0.5.13");
assert_eq!(v.timeout, 300);
let s = v.to_json().to_json_string();
for k in [
"templateID",
"sandboxID",
"clientID",
"envdVersion",
"timeout",
"memory",
] {
assert!(s.contains(k), "缺 e2b 字段 {k}: {s}");
}
}
#[test]
fn create_request_requires_every_field() {
// 少给字段必须拒绝 —— 不能猜默认值。
let e = parse_create_request(r#"{"site":"a"}"#).unwrap_err();
assert!(e.contains("session_id"), "got {e}");
let e = parse_create_request(r#"{"session_id":"s"}"#).unwrap_err();
assert!(e.contains("site"), "got {e}");
let e = parse_create_request(r#"{"session_id":"s","site":"a"}"#).unwrap_err();
assert!(e.contains("platform"), "got {e}");
let e = parse_create_request(r#"{"session_id":"s","site":"a","platform":"sev-snp"}"#)
.unwrap_err();
assert!(e.contains("program"), "got {e}");
}
#[test]
fn create_request_parses_full_body() {
let r = parse_create_request(
r#"{"session_id":"s1","site":"alice","platform":"sev-snp","template":"t","program":"/bin/sleep","args":["-c","x"],"timeout":120}"#,
)
.unwrap();
assert_eq!(r.session_id, "s1");
assert_eq!(r.platform, PlatformKind::SevSnp);
assert_eq!(r.args, vec!["-c", "x"]);
assert_eq!(r.timeout_secs, 120);
}
#[test]
fn create_request_rejects_bad_platform() {
let e = parse_create_request(
r#"{"session_id":"s","site":"a","platform":"quantum","program":"/bin/true"}"#,
)
.unwrap_err();
assert!(e.contains("platform"), "错误信息里要点名 platform: {e}");
}
#[test]
fn list_returns_bare_array() {
// e2b SDK 反序列化 Vec<SandboxView> —— 包在对象里就解析不了。
let rt = TeeRuntime::new();
let resp = dispatch(&rt, &req("GET", "/sandboxes", ""));
assert_eq!(resp.status, Status::Ok);
let b = body_of(&resp);
assert!(b.starts_with('['), "必须是裸数组: {b}");
assert!(b.ends_with(']'), "必须是裸数组: {b}");
}
#[test]
fn unknown_endpoint_is_404() {
let rt = TeeRuntime::new();
let resp = dispatch(&rt, &req("GET", "/nope", ""));
assert_eq!(resp.status, Status::NotFound);
}
#[test]
fn get_missing_sandbox_is_404() {
let rt = TeeRuntime::new();
let resp = dispatch(&rt, &req("GET", "/sandboxes/nope", ""));
assert_eq!(resp.status, Status::NotFound);
assert!(body_of(&resp).contains("\"code\":404"));
}
#[test]
fn delete_missing_sandbox_is_404() {
let rt = TeeRuntime::new();
let resp = dispatch(&rt, &req("DELETE", "/sandboxes/nope", ""));
assert_eq!(resp.status, Status::NotFound);
}
/// ★★ 回归钉子:DELETE 必须**真删**记录。
///
/// 2026-11-07 真机联调(沙箱管理节点 → 海光真机 `192.168.1.102`)实测
/// 发现的缺口:DELETE 原来只调 `stop()`(停进程 + 标终态),
/// **记录仍在表里** —— 删完再 `GET /sandboxes` 还能看到它。
/// 而 e2b 兼容面的语义是「DELETE 就是删除」,
/// api.rs 的注释也写着「显式删除」,实现与注释不符。
///
/// 症状很静默:客户端 DELETE 返回 204,看起来成功;
/// 但列表越积越多,且「删了没删」没有任何报错。
#[test]
fn delete_really_removes_the_record() {
let rt = TeeRuntime::new();
// 用真进程(`/bin/sleep 300`)—— 这样测的才是「真起、真停、真删」,
// 而不是手工往表里塞一条假记录。
let mut spec = crate::runtime::SpawnSpec::new(
"sess-del",
"alice",
PlatformKind::SevSnp,
"/bin/sleep",
);
spec.args = vec![String::from("300")];
let inst = rt.spawn(&spec).unwrap();
let id = inst.sandbox_id.clone();
// 删除前:列表里有它
let before = body_of(&dispatch(&rt, &req("GET", "/sandboxes", "")));
assert!(before.contains(&id), "删除前列表里应有它: {before}");
// DELETE → 204 空体(e2b 硬要求)
let resp = dispatch(&rt, &req("DELETE", &format!("/sandboxes/{id}"), ""));
assert_eq!(resp.status, Status::NoContent);
assert!(
body_of(&resp).is_empty(),
"DELETE 必须 204 空体: {}",
body_of(&resp)
);
// ★ 删除后:列表里**不再**有它
let after = body_of(&dispatch(&rt, &req("GET", "/sandboxes", "")));
assert!(
!after.contains(&id),
"DELETE 之后 GET /sandboxes 不应再返回它(这正是真机联调挖出的 bug): {after}"
);
// 单点查询也应 404
let g = dispatch(&rt, &req("GET", &format!("/sandboxes/{id}"), ""));
assert_eq!(g.status, Status::NotFound);
// 记录确实从表里消失了(不是只把状态改掉)
assert!(rt.get(&id).is_none(), "记录必须从表里删除");
}
/// ★★ 回归钉子:DELETE 必须**真删**记录。
///
/// 2026-11-07 真机联调(沙箱管理节点 → 海光真机 `192.168.1.102`)实测
/// 发现的缺口:DELETE 原来只调 `stop()`(停进程 + 标终态),
/// **记录仍在表里** —— 删完再 `GET /sandboxes` 还能看到它。
/// 而 e2b 兼容面的语义是「DELETE 就是删除」,
/// api.rs 的注释也写着「显式删除」,实现与注释不符。
///
/// 症状很静默:客户端 DELETE 返回 204,看起来成功;
/// 但列表越积越多,且「删了没删」没有任何报错。
#[test]
fn health_returns_ok() {
let rt = TeeRuntime::new();
let resp = dispatch(&rt, &req("GET", "/health", ""));
assert_eq!(resp.status, Status::Ok);
assert_eq!(body_of(&resp), "ok");
}
#[test]
fn create_rejects_bad_body_with_400() {
let rt = TeeRuntime::new();
let resp = dispatch(&rt, &req("POST", "/sandboxes", "{not json"));
assert_eq!(resp.status, Status::BadRequest);
}
/// ★ 核心纪律:四个布尔必须分开,不许合并成一个 ok。
#[test]
fn attestation_keeps_four_booleans_separate() {
let v = AttestationVerdict {
session_id: String::from("s"),
platform: PlatformKind::SevSnp,
tcb: 5,
min_tcb: 3,
user_data_ok: true,
meas_ok: true,
tcb_ok: true,
chip_sig: false,
chip_sig_failed: false,
status: AttestationStatus::Verified,
chip_sig_note: String::from("未提供验签器"),
verdict: String::from("x"),
collected_at: 0,
};
let s = v.to_json().to_json_string();
for k in ["user_data_ok", "meas_ok", "tcb_ok", "chip_sig"] {
assert!(s.contains(k), "缺字段 {k}: {s}");
}
// 不许出现合并后的 ok 字段。
assert!(!s.contains("\"ok\""), "不许有合并的 ok 字段: {s}");
// chip_sig=false 必须带说明。
assert!(s.contains("未提供验签器"), "未验签要说清楚: {s}");
// ★ 三态字段必须在(它是「证据还没到」与「没通过」的唯一区分)。
assert!(s.contains("\"status\""), "缺 status 字段: {s}");
}
#[test]
fn attestation_of_exited_instance_is_conflict() {
let rt = TeeRuntime::new();
let spec = crate::runtime::SpawnSpec::new(
"s",
"a",
PlatformKind::SevSnp,
"/bin/sleep",
);
let inst = rt.spawn(&spec).unwrap();
rt.stop(&inst.sandbox_id).unwrap();
let resp = dispatch(&rt, &req("GET", &format!("/sandboxes/{}/attestation", inst.sandbox_id), ""));
assert_eq!(resp.status, Status::Conflict);
}
// =======================================================================
// ★ Task #18:证据上传 + 三态 + 独立判定
//
// 这组判据钉的是本轮修掉的**真实缺陷**:
// 早先 `GET /sandboxes/{id}/attestation` **恒返回四项全 false**
// (宿主侧压根不读证据表),于是集群面的 `all_ok()` 永不成立,
// 端点永远公布不出去 —— 症状是「会话起不来」而根因在宿主侧。
// =======================================================================
/// 构造一个带绑定上下文的实例(证明门控用)。
fn bound_instance(rt: &TeeRuntime) -> Instance {
let binding = SessionBinding::new([1u8; 32], "alice", [2u8; 32], [3u8; 32]);
let mut spec = crate::runtime::SpawnSpec::new(
"sess-1",
"alice",
PlatformKind::SevSnp,
"/bin/sleep",
);
spec.args = vec![String::from("300")];
spec = spec.with_binding(binding, 5, 3, Some([3u8; 32]));
rt.spawn(&spec).unwrap()
}
/// 造一份**结构合法**且绑定一致的证明包(模拟 guest 上传的)。
fn good_bundle(binding: &SessionBinding) -> Vec<u8> {
let ud = binding.user_data(PlatformKind::SevSnp, 5);
mpc_tee::bundle::AttestationBundle::new(
PlatformKind::SevSnp,
mpc_tee::verify::synthetic_snp_report(&ud),
Vec::new(),
ud,
)
.unwrap()
.to_bytes()
}
/// ★ **证据未到 ⇒ pending**,不是 rejected、也不是 verified。
///
/// 这条是三态的核心:早先宿主侧恒返回四项全 false,
/// 对账器把它读成「没通过」⇒ 刚起来的 guest 当场被销毁。
#[test]
fn no_evidence_yet_is_pending() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let resp = dispatch(
&rt,
&req("GET", &format!("/sandboxes/{}/attestation", inst.sandbox_id), ""),
);
assert_eq!(resp.status, Status::Ok);
let b = body_of(&resp);
assert!(
b.contains("\"status\":\"pending\""),
"★ 证据未到必须是 pending: {b}"
);
assert!(b.contains("\"user_data_ok\":false"), "{b}");
assert!(b.contains("\"chip_sig\":false"), "{b}");
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **上传合法证据 ⇒ verified**。
///
/// 这条钉的是「宿主侧真的读证据表并独立判定」——
/// 早先这里是恒 false,端点永远公布不出去。
#[test]
fn uploaded_evidence_is_independently_verified() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
let bundle = good_bundle(&rt.binding(&inst.sandbox_id).unwrap().binding);
// 上传(带实例级令牌)。
let mut headers = HashMap::new();
headers.insert(
String::from("authorization"),
format!("Bearer {token}"),
);
let up = Request {
method: String::from("POST"),
path: format!("/sandboxes/{}/attestation", inst.sandbox_id),
query: String::new(),
headers,
body: bundle,
};
let r = dispatch(&rt, &up);
assert_eq!(r.status, Status::Ok, "上传必须成功: {}", body_of(&r));
// 再查:应当是 verified。
let resp = dispatch(
&rt,
&req("GET", &format!("/sandboxes/{}/attestation", inst.sandbox_id), ""),
);
let b = body_of(&resp);
assert!(
b.contains("\"status\":\"verified\""),
"★ 合法证据上传后必须 verified: {b}"
);
assert!(b.contains("\"user_data_ok\":true"), "{b}");
assert!(b.contains("\"meas_ok\":true"), "{b}");
assert!(b.contains("\"tcb_ok\":true"), "{b}");
// 没配验签器 ⇒ chip_sig=false(且**不是**验签失败)。
assert!(b.contains("\"chip_sig\":false"), "{b}");
assert!(b.contains("\"chip_sig_failed\":false"), "{b}");
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **上传别的会话的证据 ⇒ rejected**。
///
/// 宿主用**自己保存的**绑定材料重算 `user_data`,
/// 与报告里的那份对不上 ⇒ 拒绝。
#[test]
fn evidence_from_another_session_is_rejected() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let ctx = rt.binding(&inst.sandbox_id).unwrap();
// 用**别的**会话的绑定值造证明包。
let other = SessionBinding::new([9u8; 32], "alice", [2u8; 32], [3u8; 32]);
let bundle = good_bundle(&other);
let mut headers = HashMap::new();
headers.insert(
String::from("authorization"),
format!("Bearer {}", ctx.upload_token),
);
let up = Request {
method: String::from("POST"),
path: format!("/sandboxes/{}/attestation", inst.sandbox_id),
query: String::new(),
headers,
body: bundle,
};
assert_eq!(dispatch(&rt, &up).status, Status::Ok);
let resp = dispatch(
&rt,
&req("GET", &format!("/sandboxes/{}/attestation", inst.sandbox_id), ""),
);
let b = body_of(&resp);
assert!(
b.contains("\"status\":\"rejected\""),
"★ 绑定对不上的证据必须 rejected: {b}"
);
assert!(b.contains("\"user_data_ok\":false"), "{b}");
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **没有令牌 ⇒ 401**(实例级令牌是硬要求)。
#[test]
fn evidence_upload_without_token_is_rejected() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let bundle = good_bundle(&rt.binding(&inst.sandbox_id).unwrap().binding);
let up = Request {
method: String::from("POST"),
path: format!("/sandboxes/{}/attestation", inst.sandbox_id),
query: String::new(),
headers: HashMap::new(),
body: bundle,
};
let r = dispatch(&rt, &up);
assert_eq!(r.status, Status::Unauthorized, "缺令牌必须 401");
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **错令牌 ⇒ 401**。
#[test]
fn evidence_upload_with_wrong_token_is_rejected() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let bundle = good_bundle(&rt.binding(&inst.sandbox_id).unwrap().binding);
let mut headers = HashMap::new();
headers.insert(
String::from("authorization"),
format!("Bearer {}", "f".repeat(64)),
);
let up = Request {
method: String::from("POST"),
path: format!("/sandboxes/{}/attestation", inst.sandbox_id),
query: String::new(),
headers,
body: bundle,
};
let r = dispatch(&rt, &up);
assert_eq!(r.status, Status::Unauthorized, "错令牌必须 401");
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **上传的不是证明包 ⇒ 400**(不把垃圾存进证据表)。
#[test]
fn evidence_upload_with_garbage_is_rejected() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
let mut headers = HashMap::new();
headers.insert(
String::from("authorization"),
format!("Bearer {token}"),
);
let up = Request {
method: String::from("POST"),
path: format!("/sandboxes/{}/attestation", inst.sandbox_id),
query: String::new(),
headers,
body: b"not-a-bundle".to_vec(),
};
let r = dispatch(&rt, &up);
assert_eq!(r.status, Status::BadRequest, "垃圾字节必须 400");
// 证据表必须仍是空的(没存进去)。
assert!(rt.evidence(&inst.sandbox_id).is_none());
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **绑定材料必须成套给全**:给一半必须拒绝。
#[test]
fn partial_binding_material_is_rejected() {
let e = parse_create_request(
r#"{"session_id":"s","site":"a","platform":"sev-snp","program":"/bin/true",
"bind_session_id":"0101010101010101010101010101010101010101010101010101010101010101"}"#,
)
.unwrap_err();
assert!(
e.contains("绑定材料") || e.contains("bind_"),
"半套绑定材料必须拒绝: {e}"
);
}
/// ★ **绑定材料解析正确**(64 位 hex → 32 字节)。
#[test]
fn binding_material_is_parsed_from_hex() {
let sid = "01".repeat(32);
let pk = "02".repeat(32);
let meas = "03".repeat(32);
let body = format!(
r#"{{"session_id":"s","site":"alice","platform":"sev-snp","program":"/bin/true",
"bind_session_id":"{sid}","bind_session_pubkey":"{pk}","bind_code_measurement":"{meas}",
"tcb":5,"min_tcb":3}}"#
);
let r = parse_create_request(&body).unwrap();
let b = r.binding.expect("必须解析出绑定材料");
assert_eq!(b.session_id, [1u8; 32]);
assert_eq!(b.session_pubkey, [2u8; 32]);
assert_eq!(b.code_measurement, [3u8; 32]);
assert_eq!(b.site, "alice");
assert_eq!(r.tcb, 5);
assert_eq!(r.min_tcb, 3);
}
/// ★ **长度不对的 hex 必须拒绝**(不能截断,也不能补零)。
#[test]
fn wrong_length_hex_is_rejected() {
assert!(parse_hex32("01").is_none());
assert!(parse_hex32(&"01".repeat(33)).is_none());
assert!(parse_hex32(&"zz".repeat(32)).is_none());
assert!(parse_hex32(&"01".repeat(32)).is_some());
}
/// ★ **实例删除后令牌失效**(绑定上下文必须一起清)。
#[test]
fn upload_token_dies_with_the_instance() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
rt.remove(&inst.sandbox_id).unwrap();
assert!(
rt.binding(&inst.sandbox_id).is_none(),
"★ 实例删除后绑定上下文必须清掉(令牌不得继续有效)"
);
assert!(rt.evidence(&inst.sandbox_id).is_none());
// 令牌查不到实例了。
assert!(rt.sandbox_id_by_upload_token(&token).is_none());
}
// =======================================================================
// ★ Task #18:实例级令牌这条**新开的授权路径**的负向判据
//
// 这条路径是本轮**新开的例外**(全局鉴权之外的一条口子)。
// 新开的授权路径不钉死就是盲区 ——
// 稍不留神就会变成「带任何 Authorization 头都能绕过全局鉴权」。
// =======================================================================
/// 造一个带 `Authorization: Bearer <v>` 的 POST 上传请求。
fn upload_req(id: &str, bearer: Option<&str>, body: Vec<u8>) -> Request {
let mut headers = HashMap::new();
if let Some(b) = bearer {
headers.insert(String::from("authorization"), String::from(b));
}
Request {
method: String::from("POST"),
path: format!("/sandboxes/{id}/attestation"),
query: String::new(),
headers,
body,
}
}
/// ★ **这条例外只对「精确形状」生效**。
///
/// 逐条破坏 method / 路径形状,每一个都必须仍然走全局鉴权
/// ⇒ 回环模式下「带凭据一律拒」。
#[test]
fn attestation_upload_exception_is_narrow() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
let bundle = good_bundle(&rt.binding(&inst.sandbox_id).unwrap().binding);
// 形状对、令牌对 ⇒ 放行(正向对照,证明这条路径**真的通**,
// 否则下面的负向全是恒真)。
let ok = dispatch(&rt, &upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), bundle.clone()));
assert_eq!(ok.status, Status::Ok, "正向对照必须通: {}", body_of(&ok));
// 破坏 1:GET 同路径(读判定结论)⇒ 不走例外 ⇒ 401。
let mut r = upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), bundle.clone());
r.method = String::from("GET");
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ GET 不得走实例级例外(读结论仍归全局鉴权)"
);
// 破坏 2:多一段路径 ⇒ 不是那条路径 ⇒ 401。
let mut r = upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), bundle.clone());
r.path = format!("/sandboxes/{}/attestation/extra", inst.sandbox_id);
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ 路径形状不对不得走实例级例外"
);
// 破坏 3:末段名字不对 ⇒ 401。
let mut r = upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), bundle.clone());
r.path = format!("/sandboxes/{}/evidence", inst.sandbox_id);
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ 末段名字不对不得走实例级例外"
);
// 破坏 4:别的段前缀(不是 sandboxes)⇒ 401。
let mut r = upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), bundle.clone());
r.path = format!("/nodes/{}/attestation", inst.sandbox_id);
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ 前缀不对不得走实例级例外"
);
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **别的主权限端点不许被这条例外捎带放行**。
///
/// 这条钉的是「例外只对那一个方法+路径组合生效」——
/// 同一个令牌不能拿去 `DELETE /sandboxes/{id}`(删实例)或
/// `GET /sandboxes`(列全部实例)。
#[test]
fn upload_token_cannot_reach_other_endpoints() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
let bearer = format!("Bearer {token}");
// DELETE /sandboxes/{id} —— 带实例级令牌 ⇒ 必须 401,不得删实例。
let mut r = upload_req(&inst.sandbox_id, Some(&bearer), Vec::new());
r.method = String::from("DELETE");
r.path = format!("/sandboxes/{}", inst.sandbox_id);
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ 实例级令牌不得删除实例"
);
assert!(rt.get(&inst.sandbox_id).is_some(), "实例必须还在");
// GET /sandboxes —— 带实例级令牌 ⇒ 必须 401(不得列出全部实例)。
let mut r = upload_req(&inst.sandbox_id, Some(&bearer), Vec::new());
r.method = String::from("GET");
r.path = String::from("/sandboxes");
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ 实例级令牌不得列出全部实例"
);
// POST /sandboxes(起新 guest)—— 必须 401。
let mut r = upload_req(&inst.sandbox_id, Some(&bearer), Vec::new());
r.method = String::from("POST");
r.path = String::from("/sandboxes");
assert_eq!(
dispatch(&rt, &r).status,
Status::Unauthorized,
"★ 实例级令牌不得起新 guest"
);
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **A 实例的令牌不得往 B 实例上传**(最小权限:只对本实例)。
#[test]
fn upload_token_is_scoped_to_its_own_instance() {
let rt = TeeRuntime::new();
let a = bound_instance(&rt);
let b = bound_instance(&rt);
let token_a = rt.binding(&a.sandbox_id).unwrap().upload_token;
let bundle = good_bundle(&rt.binding(&b.sandbox_id).unwrap().binding);
// 用 A 的令牌往 B 上传 ⇒ 必须 401。
let r = dispatch(
&rt,
&upload_req(&b.sandbox_id, Some(&format!("Bearer {token_a}")), bundle),
);
assert_eq!(
r.status,
Status::Unauthorized,
"★ A 的令牌不得往 B 上传"
);
assert!(
rt.evidence(&b.sandbox_id).is_none(),
"★ 未授权的上传不得进证据表"
);
let _ = rt.stop(&a.sandbox_id);
let _ = rt.stop(&b.sandbox_id);
}
/// ★ **回环信任模式下,上传端点也必须带凭据**。
///
/// 这条钉的是本轮修掉的一个**真实安全倒退**:
/// 回环模式「不带凭据即放行」是全局鉴权的规矩,
/// 但若上传端点沿用它 ⇒ **谁能连上就能往证据表里写** ——
/// 证据表是判定输入,写它就是改判定结论。
/// 所以上传端点在回环模式下也要求**真的带上一种凭据**。
#[test]
fn attestation_upload_requires_a_credential_even_in_loopback_mode() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let bundle = good_bundle(&rt.binding(&inst.sandbox_id).unwrap().binding);
// 不带任何凭据 ⇒ 401(不能沿用回环模式的「放行」)。
let r = dispatch(&rt, &upload_req(&inst.sandbox_id, None, bundle.clone()));
assert_eq!(
r.status,
Status::Unauthorized,
"★ 回环模式下上传端点也必须带凭据"
);
assert!(
rt.evidence(&inst.sandbox_id).is_none(),
"★ 未授权的上传不得进证据表"
);
// 带一个**错的**凭据 ⇒ 仍然 401。
let r = dispatch(
&rt,
&upload_req(
&inst.sandbox_id,
Some("Bearer whatever-not-the-token"),
bundle.clone(),
),
);
assert_eq!(r.status, Status::Unauthorized, "错凭据必须 401");
// 正向对照:带对令牌 ⇒ 放行(证明上面两条不是恒真)。
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
let r = dispatch(
&rt,
&upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), bundle),
);
assert_eq!(r.status, Status::Ok, "正向对照必须通: {}", body_of(&r));
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ **凭据模式下,实例级令牌不得替代共享密钥**去调主权限端点。
///
/// 反过来也要成立:凭据模式下,**正确**的共享密钥仍然能调
/// 主权限端点(不能因为开了例外就误伤主路径)。
#[test]
fn configured_secret_still_gates_the_main_surface() {
let rt = TeeRuntime::new();
let inst = bound_instance(&rt);
let token = rt.binding(&inst.sandbox_id).unwrap().upload_token;
let secret = "0123456789abcdef0123456789abcdef";
let auth = crate::auth::Authenticator::from_secret(secret.as_bytes()).unwrap();
// 实例级令牌 ⇒ 主权限端点仍 401。
let mut r = upload_req(&inst.sandbox_id, Some(&format!("Bearer {token}")), Vec::new());
r.method = String::from("GET");
r.path = String::from("/sandboxes");
assert_eq!(
dispatch_with_auth(&rt, &r, &auth).status,
Status::Unauthorized,
"★ 实例级令牌不得替代共享密钥"
);
// 共享密钥 ⇒ 主权限端点放行(正向对照)。
let mut r = upload_req(&inst.sandbox_id, Some(&format!("Bearer {secret}")), Vec::new());
r.method = String::from("GET");
r.path = String::from("/sandboxes");
assert_eq!(
dispatch_with_auth(&rt, &r, &auth).status,
Status::Ok,
"★ 共享密钥必须仍能调主权限端点"
);
// 共享密钥也能调上传端点(不必非要实例级令牌)——
// 上传端点接受**两种**凭据:全局共享密钥 或 本实例令牌。
let bundle = good_bundle(&rt.binding(&inst.sandbox_id).unwrap().binding);
let up = upload_req(
&inst.sandbox_id,
Some(&format!("Bearer {secret}")),
bundle,
);
assert_eq!(
dispatch_with_auth(&rt, &up, &auth).status,
Status::Ok,
"★ 共享密钥也必须能上传证明材料"
);
let _ = rt.stop(&inst.sandbox_id);
}
#[test]
fn platform_parsing_covers_all_kinds() {
assert_eq!(parse_platform("sev-snp"), Some(PlatformKind::SevSnp));
assert_eq!(parse_platform("snp"), Some(PlatformKind::SevSnp));
assert_eq!(parse_platform("csv"), Some(PlatformKind::HygonCsv));
assert_eq!(parse_platform("hygon-csv"), Some(PlatformKind::HygonCsv));
assert_eq!(parse_platform("tdx"), Some(PlatformKind::Tdx));
assert_eq!(parse_platform("optee"), Some(PlatformKind::Optee));
assert_eq!(parse_platform("nope"), None);
}
#[test]
fn timeout_endpoint_updates_record() {
let rt = TeeRuntime::new();
let spec = crate::runtime::SpawnSpec::new(
"s",
"a",
PlatformKind::SevSnp,
"/bin/sleep",
);
let inst = rt.spawn(&spec).unwrap();
let resp = dispatch(
&rt,
&req("POST", &format!("/sandboxes/{}/timeout", inst.sandbox_id), r#"{"timeout":77}"#),
);
assert_eq!(resp.status, Status::Ok);
assert_eq!(rt.get(&inst.sandbox_id).unwrap().timeout_secs, 77);
let _ = rt.stop(&inst.sandbox_id);
}
/// 客户端解析往返:宿主吐什么,客户端就能读回什么。
#[test]
fn sandbox_view_roundtrips_through_json() {
let rt = TeeRuntime::new();
let spec = crate::runtime::SpawnSpec::new(
"sess-1",
"alice",
PlatformKind::SevSnp,
"/bin/sleep",
);
let inst = rt.spawn(&spec).unwrap();
let v = SandboxView::of(&inst).to_json();
let back = SandboxView::from_json(&v);
assert_eq!(back.sandbox_id, inst.sandbox_id);
assert_eq!(back.session_id, "sess-1");
assert_eq!(back.site, "alice");
assert_eq!(back.platform, PlatformKind::SevSnp);
assert_eq!(back.argv, inst.argv);
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ 布尔字段缺失必须当作 `false` —— 「没拿到」不能被读成「通过」。
#[test]
fn missing_attestation_booleans_read_as_false() {
let v = crate::json::parse(r#"{"session_id":"s","platform":"snp"}"#).unwrap();
let a = AttestationVerdict::from_json(&v);
assert!(!a.user_data_ok);
assert!(!a.meas_ok);
assert!(!a.tcb_ok);
assert!(!a.chip_sig);
}
#[test]
fn pause_and_resume_endpoints_work() {
let rt = TeeRuntime::new();
let spec = crate::runtime::SpawnSpec::new(
"s",
"a",
PlatformKind::SevSnp,
"/bin/sleep",
);
let inst = rt.spawn(&spec).unwrap();
let p = dispatch(
&rt,
&req("POST", &format!("/sandboxes/{}/pause", inst.sandbox_id), ""),
);
// 发不出 SIGSTOP 的环境里 pause 会失败 ——
// ★ 关键是不能「假装成功」:返回 200 会让站点端以为实例停了。
if p.status == Status::Ok {
assert!(body_of(&p).contains("\"paused\":true"));
let r = dispatch(
&rt,
&req("POST", &format!("/sandboxes/{}/resume", inst.sandbox_id), ""),
);
assert_eq!(r.status, Status::Ok);
assert!(body_of(&r).contains("\"paused\":false"));
} else {
assert!(
body_of(&p).contains("SIGSTOP"),
"pause 失败必须说明是发不出信号: {}",
body_of(&p)
);
}
let _ = rt.stop(&inst.sandbox_id);
}
}