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 步门禁全绿。
432 lines
17 KiB
Rust
432 lines
17 KiB
Rust
//! `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);
|
||
}
|
||
}
|