feat(tee): 接入海光 CSV 真实芯片验签,打通报告捕获到验签的端到端闭环

海光 CSV 报告的 user_data / mnonce / measure / pek_cert / sn 被 anonce
按 u32 数组逐个异或混淆,此前框架按明文比对,永远对不上。现按厂商 SDK
(csv_sdk/csv_status.c)规则还原(deobfuscate_csv_field),SNP 走明文分支。

另修两个真实 CLI bug:
- 全局 --report text|json 与 `tee verify --report <文件>` 撞名,导致
  tee verify 永远拿不到文件路径;改为上下文感知。
- tee verify 的 --tcb 默认 0,而 tee plan 用节点描述里的 tcb 算绑定值,
  二者不一致时报「user_data 与本次会话绑定不一致(疑似重放报告)」,
  把实现问题误导成安全事件。现给 tee verify 加 --node,site / measurement /
  tcb / platform 默认与 tee plan 同源,平台冲突直接拒绝。

新增真机可复现资产(deploy/tee/real-machine/):
- csv-attest-request.c:支持自定义挑战值取报告,自带 SM3 实现
  (厂商 get-attestation 把挑战值写死成 "user data",无法与会话绑定)
- csv-report-restore.py:还原 anonce 混淆字段
- csv-verify-attestation.sh:官方验签器 wrapper,堵住退出码恒 0、
  报告路径写死、离线证书 fallback 同目录、截断报告 fail-open 四个坑
- capture-csv-report.sh / verify-csv-report-e2e.sh / attest-init.sh /
  build-attest-initrd.sh

真机(192.168.1.102)实测:捕获 2548 字节真实报告,官方验签器完成
芯片签名与 hrk→hsk→cek→pek 全链验证,框架校验通过(structure_ok /
bound_ok / chip=已验证)。篡改 user_data、篡改 sig1、截断报告三种负向
场景全部 fail-closed。
This commit is contained in:
admin committed 2026-11-06 21:28:41 +08:00
1 parent 9c47e1076a
commit 14eb9065de
15 files changed
+1665 -43

No files matched your search

+12
View File
@@ -13,5 +13,17 @@ rustflags = [
"-C", "target-feature=+crt-static",
]
# 交叉编译到 x86_64 Linux(海光 / AMD 真机宿主)。
#
# 与 armv7 同思路:rustc 自带的 rust-lld + 自带 crt/musl,不依赖外部 gcc。
# 产物是静态单文件,拷到真机上直接跑(真机自带的 qemu 是 glibc 动态链接,
# 但我们的 mpc 二进制本身不依赖任何动态库)。
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
rustflags = [
"-C", "link-self-contained=yes",
"-C", "target-feature=+crt-static",
]
# 如果哪天非要用 glibc 目标 armv7-unknown-linux-gnueabihf,那才需要外部
# arm-linux-gnueabihf-gcc 当 linker(macOS 上没有,只能靠 zig cc 或 Linux 宿主)。
+175 -16
View File
@@ -167,6 +167,26 @@ mpc tee 参数(直接调度 TEE,不经过任何容器编排层):
--demo 用固定示例会话值做离线演练(会明确警告,不能上生产)
准入任一项不满足即失败,不存在降级通过;输出的是启动规格,不是部署清单。
mpc tee verify --report FILE --platform snp|csv|tdx|optee
--report PATH 证明报告原始字节文件
--platform K 报告所属平台(给了 --node 时可省,取节点描述里的平台)
--user-data HEX 报告里那 64 字节挑战值(128 位十六进制)
--session-id HEX 本轮会话标识(64 位十六进制)
--pubkey HEX 本轮会话公钥哈希(64 位十六进制)
--site NAME 本方站点名(给了 --node 时可省)
--measurement HEX 代码度量 pin(给了 --node 时可省,取节点描述里的 measurement)
--tcb N 节点 TCB(给了 --node 时可省,取节点描述里的 tcb)
--node PATH 节点描述文件:**与 tee plan 用同一份**。
site / measurement / tcb / platform 默认全部取自它 ——
这几个值参与 user_data 绑定,手工重填极易对不上,
而对不上时报出来的是「疑似重放报告」,会误导排查方向。
--min-tcb N 最低 TCB 门槛(默认 0)
--pin HEX 额外 pin 一份度量(64 位十六进制)
--verifier PATH 外部芯片验签器(stdout 打印 OK 或 verified=true 视为通过)
--verifier-arg A 传给验签器的额外参数(可重复)
--certs PATH 证书链文件(传给验签器)
结论里严格区分「芯片签名未验证」与「已验证」,Ok 不等于硬件证明通过。
mpc node 参数:
--site NAME 本方站点名(必填)
--sites A,B 全体站点,逗号分隔(必填,各方必须一致)
@@ -787,14 +807,50 @@ fn cmd_tee_plan(args: &[String]) -> Result<(), String> {
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")),
// 节点描述:验证方与启动方读**同一份**真相源。
//
// 为什么必须有这个:`user_data` 的第二段哈希绑的是
// 「代码度量 + 平台标签 + TCB」,其中 **TCB 来自节点描述**。
// 启动时 `tee plan` 用 node 里的 tcb 算绑定值,验证时若手工重填
// `--tcb`(或漏填 → 默认 0),算出来的期望值必然对不上,报出来的是
// 「user_data 与本次会话绑定不一致」——一个指向重放攻击的误导性结论。
let node = match parse_flag(args, "--node") {
Some(p) => {
let src = std::fs::read_to_string(p).map_err(|e| format!("读节点描述 {p} 失败: {e}"))?;
Some(mpc_tee::schedule::TeeNode::parse(&src).map_err(|e| e.to_string())?)
}
None => None,
};
let platform = match parse_flag(args, "--platform") {
Some(p) => match p {
"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")),
},
None => node
.as_ref()
.map(|n| n.platform.kind)
.ok_or("缺少 --platform(也没给 --node)")?,
};
// 节点描述与显式 --platform 不一致 = 拿 A 节点的报告去按 B 平台验,
// 必须直接拒绝,不能「以 --platform 为准」闷头算下去。
if let (Some(n), Some(p)) = (node.as_ref(), parse_flag(args, "--platform")) {
let nk = n.platform.kind;
if nk != platform {
return Err(format!(
"--node 的平台是 {},与 --platform {p:?} 不一致",
nk
));
}
}
// 报告在参数都合法之后再读 —— 参数错误比 IO 错误更早暴露,
// 免得排查时被「文件不存在」盖住真正的语义问题。
let report = std::fs::read(report_path).map_err(|e| format!("读报告 {report_path} 失败: {e}"))?;
let user_data = mpc_tee::platform::parse_hex::<64>(
parse_flag(args, "--user-data").ok_or("缺少 --user-data(64 字节 / 128 位十六进制)")?,
)
@@ -811,15 +867,29 @@ fn cmd_tee_verify(args: &[String]) -> Result<(), String> {
};
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();
// site / measurement / tcb 优先取节点描述(与 `tee plan` 同源),
// 显式传参才覆盖 —— 手工重填这些值是绑定对不上的头号来源。
let site = match parse_flag(args, "--site") {
Some(s) => s.to_string(),
None => node
.as_ref()
.map(|n| n.site.clone())
.filter(|s| !s.is_empty())
.ok_or("缺少 --site(也没给 --node)")?,
};
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 measurement = match parse_flag(args, "--measurement") {
Some(m) => cli_parse_hex32(m)?,
None => node
.as_ref()
.map(|n| n.measurement)
.ok_or("缺少 --measurement(也没给 --node)")?,
};
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,
None => node.as_ref().map(|n| n.platform.tcb).unwrap_or(0),
};
let min_tcb: u32 = match parse_flag(args, "--min-tcb") {
Some(v) => v.parse().map_err(|_| format!("--min-tcb {v:?} 不是整数"))?,
@@ -1530,7 +1600,22 @@ pub(crate) fn parse_flag<'a>(args: &'a [String], name: &str) -> Option<&'a str>
/// 支持 `--report json` 与 `--report=json` 两种写法,位置不限。
/// 摘掉而不是留给子命令忽略 —— 因为子命令的参数解析(`parse_flag`)是
/// 「找第一个同名字符串」,留着会占掉一个位置,容易和真实参数混淆。
///
/// **例外:`mpc tee verify` 的 `--report` 是证明报告的*文件路径***,与全局的
/// 输出格式参数同名。全局参数在子命令之前解析,若不在这里让位,`tee verify`
/// 就永远拿不到文件路径(真机上表现为
/// `--report 只认 text / json,得到 "report.cert"`)。
/// 判定规则:只有当命令行确实是 `tee verify` 时,`--report` 的非格式值才当文件路径;
/// 其余子命令仍然只认 `text` / `json`,写错就报错。
fn split_report_flag(raw: &[String]) -> Result<(Vec<String>, bool), String> {
// `tee verify` 的 `--report` 是文件路径,让位给它。
let report_is_path = raw
.iter()
.position(|a| a == "tee")
.and_then(|i| raw.get(i + 1))
.map(|a| a == "verify")
.unwrap_or(false);
let mut out = Vec::with_capacity(raw.len());
let mut json = false;
let mut i = 0;
@@ -1539,7 +1624,7 @@ fn split_report_flag(raw: &[String]) -> Result<(Vec<String>, bool), String> {
let val = if a == "--report" {
let v = raw
.get(i + 1)
.ok_or("--report 后面要跟 text 或 json")?;
.ok_or("--report 后面要跟 text 或 json,或一个文件路径")?;
i += 2;
Some(v.as_str())
} else if let Some(v) = a.strip_prefix("--report=") {
@@ -1551,11 +1636,16 @@ fn split_report_flag(raw: &[String]) -> Result<(Vec<String>, bool), String> {
None
};
if let Some(v) = val {
json = match v {
"json" => true,
"text" => false,
match v {
"json" => json = true,
"text" => json = false,
other if report_is_path => {
// 保留分离形式,`parse_flag` 只认精确串 `--report`。
out.push(String::from("--report"));
out.push(String::from(other));
}
other => return Err(format!("--report 只认 text / json,得到 {other:?}")),
};
}
}
}
Ok((out, json))
@@ -3241,6 +3331,46 @@ mod tests {
let _ = std::fs::remove_file(&p);
}
/// `tee verify` 必须与 `tee plan` 用**同一份**节点描述。
///
/// `user_data` 第二段哈希绑的是「度量 + 平台 + TCB」,TCB 来自节点描述。
/// 启动方用 node 里的 tcb 算绑定值,验证方若手工重填或漏填 `--tcb`
/// (默认 0),期望值必然对不上 —— 而报错是「user_data 与本次会话绑定不一致」,
/// 指向重放攻击,排查方向会被带偏。
#[test]
fn tee_verify_reads_binding_inputs_from_node() {
let p = std::env::temp_dir().join(format!("mpc-cli-teeverify-{}.node", std::process::id()));
let src = format!(
"site=bob\nhost=127.0.0.1\nkind=hygon-csv\ntcb=3\n\
device_present=true\nqemu_present=true\nfirmware_present=true\n\
image_present=true\nkbc=offline\nkbs_reachable=false\nmeasurement={}\n\
qemu=/usr/bin/qemu-system-x86_64\nfirmware=/srv/tee/HYGONCSV.fd\n\
kernel=/srv/tee/vmlinuz\ninitrd=/srv/tee/initrd.img\n",
"53".repeat(32)
);
std::fs::write(&p, &src).expect("写节点描述");
let node = p.to_str().unwrap();
// 缺 --session-id / --pubkey 时必须报错,不能静默用默认值。
let missing = v(&["verify", "--report", "/nonexistent", "--node", node]);
assert!(
cmd_tee_verify(&missing).is_err(),
"缺少报告文件 / 会话参数必须拒绝"
);
// 节点描述与 --platform 冲突必须直接拒绝。
let conflict = v(&[
"verify", "--report", "/nonexistent", "--node", node, "--platform", "snp",
"--session-id", &"ab".repeat(32), "--pubkey", &"cd".repeat(32),
]);
let err = cmd_tee_verify(&conflict).unwrap_err();
assert!(
err.contains("不一致"),
"节点平台与 --platform 冲突必须报错,实际: {err}"
);
let _ = std::fs::remove_file(&p);
}
#[test]
fn tee_argv_json_keeps_parameter_boundaries() {
let a = vec![String::from("-append"), String::from("a=1 b=2")];
@@ -3279,4 +3409,33 @@ mod tests {
assert!(split_report_flag(&v(&["fl", "--report"])).is_err());
assert!(split_report_flag(&v(&["fl", "--report", "yaml"])).is_err());
}
/// 真机回归:`mpc tee verify --report <文件>` 的 `--report` 是**证明报告的
/// 文件路径**,与全局输出格式参数同名。全局参数先解析,若不让位,
/// `tee verify` 就永远拿不到文件路径(真机表现为
/// `--report 只认 text / json,得到 "report.cert"`)。
#[test]
fn tee_verify_report_path_survives_global_report_flag() {
// tee verify 的 --report 是路径,必须原样留给子命令。
let (a, j) = split_report_flag(&v(&["tee", "verify", "--report", "report.cert"])).unwrap();
assert!(!j);
assert_eq!(a, v(&["tee", "verify", "--report", "report.cert"]));
assert_eq!(
parse_flag(&a, "--report"),
Some("report.cert"),
"tee verify 必须能读到文件路径"
);
// `=` 写法同样要还原成分离形式(parse_flag 只认精确串)。
let (a, _j) = split_report_flag(&v(&["tee", "verify", "--report=report.cert"])).unwrap();
assert_eq!(parse_flag(&a, "--report"), Some("report.cert"));
// tee verify 依然可以用全局格式参数(text/json 仍是格式)。
let (a, j) = split_report_flag(&v(&["tee", "verify", "--report", "json"])).unwrap();
assert!(j);
assert_eq!(a, v(&["tee", "verify"]));
// 其它子命令不受影响:非格式值仍然报错。
assert!(split_report_flag(&v(&["fl", "--report", "report.cert"])).is_err());
}
}
+167 -12
View File
@@ -44,6 +44,32 @@
//!
//! 两者不是一回事,**不能用其中一个去校验另一个相等**。这里对后者只做「非全零」
//! 的存在性检查,前者通过 `measurement` 参数与绑定值做定长 pin 比较。
//!
//! # CSV 报告的字段被 anonce 混淆,必须先还原
//!
//! 海光 CSV 的固件报告把若干字段与一个 32 位随机数 `anonce` 异或后再落盘,
//! 防止旁路直接读出明文。厂商 SDK 的还原写法(`csv_sdk/csv_status.c`)是
//! **按 u32 数组逐个异或**:
//!
//! ```c
//! ((uint32_t *)g_user_data)[i] = ((uint32_t *)report.user_data)[i] ^ report.anonce;
//! ((uint32_t *)g_mnonce)[i] = ((uint32_t *)report.mnonce)[i] ^ report.anonce;
//! ((uint32_t *)g_measure)[i] = ((uint32_t *)report.measure.block)[i] ^ report.anonce;
//! ((uint32_t *)&g_pek_cert)[i] = ((uint32_t *)&report.pek_cert)[i] ^ report.anonce;
//! ((uint32_t *)g_chip_id)[i] = ((uint32_t *)report.sn)[i] ^ report.anonce;
//! ```
//!
//! 被混淆的字段:`user_data` / `mnonce` / `measure` / `pek_cert` / `sn`。
//! **未**被混淆的字段:`policy` / `sig_usage` / `sig_algo` / `anonce` 本身 / `sig1`。
//!
//! 这一步是硬要求:直接在报告原始字节上比对会话绑定值**必然失败**。
//! 真机实测(`192.168.1.102` 采集的真实 2548 字节报告,`anonce = c96e190d`):
//! 原始 `user_data` 是 `786a0bbb…`,异或还原后是 `757365722064617461`(即
//! "user data"),与官方验签器打印的 userdata 完全一致。
//!
//! `anonce` 自身位于报告 `0xBC`,是**未混淆的原值**(SDK 直接拿它做 XOR 密钥)。
//!
//! SNP 没有这层混淆(`report_data` 就是明文),所以还原只对 CSV 生效。
use crate::session::{verify_bound_attestation, SessionBinding};
use crate::{Attestation, PlatformKind, TeeError};
@@ -87,6 +113,12 @@ pub struct ReportLayout {
pub signature_offset: usize,
/// 签名字段长度。
pub signature_len: usize,
/// 混淆密钥 `anonce` 的偏移;`None` 表示此平台的报告不做字段混淆。
///
/// CSV 报告把 `user_data` / `mnonce` / `measure` / `pek_cert` / `sn` 与
/// `anonce` 异或后落盘,解析前必须还原;SNP 的 `report_data` 是明文,
/// 这里为 `None`。
pub anonce_offset: Option<usize>,
}
/// AMD SEV-SNP(qemu 9.x / 固件 `sev-snp-guest`)的固件报告布局。
@@ -104,6 +136,7 @@ pub const fn snp_layout() -> ReportLayout {
policy_len: 8,
signature_offset: SNP_REPORT_LEN - 512,
signature_len: 512,
anonce_offset: None,
}
}
@@ -116,11 +149,15 @@ pub const fn snp_layout() -> ReportLayout {
/// - `user_data` @0x40(64B 挑战值)、`mnonce` @0x80(16B,框架不用)
/// - `measure` @0x90(32B SM3 度量)、`policy` @0xB0(4B)
/// - `sig1` @0xC0(144B ECC 签名,`ECC_POINT_SIZE*2`)、`pek_cert` @0x150
/// - `anonce` @0xBC(4B,混淆密钥,**本身不被混淆**)
/// - `sizeof(struct)` = **2548**,`get-attestation` 写出的就是 2548 字节
/// - 结构体内**没有** `version` 字段 → `version_offset: None` 成立
///
/// hypercall/mmap 用 4096 一页,但报告结构体本身 2548 字节;解析按 2548 做下限,
/// 4096 的页填充文件同样接受。签名算法 / ECC 曲线语义仍交给验签器按芯片规范解析。
///
/// 注意 `user_data` / `mnonce` / `measure` / `pek_cert` / `sn` 都与 `anonce`
/// 异或混淆,解析时由 [`deobfuscate_csv_field`] 还原。
pub const fn hygon_csv_layout() -> ReportLayout {
ReportLayout {
total_len: CSV_REPORT_LEN,
@@ -132,6 +169,7 @@ pub const fn hygon_csv_layout() -> ReportLayout {
policy_len: 4,
signature_offset: 0xC0,
signature_len: 144,
anonce_offset: Some(0xBC),
}
}
@@ -161,6 +199,32 @@ fn ct_eq_bytes(a: &[u8], b: &[u8]) -> bool {
diff == 0
}
/// 按海光 CSV 的规则还原被 `anonce` 混淆的字段。
///
/// 厂商 SDK 的写法是**按 u32 数组逐个异或**(`csv_sdk/csv_status.c`):
/// `((uint32_t *)dst)[i] = ((uint32_t *)src)[i] ^ report.anonce;`
///
/// 因此:
/// - 缓冲区长度必须是 4 的倍数,否则 SDK 语义无从谈起;
/// - 末尾不足 4 字节的尾巴按 SDK 的 `uint32_t` 数组语义处理不可靠,这里直接报错,
/// 不做「尽力而为」的补齐——宁可拒绝,也不要给出一个可能错误的明文。
///
/// `anonce` 取自报告 `anonce_offset`,是**未混淆的原值**。
pub fn deobfuscate_csv_field(field: &[u8], anonce: u32) -> Result<Vec<u8>, TeeError> {
if field.len() % 4 != 0 {
return Err(TeeError::AttestFailed(format!(
"混淆字段长度 {} 不是 4 的倍数,无法按 u32 数组还原",
field.len()
)));
}
let mut out = Vec::with_capacity(field.len());
for chunk in field.chunks_exact(4) {
let v = u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]) ^ anonce;
out.extend_from_slice(&v.to_le_bytes());
}
Ok(out)
}
/// 芯片签名/证书链的判定结果。
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ChipVerdict {
@@ -218,12 +282,27 @@ pub fn parse_sev_like_report(report: &[u8], layout: &ReportLayout) -> Result<Sev
None => 0,
};
let mut user_data = [0u8; 64];
user_data.copy_from_slice(&report[layout.user_data_offset..layout.user_data_offset + 64]);
// 混淆还原:CSV 的 user_data / measure 与 anonce 异或,SNP 无此层。
// anonce 本身不被混淆,直接取原值。
let anonce = match layout.anonce_offset {
Some(off) => u32_le(&report[off..off + 4]),
None => 0,
};
let restore = |bytes: &[u8]| -> Result<Vec<u8>, TeeError> {
if layout.anonce_offset.is_none() {
return Ok(bytes.to_vec());
}
deobfuscate_csv_field(bytes, anonce)
};
let measurement = report
[layout.measurement_offset..layout.measurement_offset + layout.measurement_len]
.to_vec();
let user_data_raw = &report[layout.user_data_offset..layout.user_data_offset + 64];
let user_data_bytes = restore(user_data_raw)?;
let mut user_data = [0u8; 64];
user_data.copy_from_slice(&user_data_bytes);
let measurement = restore(
&report[layout.measurement_offset..layout.measurement_offset + layout.measurement_len],
)?;
if measurement.iter().all(|b| *b == 0) {
return Err(TeeError::AttestFailed(String::from(
"launch measurement 全零,报告不完整",
@@ -473,10 +552,31 @@ mod tests {
/// CSV 报告 fixture:真实尺寸 2548 字节(`sizeof(struct csv_attestation_report)`,
/// 在 192.168.1.102 用海光厂商 SDK 头文件经 gcc 实测),user_data@0x40 =
/// 调用方挑战值,measure@0x90 与 sig1@0xC0 非零。版本号不在报告体内,故不构造。
///
/// **真实 CSV 报告里 user_data / measure 是与 `anonce` 异或后的混淆值**,
/// 所以 fixture 也按混淆写入 —— 否则测的就不是真实路径了。
fn csv_fixture(user_data: &[u8; 64]) -> Vec<u8> {
csv_fixture_with_anonce(user_data, 0xc96e_190d)
}
/// 带指定 `anonce` 的 CSV fixture(异或混淆写入)。
fn csv_fixture_with_anonce(user_data: &[u8; 64], anonce: u32) -> Vec<u8> {
fn xor_in_place(dst: &mut [u8], src: &[u8], anonce: u32) {
for i in 0..dst.len() / 4 {
let v = u32::from_le_bytes([
src[i * 4],
src[i * 4 + 1],
src[i * 4 + 2],
src[i * 4 + 3],
]) ^ anonce;
dst[i * 4..i * 4 + 4].copy_from_slice(&v.to_le_bytes());
}
}
let mut r = vec![0u8; CSV_REPORT_LEN];
r[0x40..0x40 + 64].copy_from_slice(user_data);
r[0x90..0x90 + 32].fill(0x6b);
r[0xBC..0xBC + 4].copy_from_slice(&anonce.to_le_bytes());
let measure = [0x6bu8; 32];
xor_in_place(&mut r[0x40..0x40 + 64], &user_data[..], anonce);
xor_in_place(&mut r[0x90..0x90 + 32], &measure[..], anonce);
r[0xC0..0xC0 + 144].fill(0x7c);
r
}
@@ -537,11 +637,16 @@ mod tests {
let ud = [9u8; 64];
// 长度不足(真实报告 2548,这里给 100)
assert!(parse_sev_like_report(&csv_fixture(&ud)[..100], &hygon_csv_layout()).is_err());
// measure 全零
let mut r = csv_fixture(&ud);
r[0x90..0x90 + 32].fill(0);
assert!(parse_sev_like_report(&r, &hygon_csv_layout()).is_err(), "CSV measure 全零");
// 签名全零
// measure 还原后全零必须被拒:混淆区全填 anonce(0 ^ anonce = anonce)。
let mut r2 = csv_fixture(&ud);
for i in 0..8 {
r2[0x90 + i * 4..0x90 + i * 4 + 4].copy_from_slice(&0xc96e_190du32.to_le_bytes());
}
assert!(
parse_sev_like_report(&r2, &hygon_csv_layout()).is_err(),
"CSV measure 还原后全零必须被拒"
);
// 签名全零(sig1 不参与混淆)
let mut r = csv_fixture(&ud);
r[0xC0..0xC0 + 144].fill(0);
assert!(parse_sev_like_report(&r, &hygon_csv_layout()).is_err(), "CSV 签名全零");
@@ -598,6 +703,56 @@ mod tests {
assert!(check(&tampered, &b, PlatformKind::HygonCsv, None).is_err());
}
/// 真机真值回归:CSV 报告的 `user_data` / `measure` 与 `anonce` 异或混淆,
/// 解析必须先还原再比对。数据取自 `192.168.1.102` 采集的真实报告
/// (`anonce = c96e190d`),还原后 user_data 应为 ASCII "user data"。
#[test]
fn csv_fields_are_deobfuscated_with_anonce() {
let anonce = 0xc96e_190du32;
// 真实报告里 user_data 原文是 "user data" + 全零。
let mut plain = [0u8; 64];
plain[..9].copy_from_slice(b"user data");
let report = csv_fixture_with_anonce(&plain, anonce);
// 原始字节确实不是明文。
assert_ne!(&report[0x40..0x49], b"user data");
assert_eq!(
&report[0x40..0x49],
&[0x78, 0x6a, 0x0b, 0xbb, 0x2d, 0x7d, 0x0f, 0xbd, 0x6c],
"真实报告里 user_data 是混淆值"
);
// 还原后必须拿到明文。
let view = parse_sev_like_report(&report, &hygon_csv_layout()).unwrap();
assert_eq!(&view.user_data[..9], b"user data");
assert!(view.user_data[9..].iter().all(|b| *b == 0));
// measure 还原后不再全零。
assert!(!view.measurement.iter().all(|b| *b == 0));
// 换了 anonce:用错误的密钥还原就得不到明文(绑定必然不匹配)。
let other = csv_fixture_with_anonce(&plain, 0x1234_5678);
let wrong = deobfuscate_csv_field(&other[0x40..0x80], 0x1234_5678).unwrap();
// 用**别的** anonce 去还原这份报告 -> 得不到明文。
let mistaken = deobfuscate_csv_field(&other[0x40..0x80], anonce).unwrap();
assert_ne!(&wrong[..9], &mistaken[..9]);
assert_ne!(&mistaken[..9], b"user data");
}
/// SNP 报告的 `report_data` 是明文,**不能**被 CSV 的 anonce 还原逻辑影响。
#[test]
fn snp_report_data_is_not_deobfuscated() {
let (b, a) = setup(PlatformKind::SevSnp);
let view = parse_snp_report(&a.report).unwrap();
assert_eq!(view.user_data, b.user_data(PlatformKind::SevSnp, 5));
}
/// 混淆还原的边界:长度不是 4 的倍数必须拒绝,不做补齐。
#[test]
fn deobfuscate_rejects_non_multiple_of_four() {
assert!(deobfuscate_csv_field(&[1, 2, 3], 0).is_err());
assert!(deobfuscate_csv_field(&[0u8; 64], 0).is_ok());
}
#[test]
fn report_data_mismatch_is_rejected() {
let (b, mut a) = setup(PlatformKind::SevSnp);
+89 -6
View File
@@ -7,14 +7,20 @@ xop 键名经环境变量注入,PSK / seed / 根密钥由 KBS 下发(或离
## 前置物料
1. **Linux 静态 `mpc`**(macOS 上交叉编译):
仓库根的 `.cargo/config.toml` 已经配好 `x86_64-unknown-linux-musl` 段
(`rust-lld` + `link-self-contained=yes` + `+crt-static`),直接:
```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
cargo build --release -p mpc-cli --target x86_64-unknown-linux-musl
# 产物:target/x86_64-unknown-linux-musl/release/mpc(static-pie,约 1.4 MB)
```
`-C link-self-contained=no` 是必须的,否则 zig 的 crt 与 Rust 自带 crt 重复定义 `_start`。
依赖系统有 `rust-lld`(随 Rust 工具链自带),**不需要**额外的 musl gcc,
也不需要 zig。若目标机缺 `rust-lld`,退化路径是
`CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=x86_64-linux-musl-gcc`
加 `RUSTFLAGS="-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>`。
@@ -98,3 +104,80 @@ python3 deploy/tee/real-machine/csv-report-check.py --report report.cert \
脚本只做**布局与 `user_data` 绑定**核对,不验签;`sig1` / `pek_cert` 的签名与
证书链交给厂商 `verify-attestation` 或 `mpc tee verify` 的外部验签器。
脚本兼容 Python 3.6(海光节点自带版本),不依赖第三方库。
## 海光 CSV 真实报告:捕获 → 还原 → 验签(端到端)
这一整套在 `192.168.1.102` 上实测跑通,产物可复现。
### 1. 采一份真实报告
```bash
./capture-csv-report.sh --mpc /path/to/mpc-linux --out /tmp/csv-report3
```
做三件事:造一个专门取报告的 initrd → 用**框架原生 argv**(`mpc tee plan --argv`)
direct boot 一个 CSV guest → 从串口日志里提取报告十六进制还原成 `report.cert`。
产出 `report.cert`(2548 字节)、`node`(节点描述)、`plan.json`(框架 argv)、
`session.env`(**本次采集用的会话参数**,验证脚本从这里读,不靠人手抄)。
### 2. CSV 字段被 anonce 混淆,必须先还原
厂商 SDK 把 `user_data` / `mnonce` / `measure` / `pek_cert` / `sn` 与 `anonce`
**按 u32 数组逐个异或**后落盘;`anonce`@0xBC 本身是原值。
不还原就拿混淆值去比对绑定值,**永远对不上**,而且报错会指向「疑似重放报告」。
```bash
python3 csv-report-restore.py --report report.cert --field user_data --json
python3 csv-report-restore.py --report report.cert --field all
python3 csv-report-restore.py --selftest # 用真机实测值自检
```
### 3. 取报告的 ioctl 契约
报告必须在 **CSV guest 内**用 ioctl 取(宿主机没有 `/dev/csv-guest`):
- `GET_ATTESTATION_REPORT = _IOWR('D', 1, struct csv_guest_mem)`,
`struct csv_guest_mem { unsigned long va; int size; }`
- 用户态缓冲区 = **整页 4096 字节**,前 112 字节是
`user_data[64] + mnonce[16] + hash_block[32]`,`hash = SM3(user_data || mnonce)`
- 固件在**同一缓冲区**就地写回 2548 字节报告 → `size` 必须 ≥ 2548
(缓冲区只给 112 字节会报 `EFAULT`/Bad address,它要回写 2548 字节)
厂商 `get-attestation` 把挑战值**写死成 ASCII `"user data"`**,报告因此无法与框架
会话绑定对上。`csv-attest-request.c` 支持自定义挑战值
(`--user-data HEX64`),并**自带 SM3 实现**(guest rootfs 无 `openssl/sm3.h`),
已用 GB/T 32905-2016 两个标准向量验证。
### 4. 官方验签器:四个坑
`csv-verify-attestation.sh` 是厂商 `verify-attestation` 的 wrapper,坑都堵在这里:
| 坑 | 现象 | 处置 |
|---|---|---|
| 退出码恒为 0 | 失败也返回 0 | 按 stdout 文本判定 |
| 报告路径写死 | 固定读 `./report.cert` | 工作目录里放 `report.cert` |
| 离线证书 fallback 只在自己所在目录 | `dirname(readlink("/proc/self/exe"))` | 把二进制复制到工作目录再执行 |
| **对截断报告 fail-open** | 1000 字节截断报告照样打印 "verify success" | **wrapper 层自卡长度**(必须 == 2548) |
另:`LD_LIBRARY_PATH=/opt/gmssl/lib` 会污染 curl(GmSSL 的 libssl 缺
`OPENSSL_1_1_1` 符号版本),官方工具自带 rpath,**不能**设这个变量。
### 5. 端到端
```bash
./verify-csv-report-e2e.sh --report-dir /tmp/csv-report3 \
--mpc /tmp/mpc-linux \
--verifier /tmp/mpc-tee-tools/csv-verify-attestation.sh \
[--chain-dir /tmp/csv-chain]
```
三步:还原 anonce → 官方验签器(芯片签名 + 证书链)→ 框架 `mpc tee verify`
(结构 + 会话绑定 + 芯片签名)。成功输出 `E2E_OK`。
会话参数默认从 `<report-dir>/session.env` 读 —— **验证方必须用采集时那一组参数**
重算绑定值。手工抄 site / measurement / tcb 是绑定对不上的头号来源,而那个报错
会误导成重放攻击。
> `mpc tee verify` 也支持 `--node <节点描述>`:site / measurement / tcb / platform
> 默认全部取自它,与 `tee plan` 读同一份真相源。
+88
View File
@@ -0,0 +1,88 @@
#!/usr/bin/env bash
# CSV 证明采集 guest 的 /init:在 CSV guest 内取真实 attestation 报告并回传。
#
# 用途:验证框架对海光 CSV 固件报告的字节布局假设(deploy/tee/real-machine/csv-report-check.py),
# 并为外部验签器提供真实报告样本。
#
# 为什么必须进 guest:海光 CSV 的报告由 guest 内的 vmmcall / csv-guest 驱动签发,
# 宿主机没有 /dev/csv-guest(主机上跑 get-attestation 会 open 失败)。
#
# 挑战值:优先用**框架钉死的会话绑定值**(内核参数 mpc.tee.user_data=),
# 这样取到的报告就能直接与框架的会话绑定对上(vendor get-attestation 把挑战值
# 写死成 "user data",只能做布局对照、不能做绑定验证)。
#
# 依赖(由构建脚本注入 rootfs):
# /bin/csv-attest-request 本仓库的取报告工具(挑战值可自定义)
# /bin/get-attestation 海光厂商 SDK 的 vmmcall 版(备用 / 对照)
# /opt/mpc/csv-report-check.py 本仓库的 CSV 报告布局校验器
#
# 产出:
# 串口输出 report.cert 的十六进制(HEX_REPORT_BEGIN/END 之间),由宿主脚本提取;
# 同时把报告留在 guest 内 /report.cert 供后续验签器使用。
set -u
BB=/bin/busybox
[ -x "$BB" ] || BB=/bin/sh
mount -t proc proc /proc 2>/dev/null || true
mount -t sysfs sysfs /sys 2>/dev/null || true
mount -t devtmpfs devtmpfs /dev 2>/dev/null || true
echo "===== MPC CSV ATTEST GUEST ====="
echo "kernel: $(uname -r 2>/dev/null)"
echo "cmdline: $(cat /proc/cmdline 2>/dev/null)"
if [ -e /dev/csv-guest ]; then
echo "csv-guest device: present"
else
echo "csv-guest device: ABSENT (无法签发报告)"
fi
cd /tmp || exit 1
# 从 /proc/cmdline 取框架钉死的会话绑定值。
UD=""
for tok in $(cat /proc/cmdline 2>/dev/null); do
case "$tok" in
mpc.tee.user_data=*) UD="${tok#mpc.tee.user_data=}" ;;
esac
done
if [ -n "$UD" ]; then
echo "session binding user_data = $UD"
else
echo "no mpc.tee.user_data in cmdline -> fallback to vendor default challenge"
fi
echo "--- request attestation (challenge from cmdline) ---"
if [ -x /bin/csv-attest-request ] && [ -n "$UD" ]; then
/bin/csv-attest-request --user-data "$UD" --out /tmp/report.cert
echo "csv-attest-request rc=$?"
elif [ -x /bin/get-attestation ]; then
/bin/get-attestation
echo "get-attestation rc=$?"
else
echo "NO attestation tool available"
fi
if [ -f /tmp/report.cert ]; then
echo "--- report size ---"
wc -c /tmp/report.cert
cp /tmp/report.cert /report.cert 2>/dev/null || true
echo "--- restored user_data (anonce deobfuscated) ---"
if [ -x /usr/bin/python3 ] && [ -f /opt/mpc/csv-report-restore.py ]; then
python3 /opt/mpc/csv-report-restore.py --report /tmp/report.cert --field user_data 2>&1 || true
fi
echo "--- report hex dump for host extraction ---"
echo "HEX_REPORT_BEGIN"
od -An -v -tx1 /tmp/report.cert | tr -d ' \n'
echo ""
echo "HEX_REPORT_END"
else
echo "NO report.cert produced"
fi
echo "===== MPC CSV ATTEST GUEST DONE ====="
sync
sleep 1
poweroff -f 2>/dev/null || halt -f 2>/dev/null || true
+83
View File
@@ -0,0 +1,83 @@
#!/usr/bin/env bash
# 构建「CSV 证明采集 guest」的 initrd:厂商 CSV guest rootfs + 我们的 /init。
#
# 为什么不自己拼 alpine rootfs:厂商 get-attestation 是 glibc 动态链接,
# musl 的 alpine guest 跑不起来。这里直接用 CoCo 的 CSV initrd 当 rootfs
# (Ubuntu 20.04 / glibc 2.31),只替换 /init,注入取报告工具。
#
# 素材(均在 192.168.1.102 上):
# KATA_CSV_INITRD 默认 /opt/confidential-containers/share/kata-containers/kata-containers-initrd-csv-hygon-gpu.img.offline_fs_kbc
# GET_ATTESTATION 默认 /opt/hygon/csv/attestation/get-attestation(vmmcall 版)
#
# 用法(**在海光节点上执行**):
# ./build-attest-initrd.sh --out /tmp/mpc-attest-initrd.img [--tools-dir DIR]
#
# --tools-dir 指向存放 csv-report-check.py 与 attest-init.sh 的目录(默认本脚本所在目录)。
set -eu
KATA_CSV_INITRD=${KATA_CSV_INITRD:-/opt/confidential-containers/share/kata-containers/kata-containers-initrd-csv-hygon-gpu.img.offline_fs_kbc}
GET_ATTESTATION=${GET_ATTESTATION:-/opt/hygon/csv/attestation/get-attestation}
OUT=/tmp/mpc-attest-initrd.img
WORK=/tmp/mpc-attest-build
SELF_DIR=$(cd "$(dirname "$0")" && pwd)
while [ $# -gt 0 ]; do
case "$1" in
--out) OUT=${2:?}; shift 2 ;;
--tools-dir) SELF_DIR=${2:?}; shift 2 ;;
*) echo "未知参数: $1" >&2; exit 2 ;;
esac
done
[ -r "$KATA_CSV_INITRD" ] || { echo "找不到 CSV guest initrd: $KATA_CSV_INITRD" >&2; exit 1; }
[ -x "$GET_ATTESTATION" ] || { echo "找不到 get-attestation: $GET_ATTESTATION" >&2; exit 1; }
rm -rf "$WORK"
mkdir -p "$WORK/root"
echo "=== 解包 CSV guest rootfs ==="
( cd "$WORK/root" && zcat "$KATA_CSV_INITRD" | cpio -idm --quiet )
echo "rootfs 解包完成: $(du -sh "$WORK/root" | cut -f1)"
echo "=== 注入 get-attestation(vmmcall 版) ==="
mkdir -p "$WORK/root/bin"
cp "$GET_ATTESTATION" "$WORK/root/bin/get-attestation"
chmod 755 "$WORK/root/bin/get-attestation"
echo "=== 注入 csv-attest-request(挑战值可自定义) ==="
# 厂商 get-attestation 把挑战值写死成 "user data",无法与框架会话绑定对上;
# csv-attest-request 用同样的 ioctl 契约但允许传入框架算出的 64 字节绑定值。
# 编译在宿主完成:guest rootfs 是 Ubuntu/glibc,宿主上也是 glibc,动态链接即可。
# 优先静态(不依赖 guest 里的 libc 版本),静态不可用时退回动态。
ATTEST_REQ_SRC="$SELF_DIR/csv-attest-request.c"
if [ -r "$ATTEST_REQ_SRC" ] && command -v gcc >/dev/null 2>&1; then
gcc -O2 -static -o "$WORK/root/bin/csv-attest-request" "$ATTEST_REQ_SRC" 2>/dev/null \
&& echo "csv-attest-request 编译完成(静态)" \
|| { gcc -O2 -o "$WORK/root/bin/csv-attest-request" "$ATTEST_REQ_SRC" \
&& echo "csv-attest-request 编译完成(动态链接)"; }
chmod 755 "$WORK/root/bin/csv-attest-request"
fi
echo "=== 注入本仓库的 CSV 报告校验器 ==="
mkdir -p "$WORK/root/opt/mpc"
cp "$SELF_DIR/csv-report-check.py" "$WORK/root/opt/mpc/csv-report-check.py"
cp "$SELF_DIR/csv-report-restore.py" "$WORK/root/opt/mpc/csv-report-restore.py"
chmod 755 "$WORK/root/opt/mpc/csv-report-check.py" "$WORK/root/opt/mpc/csv-report-restore.py"
# CoCo 的 initrd 里 /init 可能是指向 systemd 的符号链接,直接 cp 会报
# "Text file busy"(写正在被占用的 inode)。先摘掉再写。
echo "--- 原 /init ---"
ls -l "$WORK/root/init" 2>/dev/null || echo "(无 /init)"
rm -f "$WORK/root/init"
cp "$SELF_DIR/attest-init.sh" "$WORK/root/init"
chmod 755 "$WORK/root/init"
echo "=== 替换 /init(备份原 systemd init) ==="
[ -e "$WORK/root/sbin/init" ] && mv "$WORK/root/sbin/init" "$WORK/root/sbin/init.orig" || true
# systemd 相关的 unit 不再需要,但保留目录结构无害
echo "=== 打包 initrd ==="
( cd "$WORK/root" && find . | cpio -o -H newc --quiet | gzip -9 > "$OUT" )
ls -lh "$OUT"
echo "=== initrd 顶层检查(应含 init / bin/get-attestation / opt/mpc) ==="
gzip -dc "$OUT" | cpio -t 2>/dev/null | grep -E '^\./?(init|bin/get-attestation|opt/mpc/csv-report-check.py)$' | head -5 || true
echo "BUILD_OK: $OUT"
+193
View File
@@ -0,0 +1,193 @@
#!/usr/bin/env bash
# 在海光 CSV 节点上启动「证明采集 guest」,取出真实 attestation 报告并回传宿主。
#
# 流程:
# 1. 用 build-attest-initrd.sh 造一个专门取报告的 initrd(Ubuntu/glibc + get-attestation);
# 2. 用**框架原生 argv**(mpc tee plan --argv)direct boot 一个 CSV guest
# ——框架负责 CSV 专属参数(cbitpos=47 / policy / pflash 固件 / kernel-hashes=on),
# 部署层只补串口与内存后端,**不覆盖**框架的 -machine / -object / 固件参数;
# 3. 从串口日志里提取 guest 输出的报告十六进制,还原成 report.cert;
# 4. 用 csv-report-check.py 按已验证的 2548 布局做字段级核对。
#
# 用法(**在海光节点 192.168.1.102 上执行**):
# ./capture-csv-report.sh --mpc /path/to/mpc --out /tmp/csv-report
#
# 环境变量:
# MPC_TEE_MPC_BIN 静态 mpc 二进制(默认 mpc)
# MPC_CSV_KERNEL CSV guest 内核(默认 CoCo 的 vmlinuz-5.10.134-102cc-csv-hygon-gpu)
# MPC_CSV_FIRMWARE CSV 固件(默认 CoCo 的 HYGONCSV.fd)
# MPC_CSV_QEMU qemu(默认 CoCo 的 kata-static qemu)
# MPC_CSV_TIMEOUT 超时秒数(默认 120)
set -eu
SELF_DIR=$(cd "$(dirname "$0")" && pwd)
MPC=${MPC_TEE_MPC_BIN:-mpc}
KERNEL=${MPC_CSV_KERNEL:-/opt/confidential-containers/share/kata-containers/vmlinuz-5.10.134-102cc-csv-hygon-gpu}
FIRMWARE=${MPC_CSV_FIRMWARE:-/opt/confidential-containers/share/ovmf/HYGONCSV.fd}
QEMU=${MPC_CSV_QEMU:-/opt/confidential-containers/bin/qemu-system-x86_64}
TIMEOUT=${MPC_CSV_TIMEOUT:-120}
OUTDIR=/tmp/csv-report
SESSION_ID=$(printf 'ab%.0s' $(seq 1 32))
PUBKEY=$(printf 'cd%.0s' $(seq 1 32))
while [ $# -gt 0 ]; do
case "$1" in
--mpc) MPC=${2:?}; shift 2 ;;
--out) OUTDIR=${2:?}; shift 2 ;;
--timeout) TIMEOUT=${2:?}; shift 2 ;;
*) echo "未知参数: $1" >&2; exit 2 ;;
esac
done
mkdir -p "$OUTDIR"
INITRD="$OUTDIR/attest-initrd.img"
NODE="$OUTDIR/node"
echo "===== 1. 构建 attestation initrd ====="
KATA_CSV_INITRD=${KATA_CSV_INITRD:-/opt/confidential-containers/share/kata-containers/kata-containers-initrd-csv-hygon-gpu.img.offline_fs_kbc}
BUILD_LOG="$OUTDIR/build.log"
set +e
KATA_CSV_INITRD="$KATA_CSV_INITRD" GET_ATTESTATION=${GET_ATTESTATION:-/opt/hygon/csv/attestation/get-attestation} \
"$SELF_DIR/build-attest-initrd.sh" --out "$INITRD" --tools-dir "$SELF_DIR" > "$BUILD_LOG" 2>&1
BRC=$?
set -e
tail -25 "$BUILD_LOG"
if [ "$BRC" != "0" ] || [ ! -s "$INITRD" ]; then
echo "initrd 构建失败 (rc=$BRC),完整日志: $BUILD_LOG"
exit 2
fi
echo "===== 2. 写节点描述 ====="
# measurement 用 initrd 的真实 sha256 —— 框架准入要求 node.measurement 与会话绑定一致,
# 且不允许「未 pin」(全 0)。这里 pin 的是本次采集用的 initrd 实际摘要。
INITRD_SHA=$(sha256sum "$INITRD" | cut -d' ' -f1)
echo "initrd sha256 = $INITRD_SHA"
cat > "$NODE" <<EOF
site=bob
host=127.0.0.1
kind=hygon-csv
tcb=3
device_present=true
qemu_present=true
firmware_present=true
image_present=true
kbc=offline
kbs_reachable=false
measurement=$INITRD_SHA
qemu=$QEMU
firmware=$FIRMWARE
kernel=$KERNEL
initrd=$INITRD
EOF
cat "$NODE"
echo "===== 3. 框架原生 argv ====="
"$MPC" --report json tee plan --node "$NODE" --session-id "$SESSION_ID" --pubkey "$PUBKEY" --min-tcb 3 --argv > "$OUTDIR/plan.json" 2>&1 || {
echo "tee plan 失败:"; tail -5 "$OUTDIR/plan.json"; exit 2; }
# 把本次采集用的会话参数落成一份可被校验脚本读取的清单。
# 验证方必须用**采集时**的同一组参数重算绑定值 —— 这里固化的就是那组参数,
# 验证脚本从本文件读,不靠人手抄,避免「参数抄错 → 报疑似重放」这种误导。
cat > "$OUTDIR/session.env" <<EOF
SESSION_ID=$SESSION_ID
PUBKEY=$PUBKEY
SITE=bob
TCB=3
MEASUREMENT=$INITRD_SHA
NODE=$NODE
EOF
cat "$OUTDIR/session.env"
python3 - "$OUTDIR/plan.json" "$OUTDIR/argv.txt" <<'PY'
import json, sys
plan, out = sys.argv[1], sys.argv[2]
argv = None
for line in open(plan, encoding="utf-8", errors="replace"):
line = line.strip()
if not line.startswith("{"):
continue
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")
sys.exit(2)
# 部署层只补串口与内存后端;不碰 -machine / -object / 固件 / -cpu / -smp
i = argv.index("-append") + 1
argv[i] += " console=ttyS0 earlyprintk=serial"
argv += ["-object", "memory-backend-ram,id=dimm1,size=2048M",
"-numa", "node,memdev=dimm1", "-no-reboot"]
with open(out, "w", encoding="utf-8") as f:
f.write("\n".join(argv) + "\n")
print("argv %d args" % len(argv))
for a in argv:
print(" " + a)
PY
echo "===== 4. 启动 CSV guest(最多 ${TIMEOUT}s) ====="
LOG="$OUTDIR/guest.log"
: > "$LOG"
# 注意:不能用 `xargs -0 <qemu> <args...>` —— xargs 会把 argv.txt 里的 argv[0]
# 再追加一次,qemu 于是把「自己」当成磁盘镜像去 open,报
# "Could not open '/path/qemu': Text file busy"。这里用 python 做真正的 exec。
set +e
timeout "$TIMEOUT" python3 -c '
import os, sys
argv = [a for a in open(sys.argv[1]).read().split("\n") if a]
os.execv(argv[0], argv)
' "$OUTDIR/argv.txt" > "$LOG" 2>&1
GRC=$?
set -e
echo "qemu rc=$GRC"
tail -30 "$LOG"
echo "===== 5. 提取报告 ====="
python3 - "$LOG" "$OUTDIR/report.cert" <<'PY'
import binascii, sys
log, out = sys.argv[1], sys.argv[2]
data = open(log, "rb").read().decode("utf-8", "replace")
if "HEX_REPORT_BEGIN" not in data:
sys.stderr.write("串口日志里没有 HEX_REPORT_BEGIN —— guest 没产出报告\n")
sys.exit(1)
seg = data.split("HEX_REPORT_BEGIN", 1)[1].split("HEX_REPORT_END", 1)[0]
hexs = "".join(seg.split())
try:
raw = binascii.unhexlify(hexs)
except Exception as e:
sys.stderr.write("报告十六进制解码失败: %s\n" % e)
sys.exit(1)
open(out, "wb").write(raw)
print("报告已写出: %s (%d 字节)" % (out, len(raw)))
if len(raw) != 2548:
print("注意: 长度 %d != 2548(sizeof(struct csv_attestation_report))" % len(raw))
PY
echo "===== 6. 按已验证布局核对 ====="
python3 "$SELF_DIR/csv-report-check.py" --report "$OUTDIR/report.cert" || true
echo
echo "===== 7. 还原 anonce 混淆并比对会话绑定 ====="
# CSV 报告的 user_data / measure 被 anonce 异或混淆,必须还原后才能与框架
# 钉死的会话绑定值比对。
python3 - "$OUTDIR/report.cert" "$SELF_DIR/csv-report-restore.py" <<'PY'
import json, subprocess, sys
report, tool = sys.argv[1], sys.argv[2]
out = subprocess.check_output([sys.executable, tool, "--report", report,
"--field", "user_data", "--json"])
ud = json.loads(out)["user_data"]["hex"]
print("还原后的 user_data = %s" % ud)
open(report + ".user_data", "w").write(ud + "\n")
PY
echo
echo "产物: $OUTDIR/report.cert"
echo "官方验签器(退出码恒 0,看 stdout 文本):"
echo " cd $OUTDIR && /opt/hygon/csv/attestation/verify-attestation false"
echo "框架验签(结构 + 会话绑定 + 芯片签名):"
echo " mpc tee verify --report $OUTDIR/report.cert --platform csv --user-data <还原后的值> ..."
echo "CAPTURE_DONE"
@@ -0,0 +1,313 @@
/*
* csv-attest-request —— 海光 CSV guest 内取证明报告,**挑战值可自定义**。
*
* 为什么不用厂商的 get-attestation:它把挑战值写死成 ASCII "user data",
* 报告里的 user_data 就永远是那串固定字节,**无法与框架的会话绑定值对上**,
* 也就没法验证「这份报告确实是本轮会话的」。本工具按同样的 ioctl 契约,
* 把调用方给的 64 字节挑战值原样递给固件。
*
* ioctl 契约(来自 /opt/hygon/csv/attestation/csv-guest.c 与
* csv_sdk/ioctl_get_attestation_report.c):
* - 设备:/dev/csv-guest(misc device,mode 0777)
* - cmd :GET_ATTESTATION_REPORT = _IOWR('D', 1, struct csv_guest_mem)
* - struct csv_guest_mem { unsigned long va; int size; }
* - 用户态缓冲区:一整页 4096 字节,前 112 字节布局为
* user_data[64] + mnonce[16] + hash_block[32]
* 其中 hash = SM3(user_data[64] || mnonce[16]),
* 固件在同一个缓冲区里就地写回完整报告
* (sizeof(struct csv_attestation_report) = 2548 字节)。
*
* SM3 自行实现(GB/T 32905-2016),不依赖 openssl —— guest rootfs 里没有
* sm3.h 头文件,自带实现才能静态编进 initrd。
*
* 用法:
* csv-attest-request --user-data HEX64 [--out report.cert] [--nonce HEX32]
* csv-attest-request --user-data-from-cmdline mpc.tee.user_data=...
*
* 不带参数时沿用厂商默认挑战值 "user data",便于与 get-attestation 的行为对照。
*
* 编译:
* gcc -O2 -static -o csv-attest-request csv-attest-request.c
*/
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#define CSV_GUEST_IOC_TYPE 'D'
#define GUEST_ATTESTATION_NONCE_SIZE 16
#define GUEST_ATTESTATION_DATA_SIZE 64
#define HASH_LEN 32
#define CSV_REPORT_LEN 2548
#define PAGE_SIZE 4096
struct csv_guest_mem {
unsigned long va;
int size;
};
#define GET_ATTESTATION_REPORT \
_IOWR(CSV_GUEST_IOC_TYPE, 1, struct csv_guest_mem)
/* ------------------------------------------------------------------ */
/* SM3 (GB/T 32905-2016) */
/* ------------------------------------------------------------------ */
static uint32_t rotl32(uint32_t x, int n)
{
return (x << n) | (x >> (32 - n));
}
static uint32_t sm3_p0(uint32_t x)
{
return x ^ rotl32(x, 9) ^ rotl32(x, 17);
}
static uint32_t sm3_p1(uint32_t x)
{
return x ^ rotl32(x, 15) ^ rotl32(x, 23);
}
static const uint32_t SM3_IV[8] = {
0x7380166fu, 0x4914b2b9u, 0x172442d7u, 0xda8a0600u,
0xa96f30bcu, 0x163138aau, 0xe38dee4du, 0xb0fb0e4eu
};
/* SM3 的 T 常量只有两个:第 0..15 轮用 0x79cc4519,第 16..63 轮用 0x7a879d8a。 */
#define SM3_T0 0x79cc4519u
#define SM3_T1 0x7a879d8au
static void sm3_block(uint32_t *V, const uint8_t *block)
{
uint32_t W[68];
uint32_t W1[64];
uint32_t A, B, C, D, E, F, G, H;
int i;
for (i = 0; i < 16; i++)
W[i] = ((uint32_t)block[i * 4] << 24) |
((uint32_t)block[i * 4 + 1] << 16) |
((uint32_t)block[i * 4 + 2] << 8) |
((uint32_t)block[i * 4 + 3]);
for (i = 16; i < 68; i++) {
/* W[j] = P1(W[j-16] ^ W[j-9] ^ rotl(W[j-3], 15)) ^ rotl(W[j-13], 7) ^ W[j-6] */
uint32_t x = W[i - 16] ^ W[i - 9] ^ rotl32(W[i - 3], 15);
W[i] = sm3_p1(x) ^ rotl32(W[i - 13], 7) ^ W[i - 6];
}
for (i = 0; i < 64; i++)
W1[i] = W[i] ^ W[i + 4];
A = V[0]; B = V[1]; C = V[2]; D = V[3];
E = V[4]; F = V[5]; G = V[6]; H = V[7];
for (i = 0; i < 64; i++) {
uint32_t SS1, SS2, TT1, TT2, T;
uint32_t FF = (i < 16) ? (A ^ B ^ C) : ((A & B) | (A & C) | (B & C));
uint32_t GG = (i < 16) ? (E ^ F ^ G) : ((E & F) | ((~E) & G));
T = (i < 16) ? SM3_T0 : SM3_T1;
SS1 = rotl32(rotl32(A, 12) + E + rotl32(T, i % 32), 7);
SS2 = SS1 ^ rotl32(A, 12);
TT1 = FF + D + SS2 + W1[i];
TT2 = GG + H + SS1 + W[i];
D = C;
C = rotl32(B, 9);
B = A;
A = TT1;
H = G;
G = rotl32(F, 19);
F = E;
E = sm3_p0(TT2);
}
V[0] ^= A; V[1] ^= B; V[2] ^= C; V[3] ^= D;
V[4] ^= E; V[5] ^= F; V[6] ^= G; V[7] ^= H;
}
/* SM3 摘要(输入长度 < 2^29 字节,单块/多块均支持)。 */
static void sm3(const uint8_t *data, size_t len, uint8_t out[32])
{
uint32_t V[8];
uint8_t block[64];
size_t i;
uint64_t bitlen = (uint64_t)len * 8;
size_t off;
memcpy(V, SM3_IV, sizeof(V));
for (off = 0; off + 64 <= len; off += 64)
sm3_block(V, data + off);
memset(block, 0, sizeof(block));
{
size_t rem = len - off;
memcpy(block, data + off, rem);
block[rem] = 0x80;
if (rem + 1 + 8 > 64) {
sm3_block(V, block);
memset(block, 0, sizeof(block));
}
for (i = 0; i < 8; i++)
block[56 + i] = (uint8_t)(bitlen >> (56 - 8 * i));
sm3_block(V, block);
}
for (i = 0; i < 8; i++) {
out[i * 4] = (uint8_t)(V[i] >> 24);
out[i * 4 + 1] = (uint8_t)(V[i] >> 16);
out[i * 4 + 2] = (uint8_t)(V[i] >> 8);
out[i * 4 + 3] = (uint8_t)V[i];
}
}
/* ------------------------------------------------------------------ */
static int hex2bin(const char *hex, unsigned char *out, size_t out_len)
{
size_t i;
size_t n = strlen(hex);
if (n != out_len * 2)
return -1;
for (i = 0; i < out_len; i++) {
unsigned int v;
char b[3] = { hex[i * 2], hex[i * 2 + 1], 0 };
if (sscanf(b, "%02x", &v) != 1)
return -1;
out[i] = (unsigned char)v;
}
return 0;
}
static void usage(const char *p)
{
fprintf(stderr,
"用法: %s [--user-data HEX64] [--out FILE] [--nonce HEX32]\n"
" %s --user-data-from-cmdline KEY\n",
p, p);
}
int main(int argc, char **argv)
{
/* 一整页:固件在同一个缓冲区里就地写回 2548 字节报告。 */
static unsigned char buf[PAGE_SIZE];
unsigned char *ud = buf;
unsigned char *nonce = buf + GUEST_ATTESTATION_DATA_SIZE;
unsigned char *hash = buf + GUEST_ATTESTATION_DATA_SIZE + GUEST_ATTESTATION_NONCE_SIZE;
const char *out_path = "report.cert";
const char *ud_hex = NULL;
const char *nonce_hex = NULL;
const char *cmdline_key = NULL;
struct csv_guest_mem mem;
int fd, i, rc = 1;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "--user-data") && i + 1 < argc) {
ud_hex = argv[++i];
} else if (!strcmp(argv[i], "--nonce") && i + 1 < argc) {
nonce_hex = argv[++i];
} else if (!strcmp(argv[i], "--out") && i + 1 < argc) {
out_path = argv[++i];
} else if (!strcmp(argv[i], "--user-data-from-cmdline") && i + 1 < argc) {
cmdline_key = argv[++i];
} else {
usage(argv[0]);
return 2;
}
}
memset(buf, 0, sizeof(buf));
if (cmdline_key) {
FILE *f = fopen("/proc/cmdline", "r");
char line[4096];
size_t klen = strlen(cmdline_key);
int found = 0;
if (!f) {
fprintf(stderr, "打不开 /proc/cmdline: %s\n", strerror(errno));
return 1;
}
if (!fgets(line, sizeof(line), f)) {
fclose(f);
fprintf(stderr, "读 /proc/cmdline 失败\n");
return 1;
}
fclose(f);
{
char *save = NULL;
char *tok = strtok_r(line, " \t\n", &save);
while (tok) {
if (!strncmp(tok, cmdline_key, klen) && tok[klen]) {
ud_hex = tok + klen;
found = 1;
break;
}
tok = strtok_r(NULL, " \t\n", &save);
}
}
if (!found) {
fprintf(stderr, "/proc/cmdline 里没有 %s=...\n", cmdline_key);
return 1;
}
}
if (ud_hex) {
if (hex2bin(ud_hex, ud, GUEST_ATTESTATION_DATA_SIZE) != 0) {
fprintf(stderr, "挑战值必须是 128 位十六进制: %s\n", ud_hex);
return 2;
}
} else {
const char *dflt = "user data";
size_t l = strlen(dflt);
memset(ud, 0, GUEST_ATTESTATION_DATA_SIZE);
memcpy(ud, dflt, l);
}
if (nonce_hex) {
if (hex2bin(nonce_hex, nonce, GUEST_ATTESTATION_NONCE_SIZE) != 0) {
fprintf(stderr, "nonce 必须是 32 位十六进制: %s\n", nonce_hex);
return 2;
}
} else {
memset(nonce, 0, GUEST_ATTESTATION_NONCE_SIZE);
}
/* hash = SM3(user_data[64] || mnonce[16]) —— 与厂商 SDK 同口径。 */
sm3(buf, GUEST_ATTESTATION_DATA_SIZE + GUEST_ATTESTATION_NONCE_SIZE, hash);
fd = open("/dev/csv-guest", O_RDWR);
if (fd < 0) {
fprintf(stderr, "打开 /dev/csv-guest 失败: %s\n", strerror(errno));
return 1;
}
mem.va = (unsigned long)buf;
mem.size = PAGE_SIZE;
if (ioctl(fd, GET_ATTESTATION_REPORT, &mem) != 0) {
fprintf(stderr, "ioctl GET_ATTESTATION_REPORT 失败: %s\n", strerror(errno));
close(fd);
return 1;
}
close(fd);
{
FILE *f = fopen(out_path, "wb");
if (!f) {
fprintf(stderr, "写 %s 失败: %s\n", out_path, strerror(errno));
return 1;
}
if (fwrite(buf, 1, CSV_REPORT_LEN, f) != CSV_REPORT_LEN) {
fprintf(stderr, "写 %s 不完整\n", out_path);
fclose(f);
return 1;
}
fclose(f);
}
fprintf(stderr, "报告已写出: %s (%d 字节)\n", out_path, CSV_REPORT_LEN);
rc = 0;
return rc;
}
+106
View File
@@ -0,0 +1,106 @@
#!/usr/bin/env python3
"""还原海光 CSV 证明报告中被 `anonce` 混淆的字段。
CSV 的固件报告把 `user_data` / `mnonce` / `measure` / `pek_cert` / `sn` 与一个
32 位随机数 `anonce` 异或后落盘(厂商 SDK `csv_sdk/csv_status.c`)。厂商验签器
在验签前会还原;我们要独立核对框架侧的解析,就用同样的规则还原一遍。
规则与 SDK 一致:**按 u32 数组逐个异或**
((uint32_t *)dst)[i] = ((uint32_t *)src)[i] ^ report.anonce;
用法:
csv-report-restore.py --report report.cert --field user_data
csv-report-restore.py --report report.cert --field all --json
兼容 Python 3.6(海光 Anolis 8.10)。
"""
import argparse
import json
import struct
import sys
REPORT_LEN = 2548 # sizeof(struct csv_attestation_report),厂商 SDK 实测
# 字段名 -> (偏移, 长度)
FIELDS = {
"user_data": (0x0040, 64),
"mnonce": (0x0080, 16),
"measure": (0x0090, 32),
"pek_cert": (0x0150, 2084),
"sn": (0x0974, 64),
}
ANONCE_OFF = 0xBC
def xor32(buf, anonce):
"""按 u32 数组逐个异或,与厂商 SDK 语义一致。"""
if len(buf) % 4 != 0:
raise ValueError("字段长度 %d 不是 4 的倍数" % len(buf))
out = bytearray(len(buf))
for i in range(len(buf) // 4):
v = struct.unpack_from("<I", buf, i * 4)[0] ^ anonce
struct.pack_into("<I", out, i * 4, v)
return bytes(out)
def restore(report, field):
anonce = struct.unpack_from("<I", report, ANONCE_OFF)[0]
off, ln = FIELDS[field]
return anonce, xor32(report[off:off + ln], anonce)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--report", help="报告原始字节文件")
ap.add_argument("--field", default="all",
help="字段名(user_data/mnonce/measure/pek_cert/sn)或 all")
ap.add_argument("--json", action="store_true", help="输出 JSON")
ap.add_argument("--selftest", action="store_true", help="自检(不需要报告文件)")
args = ap.parse_args()
if args.selftest:
# 用真机报告的实测值核对:anonce=c96e190d,user_data 混淆值 -> "user data"。
anonce = 0xC96E190D
# 真机报告里 user_data 的前 9 字节混淆值("user data" 逐字节异或 anonce)。
raw = bytes.fromhex("786a0bbb2d7d0fbd6c") + b"\x00" * 3
got = xor32(raw, anonce)[:9]
if got != b"user data":
sys.stderr.write("自检失败: 还原结果 %r\n" % got)
return 1
print("selftest ok: anonce=%08x, user_data 还原为 'user data'" % anonce)
return 0
if not args.report:
ap.error("缺少 --report(或用 --selftest)")
with open(args.report, "rb") as f:
report = f.read()
if len(report) != REPORT_LEN:
sys.stderr.write("报告长度 %d != %d(不是完整报告)\n"
% (len(report), REPORT_LEN))
return 2
names = list(FIELDS.keys()) if args.field == "all" else [args.field]
for n in names:
if n not in FIELDS:
sys.stderr.write("未知字段: %s\n" % n)
return 2
result = {}
for n in names:
anonce, val = restore(report, n)
result[n] = {"anonce": "%08x" % anonce, "hex": val.hex()}
if args.json:
print(json.dumps(result, indent=2))
else:
anonce = result[names[0]]["anonce"]
print("anonce = %s" % anonce)
for n in names:
val = result[n]["hex"]
print("%-9s %s" % (n, val[:64] + ("..." if len(val) > 64 else "")))
return 0
if __name__ == "__main__":
sys.exit(main())
+174
View File
@@ -0,0 +1,174 @@
#!/usr/bin/env bash
# CSV 芯片验签 wrapper:把海光官方 verify-attestation 的结论转成框架 ExternalVerifier 契约。
#
# 框架 `mpc_tee::verify::ExternalVerifier` 的契约(crates/mpc-tee/src/verify.rs):
# - 退出码 0 且 stdout trim 后为 `OK` 或以 `verified=true` 开头 -> 判定通过
# - 退出码非 0 或输出不是上述形式 -> 判定失败
#
# 海光官方 `verify-attestation`(/opt/hygon/csv/attestation/verify-attestation,
# 源码见 gitee.com/anolis/hygon-devkit 的 csv/attestation/)有两个坑,
# 本 wrapper 就是为绕开它们:
# 1) **退出码恒为 0**(验签失败也返回 0),所以不能只看退出码,必须看 stdout 文本;
# 2) 报告路径固定读 `./report.cert`;证书链模式下会**联网**从海光 KDS 拉
# hrk / hsk_cek(`https://cert.hygon.cn/...`),离线环境必须禁用或预置证书。
#
# 判定字符串**逐字取自官方 SDK 源码**(csv_sdk/csv_status.c 的 logcat):
# 报告验签成功 -> "verify report success" / "verify success"
# 报告验签失败 -> "verify report fail" / "SM2_do_verify fail!"
# 链校验成功 -> "validata cert chain successful"
# 链校验失败 -> "validata cert chain failed"
# MAC 完整性 -> "attestation report MAC verify success" / "... failed"
#
# 用法:
# csv-verify-attestation.sh --report FILE [--chain-dir DIR] [--no-chain] [--verifier NAME]
#
# 环境变量:
# MPC_CSV_VERIFY_BIN 官方验签器路径(默认 /opt/hygon/csv/attestation/verify-attestation)
# MPC_CSV_VERIFY_LIB GmSSL libcrypto 目录(默认 /opt/gmssl/lib)
set -u
REPORT=""
CHAIN_DIR=""
NO_CHAIN=0
VERIFIER_NAME="hygon-verify-attestation"
while [ $# -gt 0 ]; do
case "$1" in
--report) REPORT=${2:-}; shift 2 ;;
--chain-dir) CHAIN_DIR=${2:-}; shift 2 ;;
--no-chain) NO_CHAIN=1; shift ;;
--verifier) VERIFIER_NAME=${2:-}; shift 2 ;;
-h|--help)
sed -n '2,40p' "$0" | sed 's/^# \{0,1\}//'
exit 0 ;;
*) echo "未知参数: $1" >&2; exit 2 ;;
esac
done
# 框架 `mpc_tee::verify::ExternalVerifier` 的契约:报告路径经环境变量
# MPC_TEE_REPORT_FILE 传入,stdout 需以 `verified=true` 开头、退出码 0。
# 支持该契约后,本脚本可以直接作为 `mpc tee verify --verifier` 的 program 使用。
if [ -z "$REPORT" ] && [ -n "${MPC_TEE_REPORT_FILE:-}" ]; then
REPORT="$MPC_TEE_REPORT_FILE"
VERIFIER_NAME="${MPC_TEE_VERIFIER_NAME:-$VERIFIER_NAME}"
# 证书链目录也允许从环境变量给(框架 ExternalVerifier 只传报告路径)。
if [ -z "$CHAIN_DIR" ] && [ -n "${MPC_TEE_CHAIN_DIR:-}" ]; then
CHAIN_DIR="$MPC_TEE_CHAIN_DIR"
fi
fi
if [ -z "$REPORT" ]; then
echo "缺少 --report" >&2
exit 2
fi
if [ ! -r "$REPORT" ]; then
echo "报告不可读: $REPORT" >&2
exit 2
fi
# ---- 结构前置校验(自己先做,不指望官方工具)----
#
# 官方 verify-attestation 对**截断**的报告不会报错:它只读 userdata / mnonce /
# measure / sig1(都在前 200 字节内),签名覆盖的字段没被截掉,于是照样打印
# "verify success"。但被截掉的 pek_cert(0x150 起)意味着这不是一份完整报告。
# 所以长度必须在这里 fail-closed。
#
# 长度真值:sizeof(struct csv_attestation_report) = 2548
# (厂商 SDK csv_status.h 实测;4096 是 hypercall/mmap 页大小,不是报告长度)。
REPORT_LEN=$(wc -c < "$REPORT")
EXPECT_LEN=${MPC_CSV_REPORT_LEN:-2548}
if [ "$REPORT_LEN" != "$EXPECT_LEN" ]; then
echo "verify-failed: 报告长度 $REPORT_LEN != $EXPECT_LEN(报告不完整)" >&2
exit 1
fi
BIN=${MPC_CSV_VERIFY_BIN:-/opt/hygon/csv/attestation/verify-attestation}
LIBDIR=${MPC_CSV_VERIFY_LIB:-/opt/gmssl/lib}
if [ ! -x "$BIN" ]; then
echo "官方验签器不存在: $BIN" >&2
exit 2
fi
WORK=$(mktemp -d "${TMPDIR:-/tmp}/mpc-csv-verify.XXXXXX") || exit 2
cleanup() { rm -rf "$WORK"; }
trap cleanup EXIT
# 官方工具固定读 ./report.cert
cp "$REPORT" "$WORK/report.cert" || exit 2
# 官方工具的「离线证书」fallback(check_offline_cert)只在**自己所在目录**找证书
# (dirname(readlink("/proc/self/exe"))),所以把验签器二进制复制到工作目录,
# 证书跟着放同目录即可命中 fallback —— 不需要往系统目录 /opt/hygon/... 里写文件。
BIN_RUN="$BIN"
cp "$BIN" "$WORK/verify-attestation" && chmod 755 "$WORK/verify-attestation" && BIN_RUN="$WORK/verify-attestation"
# 离线证书链:官方工具期望 hrk.cert / hsk_cek.cert(+ cek/oca/pek)
if [ -n "$CHAIN_DIR" ] && [ -d "$CHAIN_DIR" ]; then
for c in hrk.cert hsk.cert hsk_cek.cert cek.cert oca.cert pek.cert; do
[ -f "$CHAIN_DIR/$c" ] && cp "$CHAIN_DIR/$c" "$WORK/$c"
done
fi
if [ "$NO_CHAIN" = "1" ]; then
ARGS=("false") # 只验报告本身(SM2 签名 + SM3-HMAC),不验证书链
else
ARGS=("true") # 验报告 + 证书链
if [ -f "$WORK/hrk.cert" ] && [ -f "$WORK/hsk_cek.cert" ]; then
export no_proxy="cert.hygon.cn,${no_proxy:-}"
export NO_PROXY="cert.hygon.cn,${NO_PROXY:-}"
fi
fi
# 注意:**不要**把 GmSSL 目录放进 LD_LIBRARY_PATH。
# 官方验签器自身已带 rpath(ldd 显示 libcrypto.so.1.1 => /opt/gmssl/lib/...),
# 而 GmSSL 的 libssl 没有 OPENSSL_1_1_1 符号版本;一旦 LD_LIBRARY_PATH 生效,
# 它会被子进程 curl/libcurl 抢先加载,导致 curl 全部报
# "version `OPENSSL_1_1_1' not found",证书下载失败、离线证书也拿不到。
OUT=$(cd "$WORK" && "$BIN_RUN" "${ARGS[@]}" 2>&1)
# ---- 失败判定(先查失败标志,任何一条命中即失败)----
if printf '%s' "$OUT" | grep -q "verify report fail"; then
echo "verify-failed: 官方验签器判定报告验签失败" >&2
printf '%s\n' "$OUT" >&2
exit 1
fi
if printf '%s' "$OUT" | grep -q "SM2_do_verify fail"; then
echo "verify-failed: SM2 验签未通过" >&2
printf '%s\n' "$OUT" >&2
exit 1
fi
if printf '%s' "$OUT" | grep -q "attestation report MAC verify failed"; then
echo "verify-failed: 报告 MAC 完整性校验失败(报告被篡改)" >&2
printf '%s\n' "$OUT" >&2
exit 1
fi
if [ "$NO_CHAIN" != "1" ] && printf '%s' "$OUT" | grep -q "validata cert chain failed"; then
echo "verify-failed: 官方验签器判定证书链校验失败" >&2
printf '%s\n' "$OUT" >&2
exit 1
fi
# ---- 通过判定:必须出现官方成功标志,否则 fail-closed ----
REPORT_OK=0
printf '%s' "$OUT" | grep -q "verify report success" && REPORT_OK=1
printf '%s' "$OUT" | grep -q "verify success" && REPORT_OK=1
CHAIN_OK=1
if [ "$NO_CHAIN" != "1" ]; then
CHAIN_OK=0
printf '%s' "$OUT" | grep -q "validata cert chain successful" && CHAIN_OK=1
fi
if [ "$REPORT_OK" != "1" ]; then
echo "verify-failed: 官方验签器输出无明确结论(fail-closed)" >&2
printf '%s\n' "$OUT" >&2
exit 1
fi
if [ "$CHAIN_OK" != "1" ]; then
echo "verify-failed: 证书链校验未给出成功结论(fail-closed)" >&2
printf '%s\n' "$OUT" >&2
exit 1
fi
echo "verified=true verifier=$VERIFIER_NAME chain=$( [ "$NO_CHAIN" = "1" ] && echo off || echo on )"
exit 0
View File
File mode changed.
View File
File mode changed.
View File
File mode changed.
+123
View File
@@ -0,0 +1,123 @@
#!/usr/bin/env bash
# 真机端到端验证:框架 mpc tee verify + 官方海光验签器,跑真实采集的 CSV 报告。
#
# 流程:
# 1. 用 csv-report-restore.py 还原报告里的 user_data(CSV 字段被 anonce 异或混淆);
# 2. 用官方 verify-attestation(经 csv-verify-attestation.sh wrapper)验芯片签名 + 证书链;
# 3. 用框架 `mpc tee verify --verifier` 跑完整校验:结构 + 会话绑定 + 芯片签名。
#
# 用法(**在海光节点 192.168.1.102 上执行**):
# ./verify-csv-report-e2e.sh --report-dir /tmp/csv-report2 \
# --mpc /tmp/mpc-linux --verifier /tmp/mpc-tee-tools/csv-verify-attestation.sh \
# [--chain-dir /tmp/csv-chain]
#
# 会话参数(session-id / pubkey / site / tcb / measurement)默认从采集目录里的
# session.env 读 —— 那是**采集时**的那一组,验证方必须用同一组重算绑定值。
# 手工抄参数极易抄错,而绑定对不上时报出来的是「疑似重放报告」,会误导排查方向。
#
# 退出码:0 = 全部通过(含芯片签名已验证);非 0 = 任一环节失败。
set -eu
SELF_DIR=$(cd "$(dirname "$0")" && pwd)
REPORT_DIR=/tmp/csv-report2
MPC=/tmp/mpc-linux
VERIFIER=/tmp/mpc-tee-tools/csv-verify-attestation.sh
CHAIN_DIR=""
SESSION_ID=""
PUBKEY=""
SITE=""
TCB=""
MEAS=""
NODE=""
while [ $# -gt 0 ]; do
case "$1" in
--report-dir) REPORT_DIR=${2:?}; shift 2 ;;
--mpc) MPC=${2:?}; shift 2 ;;
--verifier) VERIFIER=${2:?}; shift 2 ;;
--chain-dir) CHAIN_DIR=${2:?}; shift 2 ;;
--session-id) SESSION_ID=${2:?}; shift 2 ;;
--pubkey) PUBKEY=${2:?}; shift 2 ;;
--site) SITE=${2:?}; shift 2 ;;
--tcb) TCB=${2:?}; shift 2 ;;
--measurement) MEAS=${2:?}; shift 2 ;;
--node) NODE=${2:?}; shift 2 ;;
*) echo "未知参数: $1" >&2; exit 2 ;;
esac
done
# 从采集目录补齐会话参数(显式传参优先)。**不 source** session.env ——
# source 会覆盖命令行显式传入的值;这里一律用 sed 逐项取,取不到再回落。
SESSION_FILE="$REPORT_DIR/session.env"
if [ -f "$SESSION_FILE" ]; then
[ -n "$SESSION_ID" ] || SESSION_ID=$(sed -n 's/^SESSION_ID=//p' "$SESSION_FILE" | head -1)
[ -n "$PUBKEY" ] || PUBKEY=$(sed -n 's/^PUBKEY=//p' "$SESSION_FILE" | head -1)
[ -n "$SITE" ] || SITE=$(sed -n 's/^SITE=//p' "$SESSION_FILE" | head -1)
[ -n "$TCB" ] || TCB=$(sed -n 's/^TCB=//p' "$SESSION_FILE" | head -1)
[ -n "$MEAS" ] || MEAS=$(sed -n 's/^MEASUREMENT=//p' "$SESSION_FILE" | head -1)
[ -n "$NODE" ] || NODE=$(sed -n 's/^NODE=//p' "$SESSION_FILE" | head -1)
fi
# 老目录(没有 session.env)兜底:measurement 从 node 文件读。
if [ -z "$MEAS" ] && [ -f "$REPORT_DIR/node" ]; then
MEAS=$(sed -n 's/^measurement=//p' "$REPORT_DIR/node" | head -1)
fi
if [ -z "$NODE" ] && [ -f "$REPORT_DIR/node" ]; then
NODE="$REPORT_DIR/node"
fi
REPORT="$REPORT_DIR/report.cert"
[ -f "$REPORT" ] || { echo "找不到报告: $REPORT" >&2; exit 2; }
[ -x "$MPC" ] || { echo "找不到 mpc 二进制: $MPC" >&2; exit 2; }
[ -x "$VERIFIER" ] || { echo "找不到验签 wrapper: $VERIFIER" >&2; exit 2; }
[ -n "$SESSION_ID" ] || { echo "拿不到 session-id($SESSION_FILE 不存在?)" >&2; exit 2; }
[ -n "$PUBKEY" ] || { echo "拿不到 pubkey" >&2; exit 2; }
[ -n "$SITE" ] || { echo "拿不到 site" >&2; exit 2; }
[ -n "$MEAS" ] || { echo "拿不到 measurement pin($REPORT_DIR/node 里没有 measurement=)" >&2; exit 2; }
echo "===== 1. 还原 anonce 混淆 ====="
UD=$(python3 "$SELF_DIR/csv-report-restore.py" --report "$REPORT" --field user_data --json \
| python3 -c 'import json,sys; print(json.load(sys.stdin)["user_data"]["hex"])')
echo "还原后的 user_data = $UD"
echo
echo "===== 2. 官方验签器(芯片签名 + 证书链) ====="
VOUT=$(cd "$REPORT_DIR" && "$VERIFIER" --report "$REPORT" ${CHAIN_DIR:+--chain-dir "$CHAIN_DIR"} 2>&1) || {
echo "$VOUT"
echo "官方验签器判定失败"
exit 1
}
echo "$VOUT"
echo
echo "===== 3. 框架 mpc tee verify(结构 + 会话绑定 + 芯片签名) ====="
# 用 --node 让框架和采集时读**同一份**节点描述 —— site / measurement / tcb
# 都参与 user_data 绑定,手工重填任何一个都会导致绑定对不上,
# 而那个报错("user_data 与本次会话绑定不一致")会误导成重放攻击。
echo "session-id = $SESSION_ID"
echo "pubkey = $PUBKEY"
echo "site = $SITE"
echo "tcb = $TCB"
echo "measurement pin = $MEAS"
VERIFY_ARGS=(
--report "$REPORT"
--platform csv
--user-data "$UD"
--session-id "$SESSION_ID"
--site "$SITE"
--pubkey "$PUBKEY"
--measurement "$MEAS"
--verifier "$VERIFIER"
)
[ -n "$TCB" ] && VERIFY_ARGS+=(--tcb "$TCB")
[ -n "$NODE" ] && [ -f "$NODE" ] && VERIFY_ARGS+=(--node "$NODE")
set +e
"$MPC" --report json tee verify "${VERIFY_ARGS[@]}"
VRC=$?
set -e
if [ "$VRC" != "0" ]; then
echo "框架校验失败 (rc=$VRC)"
exit 1
fi
echo
echo "E2E_OK: 真实 CSV 报告的芯片签名已由官方验签器验证,框架校验通过"
+142 -9
View File
@@ -115,6 +115,22 @@ mpc tee plan --node FILE \
- `--argv` 同时给「给人看的一行」和 `argv_json`(JSON 数组,保留参数边界);
- `--demo` 用固定示例会话值离线演练,会明确警告不能上生产。
```bash
mpc tee verify --report FILE --node FILE \
--user-data <128hex> --session-id <64hex> --pubkey <64hex> \
[--platform csv] [--tcb N] [--min-tcb N] [--pin <64hex>] \
[--verifier PATH] [--verifier-arg A] [--certs PATH]
```
**`tee verify` 与 `tee plan` 必须用同一份 `--node`**:site / measurement / tcb /
platform 都参与 `user_data` 绑定,手工重填任一项都会导致绑定对不上,而那个报错
(「user_data 与本次会话绑定不一致」)指向重放攻击,**会把实现问题误导成安全事件**。
给了 `--node` 后这四项默认全部取自它;节点平台与 `--platform` 冲突直接拒绝。
芯片签名由 `--verifier` 指向的外部验签器核验(stdout trim 后为 `OK` 或以
`verified=true` 开头视为通过,退出码非 0 视为失败)。结论里严格区分
「芯片签名未验证」与「已验证」——`verify_attestation` 返回 `Ok` **不等于**硬件证明通过。
`qemu_argv()` 返回 **argv 数组**:`-append` 的内核参数含空格,必须作为一个
参数整体传给 `execvp`。`deploy/tee/launch.sh` 用的就是 `argv_json`,
不要拿文本模式那一行去跑 shell。
@@ -227,14 +243,131 @@ AMD SEV/SEV-ES,**与 SNP 共享同一套证明绑定原语**(64 字节 `user
**仍未交付(如实标注)**:
- **芯片签名真实验签器**尚未接入:框架只做结构校验 + 会话绑定,ECDSA / 证书链 /
`sig_algo` 曲线语义交给外部验签器,目前没有配置好的验签器——`verify_attestation`
返回 `Ok` 仅表示「结构与绑定通过」。
- **真实 CSV 报告的 live 捕获未做**:`.102` 主机没有 `/dev/csv-guest`(报告必须在
CSV guest 内用 ioctl 取),主机上跑 `get-attestation` 直接 `open /dev/csv-guest failed`。
本轮验证是「厂商 SDK 头文件 + 编译器确认布局」,尚未从一间运行中的 CSV guest
导出真实报告字节做端到端比对。
- **OCI 打包 + KBS 注入**链路代码已就位,但尚未在两台真机端到端复跑。
因此准确说法是:**AMD SNP 与海光 CSV 两条路径的直接启动与跨机密文会话均已端到端
跑通**;芯片验签、KBC 密钥下发、真实报告捕获、OCI 镜像流水线仍在生产化之外。
### 真实 CSV 报告捕获 + 芯片验签闭环(2026-11-06 后续,`192.168.1.102`)
上一节列的两条「仍未交付」已在同日做掉,实测结论如下。
#### ① CSV 报告字段被 anonce 异或混淆 —— 不还原就永远对不上
这是本轮最关键的框架级发现。厂商 SDK `csv_sdk/csv_status.c` 第 762–781 行的还原写法是
**按 u32 数组逐个异或**:
```c
((uint32_t *)g_user_data)[i] = ((uint32_t *)report.user_data)[i] ^ report.anonce;
((uint32_t *)g_mnonce)[i] = ((uint32_t *)report.mnonce)[i] ^ report.anonce;
((uint32_t *)g_measure)[i] = ((uint32_t *)report.measure.block)[i] ^ report.anonce;
((uint32_t *)&g_pek_cert)[i] = ((uint32_t *)&report.pek_cert)[i] ^ report.anonce;
((uint32_t *)g_chip_id)[i] = ((uint32_t *)report.sn)[i] ^ report.anonce;
```
| 字段 | 偏移 | 是否被混淆 |
|---|---|---|
| `user_data` | 0x40 (64B) | **是** |
| `mnonce` | 0x80 (16B) | **是** |
| `measure` | 0x90 (32B) | **是** |
| `pek_cert` | 0x150 (2084B) | **是** |
| `sn` | 0x974 (64B) | **是** |
| `policy` / `sig_usage` / `sig_algo` | 0xB0 / 0xB4 / 0xB8 | 否 |
| `anonce` | 0xBC (4B) | 否(**混淆密钥本身是原值**) |
| `sig1` | 0xC0 (144B) | 否 |
框架侧已实现还原(`mpc_tee::verify::deobfuscate_csv_field`,按 u32 数组异或,
长度非 4 的倍数直接报错而非尽力补齐)。真机实测:`anonce = c96e190d` 时报告里
`user_data` 的混淆值是 `786a0bbb2d7d0fbd6c…`,还原后是 `757365722064617461`
(ASCII `"user data"`),与官方验签器打印的 userdata 完全一致。
> **不做还原的后果**:框架拿混淆值与绑定值逐字节比,永远对不上,而且报错是
> 「user_data 与本次会话绑定不一致(可能是重放报告)」——**把一个实现 bug
> 报成攻击迹象**,排查方向会被彻底带偏。
#### ② 取报告的 ioctl 契约
真实报告必须在 **CSV guest 内**用 ioctl 取(`.102` 宿主没有 `/dev/csv-guest`):
- 设备 `/dev/csv-guest`(misc device, mode 0777)
- cmd `GET_ATTESTATION_REPORT = _IOWR('D', 1, struct csv_guest_mem)`
- `struct csv_guest_mem { unsigned long va; int size; }`
- 用户态缓冲区 = **整页 4096 字节**,前 112 字节布局 `user_data[64] + mnonce[16] + hash_block[32]`
- `hash = SM3(user_data[64] || mnonce[16])`
- 固件在**同一缓冲区**就地写回 2548 字节完整报告 → `size` 必须 ≥ 2548(厂商用 `PAGE_SIZE`)
坑:缓冲区只给 112 字节会让驱动 `copy_to_user` 报 `EFAULT`(Bad address)——
它要回写的是 2548 字节,不是 112。
厂商 `get-attestation` 把挑战值**写死成 ASCII `"user data"`**,报告因此无法与框架会话
绑定对上。仓库新增 `deploy/tee/real-machine/csv-attest-request.c` 支持自定义挑战值
(`--user-data HEX64`),并**自带 SM3 实现**(guest rootfs 无 `openssl/sm3.h`),
已用 GB/T 32905-2016 两个标准向量验证。
#### ③ 官方验签器的四个坑
海光官方 `verify-attestation` 的行为与文档不一致,仓库用
`deploy/tee/real-machine/csv-verify-attestation.sh` 包了一层:
| 坑 | 现象 | 处置 |
|---|---|---|
| **退出码恒为 0** | 验签失败也返回 0 | 按 stdout 文本判定,不看退出码 |
| **报告路径写死** | 固定读 `./report.cert` | 在工作目录里放 `report.cert` |
| **离线证书 fallback 只在自己所在目录** | `dirname(readlink("/proc/self/exe"))` | 把二进制复制到工作目录再执行 |
| **对截断报告 fail-open** | 1000 字节截断报告照样打印 "verify success"(签名覆盖的 userdata/mnonce/measure 未被截掉,但 `pek_cert`@0x150 已被截掉,结构已不完整) | **wrapper 层自卡长度**(必须 == 2548) |
另有一处环境陷阱:`LD_LIBRARY_PATH=/opt/gmssl/lib` 会让 curl/libcurl 抢先加载
GmSSL 的 libssl(缺 `OPENSSL_1_1_1` 符号版本),导致证书下载全部失败。
官方验签器自身已带 rpath,**不能**设 `LD_LIBRARY_PATH`。
#### ④ 端到端闭环(真机实测)
`deploy/tee/real-machine/verify-csv-report-e2e.sh` 三步走完:
```
===== 1. 还原 anonce 混淆 =====
还原后的 user_data = 4c84440cbcddb4b9fad2c2a6744c22ab5c9c0188c6a6e566d1ffc537be0f62e93b5bad450c586956d1c6f5da7ac65071aeae308b6adaf3028f8de847854811cc
===== 2. 官方验签器(芯片签名 + 证书链) =====
verified=true verifier=hygon-verify-attestation chain=on
===== 3. 框架 mpc tee verify(结构 + 会话绑定 + 芯片签名) =====
{"kind":"table","title":"证明校验结论","header":["key","value"],"rows":[
["structure_ok","true"],["bound_ok","true"],
["chip","已验证(/tmp/mpc-tee-tools/csv-verify-attestation.sh)"],
["verdict","结构与会话绑定通过,外部验签器 … 判定芯片签名通过"]]}
E2E_OK: 真实 CSV 报告的芯片签名已由官方验签器验证,框架校验通过
```
证书链走全链(`hrk → hsk → cek → pek`),官方输出
`validata cert chain successful`。
**负向矩阵(真机实测,全部 fail-closed)**:
| 场景 | wrapper rc | 框架 rc | 判定依据 |
|---|---|---|---|
| 真实报告 | 0 | 0 | 通过 |
| 篡改 `user_data`(@0x40) | 1 | 1 | `verify report fail` / 「CSV user_data 与会话绑定的 user_data 不一致」 |
| 截断到 1000 字节 | 1 | — | `verify-failed: 报告长度 1000 != 2548` |
| 篡改 `sig1`(@0xC0) | 1 | — | `verify report fail` |
#### ⑤ 一个真实 CLI bug:`--report` 参数撞名
全局 `--report text|json` 与 `mpc tee verify --report <文件路径>` 同名,
全局参数先解析 → `tee verify` 永远拿不到文件路径(真机表现为
`--report 只认 text / json,得到 "report.cert"`)。
已修为上下文感知:仅当命令是 `tee verify` 时,非格式值的 `--report` 才当文件路径。
#### ⑥ 第二个真实 CLI bug:绑定参数必须与启动同源
`user_data` 第二段哈希绑的是「度量 + 平台标签 + **TCB**」,TCB 来自节点描述。
启动方 `tee plan` 用 node 里的 `tcb=3` 算绑定值,验证方 `tee verify` 的 `--tcb`
默认却是 0 → 期望值必然对不上 → 报「user_data 与本次会话绑定不一致(可能是重放报告)」。
**手工重填 site / measurement / tcb 是绑定对不上的头号来源。**
已给 `mpc tee verify` 加 `--node`:**site / measurement / tcb / platform 默认全部取自
节点描述**,与 `tee plan` 读同一份真相源;节点平台与 `--platform` 冲突直接拒绝。
采集脚本会把本次会话参数落成 `session.env`,验证脚本从那里读,不靠人手抄。
因此准确说法是:**AMD SNP 与海光 CSV 两条路径的直接启动、跨机密文会话、
真实 CSV 报告捕获、芯片签名与证书链验证**均已端到端跑通;
**OCI 镜像流水线与 KBC 在线密钥下发**仍在生产化之外。