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 触摸验证 ⇒ 改为远端轮询一次取回。
1960 lines
80 KiB
Rust
1960 lines
80 KiB
Rust
//! 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);
|
||
}
|
||
}
|