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 触摸验证 ⇒ 改为远端轮询一次取回。
This commit is contained in:
admin committed 2026-11-09 15:34:26 +08:00
1 parent 01b8bb44aa
commit 393359ef35
16 files changed
+1955 -1234

No files matched your search

+2 -2
View File
@@ -103,7 +103,7 @@ fn cmd_query(args: &[String], path: &str) -> Result<(), String> {
};
let v = client.get(path).map_err(|e| e.to_string())?;
let text = v.to_json_string();
match crate::json::parse(&text) {
match mpc_hostd::json::parse(&text) {
Ok(_) => {}
Err(e) => return Err(format!("控制面响应不是合法 JSON: {e}")),
}
@@ -124,7 +124,7 @@ fn cmd_set_desired(args: &[String]) -> Result<(), String> {
let body = std::fs::read_to_string(path)
.map_err(|e| format!("读期望态文件 {path} 失败: {e}"))?;
// 先本地解析一次:格式错就别去打扰控制面了。
if let Err(e) = crate::json::parse(&body) {
if let Err(e) = mpc_hostd::json::parse(&body) {
return Err(format!("期望态文件不是合法 JSON: {e}"));
}
let client = HostClient::new(ep.clone()).map_err(|e| e.to_string())?;
+59 -13
View File
@@ -32,15 +32,34 @@
//! 不合并成一个 `ok`。`chip_sig=0` 的含义是「绑定关系成立,但没做芯片验签」。
use crate::report;
use mpc_tee::hostd::api::{AttestationVerdict, SandboxView};
use mpc_tee::hostd::client::HostClient;
use mpc_tee::hostd::HostConfig;
use mpc_hostd::api::{AttestationVerdict, SandboxView};
use mpc_hostd::client::HostClient;
use mpc_hostd::HostConfig;
use mpc_tee::platform::KbcMode;
use mpc_tee::probe::HostCapConfig;
/// 默认宿主控制面地址。
const DEFAULT_HOST: &str = "127.0.0.1:3010";
/// `mpc hostd`:启动宿主控制面。
pub fn cmd_hostd(args: &[String]) -> Result<(), String> {
let cfg = build_host_config(args)?;
mpc_hostd::serve(cfg)
}
/// 构造宿主控制面配置并**做全部启动前校验**。
///
/// ★ 抽成独立函数(而不是在 `cmd_hostd` 里内联)是有意的:
/// 校验逻辑必须**只有一份**,且可被单元测试直接调用。
/// 「测试验一套、生产走另一套」是最常见的判据漂移来源。
///
/// ★ 校验项与它们的理由:
/// 1. `--shared-secret` 长度 ≥ 32 字节 —— 短密钥抗不住在线穷举;
/// 2. 非回环监听 **必须**同时有共享密钥 **且** `--allow-remote`;
/// 两者互为兜底 —— 只给 `--allow-remote` 只是一句声明,不构成任何保护;
/// 3. 配了 `--control-plane` 却没配 `--node-platform` ⇒ 拒绝启动
/// (假就绪信号:以为在自报,其实推送线程永远空转)。
fn build_host_config(args: &[String]) -> Result<HostConfig, String> {
let mut cfg = HostConfig::default();
if let Some(v) = parse_flag(args, "--listen") {
cfg.listen = v.to_string();
@@ -62,6 +81,19 @@ pub fn cmd_hostd(args: &[String]) -> Result<(), String> {
cfg.control_plane = Some(v.to_string());
}
// ★ 共享密钥:配了就是「凭据模式」(每个请求都要带 Bearer token)。
// 没配就是「回环信任模式」(只放行不带凭据的请求)。
if let Some(v) = parse_flag(args, "--shared-secret") {
if v.len() < mpc_hostd::auth::MIN_SECRET_LEN {
return Err(format!(
"--shared-secret 至少要 {} 字节(现在是 {} 字节)—— 短密钥抗不住在线穷举",
mpc_hostd::auth::MIN_SECRET_LEN,
v.len()
));
}
cfg.shared_secret = Some(v.as_bytes().to_vec());
}
// ★ 芯片验签器:配了才有宿主侧的 `chip_sig=true`。
// 不配不是错,但集群面按 `require_chip_sig=true` 门控时端点不会公布 ——
// 那时 note 会写明「未提供验签器」(是「没验」,不是「验了没过」)。
@@ -87,17 +119,31 @@ pub fn cmd_hostd(args: &[String]) -> Result<(), String> {
);
}
// ★ 非回环地址必须显式确认。
// 宿主控制面**目前没有鉴权** —— 谁能连上就能起 guest、读证明。
if !is_loopback(&cfg.listen) && !args.iter().any(|a| a == "--allow-remote") {
return Err(format!(
"{} 不是回环地址。宿主控制面当前没有鉴权,暴露到远程会让任何人都能起 guest、读证明。\
确实要这么做请显式加 --allow-remote。",
cfg.listen
));
// ★ 非回环监听必须**同时**满足两个条件:配了共享密钥 **且** 显式
// `--allow-remote`。
//
// 理由:回环信任模式在非回环地址上等于**零保护** ——
// 谁能连上就能起 guest、读远程证明、拿密钥。
// 只给 `--allow-remote` 只是一句声明;只给密钥却忘了确认暴露面,
// 同样是运维事故。两条互为兜底,缺一即拒。
if !is_loopback(&cfg.listen) {
if cfg.shared_secret.is_none() {
return Err(format!(
"{} 不是回环地址 —— 回环信任模式在跨网段上等于零保护,任何能连上的人都能起 \
guest、读远程证明。请同时配共享密钥 --shared-secret(至少 {} 字节)。",
cfg.listen,
mpc_hostd::auth::MIN_SECRET_LEN
));
}
if !args.iter().any(|a| a == "--allow-remote") {
return Err(format!(
"{} 不是回环地址 —— 确实要跨网段暴露请显式加 --allow-remote。",
cfg.listen
));
}
}
mpc_tee::hostd::serve(cfg)
Ok(cfg)
}
/// 地址是不是回环。
@@ -548,7 +594,7 @@ fn cmd_down(args: &[String]) -> Result<(), String> {
}
/// 打印一个实例视图。
fn print_sandbox(v: &mpc_tee::hostd::json::Json) {
fn print_sandbox(v: &mpc_hostd::json::Json) {
let view = SandboxView::from_json(v);
let rows: Vec<(&str, report::Cell)> = vec![
("sandboxID", report::Cell::txt(view.sandbox_id.clone())),
+196 -800
View File
File diff suppressed because it is too large. Load diff
+115 -47
View File
@@ -454,6 +454,43 @@ pub fn parse_platform(raw: &str) -> Option<PlatformKind> {
}
}
/// ★ ★ **宿主控制面的路由形状只有一份,在这里。**
///
/// # 为什么宿主控制面要**拥有**这份路由
///
/// 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 兼容面决定:
@@ -524,7 +561,7 @@ pub fn dispatch_with_auth(
return Response::text(Status::Ok, "ok");
}
// 沙箱集合
if segs[0] == "sandboxes" {
if segs[0] == ROUTE_SANDBOXES {
return dispatch_sandboxes(rt, req, &segs, None);
}
// 宿主自描述:本宿主探测出的 TEE 能力自报(Cubelet 自描述,pull 接口)。
@@ -565,11 +602,11 @@ fn dispatch_sandboxes(
// DELETE /sandboxes/{id}
("DELETE", 2) => delete_sandbox(rt, segs[1]),
// GET /sandboxes/{id}/attestation
("GET", 3) if segs[2] == "attestation" => get_attestation(rt, segs[1]),
("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] == "attestation" => {
("POST", 3) if segs[2] == ROUTE_ATTESTATION => {
post_attestation(rt, req, segs[1], upload_global_authorized.unwrap_or(false))
}
// POST /sandboxes/{id}/connect
@@ -962,8 +999,8 @@ fn bearer_token(req: &Request) -> Option<String> {
fn is_attestation_upload(req: &Request, segs: &[&str]) -> bool {
req.method.eq_ignore_ascii_case("POST")
&& segs.len() == 3
&& segs[0] == "sandboxes"
&& segs[2] == "attestation"
&& segs[0] == ROUTE_SANDBOXES
&& segs[2] == ROUTE_ATTESTATION
}
/// ★ 这条请求带的令牌**是不是**该实例的上传令牌。
@@ -993,6 +1030,79 @@ 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"));
@@ -1176,48 +1286,6 @@ mod tests {
///
/// 症状很静默:客户端 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(), "记录必须从表里删除");
}
#[test]
fn health_returns_ok() {
+3 -3
View File
@@ -444,11 +444,11 @@ mod tests {
n
}
fn cp() -> ControlPlane<Arc<MockHost>> {
fn cp() -> ControlPlane<MockDispatch> {
let host = Arc::new(MockHost { up: true });
ControlPlane::new(
mpc_tee::control_plane::ControlPlaneConfig::default(),
host,
MockDispatch(host),
SessionBinding::new([1u8; 32], "alice", [2u8; 32], [9u8; 32]),
)
}
@@ -568,7 +568,7 @@ mod tests {
let host = Arc::new(MockHost { up: true });
let cp = ControlPlane::new(
mpc_tee::control_plane::ControlPlaneConfig::default(),
host,
MockDispatch(host),
SessionBinding::new([1u8; 32], "alice", [2u8; 32], [9u8; 32]),
);
// 自报的节点**度量与绑定不一致** ⇒ 准入拒绝 ⇒ 不会有会话。
+3 -3
View File
@@ -227,7 +227,7 @@ mod tests {
use mpc_tee::dispatch::AttestationSummary;
use mpc_tee::probe::NodeReport;
use mpc_tee::schedule::{LaunchSpec, TeeNode, TeeRequirement};
use mpc_tee::schedule::{LaunchSpec, TeeNode};
use mpc_tee::session::SessionBinding;
use mpc_tee::PlatformKind;
@@ -311,8 +311,8 @@ mod tests {
}
/// 发一个原始 HTTP 请求并读满响应(必须读到 EOF:TCP 是流)。
fn raw_request(addr: std::net::SocketAddr, req_bytes: &[u8]) -> String {
let mut s = TcpStream::connect(addr).unwrap();
fn raw_request(addr: &std::net::SocketAddr, req_bytes: &[u8]) -> String {
let mut s = TcpStream::connect(*addr).unwrap();
s.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
s.write_all(req_bytes).unwrap();
s.flush().unwrap();
+86 -9
View File
@@ -40,10 +40,18 @@
//! # 9p 的挂载参数
//!
//! ```text
//! -virtfs local,path=<宿主目录>,mount_tag=mpchostd,security_model=none
//! -fsdev local,id=mpchostd9p,path=<宿主目录>,security_model=none
//! -device virtio-9p-pci,fsdev=mpchostd9p,mount_tag=mpchostd
//! ```
//!
//! ★ ★ **必须用显式 `-fsdev`**,不能用 `-virtfs` 简写(2026-11-09 真机实测):
//! `-virtfs local,path=...,mount_tag=mpchostd` 会**自动**创建一个 fsdev,
//! 但它的 **id 由 qemu 自己决定**(不是 `mount_tag`)⇒ 后面
//! `-device virtio-9p-pci,fsdev=mpchostd9p` 找不到它 ⇒ qemu 直接报
//! `9pfs device couldn't find fsdev with the id = mpchostd9p` 并退出。
//! 症状极具迷惑性:qemu **秒退**、串口日志**完全为空**,
//! 看起来像「guest 根本没起来」,实际是 argv 拼接错。
//!
//! `security_model=none` 是**必需的**(默认 `mapped-xattr` / `passthrough`
//! 需要 root 与 xattr 支持,且会让 guest 看到的属主变成 nobody)。
//! 这里的目录只放一份**只属于这个 guest**的手牌,
@@ -52,6 +60,12 @@
/// guest 里的挂载点(9p mount_tag 对应)。
pub const GUEST_MOUNT_TAG: &str = "mpchostd";
/// qemu **fsdev 的 id**(`-fsdev local,id=...` 与 `-device ...,fsdev=...` 必须一致)。
///
/// ★ 这个 id 由**我们**钉死,不能交给 qemu 自动生成 ——
/// 见 [`virtfs_args`] 的说明(`-virtfs` 简写会让 qemu 自己决定 id)。
pub const FSDEV_ID: &str = "mpchostd9p";
/// guest 里的挂载路径。
pub const GUEST_MOUNT_PATH: &str = "/run/mpc-tee/hostd";
@@ -64,6 +78,17 @@ pub const FILE_UPLOAD_TOKEN: &str = "upload_token";
/// 手牌文件名:宿主控制面地址。
pub const FILE_HOSTD_ENDPOINT: &str = "hostd_endpoint";
/// 手牌文件名:证明材料上传端点的**完整路径**。
///
/// ★ 为什么路径要由**宿主**下发(而不是 guest 侧自己拼):
/// 路由形状是**宿主控制面**的事实。guest 侧写死路由 =
/// ① guest 产物带宿主面痕迹(破坏 guest 边界);
/// ② ★ **路由漂移** —— hostd 改路由而 guest 不会跟着改
/// ⇒ guest 静默 POST 到不存在的端点
/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。
/// 宿主改路由 ⇒ 手牌里的路径跟着改 ⇒ guest 不用动。
pub const FILE_UPLOAD_PATH: &str = "upload_path";
/// 一个实例的手牌(宿主侧准备,guest 侧读取)。
#[derive(Debug, Clone)]
pub struct GuestHand {
@@ -73,6 +98,8 @@ pub struct GuestHand {
pub upload_token: String,
/// guest 可达的宿主控制面地址。
pub hostd_endpoint: String,
/// 证明材料上传端点的完整路径(宿主下发)。
pub upload_path: String,
}
impl GuestHand {
@@ -90,6 +117,7 @@ impl GuestHand {
write_file(dir, FILE_SANDBOX_ID, &self.sandbox_id)?;
write_file(dir, FILE_UPLOAD_TOKEN, &self.upload_token)?;
write_file(dir, FILE_HOSTD_ENDPOINT, &self.hostd_endpoint)?;
write_file(dir, FILE_UPLOAD_PATH, &self.upload_path)?;
Ok(())
}
}
@@ -120,16 +148,25 @@ fn set_mode(p: &std::path::Path, mode: u32) -> Result<(), String> {
/// 9p 挂载的 qemu 参数(追加到 argv 尾部)。
///
/// 返回 `None` 表示**不挂**(没有手牌可给)。
/// ★ ★ **必须用显式 `-fsdev`,不能用 `-virtfs` 简写**(2026-11-09 真机实测):
///
/// `-virtfs local,path=...,mount_tag=mpchostd` 会**自动**创建一个 fsdev,
/// 但它的 **id 由 qemu 自己决定**(不是 `mount_tag`)⇒ 后面
/// `-device virtio-9p-pci,fsdev=mpchostd9p` 找不到它 ⇒ qemu 直接报
/// `9pfs device couldn't find fsdev with the id = mpchostd9p` 并退出。
///
/// 显式 `-fsdev local,id=mpchostd9p,path=...` 才能把 id **钉死**,
/// 与后面 `-device` 的 `fsdev=` 严格对齐。
///
/// 症状极具迷惑性:qemu **秒退**,串口日志**完全为空**,
/// 看起来像「guest 根本没起来」,实际是 argv 拼接错。
pub fn virtfs_args(host_dir: &std::path::Path) -> Vec<String> {
let path = host_dir.to_string_lossy().to_string();
vec![
String::from("-virtfs"),
format!(
"local,path={path},mount_tag={GUEST_MOUNT_TAG},security_model=none"
),
String::from("-fsdev"),
format!("local,id={FSDEV_ID},path={path},security_model=none"),
String::from("-device"),
format!("virtio-9p-pci,fsdev=mpchostd9p,mount_tag={GUEST_MOUNT_TAG}"),
format!("virtio-9p-pci,fsdev={FSDEV_ID},mount_tag={GUEST_MOUNT_TAG}"),
]
}
@@ -213,6 +250,7 @@ mod tests {
sandbox_id: String::from("abc123"),
upload_token: String::from("deadbeef"),
hostd_endpoint: String::from("10.93.0.1:3010"),
upload_path: String::from("/sandboxes/abc123/attestation"),
}
}
@@ -293,7 +331,7 @@ mod tests {
assert!(validate_virtfs_path(std::path::Path::new("/tmp/ok")).is_ok());
}
/// ★ 正向:手牌目录写出的三个文件内容正确、**无尾随换行**。
/// ★ 正向:手牌目录写出的四个文件内容正确、**无尾随换行**。
#[test]
fn hand_files_have_no_trailing_newline() {
let dir = std::env::temp_dir().join(format!("mpc-hand-test-{}", std::process::id()));
@@ -303,6 +341,7 @@ mod tests {
(FILE_SANDBOX_ID, "abc123"),
(FILE_UPLOAD_TOKEN, "deadbeef"),
(FILE_HOSTD_ENDPOINT, "10.93.0.1:3010"),
(FILE_UPLOAD_PATH, "/sandboxes/abc123/attestation"),
] {
let got = std::fs::read_to_string(dir.join(name)).unwrap();
assert_eq!(got, want, "{name} 内容必须逐字节相同(无尾随换行)");
@@ -320,6 +359,39 @@ mod tests {
assert!(joined.contains("virtio-9p-pci"), "{joined}");
}
/// ★ ★ **fsdev 的 id 必须与 device 的 `fsdev=` 严格一致**。
///
/// 2026-11-09 真机实测抓到的真实 bug:
/// `-virtfs local,path=...,mount_tag=mpchostd` 会**自动**创建 fsdev,
/// 但它的 id 由 qemu 自己决定(**不是** `mount_tag`)⇒
/// `-device virtio-9p-pci,fsdev=mpchostd9p` 找不到它 ⇒
/// qemu 报 `9pfs device couldn't find fsdev with the id = mpchostd9p` 并退出。
///
/// 症状极具迷惑性:qemu **秒退**、串口日志**完全为空**,
/// 看起来像「guest 根本没起来」,实际是 argv 拼接错。
///
/// 这条判据把「id 一致」钉死:不一致 ⇒ qemu 起不来 ⇒ 手牌通道整体失效。
#[test]
fn virtfs_fsdev_id_matches_device_reference() {
let a = virtfs_args(std::path::Path::new("/tmp/xyz"));
let joined = a.join(" ");
// 显式 -fsdev:id 由我们钉死
assert!(
joined.contains(&format!("-fsdev local,id={FSDEV_ID},")),
"必须用显式 -fsdev 并钉死 id(不能用 -virtfs 简写):{joined}"
);
// device 侧的 fsdev= 必须与 fsdev id 一致
assert!(
joined.contains(&format!("fsdev={FSDEV_ID},")),
"device 的 fsdev= 必须与 -fsdev 的 id 一致:{joined}"
);
// 不得回退到 -virtfs 简写(它会引入 qemu 自动生成的 id)
assert!(
!joined.contains("-virtfs "),
"不得使用 -virtfs 简写(fsdev id 不可控):{joined}"
);
}
/// ★ ★ **guest 侧的挂载约定必须与本模块一致**。
///
/// 这两侧各写各的字符串(Rust 常量 vs guest 的 shell 脚本),
@@ -345,7 +417,12 @@ mod tests {
GUEST_MOUNT_PATH
);
// 手牌文件名也必须一致 —— guest 是按文件名读的。
for name in [FILE_SANDBOX_ID, FILE_UPLOAD_TOKEN, FILE_HOSTD_ENDPOINT] {
for name in [
FILE_SANDBOX_ID,
FILE_UPLOAD_TOKEN,
FILE_HOSTD_ENDPOINT,
FILE_UPLOAD_PATH,
] {
assert!(
text.contains(name),
"★ guest init.sh 必须读同一个手牌文件名({name})"
+59 -61
View File
@@ -624,6 +624,10 @@ impl TeeRuntime {
sandbox_id: sandbox_id.clone(),
upload_token: upload_token.clone(),
hostd_endpoint: endpoint,
// ★ 上传路径由**宿主**给出(路由归 hostd 管)。
// guest 从 9p 读到手牌后原样使用 ——
// hostd 改路由时这里跟着改,guest 不用动。
upload_path: crate::api::attestation_upload_path(&sandbox_id),
};
hand.write_into(&dir)
.map_err(|e| RuntimeError::Io(format!("备 guest 手牌失败: {e}")))?;
@@ -1045,37 +1049,6 @@ impl TeeRuntime {
}
}
/// **删除**一个实例记录(e2b 的 `DELETE /sandboxes/{id}` 语义)。
///
/// ★ 与 [`Self::stop`] 的区别:`stop` 只**停进程并标终态**,
/// 记录仍在表里 —— 那是 reaper 的语义(「不删除记录,删掉就没法回答
/// 『这个实例后来怎么了』」)。
/// 但 e2b 兼容面的 `DELETE /sandboxes/{id}` 是**显式删除**:
/// 删完之后 `GET /sandboxes` 不应再返回它。
///
/// 2026-11-07 真机联调(沙箱管理节点 → 海光真机)实测发现的缺口:
/// `DELETE` 之前只调 `stop()`,实例仍留在列表里 —— 注释说「显式删除」
/// 而实现没删,与 e2b 语义不符。
///
/// 顺序很要紧:**先 stop(收进程、收僵尸)再删记录** ——
/// 反过来的话进程就没人管了,会留下僵尸。
pub fn remove(&self, id: &str) -> Result<(), RuntimeError> {
// 1. 先停:找不到实例直接报错(e2b 的 DELETE 对不存在的实例返回 404)。
let _ = self.stop(id)?;
// 2. 删记录 + 删子进程句柄(句柄留着会漏掉僵尸)。
{
let mut table = self.table.lock().unwrap();
table.remove(id);
}
{
let mut children = self.children.lock().unwrap();
children.remove(id);
}
self.flush()?;
Ok(())
}
/// 暂停一个实例。
///
/// qemu 没有 SIGSTOP 等价物,但 **Linux 上可以真的 SIGSTOP**。
@@ -1594,6 +1567,44 @@ pub fn process_start_key(pid: u32) -> Option<String> {
}
}
/// 本环境**能不能**读出进程状态(用于「判据测不了」时的显式跳过)。
///
/// # 为什么需要它
///
/// 非 Linux 平台上 [`process_start_key`] 靠 `ps -o state=` 读状态。
/// 某些受限环境(容器沙箱、受限 macOS 沙箱)**禁止 exec `ps`** ——
/// 于是 `process_start_key` 对**活进程**也返回 `None`。
///
/// 那种环境下「僵尸判据」是**测不了**,不是「实现坏了」。
/// 按项目纪律(缺环境必须显式 SKIPPED,绝不静默通过),
/// 调用方据此显式跳过并说明,而不是让整条门禁红。
///
/// Linux 上永远返回 `true` —— 它读 `/proc/<pid>/stat`,不需要外部命令。
#[cfg(test)]
fn start_key_probe_supported() -> bool {
#[cfg(target_os = "linux")]
{
true
}
#[cfg(not(target_os = "linux"))]
{
// 用**自己的 pid** 探:自己的状态一定是「活」,`ps` 能报出来就说明
// 这条路通。不行就返回 false(= 判据测不了)。
let me = std::process::id();
let ok = Command::new("ps")
.arg("-p")
.arg(me.to_string())
.arg("-o")
.arg("state=")
.stdout(Stdio::piped())
.stderr(Stdio::null())
.output()
.map(|o| o.status.success())
.unwrap_or(false);
ok
}
}
/// 进程是否还活着。
///
/// 只判「在不在」,不判「是不是我起的那一个」——
@@ -2183,6 +2194,23 @@ mod tests {
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let pid = inst.pid.unwrap();
let key = process_start_key(pid);
// ★ 环境能力探测(2026-11-09):非 Linux 平台上 `process_start_key`
// 靠 `ps -o state=` 读进程状态。某些受限环境(容器沙箱 / 受限
// macOS 沙箱)**禁止 exec `ps`** ⇒ 拿不到状态 ⇒ 返回 `None`。
//
// 那种环境下这条判据**测不了**,不是「实现坏了」。
// ★ 按项目纪律(缺环境必须显式 SKIPPED,绝不静默通过),
// 这里显式跳过并打印原因,而不是让整条门禁红。
// CI(Linux)走 `/proc/<pid>/stat` 分支,不受影响 —— 这条判据
// 在真正的门禁环境里**必须**被执行到。
if key.is_none() && !start_key_probe_supported() {
eprintln!(
"ZOMBIE_TEST_SKIPPED: 本环境无法读取进程状态(非 Linux 且 `ps` 不可用),\
僵尸判据本轮未执行"
);
let _ = rt.stop(&inst.sandbox_id);
return;
}
assert!(key.is_some(), "活进程的启动标识必须拿得到");
assert!(process_alive(pid, key.as_deref()), "活进程必须判为活");
@@ -2215,36 +2243,6 @@ mod tests {
/// - 被 SIGKILL 但**未 wait**(= 僵尸)时 start_key 必须变 `None`;
/// - `process_alive` 对僵尸必须返回 false(fail-closed)。
#[test]
fn zombie_process_is_not_treated_as_alive() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let pid = inst.pid.unwrap();
let key = process_start_key(pid);
assert!(key.is_some(), "活进程的启动标识必须拿得到");
assert!(process_alive(pid, key.as_deref()), "活进程必须判为活");
// SIGKILL 之后进程进入僵尸态(本进程是它的父 ⇒ 还没被 wait 回收)。
kill_pid_hard(pid);
std::thread::sleep(Duration::from_millis(200));
// ★ 僵尸:启动标识必须拿不到(None = 无法确认)。
assert!(
process_start_key(pid).is_none(),
"僵尸进程不得还有启动标识(否则会被当成活实例)"
);
// ★ 僵尸:存活判据必须为 false。
assert!(
!process_alive(pid, key.as_deref()),
"僵尸进程不得被判为存活"
);
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ 存活判据必须靠**子进程句柄**,不靠外部命令。
///
/// 为什么这条重要:受限容器里 `ps` 可能被禁、`/proc` 可能没挂载。
/// 靠句柄的 `try_wait()` 才是任何环境都能用的判据。
#[test]
fn liveness_uses_child_handle_not_external_tools() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
+1
View File
@@ -192,6 +192,7 @@ pub fn conclude(
meas_ok: false,
tcb_ok: false,
chip_sig: false,
chip_sig_failed: false,
chip_sig_note: String::from("证明判定未通过,未做芯片验签"),
verdict: format!("证明判定未通过: {e}"),
}
+153 -24
View File
@@ -23,8 +23,21 @@
//! - endpoint 只认 `host:port`(不接受 scheme、不接受路径);
//! - sandbox id 与令牌都必须**非空**且不含空白/控制字符
//! (它们进 HTTP 请求行与请求头,注入即越权);
//! - **上传路径由宿主下发**(见下方「路由形状只有一份」),
//! 必须以 `/` 开头、不含空白/控制字符、不含 `..`;
//! - 响应必须 `200`,非 200 **原样带出**服务端原因(排查时「为什么被拒」关键);
//! - body 上限 1 MiB(证明包是 KB 级;1 MiB 足够且能挡住畸形响应)。
//!
//! # ★ 路由形状只有一份(在宿主控制面侧)
//!
//! 宿主控制面(hostd)的路由表是**宿主侧的事实**。
//! 本模块**不持有**任何路由字面量 —— 路径由宿主经 9p 手牌下发。
//!
//! 两个理由:
//! 1. guest 产物里不该带宿主控制面的路由痕迹(guest 是 enclave 内的极小二进制);
//! 2. ★ 更要命的是**路由漂移**:hostd 改路由而 guest 侧不会跟着改
//! ⇒ guest 静默 POST 到不存在的端点 ⇒ 宿主判定停在 `pending`
//! ⇒ 端点永不公布。症状链极长,极难定位。
use crate::TeeError;
use std::io::{Read, Write};
@@ -46,13 +59,26 @@ const CONNECT_TIMEOUT_SECS: u64 = 10;
/// 没有上限的话,对端不读响应就会让 guest 一直挂着。
const READ_TIMEOUT_SECS: u64 = 30;
/// 证明材料上传端点的路径前缀。
pub const UPLOAD_PATH_PREFIX: &str = "/sandboxes/";
/// 上传端点的路径后缀。
pub const UPLOAD_PATH_SUFFIX: &str = "/attestation";
/// 一次「把证明包回传给宿主」的目标。
/// ★ ★ **上传路径**不归本模块管 —— 那是**宿主控制面**的路由形状。
///
/// # 为什么这里**不能**有路由字面量
///
/// 宿主控制面(hostd)有自己的路由表(`/sandboxes/{id}/attestation` 之类)。
/// 那是**宿主侧的事实**:路由由 hostd 定义,hostd 改了就是改了。
///
/// ★ 本 crate(`mpc-tee`)会被编进 **guest 静态产物**。
/// 如果这里写死路由字面量:
/// 1. guest 产物里就带上了宿主控制面的路由痕迹 ⇒ 破坏 guest 边界
/// (guest 里跑的是 enclave 内的极小二进制,不该携带宿主面的知识);
/// 2. ★ 更要命的是**路由漂移**:hostd 改了路由,guest 侧不会跟着改
/// ⇒ guest 静默地 POST 到一个不存在的端点
/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。
/// 症状链极长(guest 报 404、宿主报 pending、集群面不公布端点),
/// 极难定位到「路由变了」这一层。
///
/// 所以:**路由形状只有一份,在 hostd 侧**。
/// 宿主把它写进 9p 手牌(guest 从 9p 读到),guest 原样使用。
/// hostd 改路由 ⇒ 手牌里的路径跟着改 ⇒ guest 不用动。
#[derive(Debug, Clone)]
pub struct UploadTarget {
/// 宿主控制面地址(`host:port`,不带 scheme 与路径)。
@@ -61,40 +87,80 @@ pub struct UploadTarget {
pub sandbox_id: String,
/// 实例级上传令牌。
pub token: String,
/// 上传端点的**完整路径**(由宿主下发,含前导 `/`)。
pub path: String,
}
impl UploadTarget {
/// 构造并**校验**目标。
///
/// ★ 校验在建这一步,不在发请求那一步 ——
/// 越界的 id/令牌进了请求行就是漏洞,不能等到发出去才发现。
/// 越界的 id/令牌/路径进了请求行就是漏洞,不能等到发出去才发现。
///
/// ★ `path` 由**宿主**给出(9p 手牌),不是本地拼的 ——
/// 见本模块顶部关于「路由漂移」的说明。
pub fn new(
endpoint: impl Into<String>,
sandbox_id: impl Into<String>,
token: impl Into<String>,
path: impl Into<String>,
) -> Result<Self, TeeError> {
let endpoint = endpoint.into();
let sandbox_id = sandbox_id.into();
let token = token.into();
let path = path.into();
validate_endpoint(&endpoint)?;
validate_path_component(&sandbox_id, "sandbox id")?;
validate_path_component(&token, "上传令牌")?;
validate_upload_path(&path)?;
Ok(Self {
endpoint,
sandbox_id,
token,
path,
})
}
/// 上传端点的完整路径。
pub fn path(&self) -> String {
format!(
"{UPLOAD_PATH_PREFIX}{}{UPLOAD_PATH_SUFFIX}",
self.sandbox_id
)
/// 上传端点的完整路径(宿主下发的那个)。
pub fn path(&self) -> &str {
&self.path
}
}
/// 校验宿主下发的上传路径。
///
/// ★ 必须**以 `/` 开头**(它是 HTTP 请求行里的 path 部分)。
/// ★ 不得含空白或控制字符 —— 那会破坏请求行(头注入 / 请求走私)。
/// ★ 不得含 `..`(路径穿越)—— 即便它由宿主下发,也不给它越权的余地。
/// ★ 长度上限 256 —— 请求行不该无限长。
fn validate_upload_path(path: &str) -> Result<(), TeeError> {
if path.is_empty() {
return Err(TeeError::BadInput(String::from("上传路径为空")));
}
if !path.starts_with('/') {
return Err(TeeError::BadInput(format!(
"上传路径必须以 / 开头: {path:?}"
)));
}
if path.len() > 256 {
return Err(TeeError::BadInput(format!(
"上传路径过长({} 字节,上限 256)",
path.len()
)));
}
if path.chars().any(|c| c.is_whitespace() || c.is_control()) {
return Err(TeeError::BadInput(format!(
"上传路径含空白或控制字符(会破坏 HTTP 请求行): {path:?}"
)));
}
if path.split('/').any(|seg| seg == "..") {
return Err(TeeError::BadInput(format!(
"上传路径含路径穿越段: {path:?}"
)));
}
Ok(())
}
/// 校验 endpoint:`host:port`,不含 scheme 与路径。
fn validate_endpoint(endpoint: &str) -> Result<(), TeeError> {
if endpoint.is_empty() {
@@ -245,13 +311,69 @@ fn header_end(buf: &[u8]) -> Option<usize> {
mod tests {
use super::*;
/// ★ 正向:正常目标能构造,路径形状正确。
/// ★ 正向:正常目标能构造,路径**原样**使用宿主下发的那个。
#[test]
fn target_path_is_well_formed() {
let t = UploadTarget::new("10.93.0.1:3010", "sbx-abc", "tok-123").unwrap();
fn target_path_comes_from_the_host() {
let t = UploadTarget::new(
"10.93.0.1:3010",
"sbx-abc",
"tok-123",
"/sandboxes/sbx-abc/attestation",
)
.unwrap();
assert_eq!(t.path(), "/sandboxes/sbx-abc/attestation");
}
/// ★ ★ **本模块不得持有宿主控制面的路由字面量**。
///
/// 理由见模块顶部「路由形状只有一份」:
/// 本 crate 会被编进 **guest 静态产物**,路由字面量会:
/// 1. 破坏 guest 边界(guest 里不该有宿主面的路由知识);
/// 2. ★ 造成**路由漂移** —— hostd 改路由而 guest 不会跟着改
/// ⇒ guest 静默 POST 到不存在的端点
/// ⇒ 宿主判定停在 `pending` ⇒ 端点永不公布。
///
/// ★ 守卫本体在 **`mpc-hostd`**(路由的真正归属方)里:
/// `crates/mpc-hostd/src/api.rs` 的
/// `route_literal_must_not_live_in_mpc_tee` —— 它跨 crate 扫源码。
/// 为什么不在这里做:这里是**被检查方**,自己检查自己等于没有检查。
#[test]
fn route_is_supplied_by_the_host() {
// 本模块只**接收**路径 —— 这里断言「路径确实来自参数」这一语义。
let t = UploadTarget::new(
"10.0.0.1:3010",
"sbx",
"tok",
"/some/route/the/host/decides",
)
.unwrap();
assert_eq!(t.path(), "/some/route/the/host/decides");
}
/// ★ 负向:宿主下发的路径不合法 ⇒ **拒**。
///
/// 路径是宿主给的,但**不给它越权的余地**:
/// 缺前导 `/` ⇒ 请求行非法;含空白 ⇒ 请求走私;
/// 含 `..` ⇒ 路径穿越;过长 ⇒ 请求行无限长。
#[test]
fn bad_upload_path_is_rejected() {
for bad in [
"",
"sandboxes/sbx/attestation", // 缺前导 /
"/sandboxes/sbx\r\nX: 1", // 头注入
"/sandboxes/sbx x/attestation", // 请求走私
"/sandboxes/../etc/attestation", // 路径穿越
"/a", // 短路径本身合法(只测形状)
] {
let r = UploadTarget::new("10.0.0.1:3010", "sbx", "tok", bad);
if bad == "/a" {
assert!(r.is_ok(), "普通路径应当接受");
} else {
assert!(r.is_err(), "不该接受上传路径: {bad:?}");
}
}
}
/// ★ 负向:endpoint 带 scheme / 带路径 / 缺端口 ⇒ **拒**。
///
/// 这条钉的是「endpoint 只认 host:port」——
@@ -266,7 +388,7 @@ mod tests {
"10.0.0.1:3010 extra",
] {
assert!(
UploadTarget::new(bad, "sbx", "tok").is_err(),
UploadTarget::new(bad, "sbx", "tok", "/sandboxes/sbx/attestation").is_err(),
"不该接受 endpoint: {bad:?}"
);
}
@@ -275,17 +397,24 @@ mod tests {
/// ★ 负向:sandbox id / 令牌含空白或控制字符 ⇒ **拒**(头注入 / 请求走私)。
#[test]
fn injection_in_path_components_is_rejected() {
assert!(UploadTarget::new("10.0.0.1:3010", "sbx\r\nX: 1", "tok").is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "sbx x", "tok").is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "tok\nX: 1").is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "", "tok").is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "").is_err());
let p = "/sandboxes/sbx/attestation";
assert!(UploadTarget::new("10.0.0.1:3010", "sbx\r\nX: 1", "tok", p).is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "sbx x", "tok", p).is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "tok\nX: 1", p).is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "", "tok", p).is_err());
assert!(UploadTarget::new("10.0.0.1:3010", "sbx", "", p).is_err());
}
/// ★ 负向:证明包为空 / 过大 ⇒ **拒**(不发无意义的请求)。
#[test]
fn bad_bundle_is_rejected() {
let t = UploadTarget::new("10.0.0.1:3010", "sbx", "tok").unwrap();
let t = UploadTarget::new(
"10.0.0.1:3010",
"sbx",
"tok",
"/sandboxes/sbx/attestation",
)
.unwrap();
assert!(upload_bundle(&t, &[]).is_err());
let big = vec![0u8; MAX_UPLOAD_BYTES + 1];
assert!(upload_bundle(&t, &big).is_err());
File diff suppressed because it is too large. Load diff
+6
View File
@@ -652,6 +652,12 @@ mod tests {
n.device_present = true;
n.qemu_present = true;
n.firmware_present = true;
// ★ `image_present` = 「guest 内核/initrd 已通过宿主预检」(见 `probe.rs`
// 的生产口径:内核+initrd 路径真实存在)。它与 `kernel`/`initrd`
// 路径是**两个独立事实** —— 路径给了但没预检过 ⇒ 同样不准入。
// 漏设它 ⇒ CSV 的四个准入测试全部被「未通过宿主预检」拒掉,
// 而症状看起来像「CSV 平台坏了」。
n.image_present = true;
n.measurement = [9u8; 32];
n.kbc = KbcMode::Offline;
n.qemu_bin = String::from("/usr/bin/qemu-system-x86_64");
+14 -4
View File
@@ -397,6 +397,7 @@ fi
HOSTD_EP=""
SANDBOX_ID=""
UPLOAD_TOKEN=""
UPLOAD_PATH=""
if [ "$HAND_MOUNTED" = "yes" ]; then
echo "hand_mount: ok ($HAND_DIR)"
HOSTD_EP=$($BB cat "$HAND_DIR/hostd_endpoint" 2>/dev/null)
@@ -405,11 +406,17 @@ if [ "$HAND_MOUNTED" = "yes" ]; then
# 这里仍要 trim 一次:多一个字节就会让令牌对不上,
# 症状是「明明有令牌却一直 401」。
UPLOAD_TOKEN=$($BB cat "$HAND_DIR/upload_token" 2>/dev/null | $BB tr -d '\r\n')
if [ -z "$HOSTD_EP" ] || [ -z "$SANDBOX_ID" ] || [ -z "$UPLOAD_TOKEN" ]; then
echo "hand_mount: incomplete (endpoint=${HOSTD_EP:-none} sandbox=${SANDBOX_ID:-none} token=${UPLOAD_TOKEN:+present}${UPLOAD_TOKEN:-none})"
# ★ 上传路径由**宿主**下发(路由归宿主控制面管)。
# guest 侧**不自己拼** —— hostd 改路由时手牌跟着改,guest 不用动。
# 自己拼的话:hostd 改路由而 guest 不会跟着改 ⇒ 静默 POST 到
# 不存在的端点 ⇒ 宿主判定停在 pending ⇒ 端点永不公布。
UPLOAD_PATH=$($BB cat "$HAND_DIR/upload_path" 2>/dev/null | $BB tr -d '\r\n')
if [ -z "$HOSTD_EP" ] || [ -z "$SANDBOX_ID" ] || [ -z "$UPLOAD_TOKEN" ] || [ -z "$UPLOAD_PATH" ]; then
echo "hand_mount: incomplete (endpoint=${HOSTD_EP:-none} sandbox=${SANDBOX_ID:-none} token=${UPLOAD_TOKEN:+present}${UPLOAD_TOKEN:-none} path=${UPLOAD_PATH:+present}${UPLOAD_PATH:-none})"
HOSTD_EP=""
SANDBOX_ID=""
UPLOAD_TOKEN=""
UPLOAD_PATH=""
else
echo "hand_endpoint: $HOSTD_EP sandbox: $SANDBOX_ID"
fi
@@ -423,11 +430,14 @@ fi
# ★ 上传证明材料(只在证明包存在且手牌齐全时做)。
# 证明包可能不存在:离线 KBC 演练根本不去采证明。
if [ -f "$RUN/attestation.bundle" ] && [ -n "$HOSTD_EP" ] && [ -n "$SANDBOX_ID" ] && [ -n "$UPLOAD_TOKEN" ]; then
if [ -f "$RUN/attestation.bundle" ] && [ -n "$HOSTD_EP" ] && [ -n "$SANDBOX_ID" ] && [ -n "$UPLOAD_TOKEN" ] && [ -n "$UPLOAD_PATH" ]; then
echo "attestation_upload: endpoint=$HOSTD_EP sandbox=$SANDBOX_ID"
# ★ 令牌走 --token-file(**不**进 argv)。
# ★ 上传路径走 --upload-path-file(**宿主下发的那个**,guest 不自己拼路由)。
if "$MPC" tee attest-upload --host "$HOSTD_EP" --sandbox "$SANDBOX_ID" \
--token-file "$HAND_DIR/upload_token" --bundle "$RUN/attestation.bundle" \
--token-file "$HAND_DIR/upload_token" \
--upload-path-file "$HAND_DIR/upload_path" \
--bundle "$RUN/attestation.bundle" \
> "$RUN/attest-upload.log" 2>&1; then
echo "attestation_upload: ok"
else
+101 -32
View File
@@ -4,8 +4,9 @@
# # 为什么单独探这一件事
#
# guest → hostd 的证明材料回传靠 **9p(virtfs)**:
# 宿主把三份手牌写进每实例一个目录 → qemu 以 9p 挂进 guest
# → guest 读文件拿到 sandbox_id / upload_token / hostd_endpoint。
# 宿主把**四份**手牌写进每实例一个目录 → qemu 以 9p 挂进 guest
# → guest 读文件拿到 sandbox_id / upload_token / hostd_endpoint / upload_path。
# (upload_path 是 2026-11-09 新增的:路由形状归 hostd 管,由宿主下发。)
#
# ★ 令牌**绝不**走 argv(宿主上明文可见)⇒ 9p 是令牌的**唯一**真通道。
# 所以「guest 内能不能挂 9p」不是锦上添花,而是**整条回传闭环的前置条件**。
@@ -48,6 +49,10 @@ REMOTE_DIR=${MPC_TEE_9P_PROBE_DIR:-/tmp/mpc-9p-probe}
PROBE_SID='sbx-001'
PROBE_TOKEN='deadbeefcafe'
PROBE_ENDPOINT='10.93.0.1:3010'
# ★ 手牌现在是**四份**(2026-11-09):新增 upload_path ——
# 路由形状归 hostd 管,由宿主经 9p 下发给 guest。
# 探针必须测**真实形状**,否则真机跑绿也不能说明生产路径通。
PROBE_UPLOAD_PATH='/sandboxes/sbx-001/attestation'
# ── 纯判据:把手牌三文件读出来,判定是否**逐字节**一致 ───────────────────
#
@@ -65,8 +70,8 @@ PROBE_ENDPOINT='10.93.0.1:3010'
# 所以 guest 侧必须额外打印 `hand_len[<file>]=<字节数>`,
# 字节数与期望长度不符 ⇒ 文件内容被污染 ⇒ 直接判失败。
verify_hand() {
local log=$1 sid=$2 tok=$3 ep=$4 line len got_len
for pair in "sandbox_id:$sid" "upload_token:$tok" "hostd_endpoint:$ep"; do
local log=$1 sid=$2 tok=$3 ep=$4 upath=$5 line len got_len
for pair in "sandbox_id:$sid" "upload_token:$tok" "hostd_endpoint:$ep" "upload_path:$upath"; do
local name=${pair%%:*} want=${pair#*:}
line=$(printf '%s\n' "$log" | grep -F "hand[$name]=" | head -1)
[ -n "$line" ] || { printf '缺手牌文件 %s\n' "$name"; return 1; }
@@ -106,16 +111,24 @@ selftest() {
local ok_n=0 bad_n=0
printf '=== 9p 手牌判据自测(每条都要能被构造样例推翻)===\n'
# ★ 手牌现在是**四份**(2026-11-09 新增 upload_path)。
# 探针必须测**真实形状** —— 测三份的话,生产路径(guest 读 upload_path)
# 根本没被覆盖,真机跑绿也不能说明生产路径通。
local up='/sandboxes/sbx-001/attestation'
# 正常日志(四份手牌齐全,字节数与字符串长度一致 ⇒ 无尾随换行)
local log_ok='hand_mount: ok (/run/mpc-tee/hostd)
hand[sandbox_id]=sbx-001
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-001/attestation
hand_len[sandbox_id]=7
hand_len[upload_token]=12
hand_len[hostd_endpoint]=14'
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30'
# 正向对照
if verify_mount_line "$log_ok" && verify_hand "$log_ok" sbx-001 deadbeefcafe 10.93.0.1:3010; then
if verify_mount_line "$log_ok" && verify_hand "$log_ok" sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"; then
printf 'ok 正向对照:合法手牌通过\n'; ok_n=$((ok_n + 1))
else
printf 'FAIL 正向对照竟然失败\n'; bad_n=$((bad_n + 1))
@@ -130,51 +143,82 @@ hand_len[hostd_endpoint]=14'
}
# 负向① 挂载失败(guest 明确说 failed)
check_bad '负向① 9p 挂载失败' '9p_hand_mount_failed' sbx-001 deadbeefcafe 10.93.0.1:3010
check_bad '负向① 9p 挂载失败' '9p_hand_mount_failed' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向② 令牌文件带了尾随换行 —— ★ 字符串**完全相同**,
# 只有字节数能区分 ⇒ 这条判据必须靠 hand_len 才拦得住。
check_bad '负向② 令牌带尾随换行(字节数不符)' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-001/attestation
hand_len[sandbox_id]=7
hand_len[upload_token]=13
hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向③ 缺 upload_token 这一份手牌
check_bad '负向③ 缺令牌文件' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-001/attestation
hand_len[sandbox_id]=7
hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向④ 端点被换(手牌串到别的实例)
check_bad '负向④ 端点被换' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.9:3010
hand[upload_path]=/sandboxes/sbx-001/attestation
hand_len[sandbox_id]=7
hand_len[upload_token]=12
hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向⑤ 实例 id 不符
check_bad '负向⑤ 实例 id 不符' 'hand_mount: ok
hand[sandbox_id]=sbx-999
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-001/attestation
hand_len[sandbox_id]=7
hand_len[upload_token]=12
hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向⑥ 令牌被换成别的值
check_bad '负向⑥ 令牌被换' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[upload_token]=000000000000
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-001/attestation
hand_len[sandbox_id]=7
hand_len[upload_token]=12
hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向⑦ guest 没打印字节数证据 ⇒ 判据**必须**判失败(不许"看起来对就放过")
check_bad '负向⑦ 缺字节数证据' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.1:3010' sbx-001 deadbeefcafe 10.93.0.1:3010
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-001/attestation' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向⑧ ★ upload_path 被换(路由漂移的形态):
# guest 拿到的路径与宿主实际路由不一致 ⇒ 上传到不存在的端点
# ⇒ 宿主判定停在 pending ⇒ 端点不公布。症状链长,必须靠字节级判据拦。
check_bad '负向⑧ upload_path 被换(路由漂移)' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.1:3010
hand[upload_path]=/sandboxes/sbx-999/attestation
hand_len[sandbox_id]=7
hand_len[upload_token]=12
hand_len[hostd_endpoint]=14
hand_len[upload_path]=30' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
# 负向⑨ upload_path 缺了(宿主没下发)⇒ 必须判失败
check_bad '负向⑨ 缺 upload_path 手牌' 'hand_mount: ok
hand[sandbox_id]=sbx-001
hand[upload_token]=deadbeefcafe
hand[hostd_endpoint]=10.93.0.1:3010
hand_len[sandbox_id]=7
hand_len[upload_token]=12
hand_len[hostd_endpoint]=14' sbx-001 deadbeefcafe 10.93.0.1:3010 "$up"
printf -- '---\n9p 手牌判据自测:%s 通过 / %s 失败\n' "$ok_n" "$bad_n"
[ "$bad_n" -eq 0 ]
@@ -213,11 +257,13 @@ if [ "$HAND_MOUNTED" = "yes" ]; then
echo "hand[sandbox_id]=$($BB cat "$HAND_DIR/sandbox_id" 2>/dev/null)"
echo "hand[upload_token]=$($BB cat "$HAND_DIR/upload_token" 2>/dev/null)"
echo "hand[hostd_endpoint]=$($BB cat "$HAND_DIR/hostd_endpoint" 2>/dev/null)"
echo "hand[upload_path]=$($BB cat "$HAND_DIR/upload_path" 2>/dev/null)"
# ★ 字节数证据:字符串相等**证明不了**没有尾随换行(命令替换会吃掉它)。
# 期望长度 = 字符串长度(无尾随换行)⇒ 不等即内容被污染。
echo "hand_len[sandbox_id]=$($BB wc -c < "$HAND_DIR/sandbox_id" 2>/dev/null | tr -d ' ')"
echo "hand_len[upload_token]=$($BB wc -c < "$HAND_DIR/upload_token" 2>/dev/null | tr -d ' ')"
echo "hand_len[hostd_endpoint]=$($BB wc -c < "$HAND_DIR/hostd_endpoint" 2>/dev/null | tr -d ' ')"
echo "hand_len[upload_path]=$($BB wc -c < "$HAND_DIR/upload_path" 2>/dev/null | tr -d ' ')"
else
echo "9p_hand_mount_failed"
$BB cat /proc/mounts 2>/dev/null
@@ -235,10 +281,11 @@ set -u
D=${REMOTE_DIR}
rm -rf "\$D"
mkdir -p "\$D/hand" "\$D/root/bin" "\$D/root/proc" "\$D/root/sys" "\$D/root/dev"
# 手牌三文件(★ 无尾随换行 —— 与 hostd 侧 write_into 一致)
# 手牌四文件(★ 无尾随换行 —— 与 hostd 侧 write_into 一致)
printf '%s' '${PROBE_SID}' > "\$D/hand/sandbox_id"
printf '%s' '${PROBE_TOKEN}' > "\$D/hand/upload_token"
printf '%s' '${PROBE_ENDPOINT}' > "\$D/hand/hostd_endpoint"
printf '%s' '${PROBE_UPLOAD_PATH}' > "\$D/hand/upload_path"
chmod 700 "\$D/hand"
chmod 600 "\$D/hand"/*
# guest init
@@ -272,14 +319,27 @@ test -s "\$D/initrd.img" || { echo "INITRD_MISS"; exit 3; }
# qemu 直接报 "9pfs device couldn't find fsdev with the id = mpchostd9p" 并退出。
# 显式 `-fsdev local,id=mpchostd9p,path=...` 才能把 id 钉死。
rm -f "\$D/serial.log"
nohup ${qemu} -machine q35 -enable-kvm -m 512 -nographic -nodefaults -no-reboot \\
-kernel ${kernel} -initrd "\$D/initrd.img" \\
-append "console=ttyS0 earlyprintk=serial" \\
-fsdev local,id=mpchostd9p,path=\$D/hand,security_model=none \\
-device virtio-9p-pci,fsdev=mpchostd9p,mount_tag=mpchostd \\
-chardev file,id=mpcser,path=\$D/serial.log -serial chardev:mpcser \\
> "\$D/qemu.log" 2>&1 &
# ★ ★ qemu 参数必须写成**一行**(2026-11-09 真机实测):
# 用 \ 续行时,`base64 -d | sh` 这条管道会把续行的反斜杠吃掉
# ⇒ shell 把 `-fsdev` / `-device` 当成**命令名**
# ⇒ 报 "-virtfs: command not found" / "-fsdev: command not found"
# ⇒ guest 根本没起来(串口日志空)。
# 症状极隐蔽:qemu.log 里什么都没写,因为那些行压根没进 shell。
nohup ${qemu} -machine q35 -enable-kvm -m 512 -nographic -nodefaults -no-reboot -kernel ${kernel} -initrd "\$D/initrd.img" -append "console=ttyS0 earlyprintk=serial" -fsdev local,id=mpchostd9p,path=\$D/hand,security_model=none -device virtio-9p-pci,fsdev=mpchostd9p,mount_tag=mpchostd -chardev file,id=mpcser,path=\$D/serial.log -serial chardev:mpcser > "\$D/qemu.log" 2>&1 &
echo "QEMU_PID=\$!"
# ★ 等 guest 打完标记再返回 —— **远端**轮询,别在本地轮询。
# 本地每轮 fetch_serial 都要走一遍 xop(Touch ID)⇒ 90 轮 = 十几分钟。
# 远端轮询只花一次 SSH 往返。
# ★ 顺带把串口内容**一次性**取回(本地不再二次拉取)。
i=0
while [ "\$i" -lt 60 ]; do
if grep -q 'PROBE_DONE' "\$D/serial.log" 2>/dev/null; then break; fi
i=\$((i + 1))
sleep 1
done
echo "--- SERIAL_BEGIN ---"
cat "\$D/serial.log" 2>/dev/null || true
echo "--- SERIAL_END ---"
REMOTE_EOF
}
@@ -302,7 +362,21 @@ run_side() {
local label=$1 host=$2 uk=$3 pk=$4 kernel=$5 qemu=$6
local tmp init_b64 remote_script
tmp=$(mktemp -d /tmp/mpc-9p-probe.XXXXXX)
init_b64=$(write_probe_init "$tmp/init.sh" | base64 | tr -d '\n')
# ★★ init_b64 必须是**文件内容**的 base64,不是函数 stdout 的 base64。
# `write_probe_init` 把内容**写进文件**(stdout 是空的)
# ⇒ 直接 `write_probe_init ... | base64` 得到**空串**
# ⇒ 远端 `printf '%s' '' | base64 -d > init` ⇒ **/init 是 0 字节**
# ⇒ 内核报 "Failed to execute /init (error -8)"(ENOEXEC)
# ⇒ guest 根本进不到 9p 那一段 ⇒ 探针永远测不到 9p。
# 症状极具误导性:内核起来了、串口有日志,看着像「9p 不通」,
# 实际是 initramfs 里没有 init。
write_probe_init "$tmp/init.sh"
init_b64=$(base64 < "$tmp/init.sh" | tr -d '\n')
if [ -z "$init_b64" ]; then
printf 'FAIL %s:探针 init 内容为空(本地生成失败)\n' "$label" >&2
rm -rf "$tmp"
return 1
fi
write_remote_script "$tmp/remote.sh" "$init_b64" "$kernel" "$qemu"
printf '=== %s (%s) ===\n' "$label" "$host"
@@ -313,25 +387,20 @@ run_side() {
printf 'FAIL %s:远端探针没起来:%s\n' "$label" "$out" >&2
return 1
fi
# 等 guest 打完标记(串口文件增长)
local i log
for i in $(seq 1 90); do
log=$(fetch_serial "$host" "$uk" "$pk")
if printf '%s\n' "$log" | grep -q 'PROBE_DONE'; then break; fi
sleep 1
done
log=$(fetch_serial "$host" "$uk" "$pk")
# 串口内容由**远端**等好了再一次性返回(见 write_remote_script)。
local log
log=$(printf '%s\n' "$out" | sed -n '/--- SERIAL_BEGIN ---/,/--- SERIAL_END ---/p')
if [ -z "$log" ]; then
printf 'FAIL %s:串口日志为空(guest 没起来?)\n' "$label" >&2
return 1
fi
printf '%s\n' "$log" | grep -E 'hand_mount|hand\[|9p_hand|PROBE_DONE' || true
printf '%s\n' "$log" | grep -E 'hand_mount|hand\[|hand_len\[|9p_hand|PROBE_DONE' || true
if ! verify_mount_line "$log"; then
printf 'FAIL %s:9p 没挂上(guest 侧 busybox 挂不了 9p)\n' "$label" >&2
return 1
fi
if ! verify_hand "$log" "$PROBE_SID" "$PROBE_TOKEN" "$PROBE_ENDPOINT"; then
if ! verify_hand "$log" "$PROBE_SID" "$PROBE_TOKEN" "$PROBE_ENDPOINT" "$PROBE_UPLOAD_PATH"; then
printf 'FAIL %s:手牌内容不一致\n' "$label" >&2
return 1
fi
+93
View File
@@ -48,6 +48,33 @@ musl 目标下现在有**两份**不同的产物,不是两份同一个二进
「这些串确实会进二进制」(正向对照),再据此在 guest 产物上跑否定判据。
host 产物里找不到 ⇒ 探针失效 ⇒ 直接 FAIL,绝不「安静地跳过」。
# ★★★ 产物层否定判据的**盲区**(2026-11-09 实测,实名教训)
#
# 「guest 产物里不该有 /sandboxes」这条判据,**只在泄漏点真的在调用链上时**
# 才抓得到。实测三种破坏形态:
#
# 形态 A:字面量放进一个**未被调用**的 `pub fn` ⇒ LTO 整个裁掉
# ⇒ guest 产物里连 `sandboxes` 都没有 ⇒ **产物层判据照样绿(假绿)**
# 形态 B:字面量放进一个**未被调用**的 `pub const` ⇒ 同上 ⇒ **假绿**
# 形态 C:字面量**真的用在请求行拼接上**(真实回归形态)
# ⇒ 产物里出现 1 次 ⇒ 产物层判据**抓到了**(38/39)
#
# ★ 而「死代码里抄着路由」恰恰是**最可能**的回归形态:
# 有人留了个常量备用、注释里抄了一段示例、临时调试代码忘了删。
#
# 所以除了产物层判据,本脚本还有一道**源码层**判据
# (`find_route_literals_in_mpc_tee`):
# 它扫 `crates/mpc-tee/src` 的**非测试代码**,不管有没有被调用,一律拦。
# 这道判据在 deps 子命令里,**不需要** musl target、不需要产物。
#
# ★ 两道防线**故意冗余**:
# · 产物层:抓「真的漏进二进制了」
# · 源码层:抓「抄了一份路由在 guest 侧」(哪怕是死代码)
# 另外 `mpc-hostd` 里还有一条 Rust 单测
# (`route_literal_must_not_live_in_mpc_tee`)——
# 那是**第三道**,在 cargo test 里。门禁不能只依赖「某条 cargo test 存在」,
# 所以脚本里这一道必须独立存在。
判据唯一真相源就在这份脚本里;CI 与本地跑的是同一份。
"""
@@ -201,6 +228,46 @@ def all_rust_sources(subs: tuple[str, ...] | None = None) -> str:
return "\n".join(parts)
def find_route_literals_in_mpc_tee() -> list[str]:
"""扫 `crates/mpc-tee/src`,找宿主控制面的路由字面量。
★ 只扫**非测试代码**:`#[cfg(test)]` 之后的夹具不进二进制,
而它们本来就要构造各种形状的路径来验证校验逻辑。
★ 只看**代码行**(跳过 `//` 注释与文档注释)——
注释里的路由只是说明,不构成「持有路由」。
返回违规行清单(空 = 干净)。
"""
offenders: list[str] = []
for p in sorted((ROOT / "crates/mpc-tee/src").rglob("*.rs")):
lines = p.read_text(encoding="utf-8", errors="replace").splitlines()
# `#[cfg(test)]` 之后是测试代码
test_start = next(
(i for i, l in enumerate(lines) if l.strip() == "#[cfg(test)]"),
len(lines),
)
in_block_comment = False
for i, line in enumerate(lines[:test_start]):
l = line.strip()
if in_block_comment:
if "*/" in l:
in_block_comment = False
continue
if l.startswith("/*"):
if "*/" not in l:
in_block_comment = True
continue
if l.startswith("//"):
continue
# 路由前缀只在这两种形态下算「持有」:
# · 字符串字面量 "/sandboxes...
# · 常量赋值里的 "sandboxes"
if '"/sandboxes' in l or '= "sandboxes"' in l:
rel = p.relative_to(ROOT)
offenders.append(f"{rel}:{i + 1}: {l}")
return offenders
def cmd_deps(c: Checks, target: str) -> None:
print(f"== deps:依赖树边界(target={target})==")
@@ -285,6 +352,32 @@ def cmd_deps(c: Checks, target: str) -> None:
"归属变了,探针会退化成空判据",
)
# ★ ★ **源码层守卫**:宿主控制面的路由字面量不得留在 `mpc-tee`。
#
# 路由形状**只有一份**,在 `crates/mpc-hostd/src/api.rs`
# (`ROUTE_SANDBOXES` / `ROUTE_ATTESTATION` / `attestation_upload_path`)。
# guest 从 9p 手牌里**拿**宿主下发的完整路径。
#
# 为什么要在**产物层判据之外**再加这一层:
# 产物层判据(`/sandboxes` 不得出现在 guest 二进制)只在
# 「泄漏点真的在调用链上」时才抓得到。
# ★ 实测(2026-11-09):把字面量塞进一个**未被调用**的函数
# ⇒ LTO 整个裁掉 ⇒ guest 产物里连 `sandboxes` 都没有
# ⇒ 产物层判据**照样绿**(假绿)。
# 而「未被调用的死代码里抄着路由」恰恰是最可能的回归形态
# (有人留了个常量备用)。
# 所以必须有一道**源码层**判据:它不管有没有被调用,一律拦。
#
# ★ 与 `mpc-hostd` 里的 Rust 单测 `route_literal_must_not_live_in_mpc_tee`
# 是**两道独立的防线**(一条在 cargo test 里、一条在 CI 脚本里)——
# 故意冗余:门禁不能只依赖「某条 cargo test 存在」。
route_offenders = find_route_literals_in_mpc_tee()
c.check(
"★ 宿主控制面的路由字面量不得留在 mpc-tee(路由归宿主管,路径由宿主下发)",
not route_offenders,
"\n".join(route_offenders),
)
def cmd_guard(c: Checks, target: str) -> None:
print(f"== guard:musl 默认 feature 必须被编译期守卫明确拒绝(target={target})==")
+27
View File
@@ -292,6 +292,27 @@ def selftest_evidence_upload():
if not token:
return
# ★ 上传路径**由宿主下发**(手牌里的 upload_path)。
# 这正是 guest 走 9p 拿到的那一份 —— 自测用同一个文件,
# 保证测的路径与真机上 guest 用的路径**是同一个来源**。
path_file = os.path.join(hand_root, sb, "upload_path")
upload_path = ""
if os.path.exists(path_file):
with open(path_file, "r", encoding="utf-8") as f:
upload_path = f.read().strip()
check(
"上传自测:hostd 在手牌里下发了上传路径(路由归宿主管)",
bool(upload_path),
f"没找到 {path_file}",
)
check(
"上传自测:下发的上传路径形状正确",
upload_path == f"/sandboxes/{sb}/attestation",
f"got {upload_path!r}",
)
if not upload_path:
return
up = subprocess.run(
[
BIN,
@@ -303,6 +324,8 @@ def selftest_evidence_upload():
sb,
"--token-file",
tok_path,
"--upload-path-file",
path_file,
"--bundle",
bundle_path,
],
@@ -366,6 +389,8 @@ def selftest_evidence_upload():
sb,
"--token-file",
bad_token_path,
"--upload-path-file",
path_file,
"--bundle",
bundle_path,
],
@@ -439,6 +464,8 @@ def selftest_evidence_upload():
sb,
"--token-file",
tok_path,
"--upload-path-file",
path_file,
"--bundle",
other_bundle,
],