Files
ssw-mpc/crates/mpc-cli/src/sa.rs
T
admin f676a6aa97 fix(registry): 节点自报支持 optee/none,平台名解析收敛为一份口径
PlatformKind 新增 ALL/as_str/parse,Display 由 as_str 派生;规范名解析唯一来源下沉到枚举定义处。

TeeNode::parse 删除手写 parse_kind;hostd parse_platform 与 CLI 四处别名表复用同一份规范名,历史别名继续可用。

影响:kind=optee/none/tdx 可登记并出现在 GET /nodes;admit()/builtin() 不变,注册不因缺少 guest 启动规格被拒。

回归:规范名契约、全变体 descriptor 往返、optee/none 端到端注册单测;全量测试与 25 步门禁全绿。
2026-11-11 15:11:52 +08:00

432 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 tee sa-serve` / `mpc tee sa-client` —— SA 扩展模式的两个入口。
//!
//! # 形态
//!
//! ```text
//! 板子 / 安全世界(armv7) 外挂 VM / 算力(x86)
//! ┌──────────────────────────┐ ┌──────────────────────────┐
//! │ mpc tee sa-serve │ │ mpc tee sa-client │
//! │ └ SaServer │ HTTP/1.1 │ └ SaClient │
//! │ 持 K_root,永不导出 │ ─────────▶ │ 只拿能力,不拿密钥 │
//! └──────────────────────────┘ └──────────────────────────┘
//! ```
//!
//! # 为什么密钥必须走文件而不是命令行
//!
//! 命令行参数会进 `ps` 输出,任何本机用户都能看到。`--root-key` 这种写法
//! 等于把 `K_root` 摊在进程表里 —— 而 `K_root` 是整个 SA 形态的信任根。
//!
//! 所以这里只接受 `--root-key-file` / `--shared-secret-file`:
//!
//! * 根密钥文件按**十六进制**读(64 位 = 32 字节);不接受裸文本 ——
//! 裸文本熵密度太低,且「看起来像 hex 的文本」极易被误当成裸字节;
//! * 共享密钥文件按**单行文本**读,**只去尾部换行** —— `echo key > f`
//! 会带一个 `\n`,不去掉的话客户端与服务端的 token 不一致,
//! 症状是「401 但密码没错」;
//! * 文件权限建议 `0600`,但**不强制** —— 板子上很多 rootfs 是 vfat /
//! overlayfs,根本没有 POSIX 权限位,强制检查会让部署寸步难行。
//! 这一点必须**说清楚**:权限检查缺失是部署侧的责任,不是本命令保证的。
//!
//! # 诚实边界
//!
//! 阶段一的 SA 跑在**普通 Linux** 上:`K_root` 在进程内存里,root 能读
//! `/proc/<pid>/mem`。⇒ 它是**接口验证**,不是安全实现。
//!
//! 所以 `sa-serve` 默认 `--platform none`(诚实自曝),只有显式传
//! `--platform optee` 才上报 OP-TEE —— 而那要求 `K_root` 真的在
//! OP-TEE secure storage 里。
use std::net::{SocketAddr, TcpListener};
use mpc_tee::sa::client::{SaClient, SEAL_VERSION};
use mpc_tee::sa::protocol::MIN_SECRET_LEN;
use mpc_tee::sa::server::{sealed_from_payload, sealed_payload, ConfigVerdict, SaConfig, SaServer};
use mpc_tee::Tee;
use crate::report;
/// `mpc tee sa-serve`:启动 SA 服务端(持 `K_root`,对外供能力)。
pub fn cmd_sa_serve(args: &[String]) -> Result<(), String> {
let listen = parse_flag(args, "--listen").unwrap_or("127.0.0.1:9300").to_string();
let addr: SocketAddr = listen
.parse()
.map_err(|_| format!("--listen {listen:?} 不是 host:port"))?;
// ★ 平台类型:默认 `none` = 诚实自曝「本 SA 没有硬件保护」。
let platform_raw = parse_flag(args, "--platform").unwrap_or("none");
let platform = crate::parse_platform_loose(platform_raw)
.ok_or_else(|| format!("--platform {platform_raw:?} 只认 none/optee/snp/tdx/csv"))?;
let tcb: u32 = match parse_flag(args, "--tcb") {
Some(v) => v
.parse()
.map_err(|_| format!("--tcb {v:?} 不是无符号整数"))?,
None => 0,
};
// ★ 根密钥:要么给文件,要么从系统熵源现取。
// 现取的那份**不落盘** —— 重启后就是新的根密钥,
// 之前下发过的派生材料全部作废(这是安全属性,不是缺陷)。
let root_key = match parse_flag(args, "--root-key-file") {
Some(path) => read_root_key_file(path)?,
None => {
let k = mpc_core::osrand::seed32()
.map_err(|e| format!("取不到系统熵源: {e}(请改用 --root-key-file)"))?;
note!("SA_ROOT_KEY_EPHEMERAL=true(本次运行随机生成,未落盘;重启即失效)");
k
}
};
let shared_secret = match parse_flag(args, "--shared-secret-file") {
Some(path) => {
let s = read_secret_file(path)?;
if s.len() < MIN_SECRET_LEN {
return Err(format!(
"共享密钥太短({} 字节 < {MIN_SECRET_LEN} 字节)—— 短密钥抗不住在线穷举",
s.len()
));
}
Some(s)
}
None => None,
};
let cfg = SaConfig {
listen: addr,
shared_secret,
platform,
tcb,
};
// ★ 先校验再绑定 —— `SaServer::new` 里也会校验,但这里提前判是为了
// **不把端口开出去**。顺序反了的话会出现「端口已经在监听、
// 但鉴权配置不合法」的窗口,那窗口里的每个请求都是未鉴权的。
match cfg.validate() {
ConfigVerdict::MissingSecret => {
return Err(format!(
"{addr} 不是回环地址 —— 回环信任模式在跨网段上等于零保护,任何能连上的人都能取走密钥材料。\
请配 --shared-secret-file(至少 {MIN_SECRET_LEN} 字节)。"
));
}
ConfigVerdict::SecretTooShort => {
return Err(format!(
"共享密钥长度不足 {MIN_SECRET_LEN} 字节,拒绝启动"
));
}
ConfigVerdict::Ok => {}
}
let server = SaServer::new(root_key, &cfg).map_err(|e| e.to_string())?;
let listener = TcpListener::bind(addr).map_err(|e| format!("绑定 {addr} 失败: {e}"))?;
let rows: Vec<(&str, report::Cell)> = vec![
("listen", report::Cell::txt(addr.to_string())),
("platform", report::Cell::txt(platform.to_string())),
("tcb", report::Cell::int(tcb as i64)),
(
"auth",
report::Cell::txt(if cfg.shared_secret.is_some() {
"credential"
} else {
"loopback-trust"
}),
),
(
"hardware_protected",
report::Cell::flag(platform != mpc_tee::PlatformKind::None),
),
];
report::kv("SA 服务端已启动", &rows);
note!("sa_serve_ready=true");
server.serve(listener).map_err(|e| format!("SA 服务端退出: {e}"))
}
/// `mpc tee sa-client`:外挂 VM 侧的客户端。
///
/// 只做**能力调用**与**物料获取**,不承载算法 —— 与 `SaClient` 的定位一致。
pub fn cmd_sa_client(args: &[String]) -> Result<(), String> {
let endpoint = parse_flag(args, "--endpoint")
.ok_or("缺少 --endpoint(host:port,不带 scheme)")?
.to_string();
// 操作名 = 第一个既不是 `--flag`、也不是某个 `--flag` 的值的参数。
let op = find_op(args)
.ok_or("缺少操作名(seal / unseal / attest / sign / master-seed / party-seed)")?
.to_string();
let shared_secret = match parse_flag(args, "--shared-secret-file") {
Some(path) => Some(read_secret_file(path)?),
None => None,
};
let mut client = SaClient::new(endpoint.clone()).map_err(|e| e.to_string())?;
if let Some(s) = shared_secret {
client = client.with_secret(s);
}
match op.as_str() {
"seal" => {
let pt = read_hex_arg(args, "--plaintext-hex")
.ok_or("缺少 --plaintext-hex(待密封内容的十六进制)")?;
let aad = read_hex_arg(args, "--aad-hex").unwrap_or_default();
let blob = client.seal(&pt, &aad).map_err(|e| e.to_string())?;
note!("sealed_len={}", sealed_payload(&blob).len());
note!("sealed_hex={}", hex_of(sealed_payload(&blob)));
note!("sa_seal_ok=true");
}
"unseal" => {
let blob_hex = read_hex_arg(args, "--blob-hex")
.ok_or("缺少 --blob-hex(sa-seal 输出的 sealed_hex)")?;
let aad = read_hex_arg(args, "--aad-hex").unwrap_or_default();
let blob = sealed_from_payload(
client.platform().kind,
SEAL_VERSION,
aad.clone(),
&blob_hex,
);
let pt = client.unseal(&blob, &aad).map_err(|e| e.to_string())?;
note!("plaintext_len={}", pt.len());
note!("plaintext_hex={}", hex_of(&pt));
note!("sa_unseal_ok=true");
}
"attest" => {
let ud_hex = parse_flag(args, "--user-data-hex")
.ok_or("缺少 --user-data-hex(64 字节 / 128 位十六进制)")?;
let ud = parse_hex_64(ud_hex)?;
let att = client.attest(&ud).map_err(|e| e.to_string())?;
note!("platform={}", att.platform);
note!("report_len={}", att.report.len());
note!("report_hex={}", hex_of(&att.report));
note!("cert_chain_len={}", att.cert_chain.len());
note!("sa_attest_ok=true");
}
"sign" => {
let msg = read_hex_arg(args, "--message-hex")
.ok_or("缺少 --message-hex(待签消息的十六进制)")?;
let sig = client.sign(&msg).map_err(|e| e.to_string())?;
note!("alg={}", sig.alg);
note!("sig_hex={}", hex_of(&sig.bytes));
note!("sa_sign_ok=true");
}
"master-seed" => {
let sid = parse_hex_32(
parse_flag(args, "--session-id").ok_or("缺少 --session-id(32 字节十六进制)")?,
)?;
let seed = client.master_seed(&sid).map_err(|e| e.to_string())?;
note!("master_seed_hex={}", hex_of(&seed));
note!("sa_master_seed_ok=true");
}
"party-seed" => {
let sid = parse_hex_32(
parse_flag(args, "--session-id").ok_or("缺少 --session-id(32 字节十六进制)")?,
)?;
let site = parse_flag(args, "--site").ok_or("缺少 --site(参与方名)")?;
let seed = client.party_seed(&sid, site).map_err(|e| e.to_string())?;
note!("party_seed_hex={}", hex_of(&seed));
note!("sa_party_seed_ok=true");
}
other => return Err(format!("未知操作 {other:?}")),
}
Ok(())
}
/// 找出操作名:第一个**不是** `--flag`、也不是某个 `--flag` 的值的参数。
///
/// ★ 必须成对跳过 flag 与它的值 —— 否则 `--site alice` 里的 `alice`
/// 会被当成操作名。
fn find_op(args: &[String]) -> Option<&str> {
let mut i = 0usize;
while i < args.len() {
if args[i].starts_with("--") {
i += 2;
continue;
}
return Some(args[i].as_str());
}
None
}
/// 从十六进制参数读字节。
fn read_hex_arg(args: &[String], name: &str) -> Option<Vec<u8>> {
let raw = parse_flag(args, name)?;
parse_hex_any_len(raw)
}
/// 解析任意长度的十六进制。
fn parse_hex_any_len(s: &str) -> Option<Vec<u8>> {
let t: String = s.chars().filter(|c| !c.is_ascii_whitespace()).collect();
if t.len() % 2 != 0 {
return None;
}
let mut out = Vec::with_capacity(t.len() / 2);
let b = t.as_bytes();
let mut i = 0;
while i < b.len() {
let hi = (b[i] as char).to_digit(16)?;
let lo = (b[i + 1] as char).to_digit(16)?;
out.push(((hi << 4) | lo) as u8);
i += 2;
}
Some(out)
}
/// 解析 32 字节(64 位十六进制)。
fn parse_hex_32(s: &str) -> Result<[u8; 32], String> {
let v = parse_hex_any_len(s).ok_or(format!("{s:?} 不是合法十六进制"))?;
if v.len() != 32 {
return Err(format!("{s:?} 必须是 32 字节(64 位十六进制)"));
}
let mut out = [0u8; 32];
out.copy_from_slice(&v);
Ok(out)
}
/// 解析 64 字节(128 位十六进制)。
fn parse_hex_64(s: &str) -> Result<[u8; 64], String> {
let v = parse_hex_any_len(s).ok_or(format!("{s:?} 不是合法十六进制"))?;
if v.len() != 64 {
return Err(format!("{s:?} 必须是 64 字节(128 位十六进制)"));
}
let mut out = [0u8; 64];
out.copy_from_slice(&v);
Ok(out)
}
/// 字节 → 小写十六进制。
fn hex_of(bytes: &[u8]) -> String {
mpc_tee::sa::protocol::hex_encode(bytes)
}
/// 读根密钥文件。
///
/// 内容按**十六进制**解析(64 位 = 32 字节);不接受裸文本 ——
/// 裸文本的熵密度太低,而且「看起来像 hex 的文本」很容易被误当成裸字节。
fn read_root_key_file(path: &str) -> Result<[u8; 32], String> {
let raw = std::fs::read(path).map_err(|e| format!("读根密钥文件 {path} 失败: {e}"))?;
let text = String::from_utf8_lossy(&raw);
let t = text.trim();
if t.is_empty() {
return Err(format!("根密钥文件 {path} 是空的"));
}
let key = parse_hex_32(t).map_err(|e| format!("根密钥文件 {path}: {e}"))?;
if !mpc_core::material::seed_is_valid(&key) {
return Err(format!(
"根密钥文件 {path} 里是**全零** —— 拒绝启动(全零会让所有派生密钥可预测)"
));
}
Ok(key)
}
/// 读共享密钥文件(文本,去掉尾部换行)。
fn read_secret_file(path: &str) -> Result<String, String> {
let raw = std::fs::read(path).map_err(|e| format!("读共享密钥文件 {path} 失败: {e}"))?;
let s = String::from_utf8_lossy(&raw).to_string();
// ★ 只去**尾部**换行 —— 中间若有换行说明文件坏了,保留它让鉴权必然失败,
// 而不是悄悄把多行拼成一行(那会让「配的密钥」与「用的密钥」不一致)。
let trimmed = s.trim_end_matches(['\n', '\r']);
if trimmed.is_empty() {
return Err(format!("共享密钥文件 {path} 是空的"));
}
if trimmed.contains('\n') {
return Err(format!(
"共享密钥文件 {path} 含多行 —— 共享密钥必须是**单行**(否则客户端与服务端的凭据必然不一致)"
));
}
Ok(trimmed.to_string())
}
/// 从 argv 里摘出 `--flag value`。
fn parse_flag<'a>(args: &'a [String], name: &str) -> Option<&'a str> {
args.iter()
.position(|a| a == name)
.and_then(|i| args.get(i + 1))
.map(String::as_str)
}
#[cfg(test)]
mod tests {
use super::*;
fn args(v: &[&str]) -> Vec<String> {
v.iter().map(|s| String::from(*s)).collect()
}
#[test]
fn find_op_skips_flag_values() {
// ★ `--site alice` 里的 alice 不能被当成操作名
let a = args(&["--endpoint", "h:1", "--site", "alice", "master-seed"]);
assert_eq!(find_op(&a), Some("master-seed"));
let b = args(&["master-seed", "--site", "alice"]);
assert_eq!(find_op(&b), Some("master-seed"));
}
#[test]
fn find_op_returns_none_without_op() {
assert_eq!(find_op(&args(&["--endpoint", "h:1"])), None);
}
#[test]
fn hex_parsing_rejects_bad_input() {
assert!(parse_hex_any_len("zz").is_none());
assert!(parse_hex_any_len("abc").is_none());
assert_eq!(parse_hex_any_len("0a0B").unwrap(), vec![0x0a, 0x0b]);
}
#[test]
fn hex_32_requires_exact_length() {
assert!(parse_hex_32(&"00".repeat(32)).is_ok());
assert!(parse_hex_32(&"00".repeat(31)).is_err());
assert!(parse_hex_32(&"00".repeat(33)).is_err());
}
#[test]
fn hex_64_requires_exact_length() {
assert!(parse_hex_64(&"00".repeat(64)).is_ok());
assert!(parse_hex_64(&"00".repeat(32)).is_err());
}
#[test]
fn zero_root_key_file_is_rejected() {
let p = std::env::temp_dir().join(format!("mpc-sa-root-{}", std::process::id()));
std::fs::write(&p, "00".repeat(32)).unwrap();
let e = read_root_key_file(p.to_str().unwrap()).unwrap_err();
assert!(e.contains("全零"), "错误信息必须点明全零: {e}");
let _ = std::fs::remove_file(&p);
}
#[test]
fn root_key_file_rejects_non_hex() {
let p = std::env::temp_dir().join(format!("mpc-sa-root2-{}", std::process::id()));
std::fs::write(&p, "not-hex-at-all").unwrap();
assert!(read_root_key_file(p.to_str().unwrap()).is_err());
let _ = std::fs::remove_file(&p);
}
#[test]
fn secret_file_trims_only_trailing_newline() {
let p = std::env::temp_dir().join(format!("mpc-sa-sec-{}", std::process::id()));
std::fs::write(&p, "0123456789abcdef0123456789abcdef\n").unwrap();
let s = read_secret_file(p.to_str().unwrap()).unwrap();
assert_eq!(s, "0123456789abcdef0123456789abcdef");
assert_eq!(s.len(), 32);
let _ = std::fs::remove_file(&p);
}
#[test]
fn secret_file_rejects_multiline() {
let p = std::env::temp_dir().join(format!("mpc-sa-sec2-{}", std::process::id()));
std::fs::write(&p, "line1\nline2\n").unwrap();
let e = read_secret_file(p.to_str().unwrap()).unwrap_err();
assert!(e.contains("单行"), "错误信息必须点明单行: {e}");
let _ = std::fs::remove_file(&p);
}
#[test]
fn empty_secret_file_is_rejected() {
let p = std::env::temp_dir().join(format!("mpc-sa-sec3-{}", std::process::id()));
std::fs::write(&p, "\n").unwrap();
assert!(read_secret_file(p.to_str().unwrap()).is_err());
let _ = std::fs::remove_file(&p);
}
}