diff --git a/crates/mpc-cli/src/main.rs b/crates/mpc-cli/src/main.rs index 19360c0..a5c7477 100644 --- a/crates/mpc-cli/src/main.rs +++ b/crates/mpc-cli/src/main.rs @@ -665,8 +665,10 @@ fn cmd_tee(args: &[String]) -> Result<(), String> { match args.first().map(String::as_str).unwrap_or("") { "paths" => cmd_tee_paths(), "plan" => cmd_tee_plan(&args[1..]), + "verify" => cmd_tee_verify(&args[1..]), + "kbs-get" => cmd_tee_kbs_get(&args[1..]), _ => Err(String::from( - "用法: mpc tee paths | mpc tee plan --node FILE --session-id HEX --pubkey HEX", + "用法: mpc tee paths | plan --node FILE | verify --report FILE --platform snp|csv|tdx|optee | kbs-get --endpoint HOST:PORT --repo R --kind K", )), } } @@ -783,6 +785,127 @@ fn cmd_tee_plan(args: &[String]) -> Result<(), String> { Ok(()) } +fn cmd_tee_verify(args: &[String]) -> Result<(), String> { + let report_path = parse_flag(args, "--report").ok_or("缺少 --report(证明报告原始字节文件)")?; + let report = std::fs::read(report_path).map_err(|e| format!("读报告 {report_path} 失败: {e}"))?; + let platform = match parse_flag(args, "--platform").ok_or("缺少 --platform")? { + "snp" | "sev-snp" => mpc_tee::PlatformKind::SevSnp, + "csv" | "hygon" | "hygon-csv" => mpc_tee::PlatformKind::HygonCsv, + "tdx" => mpc_tee::PlatformKind::Tdx, + "optee" => mpc_tee::PlatformKind::Optee, + other => return Err(format!("--platform {other:?} 只认 snp/csv/tdx/optee")), + }; + let user_data = mpc_tee::platform::parse_hex::<64>( + parse_flag(args, "--user-data").ok_or("缺少 --user-data(64 字节 / 128 位十六进制)")?, + ) + .ok_or("user-data 不是 128 位十六进制")?; + let cert_chain: Vec> = match parse_flag(args, "--certs") { + Some(p) => vec![std::fs::read(p).map_err(|e| format!("读证书 {p} 失败: {e}"))?], + None => Vec::new(), + }; + let att = mpc_tee::Attestation { + platform, + user_data, + report, + cert_chain, + }; + + let session_id = cli_parse_hex32(parse_flag(args, "--session-id").ok_or("缺少 --session-id")?)?; + let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string(); + let pubkey = cli_parse_hex32(parse_flag(args, "--pubkey").ok_or("缺少 --pubkey")?)?; + let measurement = + cli_parse_hex32(parse_flag(args, "--measurement").ok_or("缺少 --measurement(节点度量)")?)?; + let binding = mpc_tee::session::SessionBinding::new(session_id, &site, pubkey, measurement); + + let tcb: u32 = match parse_flag(args, "--tcb") { + Some(v) => v.parse().map_err(|_| format!("--tcb {v:?} 不是整数"))?, + None => 0, + }; + let min_tcb: u32 = match parse_flag(args, "--min-tcb") { + Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?, + None => 0, + }; + let pin = match parse_flag(args, "--pin") { + Some(v) => Some(cli_parse_hex32(v)?), + None => None, + }; + let verifier: Option = match parse_flag(args, "--verifier") { + Some(prog) => { + let mut v = mpc_tee::verify::ExternalVerifier::new(prog); + let mut i = 0; + while i < args.len() { + if args[i].as_str() == "--verifier-arg" && i + 1 < args.len() { + v = v.arg(args[i + 1].clone()); + i += 2; + } else { + i += 1; + } + } + Some(v) + } + None => None, + }; + + let result = mpc_tee::verify::verify_attestation( + &att, + &binding, + platform, + tcb, + min_tcb, + pin.as_ref(), + verifier.as_ref().map(|x| x as &dyn mpc_tee::verify::ChipVerifier), + ) + .map_err(|e| e.to_string())?; + + let chip = match &result.chip { + mpc_tee::verify::ChipVerdict::NotVerified => String::from("未验证"), + mpc_tee::verify::ChipVerdict::VerifiedBy(n) => format!("已验证({n})"), + mpc_tee::verify::ChipVerdict::Failed(_) => String::from("失败"), + }; + let rows: Vec<(&str, report::Cell)> = vec![ + ("structure_ok", report::Cell::txt(result.structure_ok.to_string())), + ("bound_ok", report::Cell::txt(result.bound_ok.to_string())), + ("chip", report::Cell::txt(chip)), + ("verdict", report::Cell::txt(result.verdict.clone())), + ]; + report::kv("证明校验结论", &rows); + Ok(()) +} + +fn cmd_tee_kbs_get(args: &[String]) -> Result<(), String> { + let endpoint = parse_flag(args, "--endpoint").ok_or("缺少 --endpoint(host:port,不带 scheme)")?; + let repo = parse_flag(args, "--repo").ok_or("缺少 --repo")?.to_string(); + let kind = parse_flag(args, "--kind").ok_or("缺少 --kind")?.to_string(); + let token = parse_flag(args, "--token").map(|s| s.to_string()); + + let resource = match parse_flag(args, "--session-id") { + Some(sid) => { + let sid = cli_parse_hex32(sid)?; + mpc_tee::kbs::ResourcePath::for_session(&repo, &kind, &sid).map_err(|e| e.to_string())? + } + None => { + let tag = parse_flag(args, "--tag").ok_or("缺少 --tag 或 --session-id")?.to_string(); + mpc_tee::kbs::ResourcePath::new(repo, kind, tag).map_err(|e| e.to_string())? + } + }; + + let mut client = mpc_tee::kbs::KbsClient::new(endpoint).map_err(|e| e.to_string())?; + if let Some(t) = token { + client = client.with_token(t); + } + let bytes = client.get(&resource).map_err(|e| e.to_string())?; + match parse_flag(args, "--out") { + Some(p) => { + std::fs::write(p, &bytes).map_err(|e| format!("写 {p} 失败: {e}"))?; + println!("已写入 {p}({} 字节)", bytes.len()); + } + None => { + println!("{} 字节: {}", bytes.len(), cli_hex_bytes(&bytes)); + } + } + Ok(()) +} + fn cli_parse_hex32(s: &str) -> Result<[u8; 32], String> { mpc_tee::platform::parse_hex::<32>(s) .ok_or_else(|| format!("{s:?} 不是 64 位十六进制")) diff --git a/crates/mpc-core/src/catalog.rs b/crates/mpc-core/src/catalog.rs index 9a3044d..a67367d 100644 --- a/crates/mpc-core/src/catalog.rs +++ b/crates/mpc-core/src/catalog.rs @@ -131,6 +131,8 @@ use mpc_tee::platform::{builtin_profiles, PlatformProfile, CsvVariant, KbcMode, use mpc_tee::session::{SessionBinding, verify_bound_attestation}; use mpc_tee::schedule::{TeeRequirement, TeeNode, LaunchSpec, admit}; #[cfg(feature = "std")] use mpc_tee::guest::{GuestTee, FileAttestationSource, HexFileKeySource}; +#[cfg(feature = "std")] use mpc_tee::verify::{verify_attestation, ExternalVerifier, ChipVerifier, ChipVerdict}; +#[cfg(feature = "std")] use mpc_tee::kbs::{KbsClient, ResourcePath, KbsKeySource}; let profiles = builtin_profiles(); // -> [PlatformProfile; 5] let node = TeeNode::parse(src)?; // 行式 key=value 节点描述 -> Result let req = TeeRequirement::new(PlatformKind::SevSnp, min_tcb); // 默认要求证明、要求 pin 镜像 @@ -138,7 +140,11 @@ let binding = SessionBinding::new(session_id, "alice", session_pubkey, node.meas let ud = binding.user_data(PlatformKind::SevSnp, node.platform.tcb); // -> [u8; 64] let spec = admit(&req, &node, &binding)?; // -> Result,fail-closed,无降级 let argv = spec.qemu_argv(); // -> Vec,交给 Command::args,不经过 shell -verify_bound_attestation(&att, &binding, PlatformKind::SevSnp, tcb, min_tcb, None)?; // 6 参 +verify_bound_attestation(&att, &binding, PlatformKind::SevSnp, tcb, min_tcb, None)?; // 6 参;只查结构 + 绑定,不做芯片验签 +let result = verify_attestation(&att, &binding, PlatformKind::SevSnp, tcb, min_tcb, None, None)?; // 7 参;ChipVerdict::NotVerified 表示芯片签名未验,不许伪装成通过 +let client = KbsClient::new("kbs.host:8080")?; // endpoint 只认 host:port,拒绝 scheme/路径 +let rp = ResourcePath::for_session("mpc", "psk", &session_id)?; // tag = 会话标识十六进制 +let _ = client.get(&rp)?; // fail-closed:非 200 / chunked / 长度不符一律拒绝 # GuestTee 实现 Tee trait;FileAttestationSource / HexFileKeySource 只在 std 下存在。 # verify_bound_attestation 只查报告结构与会话绑定,**不做芯片验签**(验证方 / KBS 的职责)。 # 禁止写 runtimeClass / Pod / 容器注解:框架层直接启动 guest,不经过任何编排层。 @@ -264,6 +270,8 @@ mod tests { "mpc_tee::session::{SessionBinding, verify_bound_attestation}", "mpc_tee::schedule::{TeeRequirement, TeeNode, LaunchSpec, admit}", "mpc_tee::guest::{GuestTee, FileAttestationSource, HexFileKeySource}", + "mpc_tee::verify::{verify_attestation, ExternalVerifier, ChipVerifier, ChipVerdict}", + "mpc_tee::kbs::{KbsClient, ResourcePath, KbsKeySource}", "mpc_policy::{AuditLog, Guard, Handle, Label}", "mpc_core::hash::{sha256, derive, derive2}", "mpc_core::prg::Stream", @@ -358,6 +366,9 @@ mod tests { "admit(&req, &node, &binding)?", "spec.qemu_argv()", "verify_bound_attestation(&att, &binding, PlatformKind::SevSnp, tcb, min_tcb, None)?", + "verify_attestation(&att, &binding, PlatformKind::SevSnp, tcb, min_tcb, None, None)?", + "KbsClient::new(\"kbs.host:8080\")?", + "ResourcePath::for_session(\"mpc\", \"psk\", &session_id)?", "let profiles = builtin_profiles();", ] { assert!(CATALOG.contains(key), "清单缺少真实 TEE 调度签名:{key}"); @@ -366,6 +377,10 @@ mod tests { CATALOG.contains("不做芯片验签"), "必须写明框架不验芯片签名,否则模型会误以为 Ok == 证明通过" ); + assert!( + CATALOG.contains("芯片签名未验"), + "必须写明 ChipVerdict::NotVerified 表示芯片签名未验,否则模型会误以为 Ok == 证明通过" + ); } /// 方向钉子:框架层不许回到容器编排路线。 diff --git a/crates/mpc-tee/src/kbs.rs b/crates/mpc-tee/src/kbs.rs new file mode 100644 index 0000000..9e32fba --- /dev/null +++ b/crates/mpc-tee/src/kbs.rs @@ -0,0 +1,417 @@ +//! KBS 资源获取的最小客户端(guest 内 `mpc tee kbs-get` 用)。 +//! +//! # 定位 +//! +//! 把「PSK / seed / 根密钥内置在 initrd 里」换成「按本轮会话从 KBS 取」。 +//! 资源路径固定为 `/kbs/v0/resource///`,`tag` 是会话标识的 +//! 十六进制,服务端据此决定下发哪一份物料。 +//! +//! **这不是证明代理,也不做芯片验签**:token 只是把证明代理的产物原样带给 +//! 服务端,报告、证书链、TCB 是否可信必须由 KBS 自己验证。本模块不替代 +//! Trustee/KBS 的证明校验,也不解析任何芯片报告。生产环境的明文 HTTP 应换成 +//! 带证明校验的 KBS(或在其前面做 TLS 终止),框架不假装这层已经安全。 +//! +//! # fail-closed +//! +//! 路径三段只允许 `[A-Za-z0-9._-]`、endpoint 只认 `host:port`、响应必须有 +//! 准确的 `Content-Length`(拒绝 chunked)、body 上限 64 KiB、非 200 一律报错。 +//! 任何一项不满足都不返回物料,没有「先给个默认值」的分支。 + +use crate::guest::KeySource; +use crate::TeeError; +use std::io::{Read, Write}; +use std::net::TcpStream; +use std::string::{String, ToString}; +use std::time::Duration; +use std::vec::Vec; + +/// KBS 资源路径前缀。 +pub const KBS_RESOURCE_PREFIX: &str = "/kbs/v0/resource"; +/// 单个资源 body 的上限(密钥类物料远小于此)。 +pub const MAX_RESOURCE_BYTES: usize = 64 * 1024; + +fn valid_component(s: &str) -> bool { + !s.is_empty() + && s != "." + && s != ".." + && !s.contains("..") + && s.bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'.' || b == b'_' || b == b'-') +} + +/// 字节转小写十六进制。 +pub fn hex_encode(bytes: &[u8]) -> String { + let mut s = String::with_capacity(bytes.len() * 2); + for b in bytes { + s.push_str(&format!("{b:02x}")); + } + s +} + +/// 解析定长十六进制( trimming 由调用方负责)。 +pub fn parse_hex_bytes(s: &str, n: usize) -> Option> { + let b = s.as_bytes(); + if b.len() != n * 2 { + return None; + } + let mut out = Vec::with_capacity(n); + for i in 0..n { + let hi = (b[2 * i] as char).to_digit(16)?; + let lo = (b[2 * i + 1] as char).to_digit(16)?; + out.push(((hi << 4) | lo) as u8); + } + Some(out) +} + +/// 一个 KBS 资源的三段式路径。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResourcePath { + /// 资源仓库(如 `mpc`)。 + pub repo: String, + /// 资源种类(如 `psk` / `seed` / `root-key`)。 + pub kind: String, + /// 资源标签,通常是会话标识。 + pub tag: String, +} + +impl ResourcePath { + /// 构造并校验三段都合法。 + pub fn new( + repo: impl Into, + kind: impl Into, + tag: impl Into, + ) -> Result { + let (repo, kind, tag) = (repo.into(), kind.into(), tag.into()); + for (name, v) in [("repo", &repo), ("kind", &kind), ("tag", &tag)] { + if !valid_component(v) { + return Err(TeeError::BadInput(format!( + "KBS 资源 {name} 含非法字符: {v:?}" + ))); + } + } + Ok(Self { repo, kind, tag }) + } + + /// 用会话标识的十六进制作 tag。 + pub fn for_session( + repo: &str, + kind: &str, + session_id: &[u8; 32], + ) -> Result { + Self::new(repo, kind, hex_encode(session_id)) + } + + /// 完整的 HTTP 请求路径。 + pub fn path(&self) -> String { + format!( + "{}/{}/{}/{}", + KBS_RESOURCE_PREFIX, self.repo, self.kind, self.tag + ) + } +} + +fn validate_endpoint(ep: &str) -> Result<(), TeeError> { + if ep.is_empty() + || ep.contains("://") + || ep.contains('/') + || ep.chars().any(|c| c.is_whitespace()) + { + return Err(TeeError::BadInput(format!( + "KBS endpoint 只能是 host:port: {ep:?}" + ))); + } + let (host, port) = ep + .rsplit_once(':') + .ok_or_else(|| TeeError::BadInput(String::from("KBS endpoint 缺少端口")))?; + if host.is_empty() + || host + .chars() + .any(|c| !c.is_ascii_alphanumeric() && c != '.' && c != '-') + { + return Err(TeeError::BadInput(format!( + "KBS endpoint 主机名不合法: {host:?}" + ))); + } + let p: u32 = port + .parse() + .map_err(|_| TeeError::BadInput(format!("KBS 端口不合法: {port:?}")))?; + if p == 0 || p > 65535 { + return Err(TeeError::BadInput(format!("KBS 端口越界: {p}"))); + } + Ok(()) +} + +fn header_end(buf: &[u8]) -> Option { + buf.windows(4).position(|w| w == b"\r\n\r\n") +} + +/// 最小 KBS 客户端(HTTP/1.1 GET over TcpStream,无第三方依赖)。 +#[derive(Debug, Clone)] +pub struct KbsClient { + /// `host:port`,不带 scheme 与路径。 + pub endpoint: String, + /// 证明代理产物的占位传递;服务端必须自己验证明。 + pub token: Option, +} + +impl KbsClient { + /// 新建客户端。 + pub fn new(endpoint: impl Into) -> Result { + let endpoint = endpoint.into(); + validate_endpoint(&endpoint)?; + Ok(Self { + endpoint, + token: None, + }) + } + + /// 带上证明代理产出的 token。 + pub fn with_token(mut self, token: impl Into) -> Self { + self.token = Some(token.into()); + self + } + + /// 取回一个资源的原始字节。 + pub fn get(&self, resource: &ResourcePath) -> Result, TeeError> { + let token = self.token.as_deref().unwrap_or(""); + if token.contains('\r') || token.contains('\n') { + return Err(TeeError::BadInput(String::from( + "KBS token 含换行,拒绝拼接进请求头", + ))); + } + let mut req = format!( + "GET {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\nMPC-Tee-Session: {}\r\n", + resource.path(), + self.endpoint, + resource.tag + ); + if !token.is_empty() { + req.push_str(&format!("MPC-Tee-Attestation: {token}\r\n")); + } + req.push_str("\r\n"); + + let mut stream = TcpStream::connect(self.endpoint.as_str()) + .map_err(|e| TeeError::Io(format!("连 KBS 失败: {e}")))?; + let timeout = Some(Duration::from_secs(5)); + stream + .set_read_timeout(timeout) + .map_err(|e| TeeError::Io(e.to_string()))?; + stream + .set_write_timeout(timeout) + .map_err(|e| TeeError::Io(e.to_string()))?; + stream + .write_all(req.as_bytes()) + .map_err(|e| TeeError::Io(format!("写 KBS 请求失败: {e}")))?; + let mut resp = Vec::new(); + stream + .read_to_end(&mut resp) + .map_err(|e| TeeError::Io(format!("读 KBS 响应失败: {e}")))?; + + let pos = header_end(&resp).ok_or_else(|| { + TeeError::Io(String::from("KBS 响应缺少完整头部")) + })?; + let head = String::from_utf8_lossy(&resp[..pos]).to_string(); + let body = resp[pos + 4..].to_vec(); + let mut lines = head.split("\r\n"); + let status = lines.next().unwrap_or(""); + if !status.starts_with("HTTP/1.1 200") && !status.starts_with("HTTP/1.0 200") { + return Err(TeeError::Io(format!("KBS 返回非 200: {status}"))); + } + let mut content_length: Option = None; + for line in lines { + if let Some((k, v)) = line.split_once(':') { + let v = v.trim(); + if k.eq_ignore_ascii_case("transfer-encoding") + && v.to_ascii_lowercase().contains("chunked") + { + return Err(TeeError::Io(String::from( + "KBS 响应使用 chunked,客户端不解析,拒绝放行", + ))); + } + if k.eq_ignore_ascii_case("content-length") { + content_length = Some(v.parse().map_err(|_| { + TeeError::Io(String::from("KBS Content-Length 不是整数")) + })?); + } + } + } + let len = content_length.ok_or_else(|| { + TeeError::Io(String::from("KBS 响应缺少 Content-Length,拒绝放行")) + })?; + if len > MAX_RESOURCE_BYTES { + return Err(TeeError::Io(format!( + "KBS 资源超过 {MAX_RESOURCE_BYTES} 字节上限" + ))); + } + if len != body.len() { + return Err(TeeError::Io(format!( + "KBS Content-Length={len} 与实际 body={} 不符", + body.len() + ))); + } + Ok(body) + } +} + +/// 用 KBS 资源作为 `GuestTee` 的根密钥来源。 +#[derive(Debug, Clone)] +pub struct KbsKeySource { + client: KbsClient, + resource: ResourcePath, +} + +impl KbsKeySource { + /// 绑定客户端与资源路径。 + pub fn new(client: KbsClient, resource: ResourcePath) -> Self { + Self { client, resource } + } +} + +impl KeySource for KbsKeySource { + fn root_key(&self) -> Result<[u8; 32], TeeError> { + let body = self.client.get(&self.resource)?; + let text = std::str::from_utf8(&body) + .map_err(|_| TeeError::Io(String::from("KBS 根密钥不是 UTF-8 文本")))?; + let parsed = parse_hex_bytes(text.trim(), 32).ok_or_else(|| { + TeeError::Io(String::from("KBS 根密钥不是 64 位十六进制")) + })?; + let mut key = [0u8; 32]; + key.copy_from_slice(&parsed); + Ok(key) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::net::TcpListener; + use std::thread; + + fn response(status: &str, extra: &str, body: &[u8]) -> Vec { + let mut v = format!( + "HTTP/1.1 {status}\r\nContent-Length: {}\r\n{extra}\r\n", + body.len() + ) + .into_bytes(); + v.extend_from_slice(body); + v + } + + fn serve(resp: Vec) -> (u16, thread::JoinHandle<()>) { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let port = listener.local_addr().unwrap().port(); + let handle = thread::spawn(move || { + let (mut s, _) = listener.accept().unwrap(); + let mut buf = [0u8; 4096]; + let _ = s.read(&mut buf); + let _ = s.write_all(&resp); + }); + (port, handle) + } + + fn client(port: u16) -> KbsClient { + KbsClient::new(format!("127.0.0.1:{port}")).unwrap() + } + + fn resource() -> ResourcePath { + ResourcePath::new("mpc", "psk", "ab".repeat(32)).unwrap() + } + + #[test] + fn resource_path_rejects_traversal_and_odd_input() { + for (r, k, t) in [ + ("../etc", "psk", "tag"), + ("mpc", "psk/seed", "tag"), + ("mpc", "psk", ".."), + ("mpc", "psk", ""), + ("mp c", "psk", "tag"), + ("mpc", "psk", "a/b"), + ] { + assert!(ResourcePath::new(r, k, t).is_err(), "{r}/{k}/{t} 不该通过"); + } + assert_eq!( + ResourcePath::new("mpc", "psk", "tag").unwrap().path(), + "/kbs/v0/resource/mpc/psk/tag" + ); + } + + #[test] + fn for_session_is_deterministic() { + let sid = [7u8; 32]; + let a = ResourcePath::for_session("mpc", "root-key", &sid).unwrap(); + let b = ResourcePath::for_session("mpc", "root-key", &sid).unwrap(); + assert_eq!(a, b); + assert_eq!(a.tag, "07".repeat(32)); + } + + #[test] + fn endpoint_only_accepts_host_port() { + for ep in [ + "http://127.0.0.1:8080", + "127.0.0.1", + "127.0.0.1:0", + "127.0.0.1:70000", + "127.0.0.1:abc", + "127.0.0.1:8080/path", + "127.0.0.1 :8080", + ] { + assert!(KbsClient::new(ep).is_err(), "{ep} 不该通过"); + } + assert!(KbsClient::new("127.0.0.1:8080").is_ok()); + } + + #[test] + fn get_success_and_token_header() { + let key = "11".repeat(32); + let (port, h) = serve(response("200 OK", "", key.as_bytes())); + let c = client(port).with_token("demo-token"); + assert_eq!(c.get(&resource()).unwrap(), key.as_bytes().to_vec()); + h.join().unwrap(); + } + + #[test] + fn non_200_and_bad_length_fail_closed() { + for (status, extra, body) in [ + ("403 Forbidden", "", &b"denied"[..]), + ("404 Not Found", "", &b"missing"[..]), + ("200 OK", "Transfer-Encoding: chunked\r\n", &b"aa"[..]), + ] { + let (port, h) = serve(response(status, extra, body)); + assert!(client(port).get(&resource()).is_err(), "{status} 不该放行"); + h.join().unwrap(); + } + let (port, h) = serve(format!( + "HTTP/1.1 200 OK\r\nContent-Length: 99\r\n\r\nshort" + ).into_bytes()); + assert!(client(port).get(&resource()).is_err(), "长度不符必须拒绝"); + h.join().unwrap(); + + let big = vec![b'x'; MAX_RESOURCE_BYTES + 1]; + let (port, h) = serve(response("200 OK", "", &big)); + assert!(client(port).get(&resource()).is_err(), "超长 body 必须拒绝"); + h.join().unwrap(); + } + + #[test] + fn key_source_parses_hex_and_rejects_garbage() { + let good = "ab".repeat(32); + let (port, h) = serve(response("200 OK", "", good.as_bytes())); + let src = KbsKeySource::new(client(port), resource()); + assert_eq!(src.root_key().unwrap(), [0xabu8; 32]); + h.join().unwrap(); + + let (port, h) = serve(response("200 OK", "", b"not-hex")); + let src = KbsKeySource::new(client(port), resource()); + assert!(src.root_key().is_err()); + h.join().unwrap(); + } + + #[test] + fn hex_roundtrip() { + let bytes = [0x00u8, 0x0f, 0xab, 0xff]; + assert_eq!(hex_encode(&bytes), "000fabff"); + assert_eq!(parse_hex_bytes("000fabff", 4).unwrap(), bytes.to_vec()); + assert!(parse_hex_bytes("00f", 2).is_none()); + assert!(parse_hex_bytes("zz", 1).is_none()); + } +} diff --git a/crates/mpc-tee/src/lib.rs b/crates/mpc-tee/src/lib.rs index 81c786c..04ad6be 100644 --- a/crates/mpc-tee/src/lib.rs +++ b/crates/mpc-tee/src/lib.rs @@ -207,9 +207,15 @@ pub mod optee; // 三者都是 no_std(只用 alloc),因为 TA 侧也要能算同一份绑定值。 #[cfg(feature = "std")] pub mod guest; +/// KBS 资源下发的最小客户端(guest 内按会话取密钥)。 +#[cfg(feature = "std")] +pub mod kbs; pub mod platform; pub mod schedule; pub mod session; +/// 证明报告结构校验与芯片验签委托(框架不自验签)。 +#[cfg(feature = "std")] +pub mod verify; // pub mod snp; // P6 // pub mod tdx; // P6 diff --git a/crates/mpc-tee/src/verify.rs b/crates/mpc-tee/src/verify.rs new file mode 100644 index 0000000..ae813b3 --- /dev/null +++ b/crates/mpc-tee/src/verify.rs @@ -0,0 +1,421 @@ +//! 证明报告的结构校验与芯片验签委托。 +//! +//! # 这个模块不做什么(必须说清楚) +//! +//! **框架不实现 ECDSA / 证书链验签**。SNP 的 VCEK ← ASK ← ARK 链、CSV 报告签名、 +//! TCB 语义、measurement 该不该信,全部由验证方或外部验签器负责。这里只做两件 +//! 前置门槛:报告结构是否成立、报告是否与本轮会话绑定 +//! (复用 [`crate::session::verify_bound_attestation`])。 +//! +//! 因此 `verify_attestation` 返回 `Ok` 有两种截然不同的含义,结论里必须区分: +//! - `ChipVerdict::NotVerified`:结构与绑定通过,**芯片签名未验证**; +//! - `ChipVerdict::VerifiedBy(..)`:外部验签器判定通过。 +//! +//! 只跑结构校验就宣称「远程证明通过」是虚假安全感,本模块不允许这种表述。 +//! +//! # 两种 measurement 不要混 +//! +//! - `SessionBinding.code_measurement`:框架侧的代码度量(本版是 OCI manifest +//! digest),参与 `user_data` 计算; +//! - SNP report 偏移 `0x90` 的 48 字节 launch measurement:固件对初始 guest 页 +//! 的度量,语义由芯片规范定义。 +//! +//! 两者不是一回事,**不能用其中一个去校验另一个相等**。这里对后者只做「非全零」 +//! 的存在性检查,前者通过 `measurement` 参数与绑定值做定长 pin 比较。 + +use crate::session::{verify_bound_attestation, SessionBinding}; +use crate::{Attestation, PlatformKind, TeeError}; +use std::process::{Command, Stdio}; +use std::string::String; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::vec::Vec; + +/// AMD SEV-SNP attestation report 的固定长度。 +pub const SNP_REPORT_LEN: usize = 1184; +/// `report_data` 偏移(64 字节)。 +pub const SNP_REPORT_DATA_OFFSET: usize = 0x50; +/// launch measurement 偏移(48 字节)。 +pub const SNP_MEASUREMENT_OFFSET: usize = 0x90; +/// 报告尾部签名字段长度。 +pub const SNP_SIGNATURE_LEN: usize = 512; + +static TEMP_SEQ: AtomicUsize = AtomicUsize::new(0); + +fn u32_le(b: &[u8]) -> u32 { + (b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24) +} + +fn u64_le(b: &[u8]) -> u64 { + (u32_le(&b[..4]) as u64) | ((u32_le(&b[4..8]) as u64) << 32) +} + +fn ct_eq_bytes(a: &[u8], b: &[u8]) -> bool { + if a.len() != b.len() { + return false; + } + let mut diff = 0u8; + for (x, y) in a.iter().zip(b.iter()) { + diff |= x ^ y; + } + diff == 0 +} + +/// 芯片签名/证书链的判定结果。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ChipVerdict { + /// 没有验签器,芯片签名**未验证**。 + NotVerified, + /// 外部验签器判定通过,字符串是验签器名字。 + VerifiedBy(String), + /// 外部验签器判定失败,字符串是原因。 + Failed(String), +} + +/// SNP 报告中本框架确定要用的字段。 +/// +/// 其余字段(TCB、chip_id、reported_tcb 等)交由验证方按芯片规范解析, +/// 这里不臆造偏移。 +#[derive(Debug, Clone)] +pub struct SnpReportView { + /// 报告版本。 + pub version: u32, + /// guest policy。 + pub policy: u64, + /// 64 字节调用方数据,必须等于绑定的 `user_data`。 + pub report_data: [u8; 64], + /// 48 字节 launch measurement(只做存在性检查)。 + pub measurement: [u8; 48], + /// 尾部签名字节(只做存在性检查,不验签)。 + pub signature: Vec, +} + +/// 解析 SNP 报告的确定字段。长度/version/签名字段任一不成立即拒绝。 +pub fn parse_snp_report(report: &[u8]) -> Result { + if report.len() != SNP_REPORT_LEN { + return Err(TeeError::AttestFailed(format!( + "SNP 报告长度应为 {SNP_REPORT_LEN},得到 {}", + report.len() + ))); + } + let version = u32_le(&report[0..4]); + if version == 0 { + return Err(TeeError::AttestFailed(String::from("SNP 报告 version 为 0"))); + } + let mut report_data = [0u8; 64]; + report_data.copy_from_slice( + &report[SNP_REPORT_DATA_OFFSET..SNP_REPORT_DATA_OFFSET + 64], + ); + let mut measurement = [0u8; 48]; + measurement + .copy_from_slice(&report[SNP_MEASUREMENT_OFFSET..SNP_MEASUREMENT_OFFSET + 48]); + if measurement.iter().all(|b| *b == 0) { + return Err(TeeError::AttestFailed(String::from( + "SNP launch measurement 全零,报告不完整", + ))); + } + let signature = report[report.len() - SNP_SIGNATURE_LEN..].to_vec(); + if signature.iter().all(|b| *b == 0) { + return Err(TeeError::AttestFailed(String::from( + "SNP 签名字段全零,报告不完整", + ))); + } + Ok(SnpReportView { + version, + policy: u64_le(&report[0x08..0x10]), + report_data, + measurement, + signature, + }) +} + +/// 可插拔的芯片验签器。框架不自带实现。 +pub trait ChipVerifier { + /// 验证报告原文与证书链,返回判定。 + fn verify(&self, report: &[u8], chain: &[Vec]) -> Result; +} + +/// 把验签委托给外部程序(**绝不用 sh -c**,防命令注入)。 +/// +/// 契约:报告与证书写到临时文件,路径经 `MPC_TEE_REPORT_FILE` / +/// `MPC_TEE_CERT_` 环境变量传入;退出码非 0 视为失败;stdout trim 后为 +/// `OK` 或以 `verified=true` 开头视为通过。 +#[derive(Debug, Clone)] +pub struct ExternalVerifier { + /// 外部验签器程序(绝对路径更稳妥)。 + pub program: String, + /// 附加参数。 + pub args: Vec, +} + +impl ExternalVerifier { + /// 新建验签器。 + pub fn new(program: impl Into) -> Self { + Self { + program: program.into(), + args: Vec::new(), + } + } + + /// 追加一个参数。 + pub fn arg(mut self, arg: impl Into) -> Self { + self.args.push(arg.into()); + self + } +} + +impl ChipVerifier for ExternalVerifier { + fn verify(&self, report: &[u8], chain: &[Vec]) -> Result { + let seq = TEMP_SEQ.fetch_add(1, Ordering::Relaxed); + let tag = format!("mpc-tee-{}-{seq}", std::process::id()); + let dir = std::env::temp_dir(); + let report_path = dir.join(format!("{tag}-report.bin")); + let mut paths = Vec::new(); + std::fs::write(&report_path, report) + .map_err(|e| TeeError::Io(format!("写证明报告临时文件失败: {e}")))?; + paths.push(report_path.clone()); + for (i, cert) in chain.iter().enumerate() { + let p = dir.join(format!("{tag}-cert-{i}.der")); + std::fs::write(&p, cert) + .map_err(|e| TeeError::Io(format!("写证书临时文件失败: {e}")))?; + paths.push(p); + } + + let mut cmd = Command::new(&self.program); + cmd.args(&self.args) + .env("MPC_TEE_REPORT_FILE", &report_path) + .stdout(Stdio::piped()) + .stderr(Stdio::null()); + for (i, p) in paths.iter().enumerate().skip(1) { + cmd.env(format!("MPC_TEE_CERT_{}", i - 1), p); + } + let out = cmd + .output() + .map_err(|e| TeeError::Io(format!("启动外部验签器失败: {e}")))?; + for p in &paths { + let _ = std::fs::remove_file(p); + } + if !out.status.success() { + return Ok(ChipVerdict::Failed(format!( + "外部验签器退出码 {:?}", + out.status.code() + ))); + } + let text = String::from_utf8_lossy(&out.stdout).trim().to_ascii_lowercase(); + if text == "ok" || text.starts_with("verified=true") { + Ok(ChipVerdict::VerifiedBy(self.program.clone())) + } else { + Ok(ChipVerdict::Failed(format!( + "外部验签器输出不是通过判定: {text}" + ))) + } + } +} + +/// 一次证明校验的结构化结论。 +#[derive(Debug, Clone)] +pub struct VerificationResult { + /// 报告结构检查通过。 + pub structure_ok: bool, + /// 会话绑定检查通过。 + pub bound_ok: bool, + /// 芯片签名判定。 + pub chip: ChipVerdict, + /// 一行中文结论,必须如实区分「未验签」与「已验签」。 + pub verdict: String, +} + +/// 校验一份远程证明:结构 + 会话绑定 +(可选)外部芯片验签。 +/// +/// `measurement` 是调用方给出的代码度量 pin,只与 `binding.code_measurement` +/// 做定长比较;**不**与 SNP launch measurement 比对(两者语义不同)。 +#[allow(clippy::too_many_arguments)] +pub fn verify_attestation( + att: &Attestation, + binding: &SessionBinding, + platform: PlatformKind, + tcb: u32, + min_tcb: u32, + measurement: Option<&[u8; 32]>, + verifier: Option<&dyn ChipVerifier>, +) -> Result { + verify_bound_attestation(att, binding, platform, tcb, min_tcb, measurement)?; + if let Some(pin) = measurement { + if !ct_eq_bytes(pin, &binding.code_measurement) { + return Err(TeeError::AttestFailed(String::from( + "调用方给的 measurement pin 与会话绑定值不一致", + ))); + } + } + + match platform { + PlatformKind::SevSnp => { + let view = parse_snp_report(&att.report)?; + if !ct_eq_bytes(&view.report_data, &att.user_data) { + return Err(TeeError::AttestFailed(String::from( + "SNP report_data 与会话绑定的 user_data 不一致", + ))); + } + } + PlatformKind::HygonCsv | PlatformKind::Tdx | PlatformKind::Optee => { + if att.report.len() < 64 { + return Err(TeeError::AttestFailed(String::from( + "报告原文过短,平台布局未解析", + ))); + } + } + PlatformKind::None => { + return Err(TeeError::AttestFailed(String::from( + "无 TEE 平台不能出证明", + ))); + } + } + + let chip = match verifier { + None => ChipVerdict::NotVerified, + Some(v) => { + let verdict = v.verify(&att.report, &att.cert_chain)?; + if let ChipVerdict::Failed(ref why) = verdict { + return Err(TeeError::AttestFailed(format!("外部验签器拒绝: {why}"))); + } + verdict + } + }; + let suffix = if platform == PlatformKind::SevSnp { + "" + } else { + "(该平台报告布局未解析,只做了通用结构检查)" + }; + let verdict = match &chip { + ChipVerdict::NotVerified => format!( + "结构与会话绑定通过,芯片签名未验证(需外部验签器 / KBS){suffix}" + ), + ChipVerdict::VerifiedBy(name) => format!( + "结构与会话绑定通过,外部验签器 {name} 判定芯片签名通过{suffix}" + ), + ChipVerdict::Failed(why) => { + return Err(TeeError::AttestFailed(format!("外部验签器拒绝: {why}"))) + } + }; + Ok(VerificationResult { + structure_ok: true, + bound_ok: true, + chip, + verdict, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use alloc::vec; + + struct FakeVerifier(ChipVerdict); + + impl ChipVerifier for FakeVerifier { + fn verify(&self, _: &[u8], _: &[Vec]) -> Result { + Ok(self.0.clone()) + } + } + + fn fixture() -> Vec { + let mut r = vec![0u8; SNP_REPORT_LEN]; + r[0..4].copy_from_slice(&2u32.to_le_bytes()); + r[0x08..0x10].copy_from_slice(&0x30000u64.to_le_bytes()); + r[SNP_MEASUREMENT_OFFSET..SNP_MEASUREMENT_OFFSET + 48].fill(0x5a); + r[SNP_REPORT_LEN - SNP_SIGNATURE_LEN..].fill(0x33); + r + } + + fn setup(platform: PlatformKind) -> (SessionBinding, Attestation) { + let binding = SessionBinding::new([1u8; 32], "alice", [2u8; 32], [3u8; 32]); + let ud = binding.user_data(platform, 5); + let mut report = fixture(); + if platform == PlatformKind::SevSnp { + report[SNP_REPORT_DATA_OFFSET..SNP_REPORT_DATA_OFFSET + 64] + .copy_from_slice(&ud); + } + let att = Attestation { + platform, + user_data: ud, + report, + cert_chain: Vec::new(), + }; + (binding, att) + } + + fn check( + att: &Attestation, + binding: &SessionBinding, + platform: PlatformKind, + verifier: Option<&dyn ChipVerifier>, + ) -> Result { + verify_attestation(att, binding, platform, 5, 3, None, verifier) + } + + #[test] + fn parse_rejects_malformed_reports() { + let mut r = fixture(); + assert!(parse_snp_report(&r[..100]).is_err(), "长度不足"); + r[0..4].fill(0); + assert!(parse_snp_report(&r).is_err(), "version 全零"); + r[0..4].copy_from_slice(&2u32.to_le_bytes()); + r[SNP_MEASUREMENT_OFFSET..SNP_MEASUREMENT_OFFSET + 48].fill(0); + assert!(parse_snp_report(&r).is_err(), "measurement 全零"); + r[SNP_MEASUREMENT_OFFSET..SNP_MEASUREMENT_OFFSET + 48].fill(0x5a); + r[SNP_REPORT_LEN - SNP_SIGNATURE_LEN..].fill(0); + assert!(parse_snp_report(&r).is_err(), "签名全零"); + assert_eq!(parse_snp_report(&fixture()).unwrap().version, 2); + } + + #[test] + fn snp_without_verifier_is_explicitly_not_verified() { + let (b, a) = setup(PlatformKind::SevSnp); + let r = check(&a, &b, PlatformKind::SevSnp, None).unwrap(); + assert!(r.structure_ok && r.bound_ok); + assert_eq!(r.chip, ChipVerdict::NotVerified); + assert!(r.verdict.contains("芯片签名未验证")); + } + + #[test] + fn report_data_mismatch_is_rejected() { + let (b, mut a) = setup(PlatformKind::SevSnp); + a.report[SNP_REPORT_DATA_OFFSET] ^= 0xff; + assert!(check(&a, &b, PlatformKind::SevSnp, None).is_err()); + } + + #[test] + fn measurement_pin_must_match_binding() { + let (b, a) = setup(PlatformKind::SevSnp); + let other = [9u8; 32]; + assert!(verify_attestation(&a, &b, PlatformKind::SevSnp, 5, 3, + Some(&other), None).is_err()); + assert!(verify_attestation(&a, &b, PlatformKind::SevSnp, 5, 3, + Some(&b.code_measurement), None).is_ok()); + } + + #[test] + fn csv_uses_generic_structure_check() { + let (b, a) = setup(PlatformKind::HygonCsv); + let r = check(&a, &b, PlatformKind::HygonCsv, None).unwrap(); + assert_eq!(r.chip, ChipVerdict::NotVerified); + assert!(r.verdict.contains("布局未解析")); + let (_, mut short) = setup(PlatformKind::HygonCsv); + short.report.truncate(10); + assert!(check(&short, &b, PlatformKind::HygonCsv, None).is_err()); + } + + #[test] + fn external_verifier_results_are_not_faked() { + let (b, a) = setup(PlatformKind::SevSnp); + let ok = FakeVerifier(ChipVerdict::VerifiedBy(String::from("test-verifier"))); + let r = check(&a, &b, PlatformKind::SevSnp, Some(&ok)).unwrap(); + assert_eq!(r.chip, ChipVerdict::VerifiedBy(String::from("test-verifier"))); + assert!(r.verdict.contains("判定芯片签名通过")); + + let bad = FakeVerifier(ChipVerdict::Failed(String::from("bad cert chain"))); + assert!(check(&a, &b, PlatformKind::SevSnp, Some(&bad)).is_err()); + + let missing = ExternalVerifier::new("/definitely/not/a/verifier"); + assert!(check(&a, &b, PlatformKind::SevSnp, Some(&missing)).is_err()); + } +} diff --git a/deploy/tee/guest/init.sh b/deploy/tee/guest/init.sh new file mode 100644 index 0000000..8fada15 --- /dev/null +++ b/deploy/tee/guest/init.sh @@ -0,0 +1,153 @@ +#!/bin/busybox sh +# ssw-mpc TEE guest 的 PID 1(由 deploy/tee/oci/oci-image.py 放到 /init)。 +# +# 启动顺序是 fail-closed 的: +# 1. 挂 /proc /sys /dev +# 2. 校验 OCI 层 digest 链(layers.sha256) +# 3. 校验 cmdline 里的 manifest digest 与镜像内的一致 +# 4. 由 KBC/KBS 取回本轮会话的 PSK / seed / 根密钥(不再内置明文) +# 5. 才允许启动 mpc 做跨机密文会话 +# +# 任何一步失败就 halt,绝不「先跑起来再说」。 +# +# 边界:层 digest 校验防的是分发/拉取过程中的层被替换;能同时改 initrd 里 +# /init 与校验清单的宿主不在防御范围内。芯片证明代理与证书链验签由验证方 / +# KBS 负责,这里只消费它的产物(token 文件),不自己验签。 + +set -u +BB=/bin/busybox +OCI=/etc/mpc-tee/oci +RUN=/run/mpc-tee +MPC=/mpc + +$BB mkdir -p /proc /sys /dev "$RUN" +$BB mount -t proc proc /proc 2>/dev/null || true +$BB mount -t sysfs sysfs /sys 2>/dev/null || true +$BB mount -t devtmpfs devtmpfs /dev 2>/dev/null || true + +echo "===== MPC TEE GUEST BOOT (OCI layers) =====" +echo "kernel: $($BB uname -r)" +echo "cmdline: $($BB cat /proc/cmdline)" + +cmdval() { + $BB sed -n "s/.*$1=\\([^ ]*\\).*/\\1/p" /proc/cmdline | $BB head -n 1 +} +USER_DATA=$(cmdval 'mpc\.tee\.user_data') +SITE=$(cmdval 'mpc\.tee\.site') +EXPECT_MANIFEST=$(cmdval 'mpc\.tee\.manifest') +SESSION=$(cmdval 'mpc\.tee\.session') +KBC=$(cmdval 'mpc\.tee\.kbs') +ROLE=$(cmdval 'mpc\.role') +PORT=$(cmdval 'mpc\.tee\.port') +[ -n "${PORT:-}" ] || PORT=19444 + +echo "site=${SITE:-none} role=${ROLE:-none} session_len=${#SESSION}" +if [ -e /dev/sev-guest ]; then echo "SNP device: present"; else echo "SNP device: absent"; fi + +# --- 2. 逐层校验 OCI digest 链 ------------------------------------------------- +if [ ! -f "$OCI/layers.sha256" ]; then + echo "FATAL: 镜像缺少 OCI 层校验清单" + $BB halt -f 2>/dev/null || exit 1 +fi +if ! ( cd "$OCI" && $BB sha256sum -c layers.sha256 ); then + echo "FATAL: OCI 层或 manifest/config 的 digest 与声明不符" + $BB halt -f 2>/dev/null || exit 1 +fi +echo "oci_layers: verified" + +# --- 3. 把镜像度量钉到启动参数 ------------------------------------------------ +ACTUAL_MANIFEST=$($BB cat /etc/mpc-tee/manifest.digest) +if [ -z "$EXPECT_MANIFEST" ] || [ "$EXPECT_MANIFEST" != "$ACTUAL_MANIFEST" ]; then + echo "FATAL: cmdline 的 manifest digest 与镜像不一致 (expect=${EXPECT_MANIFEST:-none})" + $BB halt -f 2>/dev/null || exit 1 +fi +if [ -z "$USER_DATA" ]; then + echo "FATAL: cmdline 没有会话绑定值" + $BB halt -f 2>/dev/null || exit 1 +fi +echo "manifest_digest=$ACTUAL_MANIFEST" +echo "user_data=$USER_DATA" + +# --- 4. KBC 取密钥 ------------------------------------------------------------- +# 在线:cc_kbc::http://HOST:PORT —— 由 mpc 自带的 KBS 客户端取资源 +# 离线:offline_fs_kbc::null —— 仅演练,镜像里带固定测试密钥,显式警告 +TOKEN=offline-demo +if [ -f "$RUN/attestation.token" ]; then + TOKEN=$($BB cat "$RUN/attestation.token") + echo "attestation_token: from guest agent" +else + echo "WARNING: 未找到证明代理 token,使用离线演练占位值(生产必须提供)" +fi + +case "$KBC" in + cc_kbc::http://*) + ENDPOINT=${KBC#cc_kbc::http://} + ENDPOINT=${ENDPOINT%/} + echo "kbs_endpoint=$ENDPOINT" + for kind in psk seed root-key; do + if ! "$MPC" tee kbs-get --endpoint "$ENDPOINT" \ + --session "$SESSION" --kind "$kind" --token "$TOKEN" \ + --out "$RUN/$kind"; then + echo "FATAL: KBS 资源 $kind 取回失败" + $BB halt -f 2>/dev/null || exit 1 + fi + done + PSK_FILE="$RUN/psk" + SEED=$($BB cat "$RUN/seed") + echo "key_source=kbs" + ;; + offline_fs_kbc::null) + echo "WARNING: 离线演练密钥,PSK/seed/root-key 内置在镜像里,禁止用于生产" + for kind in psk seed root-key; do + if [ ! -f "/etc/mpc-tee/offline/$kind" ]; then + echo "FATAL: 离线密钥缺失: $kind" + $BB halt -f 2>/dev/null || exit 1 + fi + $BB cp "/etc/mpc-tee/offline/$kind" "$RUN/$kind" + done + PSK_FILE="$RUN/psk" + SEED=$($BB cat "$RUN/seed") + echo "key_source=offline-demo" + ;; + *) + echo "FATAL: 未知 KBC 模式: ${KBC:-none}" + $BB halt -f 2>/dev/null || exit 1 + ;; +esac + +echo "--- mpc selfcheck / selftest ---" +"$MPC" selfcheck --file "$MPC" +"$MPC" selftest | tail -6 + +# --- 5. 网络与跨机密文会话 --------------------------------------------------- +IFACE=$($BB ls /sys/class/net | $BB grep -v '^lo$' | $BB head -n 1) +echo "iface=${IFACE:-none}" +case "$ROLE" in + alice) ADDR=10.0.0.1/24 ;; + bob) ADDR=10.0.0.2/24 ;; + *) ADDR= ;; +esac +if [ -n "${IFACE:-}" ] && [ -n "$ADDR" ]; then + $BB ip link set "$IFACE" up 2>/dev/null || true + $BB ip addr add "$ADDR" dev "$IFACE" 2>/dev/null || true + $BB ip addr show "$IFACE" 2>/dev/null | $BB head -n 5 || true +fi + +case "$ROLE" in + alice) + "$MPC" node --site alice --sites alice,bob \ + --listen 0.0.0.0:"$PORT" --data 1,2,3 \ + --seed "$SEED" --psk-file "$PSK_FILE" + ;; + bob) + "$MPC" node --site bob --sites alice,bob \ + --connect 10.0.0.1:"$PORT" --data 4,5,6 \ + --seed "$SEED" --psk-file "$PSK_FILE" + ;; + *) + echo "(no role: guest selftest only)" + ;; +esac + +echo "===== MPC TEE GUEST DONE =====" +$BB halt -f 2>/dev/null || true diff --git a/deploy/tee/kbs/serve.py b/deploy/tee/kbs/serve.py new file mode 100644 index 0000000..b6d55ff --- /dev/null +++ b/deploy/tee/kbs/serve.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python3 +"""可复现的 KBS 资源下发 stub(仅用于本地 / 真机演练)。 + +**这不是 Trustee / KBS,也不做芯片证明校验**。它只提供最小的 +`GET /kbs/v0/resource///` 资源接口,让 guest 内的 +`mpc tee kbs-get` 有东西可取,从而把「PSK 内置 initrd」换成 +「按会话从 KBS 取」。 + +生产必须换成带远程证明校验的 KBS:由它验证 SNP/CSV 报告、证书链与 +measurement 后才下发密钥。本 stub 只检查请求头里的 session 与 token +是否匹配启动参数,token 是占位字符串时(非 --strict)会放行并告警。 + +资源目录布局: + /mpc//psk + /mpc//seed + /mpc//root-key + +Python 3.6 兼容(海光 Anolis 8.10)。 +""" +import argparse +import os +import sys +from http.server import BaseHTTPRequestHandler, HTTPServer + +PREFIX = "/kbs/v0/resource/" +DEMO_TOKEN = "offline-demo" + + +def make_handler(resources, session, strict): + class Handler(BaseHTTPRequestHandler): + server_version = "mpc-tee-kbs-stub/1.0" + + def log_message(self, fmt, *args): + sys.stderr.write("[kbs] %s\n" % (fmt % args)) + + def _deny(self, code, reason): + body = ("denied: %s" % reason).encode("utf-8") + self.send_response(code) + self.send_header("Content-Type", "text/plain; charset=utf-8") + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + def do_GET(self): + path = self.path.split("?", 1)[0] + if not path.startswith(PREFIX): + return self._deny(404, "unknown path") + parts = path[len(PREFIX):].split("/") + if len(parts) != 3 or not all(parts): + return self._deny(400, "expected ///") + repo, tag, kind = parts + allowed = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz0123456789._-") + if any(not set(p) <= allowed for p in parts): + return self._deny(400, "illegal resource component") + + got_session = self.headers.get("MPC-Tee-Session", "") + token = self.headers.get("MPC-Tee-Attestation", "") + if got_session != session or tag != session: + return self._deny(403, "session mismatch") + if not token: + return self._deny(403, "missing attestation token") + if strict and token == DEMO_TOKEN: + return self._deny(403, "demo token rejected in strict mode") + if token == DEMO_TOKEN: + sys.stderr.write("[kbs] WARNING: 放行占位证明 token(演练模式)\n") + + full = os.path.abspath(os.path.join(resources, repo, tag, kind)) + base = os.path.abspath(os.path.join(resources, repo, tag)) + if not (full == base or full.startswith(base + os.sep)): + return self._deny(400, "path traversal") + if not os.path.isfile(full): + return self._deny(404, "resource not found") + with open(full, "rb") as f: + body = f.read() + self.send_response(200) + self.send_header("Content-Type", "application/octet-stream") + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + def do_POST(self): + self._deny(405, "read-only stub") + + return Handler + + +def main(): + ap = argparse.ArgumentParser(description="KBS 资源下发 stub(演练用)") + ap.add_argument("--resources", required=True, help="资源根目录") + ap.add_argument("--session", required=True, help="本轮会话 id(64 位十六进制)") + ap.add_argument("--host", default="127.0.0.1") + ap.add_argument("--port", type=int, default=18080) + ap.add_argument("--strict", action="store_true", + help="拒绝 offline-demo 占位 token(生产应开启)") + args = ap.parse_args() + if not os.path.isdir(args.resources): + sys.exit("资源目录不存在: %s" % args.resources) + srv = HTTPServer((args.host, args.port), + make_handler(args.resources, args.session, args.strict)) + sys.stderr.write("[kbs] stub listening %s:%d strict=%s\n" % + (args.host, args.port, args.strict)) + sys.stderr.write("[kbs] 提醒:这是演练 stub,生产请用带证明校验的 KBS\n") + try: + srv.serve_forever() + except KeyboardInterrupt: + pass + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/deploy/tee/oci/README.md b/deploy/tee/oci/README.md new file mode 100644 index 0000000..e57c3fc --- /dev/null +++ b/deploy/tee/oci/README.md @@ -0,0 +1,67 @@ +# OCI 分层镜像(无容器运行时依赖) + +`oci-image.py` 用 Python 3 标准库直接生成 OCI image layout。真机现场只有 +`docker` / `runc`,没有 `buildah` / `podman` / `krunvm`,所以这里不调用任何 +容器运行时,也不需要 registry 就能本地构建与校验。 + +## 三步 + +```bash +# 0) 准备 base rootfs:现成 alpine rootfs 目录(含 busybox 与 musl loader) +# macOS 上可直接用宿主解出的目录;真机上 /opt/.../kata-alpine-*.initrd +# 用 `gzip -dc | cpio -idm` 解出来即可。 + +# 1) 构建分层镜像(base / mpc / init) +python3 oci-image.py build \ + --base /path/to/alpine-rootfs \ + --mpc /path/to/mpc-linux-x86_64 \ + --init ../guest/init.sh \ + --out ./image + +# 2) 校验 digest 链(index → manifest → config → layers,含 diff_id) +python3 oci-image.py verify --image ./image + +# 3) 校验通过后按层解包,打成 qemu 直接启动用的 initrd +python3 oci-image.py pack --image ./image --out ./mpc-initrd.img +``` + +`build` 与 `pack` 都打印: + +```text +manifest_digest=<64hex> # 就是 SessionBinding.code_measurement +measurement=<64hex> # 写进节点描述的 measurement= +initrd_sha256=<64hex> # 分发完整性用 +``` + +把 `measurement` 填进 `deploy/tee/nodes/*.node` / `real-machine/nodes/*.node`, +并在启动 guest 时把 `mpc.tee.manifest=<64hex>` 钉进内核参数 +(`real-machine/run-guest.py` 从 `MPC_TEE_MANIFEST` 读取,缺失即 fail-closed 拒绝启动)。 + +## 层契约 + +| 层 | 内容 | 说明 | +|---|---|---| +| `base` | 整个 rootfs 目录 | 排序 + 固定 uid/gid/mtime,保证可复现 | +| `mpc` | `/mpc` | Linux 静态二进制,0755 | +| `init` | `/init` | `../guest/init.sh`,0755,后层覆盖 base 自带 init | +| `offline`(可选) | `/etc/mpc-tee/offline/{psk,seed,root-key}` | **仅离线演练**,`--offline-dir` 开启时会打印警告,禁止上生产 | + +`pack` 会把每层 tar.gz、manifest.json、config.json、`layers.json` 与 +`layers.sha256` 一起放进 initrd 的 `/etc/mpc-tee/oci/`。guest init 先 +`sha256sum -c layers.sha256`,再核对 cmdline 的 manifest digest,全部通过才启动 `mpc`。 + +## 为什么 measurement 取 manifest digest + +`SessionBinding` 的 `code_measurement` 是 32 字节,正好是 sha256。用 manifest +digest 而不是「mpc 二进制的哈希」,是因为真正决定 guest 行为的是整套层 +(rootfs + 二进制 + init),换任何一层都应让旧证明失效。这也让 registry 的 +按 digest 拉取与框架的 `--pin` 判定天然对齐。 + +## 边界 + +- 层 digest 校验防的是**分发过程被替换**;能同时改 initrd 里 `/init` 与校验清单的 + 宿主不在防御范围内。硬件级启动度量要靠 SNP/CSV 证明,见 `docs/TEE_OCI_PATH.md`。 +- 本工具只产出物料,**不启动任何东西**;执行仍走 `deploy/tee/real-machine/` 或 + `deploy/tee/launch.sh` 的 qemu 后端。 +- 兼容 Python 3.6(海光 Anolis 8.10):不用 `capture_output`、walrus、 + `gzip.compress(mtime=)`。 diff --git a/deploy/tee/oci/oci-image.py b/deploy/tee/oci/oci-image.py new file mode 100644 index 0000000..95d0beb --- /dev/null +++ b/deploy/tee/oci/oci-image.py @@ -0,0 +1,472 @@ +#!/usr/bin/env python3 +"""ssw-mpc TEE guest 镜像:OCI 分层构建 / 校验 / 打包成 initrd。 + +现场两台真机只有 docker + runc,没有 buildah / podman / krunvm,所以这里用 +Python 标准库直接生成 OCI image layout,不依赖任何容器运行时。 + +三层(顺序固定,后层覆盖前层): + base 现成 rootfs 目录(alpine + busybox + musl loader) + mpc 静态 mpc 二进制,落在 /mpc + init guest init 脚本,落在 /init + +**度量契约**:`SessionBinding.code_measurement` = OCI manifest 的 sha256 +(去掉 `sha256:` 前缀的 32 字节)。改一行 guest init、换一个二进制, +manifest digest 就变,证明里的绑定值跟着变,旧报告自然重放不了。 + +`pack` 会把每层的 tar.gz 连同 manifest/config 一起放进 initrd,并生成 +`layers.sha256` 清单;guest init 先逐层校验 digest 才允许启动 mpc。 +这道校验防的是「分发/拉取过程中层被替换」,**不替代芯片对启动镜像的 +度量** —— 能同时改 initrd 里 /init 与清单的宿主不在防御范围内,见 +docs/TEE_OCI_PATH.md 的边界说明。 + +兼容 Python 3.6(海光 Anolis 8.10 自带 3.6):不用 capture_output、不用 +walrus、不用 gzip.compress 的 mtime 参数。 +""" +import argparse +import gzip +import hashlib +import io +import json +import os +import shutil +import stat +import sys +import tarfile +import tempfile + +LAYER_MEDIA = "application/vnd.oci.image.layer.v1.tar+gzip" +CONFIG_MEDIA = "application/vnd.oci.image.config.v1+json" +MANIFEST_MEDIA = "application/vnd.oci.image.manifest.v1+json" +SCHEME = "mpc-tee/oci-layers/v1" +MAX_LAYER_BYTES = 128 * 1024 * 1024 + + +def sha256_hex(data): + return hashlib.sha256(data).hexdigest() + + +def jbytes(obj): + return json.dumps(obj, sort_keys=True, separators=(",", ":"), + ensure_ascii=False).encode("utf-8") + + +def gzip_deterministic(data): + """固定 mtime / filename,保证同样输入产出同样 digest。""" + buf = io.BytesIO() + with gzip.GzipFile(fileobj=buf, mode="wb", compresslevel=9, + mtime=0, filename="") as gz: + gz.write(data) + return buf.getvalue() + + +def normalize(info): + info.uid = 0 + info.gid = 0 + info.uname = "root" + info.gname = "root" + info.mtime = 0 + return info + + +def tar_from_dir(root): + """把目录打成确定性 tar(排序 + 固定元信息)。""" + buf = io.BytesIO() + with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tf: + tf.add(root, arcname=".", recursive=False, filter=normalize) + for cur, dirs, files in os.walk(root): + dirs.sort() + files.sort() + for name in dirs + files: + full = os.path.join(cur, name) + rel = os.path.relpath(full, root) + tf.add(full, arcname=rel, recursive=False, filter=normalize) + return buf.getvalue() + + +def tar_from_files(entries): + """entries: [(arcname, 文件绝对路径 or None(目录), 内容 bytes or None, 模式)]。""" + buf = io.BytesIO() + with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tf: + for arc, src, content, mode in entries: + if content is None: + ti = tarfile.TarInfo(arc) + ti.type = tarfile.DIRTYPE + ti.mode = mode + tf.addfile(ti) + continue + if src is not None: + with open(src, "rb") as f: + content = f.read() + ti = tarfile.TarInfo(arc) + ti.size = len(content) + ti.mode = mode + tf.addfile(ti, io.BytesIO(content)) + return buf.getvalue() + + +def blob_path(image, digest): + return os.path.join(image, "blobs", "sha256", digest) + + +def write_blob(image, data): + digest = sha256_hex(data) + path = blob_path(image, digest) + if not os.path.isdir(os.path.dirname(path)): + os.makedirs(os.path.dirname(path)) + if not os.path.exists(path): + with open(path, "wb") as f: + f.write(data) + return digest, len(data) + + +def read_blob(image, descriptor): + digest = descriptor.get("digest", "") + if not digest.startswith("sha256:") or len(digest) != 71: + raise ValueError("descriptor digest 不是 sha256:<64hex>: %s" % digest) + h = digest[7:] + path = blob_path(image, h) + with open(path, "rb") as f: + data = f.read() + if sha256_hex(data) != h: + raise ValueError("blob 内容与 descriptor 不符: %s" % h) + if descriptor.get("size") != len(data): + raise ValueError("blob 大小与 descriptor 不符: %s" % h) + return h, data + + +def safe_extract(tf, dest): + """拒绝路径穿越与绝对路径,只解常规文件/目录/符号链接。""" + for m in tf.getmembers(): + p = m.name + if p.startswith("/") or ".." in p.split("/"): + raise ValueError("层内路径不安全: %s" % p) + if not (m.isfile() or m.isdir() or m.issym() or m.islnk()): + raise ValueError("层内含不支持的类型: %s (%s)" % (p, m.type)) + tf.extractall(dest) + + +def build(args): + if not os.path.isdir(args.base): + sys.exit("base rootfs 目录不存在: %s" % args.base) + for p in (args.mpc, args.init): + if not os.path.isfile(p): + sys.exit("文件不存在: %s" % p) + + image = os.path.abspath(args.out) + if os.path.exists(image): + shutil.rmtree(image) + os.makedirs(os.path.join(image, "blobs", "sha256")) + + layer_specs = [] + layer_specs.append(("base", tar_from_dir(args.base))) + layer_specs.append(("mpc", tar_from_files([ + ("mpc", args.mpc, None, 0o755), + ]))) + layer_specs.append(("init", tar_from_files([ + ("init", args.init, None, 0o755), + ]))) + if args.offline_dir: + entries = [("etc/mpc-tee/offline", None, None, 0o700)] + for name in sorted(os.listdir(args.offline_dir)): + src = os.path.join(args.offline_dir, name) + if os.path.isfile(src): + entries.append(("etc/mpc-tee/offline/" + name, src, None, 0o600)) + layer_specs.append(("offline", tar_from_files(entries))) + + diffs, layers = [], [] + for idx, (name, tar_bytes) in enumerate(layer_specs): + if len(tar_bytes) > MAX_LAYER_BYTES: + sys.exit("层 %s 超过 %d 字节" % (name, MAX_LAYER_BYTES)) + gz = gzip_deterministic(tar_bytes) + d, size = write_blob(image, gz) + diff = sha256_hex(tar_bytes) + diffs.append("sha256:" + diff) + layers.append({ + "index": idx, + "name": name, + "digest": d, + "diff_id": diff, + "size": size, + "media_type": LAYER_MEDIA, + }) + + config = { + "architecture": "amd64", + "os": "linux", + "created": "1970-01-01T00:00:00Z", + "config": {"Cmd": ["/init"], "Env": ["PATH=/bin:/usr/bin"]}, + "rootfs": {"type": "layers", "diff_ids": diffs}, + "history": [{"created_by": "mpc-tee oci-image build"}], + } + config_digest, config_size = write_blob(image, jbytes(config)) + + manifest = { + "schemaVersion": 2, + "mediaType": MANIFEST_MEDIA, + "config": { + "mediaType": CONFIG_MEDIA, + "digest": "sha256:" + config_digest, + "size": config_size, + }, + "layers": [{ + "mediaType": LAYER_MEDIA, + "digest": "sha256:" + l["digest"], + "size": l["size"], + "annotations": {"mpc.tee.layer": l["name"]}, + } for l in layers], + "annotations": { + "mpc.tee.measurement.scheme": "oci-manifest-digest", + "mpc.tee.spec": SCHEME, + }, + } + manifest_digest, manifest_size = write_blob(image, jbytes(manifest)) + + index = { + "schemaVersion": 2, + "mediaType": "application/vnd.oci.image.index.v1+json", + "manifests": [{ + "mediaType": MANIFEST_MEDIA, + "digest": "sha256:" + manifest_digest, + "size": manifest_size, + "annotations": {"org.opencontainers.image.ref.name": args.tag}, + }], + } + with open(os.path.join(image, "oci-layout"), "wb") as f: + f.write(jbytes({"imageLayoutVersion": "1.0.0"})) + with open(os.path.join(image, "index.json"), "wb") as f: + f.write(jbytes(index)) + + layers_doc = { + "schema": SCHEME, + "manifest_digest": manifest_digest, + "config_digest": config_digest, + "measurement_scheme": "oci-manifest-digest", + "entrypoint": "/init", + "layers": layers, + } + with open(os.path.join(image, "layers.json"), "wb") as f: + f.write(jbytes(layers_doc)) + with open(os.path.join(image, "manifest.digest"), "w") as f: + f.write(manifest_digest + "\n") + + print("image=%s" % image) + print("manifest_digest=%s" % manifest_digest) + print("measurement=%s" % manifest_digest) + print("layers=%d" % len(layers)) + for l in layers: + print(" [%d] %-8s %s (%d bytes)" % + (l["index"], l["name"], l["digest"], l["size"])) + if args.offline_dir: + print("WARNING: 镜像内含离线演练密钥层,禁止用于生产") + return 0 + + +def verify(image): + """按 index → manifest → config → layers 逐跳校验 digest 与 diff_id。""" + with open(os.path.join(image, "index.json"), "rb") as f: + index = json.loads(f.read().decode("utf-8")) + if index.get("schemaVersion") != 2 or not index.get("manifests"): + raise ValueError("index.json 不合法") + manifest_digest, manifest_bytes = read_blob(image, index["manifests"][0]) + manifest = json.loads(manifest_bytes.decode("utf-8")) + if manifest.get("mediaType") != MANIFEST_MEDIA: + raise ValueError("manifest mediaType 不符") + config_digest, config_bytes = read_blob(image, manifest["config"]) + config = json.loads(config_bytes.decode("utf-8")) + diffs = config.get("rootfs", {}).get("diff_ids", []) + layers = manifest.get("layers", []) + if len(diffs) != len(layers) or not layers: + raise ValueError("config.diff_ids 与 manifest.layers 数量不符") + + checked = [] + for i, desc in enumerate(layers): + digest, gz = read_blob(image, desc) + tar_bytes = gzip.decompress(gz) + diff = sha256_hex(tar_bytes) + if diffs[i] != "sha256:" + diff: + raise ValueError("层 %d 的 diff_id 与 config 不符" % i) + checked.append((digest, desc.get("annotations", {}).get( + "mpc.tee.layer", "layer%d" % i))) + + layers_doc_path = os.path.join(image, "layers.json") + if os.path.exists(layers_doc_path): + with open(layers_doc_path, "rb") as f: + doc = json.loads(f.read().decode("utf-8")) + if doc.get("manifest_digest") != manifest_digest: + raise ValueError("layers.json 的 manifest_digest 与实测不符") + if doc.get("config_digest") != config_digest: + raise ValueError("layers.json 的 config_digest 与实测不符") + return manifest_digest, config_digest, checked + + +def cmd_verify(args): + try: + m, c, layers = verify(os.path.abspath(args.image)) + except (ValueError, OSError, IOError) as e: + sys.stderr.write("镜像校验失败: %s\n" % e) + return 1 + print("verified=ok") + print("manifest_digest=%s" % m) + print("measurement=%s" % m) + print("config_digest=%s" % c) + for d, name in layers: + print(" %-8s %s" % (name, d)) + return 0 + + +def cpio_newc(root): + """生成 newc 格式 cpio(Linux initrd 可识别)。""" + out = bytearray() + ino = 1 + + def pad(buf): + while len(buf) % 4: + buf.append(0) + + def emit(name, st, data, is_link, is_dir): + mode = stat.S_IMODE(st.st_mode) + if is_dir: + mode |= 0o040000 + elif is_link: + mode |= 0o120000 + else: + mode |= 0o100000 + nlink = 2 if is_dir else 1 + fields = [ino, mode, 0, 0, nlink, 0, len(data), 0, 0, 0, 0, + len(name) + 1, 0] + header = "070701" + "".join("%08x" % (v & 0xffffffff) for v in fields) + out.extend(header.encode("ascii")) + out.extend(name.encode("utf-8")) + out.append(0) + pad(out) + if data: + out.extend(data) + pad(out) + + emit(".", os.stat(root), b"", False, True) + for cur, dirs, files in os.walk(root): + dirs.sort() + files.sort() + for name in dirs + files: + full = os.path.join(cur, name) + rel = os.path.relpath(full, root).replace(os.sep, "/") + st = os.lstat(full) + if stat.S_ISLNK(st.st_mode): + emit(rel, st, os.readlink(full).encode("utf-8"), True, False) + elif stat.S_ISDIR(st.st_mode): + emit(rel, st, b"", False, True) + elif stat.S_ISREG(st.st_mode): + with open(full, "rb") as f: + emit(rel, st, f.read(), False, False) + else: + raise ValueError("initrd 不支持特殊文件: %s" % rel) + trailer = [0, 0o100000 | 0o755, 0, 0, 1, 0, 0, 0, 0, 0, 0, + len("TRAILER!!!") + 1, 0] + out.extend(("070701" + "".join("%08x" % v for v in trailer)).encode("ascii")) + out.extend(b"TRAILER!!!\0") + pad(out) + return bytes(out) + + +def cmd_pack(args): + image = os.path.abspath(args.image) + try: + manifest_digest, config_digest, layers = verify(image) + except (ValueError, OSError, IOError) as e: + sys.stderr.write("打包前校验失败: %s\n" % e) + return 1 + + tmp = tempfile.mkdtemp(prefix="mpc-tee-initrd-") + try: + root = os.path.join(tmp, "root") + os.makedirs(root) + with open(os.path.join(image, "layers.json"), "rb") as f: + doc = json.loads(f.read().decode("utf-8")) + for layer in doc["layers"]: + with open(blob_path(image, layer["digest"]), "rb") as f: + gz = f.read() + tf = tarfile.open(fileobj=io.BytesIO(gzip.decompress(gz)), mode="r:") + safe_extract(tf, root) + tf.close() + + oci = os.path.join(root, "etc", "mpc-tee", "oci") + blobs = os.path.join(oci, "blobs") + os.makedirs(blobs) + copies = [("layers.json", os.path.join(image, "layers.json")), + ("index.json", os.path.join(image, "index.json"))] + for name, src in copies: + shutil.copyfile(src, os.path.join(oci, name)) + with open(os.path.join(oci, "manifest.json"), "wb") as f: + f.write(open(blob_path(image, manifest_digest), "rb").read()) + with open(os.path.join(oci, "config.json"), "wb") as f: + f.write(open(blob_path(image, config_digest), "rb").read()) + + sums = [] + for layer in doc["layers"]: + d = layer["digest"] + shutil.copyfile(blob_path(image, d), + os.path.join(blobs, d + ".tar.gz")) + sums.append("%s blobs/%s.tar.gz" % (d, d)) + sums.append("%s manifest.json" % manifest_digest) + sums.append("%s config.json" % config_digest) + with open(os.path.join(oci, "layers.sha256"), "w") as f: + f.write("\n".join(sums) + "\n") + with open(os.path.join(root, "etc", "mpc-tee", "manifest.digest"), + "w") as f: + f.write(manifest_digest + "\n") + + cpio = cpio_newc(root) + packed = gzip_deterministic(cpio) + out = os.path.abspath(args.out) + with open(out, "wb") as f: + f.write(packed) + print("initrd=%s" % out) + print("initrd_sha256=%s" % sha256_hex(packed)) + print("manifest_digest=%s" % manifest_digest) + print("measurement=%s" % manifest_digest) + print("layers=%d" % len(layers)) + if not args.quiet: + top = ["init", "mpc", "bin/busybox", + "etc/mpc-tee/manifest.digest", "etc/mpc-tee/oci/layers.sha256"] + for name in top: + print(" %s %s" % ("ok" if os.path.exists(os.path.join(root, name)) + else "MISSING", name)) + finally: + shutil.rmtree(tmp, ignore_errors=True) + return 0 + + +def main(): + ap = argparse.ArgumentParser( + description="OCI 分层镜像构建 / 校验 / 打包 initrd(无容器运行时依赖)") + sub = ap.add_subparsers(dest="cmd") + + b = sub.add_parser("build", help="由 rootfs + mpc + init 构建 OCI image layout") + b.add_argument("--base", required=True, help="已解包的 rootfs 目录") + b.add_argument("--mpc", required=True, help="Linux 静态 mpc 二进制") + b.add_argument("--init", required=True, help="guest init 脚本") + b.add_argument("--out", required=True, help="输出 OCI image 目录") + b.add_argument("--tag", default="mpc-tee:local") + b.add_argument("--offline-dir", default=None, + help="离线演练密钥目录(仅测试,会打印警告)") + b.set_defaults(func=lambda a: build(a)) + + v = sub.add_parser("verify", help="校验 index/manifest/config/layer digest 链") + v.add_argument("--image", required=True) + v.set_defaults(func=cmd_verify) + + p = sub.add_parser("pack", help="校验后按层解包并打成 initrd") + p.add_argument("--image", required=True) + p.add_argument("--out", required=True) + p.add_argument("--quiet", action="store_true") + p.set_defaults(func=cmd_pack) + + args = ap.parse_args() + if not getattr(args, "func", None): + ap.print_help() + return 2 + return args.func(args) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/deploy/tee/real-machine/README.md b/deploy/tee/real-machine/README.md new file mode 100644 index 0000000..1052919 --- /dev/null +++ b/deploy/tee/real-machine/README.md @@ -0,0 +1,76 @@ +# 真机复现:AMD SEV-SNP + 海光 CSV 双加密 guest + +把 2026-11-06 的临时 `/tmp` 脚本整理成可复现资产。**凭据不入库**:SSH 口令由 +xop 键名经环境变量注入,PSK / seed / 根密钥由 KBS 下发(或离线演练层), +仓库里只有占位值与示例节点描述。 + +## 前置物料 + +1. **Linux 静态 `mpc`**(macOS 上交叉编译): + ```bash + RUSTFLAGS="-C link-self-contained=no" \ + CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=x86_64-linux-musl-gcc \ + cargo build -p mpc-cli --features secure --target x86_64-unknown-linux-musl + zig objcopy --strip-all \ + target/x86_64-unknown-linux-musl/debug/mpc /tmp/mpc-linux-x86_64 + ``` + `-C link-self-contained=no` 是必须的,否则 zig 的 crt 与 Rust 自带 crt 重复定义 `_start`。 +2. **base rootfs**:现成 alpine rootfs(含 `/bin/busybox` 与 musl loader)。 +3. **OCI 镜像与 initrd**:按 `../oci/README.md` 跑 `build` / `verify` / `pack`, + 记下 `measurement=<64hex>`。 +4. **节点描述**:复制 `nodes/*.node.example`,把 `measurement` 换成上一步的 digest, + 其余路径按真机 `preflight.sh` 结果填写。 +5. **KBS(可选,在线模式)**:`../kbs/serve.py` 只是演练 stub;生产请用带证明校验的 + Trustee/KBS。离线演练用 `MPC_TEE_KBC=offline_fs_kbc::null`, + 并在 `build` 时加 `--offline-dir` 提供 `psk` / `seed` / `root-key`。 + +## 单 guest 自检 + +```bash +export MPC_TEE_MPC_BIN=/path/to/mpc +export MPC_TEE_MANIFEST=<64hex> +export MPC_TEE_KBC=offline_fs_kbc::null +python3 run-guest.py nodes/amd-sev-snp.node.example <64hex-session> <64hex-pubkey> none +``` + +`role=none` 不挂网卡,只验证 guest 内核、`mpc selftest` 与 OCI 层校验。 + +## 双 guest 跨物理机计算 + +```bash +export MPC_TEE_MPC_BIN=/path/to/mpc-linux-x86_64 +export MPC_TEE_INITRD=/path/to/mpc-initrd.img +export MPC_TEE_AMD_NODE=nodes/amd-sev-snp.node.example +export MPC_TEE_HYGON_NODE=nodes/hygon-csv2.node.example +export MPC_TEE_MANIFEST=<64hex> +export MPC_TEE_KBC=offline_fs_kbc::null +# 可选:MPC_TEE_AMD_HOST / MPC_TEE_HYGON_HOST / *_USER_KEY / *_PASS_KEY +MPC_TEE_DRY_RUN=1 ./pair-run.sh # 先看物料与计划,不连机 +./pair-run.sh +``` + +`pair-run.sh` 会:分发物料到两台宿主 → 后台起 AMD SNP guest(alice,socket 监听)→ +只读确认端口 LISTEN → 起海光 CSV guest(bob,socket 连接)→ 输出两侧日志尾部。 +判定成功的标志是**两侧都输出 `value | 35.000000`**,且日志里有 +`oci_layers: verified`、`manifest_digest=...`、`mpc selftest 全部通过`。 + +## 分层与职责 + +| 层 | 文件 | 职责 | +|---|---|---| +| 框架 | `mpc tee plan --argv` | 平台中立的 qemu argv(含 `user_data`、kernel-hashes、pflash、cbitpos) | +| 部署 | `run-guest.py` | 只补串口 / 角色 / manifest / KBC / socket 网卡 / NUMA,**不覆盖框架参数** | +| 编排 | `pair-run.sh` | 分发物料、起两侧 guest、收日志;调度决策在本地,不在集群 | +| guest | `../guest/init.sh` | 校验 OCI 层 → 取密钥 → 启动 `mpc node` | + +框架原生 argv 已经过真机校正,**不要**再加 `-machine` / `sev-guest` / 固件 / CPU 的 +部署层覆盖;真机上那次 `Platform is already owned` 的根因是缺 `kernel-hashes=on` +与 pflash,已修进 `PlatformProfile`,详见 `docs/TEE_DIRECT_LAUNCH.md`。 + +## 边界 + +- 两台真机的静态 qemu 没编 slirp,`-netdev user` 不可用;跨 guest 链路由部署层 + 注入 `socket` netdev,核心 crate 不写死宿主网络后端。 +- 在线 KBS 的 token 目前是占位值 `offline-demo`(stub 非 strict 模式放行并告警)。 + 生产必须换成证明代理产物 + 带证明校验的 KBS。 +- `pair-run.sh` 只起 qemu,不做芯片证明互验;报告验签走 `mpc tee verify` 的外部验签器。 diff --git a/deploy/tee/real-machine/guest-role.sh b/deploy/tee/real-machine/guest-role.sh new file mode 100644 index 0000000..ea7d03a --- /dev/null +++ b/deploy/tee/real-machine/guest-role.sh @@ -0,0 +1,39 @@ +#!/usr/bin/env bash +# 单个机密 guest 的角色入口(在 TEE 宿主上执行)。 +# 由 pair-run.sh 分发到远端后调用;所有敏感值经环境变量注入,仓库内不落密钥。 +set -u + +ROLE=${1:-none} +BASE=${MPC_TEE_RUN_DIR:-/tmp/mpc-tee-run} +NODE=${MPC_TEE_NODE_FILE:-$BASE/node} +SID=${MPC_TEE_SESSION_ID:-$(printf 'ab%.0s' $(seq 1 32))} +PK=${MPC_TEE_PUBKEY:-$(printf 'cd%.0s' $(seq 1 32))} +VARIANT=${MPC_TEE_VARIANT:-} +AMD_HOST=${MPC_TEE_AMD_HOST:-192.168.1.7} +LINK_PORT=${MPC_TEE_LINK_PORT:-19777} + +export MPC_TEE_MPC_BIN=${MPC_TEE_MPC_BIN:-$BASE/mpc} +export MPC_TEE_MANIFEST=${MPC_TEE_MANIFEST:?必须给出 OCI manifest digest} +export MPC_TEE_KBC=${MPC_TEE_KBC:-offline_fs_kbc::null} +export MPC_TEE_MIN_TCB=${MPC_TEE_MIN_TCB:-3} +export MPC_TEE_SESSION_ID=$SID +export MPC_TEE_PUBKEY=$PK + +case "$ROLE" in + alice) + export MPC_NETDEV_ARGS="-netdev socket,id=mpcnet0,listen=0.0.0.0:$LINK_PORT -device virtio-net-pci,netdev=mpcnet0" + ;; + bob) + export MPC_NETDEV_ARGS="-netdev socket,id=mpcnet0,connect=$AMD_HOST:$LINK_PORT -device virtio-net-pci,netdev=mpcnet0" + ;; + none) + ;; + *) + echo "未知角色: $ROLE" >&2 + exit 2 + ;; +esac + +ARGS=("$NODE" "$SID" "$PK" "$ROLE") +[ -n "$VARIANT" ] && ARGS+=("$VARIANT") +exec python3 "$BASE/run-guest.py" "${ARGS[@]}" diff --git a/deploy/tee/real-machine/nodes/amd-sev-snp.node.example b/deploy/tee/real-machine/nodes/amd-sev-snp.node.example new file mode 100644 index 0000000..edb3607 --- /dev/null +++ b/deploy/tee/real-machine/nodes/amd-sev-snp.node.example @@ -0,0 +1,19 @@ +# AMD SEV-SNP 真机节点描述(2026-11-06 实测 192.168.1.7 / tee-node-01) +# 用 deploy/tee/preflight.sh 产出实际值;measurement 必须换成 +# `oci-image.py build` 输出的 manifest digest(64 hex),否则 fail-closed 会拒绝。 +# pair-run.sh 分发时会把 initrd= 改写成远端路径,无需手改。 +site=alice +host=192.168.1.7 +kind=sev-snp +tcb=5 +device_present=true +qemu_present=true +firmware_present=true +image_present=true +kbc=online +kbs_reachable=true +measurement=0000000000000000000000000000000000000000000000000000000000000000 +qemu=/opt/kata/bin/qemu-system-x86_64 +firmware=/opt/kata/share/ovmf/AMDSEV.fd +kernel=/opt/kata/share/kata-containers/vmlinuz-6.12.36-160-confidential +initrd=/tmp/mpc-tee-run/initrd.img diff --git a/deploy/tee/real-machine/nodes/hygon-csv2.node.example b/deploy/tee/real-machine/nodes/hygon-csv2.node.example new file mode 100644 index 0000000..9d7e345 --- /dev/null +++ b/deploy/tee/real-machine/nodes/hygon-csv2.node.example @@ -0,0 +1,20 @@ +# 海光 CSV2 真机节点描述(2026-11-06 实测 192.168.1.102) +# CSV2 实测 policy=7;CSV3 需加 `--variant csv3`。 +# 固件路径只填文件位置:框架对海光自动用 pflash 加载并带 kernel-hashes=on +# (缺任一都会导致 direct boot 失败,报错 "Platform is already owned" 是误导性的)。 +# measurement 必须换成 `oci-image.py build` 输出的 manifest digest。 +site=bob +host=192.168.1.102 +kind=hygon-csv +tcb=3 +device_present=true +qemu_present=true +firmware_present=true +image_present=true +kbc=offline +kbs_reachable=false +measurement=0000000000000000000000000000000000000000000000000000000000000000 +qemu=/opt/confidential-containers/bin/qemu-system-x86_64 +firmware=/opt/confidential-containers/share/ovmf/HYGONCSV.fd +kernel=/opt/confidential-containers/share/kata-containers/vmlinuz-5.10.134-102cc-csv-hygon-gpu +initrd=/tmp/mpc-tee-run/initrd.img diff --git a/deploy/tee/real-machine/pair-run.sh b/deploy/tee/real-machine/pair-run.sh new file mode 100644 index 0000000..619aec3 --- /dev/null +++ b/deploy/tee/real-machine/pair-run.sh @@ -0,0 +1,137 @@ +#!/usr/bin/env bash +# 跨两台 TEE 真机各起一个加密 guest,跑一次带 PSK 的密文会话。 +# +# 凭据只走 xop 键名(环境变量指定),脚本里没有任何明文口令。 +# 编排决策在本地,远端只执行 guest-role.sh —— 与「框架直接调度 TEE」一致。 +# +# 必需输入(环境变量): +# MPC_TEE_MPC_BIN Linux 静态 mpc 二进制 +# MPC_TEE_INITRD oci-image.py pack 产出的 initrd +# MPC_TEE_AMD_NODE AMD 节点描述文件 +# MPC_TEE_HYGON_NODE 海光节点描述文件 +# MPC_TEE_MANIFEST OCI manifest digest(64 hex) +# 可选:MPC_TEE_KBC(默认 offline_fs_kbc::null)、MPC_TEE_SESSION_ID、 +# MPC_TEE_PUBKEY、MPC_TEE_*_HOST、MPC_TEE_*_USER_KEY / *_PASS_KEY、 +# MPC_TEE_LOG_DIR、MPC_TEE_DRY_RUN=1 +set -u + +HERE=$(cd "$(dirname "$0")" && pwd) +AMD_HOST=${MPC_TEE_AMD_HOST:-192.168.1.7} +HYGON_HOST=${MPC_TEE_HYGON_HOST:-192.168.1.102} +AMD_USER_KEY=${MPC_TEE_AMD_USER_KEY:-tee_amd_7_user} +AMD_PASS_KEY=${MPC_TEE_AMD_PASS_KEY:-tee_amd_7_pass} +HYGON_USER_KEY=${MPC_TEE_HYGON_USER_KEY:-tee_hg_102_user} +HYGON_PASS_KEY=${MPC_TEE_HYGON_PASS_KEY:-tee_hg_102_pass} +REMOTE_DIR=${MPC_TEE_REMOTE_DIR:-/tmp/mpc-tee-run} +LOG_DIR=${MPC_TEE_LOG_DIR:-/tmp/mpc-tee-logs} +LINK_PORT=${MPC_TEE_LINK_PORT:-19777} +MANIFEST=${MPC_TEE_MANIFEST:-} +SID=${MPC_TEE_SESSION_ID:-$(printf 'ab%.0s' $(seq 1 32))} +PK=${MPC_TEE_PUBKEY:-$(printf 'cd%.0s' $(seq 1 32))} +KBC=${MPC_TEE_KBC:-offline_fs_kbc::null} +SSHO="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PreferredAuthentications=password -o PubkeyAuthentication=no -o ConnectTimeout=20" + +need() { + if [ ! -f "$1" ]; then echo "缺少文件: $1" >&2; exit 2; fi +} +need "$HERE/run-guest.py" +need "$HERE/guest-role.sh" +need "${MPC_TEE_MPC_BIN:-/nonexistent}" +need "${MPC_TEE_INITRD:-/nonexistent}" +need "${MPC_TEE_AMD_NODE:-/nonexistent}" +need "${MPC_TEE_HYGON_NODE:-/nonexistent}" +case "$MANIFEST" in + [0-9a-fA-F][0-9a-fA-F]*) [ "${#MANIFEST}" -eq 64 ] || { echo "MANIFEST 必须 64 位 hex" >&2; exit 2; } ;; + *) echo "MANIFEST 必须 64 位 hex" >&2; exit 2 ;; +esac + +stage() { + local dst=$1 node=$2 variant=$3 + mkdir -p "$dst" + cp "${MPC_TEE_MPC_BIN}" "$dst/mpc" + cp "${MPC_TEE_INITRD}" "$dst/initrd.img" + cp "$HERE/run-guest.py" "$dst/run-guest.py" + cp "$HERE/guest-role.sh" "$dst/guest-role.sh" + sed "s|^initrd=.*|initrd=$REMOTE_DIR/initrd.img|" "$node" > "$dst/node" + cat > "$dst/env.sh" < "$LOG_DIR/alice.log" 2>&1 & +P_ALICE=$! + +ready=0 +for _ in $(seq 1 40); do + if xop run --secret "SSHPASS=$AMD_PASS_KEY" --secret "TEE_USER=$AMD_USER_KEY" -- \ + sh -c "sshpass -e ssh $SSHO \"\$TEE_USER@$AMD_HOST\" \"ss -ltn | grep -q ':$LINK_PORT '\"" \ + < /dev/null > /dev/null 2>&1; then + ready=1 + break + fi + sleep 0.5 +done +echo "snp_socket_listening=$ready ($AMD_HOST:$LINK_PORT)" + +echo "=== 起 海光 CSV guest (bob) ===" +remote "$HYGON_HOST" "$HYGON_USER_KEY" "$HYGON_PASS_KEY" bob \ + > "$LOG_DIR/bob.log" 2>&1 +RC=$? +wait "$P_ALICE" 2>/dev/null || true + +clean() { grep -v "WARN NetworkGuard\|WARN FileGuard\|Permanently added" "$1" | tail -45; } +echo "=== AMD SNP guest ==="; clean "$LOG_DIR/alice.log" +echo "=== 海光 CSV guest ==="; clean "$LOG_DIR/bob.log" +echo "bob_guest_rc=$RC" +echo "完整日志: $LOG_DIR/alice.log $LOG_DIR/bob.log" +exit "$RC" diff --git a/deploy/tee/real-machine/run-guest.py b/deploy/tee/real-machine/run-guest.py new file mode 100644 index 0000000..ccbe9c3 --- /dev/null +++ b/deploy/tee/real-machine/run-guest.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +"""真机侧启动器:消费框架原生 qemu argv,只补部署层参数。 + +框架(`mpc tee plan --argv`)负责平台中立且已被真机校正过的启动规格; +这里只补宿主相关的东西:串口、guest 角色、会话/镜像度量/KBC 参数、 +socket 网卡、NUMA 内存后端。**不覆盖 -machine / -object / -bios / -cpu / -smp** +—— 那些都是框架能力表的职责,真机差异已经在 2026-11-06 校正过。 + +环境变量(全部由调用方注入,仓库内不落任何凭据或密钥): + MPC_TEE_MPC_BIN guest 内静态 mpc 二进制在宿主上的路径(默认 mpc) + MPC_TEE_MANIFEST OCI manifest digest,64 位十六进制(必填) + MPC_TEE_KBC guest 内 KBC 模式(默认 offline_fs_kbc::null) + MPC_TEE_MIN_TCB TCB 门槛(默认 3) + MPC_NETDEV_ARGS role != none 时必填,qemu 网卡参数(socket netdev) + +用法:run-guest.py NODE_FILE SESSION_ID PUBKEY ROLE [VARIANT] +兼容 Python 3.6(海光 Anolis 8.10)。 +""" +import json +import os +import shlex +import subprocess +import sys + +HEX = set("0123456789abcdef") + + +def die(msg): + sys.stderr.write("run-guest: %s\n" % msg) + sys.exit(2) + + +def drop_pair(argv, flag, pred): + while True: + for i, a in enumerate(argv): + if a == flag and i + 1 < len(argv) and pred(argv[i + 1]): + del argv[i:i + 2] + break + else: + return + + +def main(): + if len(sys.argv) < 5: + die("用法: run-guest.py NODE SESSION PUBKEY ROLE [VARIANT]") + mpc = os.environ.get("MPC_TEE_MPC_BIN", "mpc") + node_path, sid, pk, role = sys.argv[1:5] + variant = sys.argv[5] if len(sys.argv) > 5 else None + manifest = os.environ.get("MPC_TEE_MANIFEST", "").strip().lower() + kbc = os.environ.get("MPC_TEE_KBC", "offline_fs_kbc::null").strip() + min_tcb = os.environ.get("MPC_TEE_MIN_TCB", "3") + + if len(manifest) != 64 or not set(manifest) <= HEX: + die("MPC_TEE_MANIFEST 必须是 64 位十六进制(由 oci-image.py build 输出)") + if len(sid) != 64 or not set(sid.lower()) <= HEX: + die("SESSION_ID 必须是 64 位十六进制") + if len(pk) != 64 or not set(pk.lower()) <= HEX: + die("PUBKEY 必须是 64 位十六进制") + if " " in kbc or not kbc: + die("MPC_TEE_KBC 不能含空格或为空") + if role not in ("alice", "bob", "none"): + die("ROLE 只能是 alice / bob / none") + + cmd = [mpc, "--report", "json", "tee", "plan", "--node", node_path, + "--session-id", sid, "--pubkey", pk, + "--min-tcb", min_tcb, "--argv"] + if variant: + cmd += ["--variant", variant] + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + universal_newlines=True) + plan_out, plan_err = p.communicate() + if p.returncode != 0: + sys.stderr.write("tee plan 失败 rc=%d\n%s\n%s\n" % + (p.returncode, plan_out, plan_err)) + sys.exit(2) + + argv = None + for line in plan_out.splitlines(): + try: + obj = json.loads(line) + except ValueError: + continue + for k, v in obj.get("rows", []): + if k == "argv_json": + argv = json.loads(v) + if not argv: + sys.stderr.write("没拿到 argv_json\n%s" % plan_out) + sys.exit(2) + + print("=== framework argv (%d args) ===" % len(argv)) + print(" ".join(argv)) + sys.stdout.flush() + + # 1) 部署层追加的内核参数:镜像度量与 KBC 由调度侧钉进 guest。 + # framework 原有的 mpc.tee.user_data / site / aa_kbc_params 不动。 + i = argv.index("-append") + 1 + argv[i] += (" console=ttyS0 earlyprintk=serial" + " mpc.role=%s mpc.tee.session=%s" + " mpc.tee.manifest=%s mpc.tee.kbs=%s" % + (role, sid, manifest, kbc)) + + # 2) 真机自带的静态 qemu 没编 slirp,框架给的 user netdev 用不了; + # 跨 guest 链路改由部署层注入 socket netdev(核心 crate 不写死网络后端)。 + drop_pair(argv, "-netdev", lambda v: v.startswith("user,")) + drop_pair(argv, "-device", + lambda v: v.startswith("virtio-net-pci,netdev=mpcnet0")) + if role == "none": + print("=== role=none: 自检 guest 不挂网卡 ===") + else: + extra = os.environ.get("MPC_NETDEV_ARGS") + if not extra: + die("跨 guest 会话需要 MPC_NETDEV_ARGS(部署层注入 socket 网卡)") + argv += shlex.split(extra) + print("=== deploy netdev: %s ===" % extra) + + # 3) 机密 guest 需要显式 NUMA 内存后端;关机即退出 qemu。 + argv += ["-object", "memory-backend-ram,id=dimm1,size=2048M", + "-numa", "node,memdev=dimm1", "-no-reboot"] + + print("=== deployed argv (%d args) ===" % len(argv)) + print(" ".join(argv)) + sys.stdout.flush() + os.execvp(argv[0], argv) + + +if __name__ == "__main__": + main() diff --git a/docs/TEE_OCI_PATH.md b/docs/TEE_OCI_PATH.md new file mode 100644 index 0000000..6057823 --- /dev/null +++ b/docs/TEE_OCI_PATH.md @@ -0,0 +1,115 @@ +# OCI 镜像层与 libkrun 的评估(2026-11-06) + +## 结论 + +**采纳 OCI 作为镜像与分发格式,分两阶段推进;libkrun 暂不进入框架。** + +先把三样东西拆开,才能看清它和「框架直接调度 TEE、不走编排层」这条铁律的关系: + +| 概念 | 是什么 | 是否属于编排层 | +|---|---|---| +| OCI image spec | 镜像的分层格式 + manifest digest + registry 分发 | 否,只是物料格式 | +| libkrun | 嵌进宿主进程的 VMM 库(Rust/C API,Linux KVM / macOS HVF) | 否,属于执行层 | +| crun `krun` handler / krunvm | 把 OCI 镜像启成 microVM 的启动器 | 否,属于执行层 | +| Kata / Pod / runtimeClass / K8s scheduler | 容器编排与调度 | **是,仍然禁止** | + +所以在框架层引入 OCI digest 与可插拔启动后端,不违反铁律;核心 crate 依旧不生成 +容器清单、不设运行时类、不依赖集群调度器。 + +## 事实来源 + +- 上游 `containers/libkrun`:变体只有 `libkrun`(通用)、`libkrun-sev`(AMD SEV / + SEV-ES / **SEV-SNP** + 远程证明)、`libkrun-tdx`(Intel TDX);设备含 virtio-console / + block / fs / net / vsock / rng,网络有 TSI 与 virtio-net + passt/gvproxy 两种模式。 +- 2.0 的 Guest Init Subsystem:静态 musl `init-binary` 作 PID 1,宿主侧 `init-blob` + 用 `Builder::from_oci_json()` 吃 OCI spec,通过 virtio-fs overlay 注入 `/init.krun` + 与 `/.krun_config.json`;SEV/TDX 路径另有 `mount_tee_block_device()` 把 root 切到块设备。 +- 启动速度:`sandbox-bench`(2026-05,裸机 10 次冷启动)中位 libkrun/krunvm **310 ms**、 + docker 463 ms、Firecracker 808 ms。这是普通 microVM 的进程冷启动,**不含 SNP 固件 + `LAUNCH_*` 流程**。 +- 安全模型原文:guest 与 VMM 属同一安全上下文,VMM 可代理宿主资源; + `virtio-fs` 不限制 guest 访问宿主其他目录,`TSI` 让 VMM 成为 guest 的网络代理。 +- 真机只读探测(xop 凭据连 `192.168.1.7` / `192.168.1.102`):两台只有 + `docker` / `runc` / `containerd`,`libkrun`、`libkrunfw-sev`、`krunvm`、`crun`、 + `podman`、`buildah` 全部缺失。内网代码库也没有 libkrun / krunvm / crun 镜像, + 分析基于上游公开资料。 + +## 三项价值对照现状 + +| 诉求 | 现状痛点 | OCI 带来的 | +|---|---|---| +| 分层打镜像 | 13 MB initrd 手工拼,改一次 `mpc` 整体重建、整体重分发,`measurement` 跟着变 | base / mpc / init 分层,只推变化层;manifest digest 天然可 pin,正好作 `SessionBinding.code_measurement` | +| 远程调度 | scp 分发镜像,无完整性锚点 | registry 按 digest 拉取;**选节点仍在框架**(与 Kuscia 的「框架决策、K8s 执行」一致),把决策交给 scheduler 就退回编排层 | +| 快速启动 | qemu direct boot 秒级 | libkrun 的 VMM 路径确实更快,但 SNP 固件启动度量是硬成本,**真机未实测,不承诺** | + +## 四个硬约束 + +1. **度量边界**:libkrun 默认用 virtio-fs 把 rootfs 从宿主注入 guest,而 SNP 只度量 + 启动时载入的 guest 页 —— 这些层不在初始度量内。直接拿来跑 `mpc` 会把「代码度量」 + 这一环掏空。出路:SEV 路径的 TEE block device,或把 manifest / 层 digest 钉进 + `user_data` 并在 guest init 逐层校验。本版选后者。 +2. **海光 CSV 无对应变体**:CSV 是海光自研(国密、ASID 复用补丁、`HYGONCSV.fd`、 + vmmcall 证明、CSV3 kernel-hashes + 秘密注入),没有 rust-vmm 兼容证据。 + OCI/libkrun 最多覆盖 AMD,**海光必须保留已跑通的 qemu direct boot**。两个后端只能并列。 +3. **现场缺件**:SEV 变体还要 `libkrunfw-sev` + OpenSSL headers;libkrun 2.0 主线 + API/ABI 不兼容 1.x 且仍在变,生产要锁 `stable-*`。引入是实打实的装包与验证工作。 +4. **TSI 网络**:默认让 VMM 代理 guest socket,跨 guest 的 MPC 通信需改用 virtio-net + + passt/gvproxy,或保留 socket 语义并在策略里显式声明。 + +## 采纳路线 + +**阶段一(本版已落地)**:只做镜像格式与度量契约,`deploy/tee/oci/oci-image.py` 用 +Python 标准库生成 OCI image layout(不依赖现场缺失的容器运行时),`pack` 按层解包后 +仍打成 initrd 交给**已跑通的 qemu 后端**。`measurement = manifest digest`,guest init +逐层校验 digest 并核对 cmdline 里的 manifest 值。AMD / 海光都覆盖,现场无需装新运行时。 + +**阶段二(评估后再做)**:在 `192.168.1.7` 装 `libkrunfw-sev` + `crun`/`krunvm`,实测 +SNP guest 的证明链路与冷启动时间;达标后把 `LaunchSpec` 扩成后端枚举 +(`QemuDirect` / `OciMicrovm`),框架层仍保持平台中立。海光继续走 `QemuDirect`。 + +## Kata 复核(2026-11-06 傍晚) + +用户追问「用 Kata 会不会更简单,两台不是都装好了吗」。重新只读探测两台真机(xop +凭据 `tee_amd_7_*` / `tee_hg_102_*`): + +| 项 | AMD 节点 192.168.1.7 | 海光节点 192.168.1.102 | +|---|---|---| +| `/opt/kata` | **存在**,含完整安装(15 个二进制,含 `qemu-system-x86_64-snp-experimental`、`containerd-shim-kata-v2`) | 不存在 | +| 挂进 containerd / docker 运行时? | 否(`docker info` Runtimes 仅 `runc`) | 否 | +| 内核 | `6.13.0-snp-guest` | `5.10.134-csv` | +| `/dev/sev` | 有 | 有(CSV 复用 sev 接口) | + +结论:**「两台都装了」只对一半** —— 只有 AMD 那台有 Kata 二进制(且没挂进运行时), +海光那台压根没有;而且 Kata 上游只支持 SEV / SEV-ES / SEV-SNP / TDX,**没有海光 +CSV**(cbitpos=47、`HYGONCSV.fd`、vmmcall 是海光自研)。102 上我们跑通的 CSV guest +是 **qemu direct boot**,不是 Kata。 + +会不会更简单?**不会整体更简单**: +1. 只在 AMD 那台有用,海光仍要 direct boot → 没省掉这套,反而多一个后端; +2. Kata 是重依赖(in-guest kata-agent + containerd shim + runtime-rs); +3. 它会接管度量/证明模型(自带 KBC),我们刚钉死的 `SessionBinding` 要迁进去,更复杂; +4. OCI 分层镜像这个真收益,不靠 Kata 也能拿(盖在 direct launch 上)。 + +**决策**:保持 OCI 打包 + direct launch(阶段一已落地),Kata 不引入;若 `.7` 上有 +必须复用的 Kata 资产,可后续作为可选 AMD-only 后端,藏在同一 `LaunchSpec` 抽象后。 + +## 远程调度:e2b 协议参考 + +用户提示远程调度可考虑 e2b 协议。采纳为**接口形态参考**,不引入 e2b 依赖: +- e2b 的 spawn-by-spec 模式(提交 sandbox 规格 + 产物挂载 + 结果流回)正好对应本框架 + 的「框架发 TEE 启动规格(OCI digest + 会话绑定 + 节点约束)→ 选中的节点起加密 + guest → 报告/结果回传」; +- 节点选择仍是框架决策(与 Kuscia「框架决策、K8s 执行」一致),不交给外部 scheduler; +- 本版 `mpc tee plan` 已产出 `LaunchSpec`/`qemu_argv`,后续把「按 digest 从 registry + 拉 OCI 镜像 + 选节点 + 起 guest」包成 e2b 形态的调度 API 即可,核心 crate 仍零编排字样。 + +## 边界(别夸大) + +- **层 digest 校验 ≠ 芯片度量**:它防的是分发/拉取过程中层被替换。能同时改 initrd 里 + `/init` 与校验清单的宿主不在防御范围内;启动镜像的硬件度量要靠 SNP/CSV 证明体系。 +- **`deploy/tee/kbs/serve.py` 是演练 stub**:只检查 session 与占位 token,不是 Trustee/KBS, + **不做芯片证明校验**。生产必须换成验证过报告与证书链后才下发密钥的 KBS。 +- **框架仍不实现 ECDSA / 证书链验签**:`mpc-tee::verify` 做结构检查与会话绑定复核, + 芯片签名交给可插拔的外部验签器;结论里必须显式标注「芯片签名未验证」。 +- OCI 层是物料格式,不是调度器;框架不因此获得「远程调度」能力,只获得可校验的 + 镜像分发锚点。