Files
ssw-mpc/crates/mpc-hostd/src/lib.rs
T
admin 32419efc27 feat(cluster): 真机端点公布门禁跑通(真 KBS 验签后才公布会话端点)
- 新增 cluster-endpoint-gate-e2e.sh:AMD SNP + 海光 CSV 双节点自报、非回环监听 + 共享密钥、真 KBS 芯片验签后的端点公布;正向公布 / 负向零外泄(带原因)/ 收尾端点收回,真机 20 判据全绿
- mpc-tee / mpc-hostd:补齐控制面期望态绑定、宿主独立判定与 9p 手牌回传;LaunchOverride 支持真机双网卡与额外内核参数
- 修 runtime.rs 额外内核参数校验:CLI 把多个参数空格 join,服务端不得对整串判「含空白即拒」;改掉把错误行为钉死的测试并补跨端守卫
- kbs-net.sh 按端口清旧实例 + 硬判端口释放,杜绝旧参数 KBS 假就绪(端口 LISTEN 不等于本轮实例在跑)
2026-11-09 20:12:32 +08:00

373 lines
17 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 宿主控制面 `mpc-hostd` —— 两层控制面的**宿主层**。
//!
//! # 两层控制面里它站在哪
//!
//! ```text
//! 站点端(联盟级) 宿主机(机器级)
//! ┌────────────────────┐ ┌──────────────────────┐
//! │ session_admit() │ 短期 token │ mpc-hostd │
//! │ 成员资格 / 策略 │ ──────────▶ │ e2b 兼容 API │
//! │ 有效期 / deadline │ │ TeeRuntime │
//! └────────────────────┘ │ /attestation │
//! └──────────────────────┘
//! ```
//!
//! 站点端管「**这一轮能不能开始**」(联盟成员、策略、订单),
//! 宿主机管「**这台机器够不够格**」(设备、度量、TCB、芯片签名)。
//!
//! **两段不能合并** —— 站点端拿不到芯片报告,宿主机不知道联盟成员表。
//! 合并只能靠「一端信任另一端传过来的结论」,那这一段就成了新的信任根,
//! 而它恰恰是最容易被攻破的一层。
//!
//! # 为什么 e2b 兼容接口在这里
//!
//! cbox 已经验证过这条路可行(`boxe2b` 把 E2B 请求翻成 `boxlite serve` 的 REST)。
//! ssw-mpc 照搬的是这个**结构**:`sandboxID` → 实例的映射表、单二进制、
//! 控制面/数据面两个端口。**不搬的是 e2b 的语义**:
//! template 从「镜像」升级成「度量集合」,证明走独立端点。
pub mod api;
pub mod auth;
pub mod client;
/// 集群控制面(CubeMaster 等价物)的 HTTP 层:收自报 / 查注册表 / 查已证明会话。
pub mod control_plane_api;
/// 集群控制面的 HTTP 服务器(与单机 e2b 兼容面分开:暴露面与生命周期都不同)。
pub mod control_plane_server;
pub mod json;
/// guest 手牌(sandbox_id / 上传令牌 / 宿主地址)的下发:9p 挂载 + 内核参数。
pub mod guest_hand;
/// EasyTier 进程化:argv 构造、凭据签发、链路观测与进程生命周期。
pub mod link;
pub mod protocol;
pub mod runtime;
/// `TeeHostDispatch` 的实装:调度/对账层经宿主控制面 HTTP API 下发 LaunchSpec。
pub mod host_dispatch;
/// hostd 侧自报的**控制面接收端** + 推送客户端(Cubelet → CubeMaster 的注册等价物)。
pub mod registry_api;
pub mod server;
use crate::registry_api::ControlPlaneReporter;
use crate::runtime::VerifierConfig;
use mpc_tee::probe::{HostCapConfig, NodeReporter};
pub use client::HostClient;
pub use runtime::{Instance, InstanceState, LaunchOverride, RuntimeError, SpawnSpec, TeeRuntime};
pub use runtime::VerifierConfig as ChipVerifierConfig;
use std::sync::Arc;
/// 宿主控制面的配置。
#[derive(Debug, Clone)]
pub struct HostConfig {
/// 控制面监听地址。
pub listen: String,
/// reaper 扫描间隔(秒)。
pub reap_interval_secs: u64,
/// 状态落盘路径(`None` = 不落盘)。
pub state_file: Option<String>,
/// 站点端与宿主端共享的密钥材料。
///
/// ★ `None` = **回环信任模式**:不带凭据的请求放行。
/// 但绑非回环地址时**必须**配置它(见 `mpc hostd` 子命令的检查),
/// 否则等于把「能起 guest、读远程证明」的控制面暴露到网上。
pub shared_secret: Option<Vec<u8>>,
/// 本宿主的 TEE 能力配置(Cubelet 自描述源);`None` = hostd 不对外自报 TEE 能力。
pub node_capability: Option<HostCapConfig>,
/// 控制面地址(`host:port`):配了它且配了能力,hostd 会周期把自报推过去。
pub control_plane: Option<String>,
/// 自报推送间隔(秒)。
pub report_interval_secs: u64,
/// ★ 芯片验签器配置(外部程序);`None` = **不做**芯片验签。
///
/// ★ 不配它 ⇒ 宿主侧独立判定给出 `chip_sig=false`,
/// 且 note 写明「未提供验签器」—— 这是「**没验**」,
/// 与「验了没过」是两回事(后者是硬拒绝)。
///
/// 不配的后果:集群面按 `require_chip_sig=true` 门控时,
/// 端点**不会**被公布(证据成立但按策略不可公布)。
pub chip_verifier: Option<VerifierConfig>,
/// ★ **guest 可达的**宿主控制面地址(`host:port`)。
///
/// guest 在自己的网络里,宿主监听 `0.0.0.0` 对 guest 无效 ——
/// guest 需要一个**具体可路由**的地址(如 tap 网段里的宿主地址)。
///
/// ★ 不配 ⇒ 不下发 guest 手牌 ⇒ guest 传不回证明材料 ⇒
/// 判定停在 `pending` ⇒ 端点不公布(**诚实**的失败,不是缺陷)。
pub guest_endpoint: Option<String>,
/// ★ 宿主本地的**启动参数覆盖**(真机网卡 / 额外内核参数)。
///
/// ★ 为什么是**宿主本地**的事实而不是请求体字段:
/// 网卡后端决定 guest 能连到谁(`socket` 的对端地址、`tap` 的名字)。
/// 放请求体里 ⇒ 站点端可以让本机的 guest 去连**任意**对端
/// ⇒ SSRF / 流量劫持面。与 `guest_endpoint` 同理。
pub launch_override: Option<LaunchOverride>,
}
impl Default for HostConfig {
fn default() -> Self {
Self {
listen: String::from("127.0.0.1:3010"),
reap_interval_secs: 5,
state_file: None,
shared_secret: None,
node_capability: None,
control_plane: None,
report_interval_secs: 15,
chip_verifier: None,
guest_endpoint: None,
launch_override: None,
}
}
}
/// 启动宿主控制面。
///
/// 阻塞直到进程被终止。tokio runtime 由本函数**自己**建 —— 调用方
/// (`mpc hostd` 子命令)不必为了起服务而依赖 tokio,也不会出现
/// 「同步 CLI 里混一套 async IO」的两套模型。
pub fn serve(cfg: HostConfig) -> Result<(), String> {
// ★ 鉴权器在**起服务之前**构造:共享密钥不合法就让服务起不来,
// 而不是「起来了但不验」。
let auth = match &cfg.shared_secret {
Some(secret) => crate::auth::Authenticator::from_secret(secret)?,
None => crate::auth::Authenticator::unconfigured(),
};
let mut base = match &cfg.state_file {
Some(p) => TeeRuntime::with_state_file(p.clone()),
None => TeeRuntime::new(),
};
// 恢复失败**不**让服务起不来 —— 但要如实报出来。
// 静默忽略会让人以为"重启后实例还在"。
if cfg.state_file.is_some() {
match base.restore() {
Ok(n) => eprintln!("hostd: 从状态文件恢复 {n} 个实例"),
Err(e) => eprintln!("hostd: 恢复状态文件失败(当空表继续): {e}"),
}
}
// ★ Cubelet 自描述:绑定本宿主 TEE 能力(若配置)。
if let Some(cap) = &cfg.node_capability {
base = base.with_capability(cap.clone());
}
// ★ 芯片验签器:配了才有 `chip_sig=true`。
// 不配 ⇒ `chip_sig=false` 且 note 写明「未提供验签器」——
// 那是「没验」,不等于「验了没过」。
if let Some(v) = &cfg.chip_verifier {
base = base.with_chip_verifier(v.clone());
}
// ★ guest 可达地址:guest 要靠它把证明材料回传回来。
// 不配 ⇒ 不下发手牌 ⇒ 判定停在 pending ⇒ 端点不公布。
if let Some(e) = &cfg.guest_endpoint {
base = base.with_guest_endpoint(e.clone());
}
// ★ 启动参数覆盖(真机网卡 / 额外内核参数)。
// 这是**这台宿主的事实** —— 框架的 `-netdev user` 在海光真机上
// 直接起不来(没编 slirp),真机还要**两张卡**(socket 跨 guest +
// tap 进宿主网段访问 KBS)。框架的规格是平台中立的,
// 不知道这些 ⇒ 必须由宿主自己覆盖。
if let Some(ov) = &cfg.launch_override {
base = base.with_launch_override(ov.clone());
}
let rt = Arc::new(base);
rt.start_reaper(std::time::Duration::from_secs(cfg.reap_interval_secs.max(1)));
// ★ Cubelet 自报推送:配了控制面 + 能力就周期把自报推过去
// (与 reaper 同款守护线程;失败下个周期重试,不致命)。
if let Some(cp) = &cfg.control_plane {
if cfg.node_capability.is_some() {
// ★★ 自报**必须带凭据**:控制面在「凭据模式」下对每个请求
// 校验 Bearer token,缺 token 一律 401。
// ★ 2026-11-09 真机联调时踩到:这里**没带 token** ⇒
// 控制面日志里全是 401,节点在 hostd 里明明活着、
// `/nodes` 却永远是空的 ⇒ 「以为在自报,其实全被拒」。
// 这是**假就绪信号**,比不配控制面更坏。
// ★ token 口径走 `auth::secret_token`(密钥原文)——
// 与控制面 `Authenticator` 算摘要的那份**逐字节一致**。
let reporter =
ControlPlaneReporter::new(cp.clone()).map_err(|e| format!("控制面端点非法: {e}"))?;
let reporter = match cfg.shared_secret.as_deref() {
Some(secret) => match crate::auth::secret_token(secret) {
Some(tok) => reporter.with_token(tok),
None => {
return Err(
"共享密钥含非 ASCII 或换行,无法作为请求头 token —— \
请换一份纯 ASCII 且无换行的密钥"
.to_string(),
)
}
},
None => reporter,
};
let rt_rep = Arc::clone(&rt);
let interval = std::time::Duration::from_secs(cfg.report_interval_secs.max(1));
std::thread::Builder::new()
.name("mpc-tee-reporter".to_string())
.spawn(move || loop {
std::thread::sleep(interval);
if let Some(report) = rt_rep.self_report() {
if let Err(e) = reporter.report(&report) {
eprintln!("hostd: 自报推送失败(下个周期重试): {e}");
}
}
})
.map_err(|e| format!("起 reporter 线程失败: {e}"))?;
}
}
let runtime = tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()
.map_err(|e| format!("起 tokio runtime 失败: {e}"))?;
runtime.block_on(async move {
let listener = tokio::net::TcpListener::bind(&cfg.listen)
.await
.map_err(|e| format!("监听 {} 失败: {e}", cfg.listen))?;
eprintln!(
"hostd: 监听 {}(鉴权:{})",
cfg.listen,
if auth.is_configured() {
"凭据模式"
} else {
"回环信任模式"
}
);
axum::serve(listener, server::router_with_auth(rt, auth))
.await
.map_err(|e| format!("hostd 服务退出: {e}"))
})
}
#[cfg(test)]
mod tests {
use super::*;
/// 一份典型的 AMD SNP 宿主能力配置(测试用)。
fn cap_config() -> mpc_tee::probe::HostCapConfig {
mpc_tee::probe::HostCapConfig {
site: String::from("alice"),
host: String::from("192.168.1.7"),
kind: mpc_tee::PlatformKind::SevSnp,
tcb: 5,
qemu_bin: String::from("/opt/kata/bin/qemu-system-x86_64"),
firmware: String::from("/opt/kata/share/ovmf/AMDSEV.fd"),
kernel: String::from("/opt/kata/share/kata-containers/vmlinuz"),
initrd: String::from("/tmp/initrd.img"),
measurement: [7u8; 32],
kbs_endpoint: None,
kbc: mpc_tee::platform::KbcMode::Offline,
capacity: 2,
}
}
#[test]
fn default_config_is_loopback_only() {
// ★ 默认必须只听回环。绑 0.0.0.0 会把没有认证的控制面暴露到网上。
let c = HostConfig::default();
assert!(c.listen.starts_with("127.0.0.1:"), "got {}", c.listen);
}
/// ★★ 自报必须带得上凭据 —— 端到端守门人。
///
/// ★ 2026-11-09 真机联调时踩到:`serve()` 里构造 reporter 时
/// **没带 token** ⇒ 控制面(凭据模式)对每次自报都回 401 ⇒
/// 节点在 hostd 里明明活着,`/nodes` 却永远是空的。
/// 现象是「以为在自报,其实全被拒」—— 假就绪信号。
///
/// ★ 这条测试起一个**要求 Bearer** 的假控制面,
/// 验证 `secret_token` 产出的 token 能被它放行。
#[test]
fn self_report_carries_the_shared_secret_as_token() {
use std::io::{Read, Write};
use std::net::TcpListener;
let secret = b"0123456789abcdef0123456789abcdef";
let expected = crate::auth::secret_token(secret).expect("ASCII 密钥应可用");
// 假控制面:要求 `Authorization: Bearer <expected>`,否则 401。
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let expected_in_thread = expected.clone();
let handle = std::thread::spawn(move || {
let (mut sock, _) = listener.accept().unwrap();
let mut buf = [0u8; 4096];
let n = sock.read(&mut buf).unwrap();
let req = String::from_utf8_lossy(&buf[..n]).to_string();
// ★ header 名大小写不敏感 —— reqwest/hyper 会把 `Authorization`
// 写成 `authorization`。断言必须与协议一致,不能只匹配一种大小写。
let ok = req
.to_ascii_lowercase()
.contains(&format!("authorization: bearer {}", expected_in_thread.to_ascii_lowercase()));
if ok {
let _ = sock.write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n");
} else {
let _ = sock.write_all(
b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n",
);
}
(ok, req)
});
// 用真实的 reporter 走一遍 —— 与 `serve()` 里同一份构造逻辑。
let reporter = crate::registry_api::ControlPlaneReporter::new(format!("127.0.0.1:{port}"))
.unwrap()
.with_token(expected.clone());
let report = mpc_tee::probe::NodeReport {
node: mpc_tee::probe::probe_host_node(&cap_config()),
capacity: 2,
};
let res = reporter.report(&report);
let (ok, req) = handle.join().unwrap();
assert!(ok, "自报请求必须带上正确的 Bearer token,实际请求:\n{req}");
assert!(res.is_ok(), "带对 token 的自报必须成功:{res:?}");
}
/// ★ 负向:自报**不带** token 时,控制面必须拒(401)——
/// 证明上面那条不是「反正都能过」。
#[test]
fn self_report_without_token_is_rejected_by_credentialed_control_plane() {
use std::io::{Read, Write};
use std::net::TcpListener;
let secret = b"0123456789abcdef0123456789abcdef";
let expected = crate::auth::secret_token(secret).expect("ASCII 密钥应可用");
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let expected_in_thread = expected.clone();
let handle = std::thread::spawn(move || {
let (mut sock, _) = listener.accept().unwrap();
let mut buf = [0u8; 4096];
let n = sock.read(&mut buf).unwrap();
let req = String::from_utf8_lossy(&buf[..n]).to_string();
// ★ header 名大小写不敏感 —— reqwest/hyper 会把 `Authorization`
// 写成 `authorization`。断言必须与协议一致,不能只匹配一种大小写。
let ok = req
.to_ascii_lowercase()
.contains(&format!("authorization: bearer {}", expected_in_thread.to_ascii_lowercase()));
if ok {
let _ = sock.write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n");
} else {
let _ = sock
.write_all(b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n");
}
(ok, req)
});
// 刻意**不带** token。
let reporter =
crate::registry_api::ControlPlaneReporter::new(format!("127.0.0.1:{port}")).unwrap();
let report = mpc_tee::probe::NodeReport {
node: mpc_tee::probe::probe_host_node(&cap_config()),
capacity: 2,
};
let res = reporter.report(&report);
let (ok, req) = handle.join().unwrap();
assert!(!ok, "不带 token 的自报不该被放行,实际请求:\n{req}");
assert!(res.is_err(), "不带 token 的自报必须失败");
}
}