feat(chain): GmSSL 真 TLCP 握手与 TA 密钥分级,主门禁扩到 16 条

- 纠正国密链提交方法为自有 sendTransaction(4 参),eth_sendRawTransaction 在国密链禁用
- 新增 GmSSL 3.2.0 环回真 TLCP 握手自测:双证书、国密套件、应用数据往返、负向期望拒绝特征
- 落地 build_optee.sh TA 签名密钥三级硬拒绝,缺 SDK 时判据仍可被执行到
- 新增 FISCO 真机对拍契约:缺环境显式 SKIPPED 并逐项列出,环境齐备只报 NEEDS_IMPL
- 同步 catalog 守卫 / 集成文档 / CLAUDE.md,主门禁 15 条改为 16 条
This commit is contained in:
admin committed 2026-11-07 18:23:46 +08:00
1 parent 851e899b3c
commit 0e968ed5ce
14 files changed
+1256 -140

No files matched your search

+16 -3
View File
@@ -40,14 +40,16 @@ cargo check --workspace --target armv7-unknown-linux-gnueabihf # 交叉编译
cargo build --release -p mpc-cli && ./target/release/mpc selftest
# ★ guest 静态产物:musl 目标必须显式 --no-default-features
cargo build --release -p mpc-cli --target x86_64-unknown-linux-musl --no-default-features
./tools/ci.sh # CI 与本地同一份闸门(15 条)
./tools/ci.sh # CI 与本地同一份闸门(16 条)
```
主门禁 `./tools/ci.sh` 共 15 条:全量测试(**必须带 `--features secure`**)、
主门禁 `./tools/ci.sh` 共 16 条:全量测试(**必须带 `--features secure`**)、
`-Dwarnings` 零告警(作用于 test/bench/example 目标)、`mpc-core` / `mpc-tee`
no_std 双守 + TA UUID 对拍、**musl 跨目标零告警 + guest 边界探针**、12 示例冒烟、
shell 卫生、OCI 链、KBS、ash 语法、SNP 验签器、OP-TEE 判据逻辑、
hostd / 链路层 / 链上层端到端桩自测、国密签名与治理形状自测。
hostd / 链路层 / 链上层端到端桩自测、国密签名与治理形状自测、
**GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约**(第 16 条;
缺环境一律显式 `*_SKIPPED` + 逐项缺失,绝不静默通过)。
明细以脚本自身为准(**闸门不扫自己就是盲区**)。
## crate 分层
@@ -224,6 +226,17 @@ SM2 签名走系统 OpenSSL 的 EVP 接口(`openssl` crate 链接系统库,
系统代理会把这一跳端点换掉(也让国密 TLS 的实测结论失效),门禁第 14 条有回归探针。
- `--transport` / `--policy` **没有默认值**:明文传输与软件签名器都必须显式选择,
不许留「没传就悄悄降级」的后门。门禁第 15 条有回归探针。
- **国密链提交方法是自有 `sendTransaction`(4 参)**。`eth_sendRawTransaction`
是 secp256k1 + keccak256 的 web3 端点,**国密链禁用**(`rpc.rs` 守卫 + 第 14 条
4 条判据);上一版「`sendTransaction` 搜不到」是搜索假阴性,勿回退。
`sm2Verify(bytes32,bytes,bytes32,bytes32)` 是 **4 入参**,`message` 为 32B 摘要,
distid **不在 ABI**(链上不可配),只能链下对齐 + 真机对拍。
- **GmSSL 3.2.0 让本机 TLCP 环回真握手跑通**(第 16 条 19 判据:
`Protocol: TLCP` / `Version: TLCP (0101)` / 双证书)。但 3.x **不与 OpenSSL ABI
兼容**,不能当 provider 喂给 `reqwest`;本机握手通过 **≠** `bcos-rpc` 通道已通,
`TlcpReadiness` 仍只到 `NeedsFfi`、`ready` 恒 false。软件实现不能过密评。
- **TA 签名密钥三级硬拒绝已落地**:`build_optee.sh --check-only` 在 SDK 检查之前
解析,prod 缺密钥绝不回落 `default_ta.pem`;第 16 条 16 判据在没 SDK 时也测得到。
**★ `mpc` 二进制有两种 profile,别混**(2026-11-07):`mpc-cli` 同时是宿主 CLI
与 TEE guest 里的静态代理。宿主端 `mpc`(默认 `control-plane`)才有
+76 -1
View File
@@ -25,6 +25,80 @@ set -euo pipefail
REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
# ---- TA 签名密钥分级(2026-11-07 拍板;★ 脚本层硬拒绝,不只是文档)----
# dev 仓库 / SDK 自带 default_ta.pem,只允许 QEMU / CI
# staging MPC_TA_SIGN_KEY 指向受控密钥,预发布验收
# prod SIGN_KEY 由设备厂商 / OEM 持有,ssw-mpc 不持密钥
#
# ★ --check-only 必须放在 OPTEE_OS / SDK_DIR 检查之前:否则在没有 SDK 的
# 机器上守卫会被前置环境检查抢先,变成「永远测不到的判据」。
# tools/selftest-ta-key-tier.py 靠这个模式把三级规则逐条跑出来。
ta_key_fail() {
printf 'MPC_TA_KEY_FAIL: %s\n' "$1" >&2
exit 1
}
resolve_ta_sign_key() {
local tier="${MPC_TA_KEY_TIER:-dev}"
case "$tier" in
dev|staging|prod) ;;
*) ta_key_fail "MPC_TA_KEY_TIER=${tier} 只能是 dev|staging|prod" ;;
esac
local sign="${SIGN_KEY:-}"
local managed="${MPC_TA_SIGN_KEY:-}"
if [ -n "$sign" ] && [ -n "$managed" ]; then
ta_key_fail "SIGN_KEY 与 MPC_TA_SIGN_KEY 同时给出,密钥来源歧义,拒绝"
fi
local key=""
local reason=""
case "$tier" in
dev)
if [ "${MPC_TA_ALLOW_DEV_KEY:-0}" != "1" ] && [ -z "${MPC_SIM_DEV:-}" ]; then
ta_key_fail "dev 密钥 default_ta.pem 只允许 QEMU / CI;请显式设 MPC_TA_ALLOW_DEV_KEY=1 或 MPC_SIM_DEV"
fi
key="default_ta.pem"
reason="QEMU/CI 开发密钥,禁止用于 staging/prod"
;;
staging)
[ -n "$managed" ] || ta_key_fail "staging 必须给 MPC_TA_SIGN_KEY(受控密钥),不得回落 default_ta.pem"
case "$managed" in
*default_ta.pem*) ta_key_fail "staging 不得使用开发密钥 default_ta.pem" ;;
esac
[ -f "$managed" ] || ta_key_fail "MPC_TA_SIGN_KEY 指向的文件不存在: ${managed}"
key="$managed"
reason="staging 受控密钥"
;;
prod)
[ -n "$sign" ] || ta_key_fail "prod 必须给 SIGN_KEY(由 OEM 持有);缺生产密钥时不得回落开发密钥 default_ta.pem"
case "$sign" in
*default_ta.pem*) ta_key_fail "prod 不得使用开发密钥 default_ta.pem" ;;
esac
[ -f "$sign" ] || ta_key_fail "SIGN_KEY 指向的文件不存在: ${sign}"
key="$sign"
reason="prod 密钥由设备厂商/OEM 持有,ssw-mpc 不持密钥"
;;
esac
printf '{"tier":"%s","key":"%s","allowed":true,"reason":"%s"}\n' "$tier" "$key" "$reason"
}
# 纯校验模式:不碰 SDK,不需要 OPTEE_OS / 交叉工具链。
if [ "${1:-}" = "--check-only" ]; then
resolve_ta_sign_key
exit 0
fi
# 正式构建:把解析结果归一成「空 = 开发密钥 / 路径 = 指定密钥」,
# 供下面 sign_encrypt.py 的 --key 使用;任何不合规都在这一步硬退出。
TA_KEY_JSON="$(resolve_ta_sign_key)"
TA_KEY_TIER="$(printf '%s' "$TA_KEY_JSON" | python3 -c 'import json,sys; print(json.load(sys.stdin)["tier"])')"
TA_KEY_PATH="$(printf '%s' "$TA_KEY_JSON" | python3 -c 'import json,sys; print(json.load(sys.stdin)["key"])')"
if [ "$TA_KEY_TIER" = "dev" ]; then
SIGN_KEY=""
else
SIGN_KEY="$TA_KEY_PATH"
fi
echo "== TA 签名密钥 tier=${TA_KEY_TIER} key=${TA_KEY_PATH} =="
OPTEE_OS="${OPTEE_OS:?需要指向 optee_os 源码目录}"
SDK_DIR="${SDK_DIR:?需要指向 teaclave-trustzone-sdk 目录}"
OPTEE_CLIENT_EXPORT="${OPTEE_CLIENT_EXPORT:-$(dirname "$OPTEE_OS")/optee_client/out/export}"
@@ -36,7 +110,8 @@ TARGET="arm-unknown-linux-gnueabihf"
TA_FEATURES="${TA_FEATURES:-}"
OUT_PREFIX="${OUT_PREFIX:-mpc-tee}"
OUT_DIR="${OUT_DIR:-$REPO/artifacts/optee}"
SIGN_KEY="${SIGN_KEY:-}" # 留空 = 开发密钥 default_ta.pem
# SIGN_KEY 已在上方由 resolve_ta_sign_key() 归一,此处不再重新赋值:
# 留空 = QEMU/CI 开发密钥(且必须显式允许),非空 = staging/prod 受控密钥。
# ---- TA dev kit ----
DK=""
+3 -1
View File
@@ -210,7 +210,9 @@ pub fn require_transport(
match tlcp::require_tlcp_transport(t)? {
tlcp::TlcpReadiness::Ready => Ok(()),
tlcp::TlcpReadiness::NeedsFfi => Err(ChainError::NotConfigured(String::from(
"TLCP 环境齐备但 Tongsuo FFI 握手未落地,拒绝宣称能发真交易",
"TLCP 实现(Tongsuo / GmSSL)本机可用,但 Rust 侧把 JSON-RPC 经 TLCP \
发到 bcos-rpc 的 FFI / 进程通道未落地,且未验证 bcos-rpc 是否启用 TLCP;\
拒绝宣称能发真交易",
))),
tlcp::TlcpReadiness::MissingEnvironment => Err(ChainError::NotConfigured(
String::from("TLCP 环境缺失,拒绝发真交易"),
+106 -10
View File
@@ -1,16 +1,31 @@
//! JSON-RPC 最小面(FISCO BCOS 3.x)。
//!
//! # 方法名的来源
//! # ★ 两条提交路径不能混(2026-11-07 gitea 镜像源码核对)
//!
//! `docs/INTEGRATION_ANALYSIS.md` 4.8 初稿写「自有 JSON-RPC、不是 `eth_`
//! 兼容」。用 gitea 镜像核对源码后这是 **2.x 的老结论**:3.x 的
//! `bcos-rpc/bcos-rpc/web3jsonrpc/endpoints/EthMethods.h` 里明确列了
//! `eth_sendRawTransaction` / `eth_call` / `eth_getTransactionReceipt`,
//! 而 `sendTransaction` 全仓搜不到。所以常量按 3.x 写,且**钉在测试里**。
//! 4.8 初稿写「3.x 只有 `eth_*` 兼容 RPC、`sendTransaction` 全仓搜不到」
//! 是**错的**:那次搜索带了不匹配的 path glob,空结果被当成「不存在」。
//! 源码 `bcos-rpc/bcos-rpc/jsonrpc/JsonRpcInterface.cpp:18` 明确注册
//! `m_methodToFunc["sendTransaction"]`,`JsonRpcImpl_2_0.cpp:477` 是实现。
//!
//! 仍需真机确认的一件事:国密链(`sm_crypto=true`)的交易是否也走这个
//! web3 端点 —— RPC 方法名兼容不等于交易签名 / RLP 结构兼容。这条写进
//! 文档待实测项,不在这里假装已知。
//! - **`sendTransaction`(自有 RPC,国密链走这条)**:4 个参数
//! `[groupID, nodeName, data(hex FISCO 交易字节), requireProof]`。节点用
//! `transactionFactory()->decodeTransaction()` 解**自有交易结构**,
//! `cryptoSuite()->hashImpl()` 在国密链是 SM3。
//! - **`eth_sendRawTransaction`(web3 兼容端点)**:1 个参数 `[0x RLP]`。
//! `web3jsonrpc/model/Web3Transaction.cpp` include `Secp256k1Crypto.h`,
//! `txHash()` / `hashForSign()` 都是 `keccak256Hash`,签名是 `r||s||v`
//! (`SECP256K1_SIGNATURE_LEN`)。**国密链 SM2 交易不能走这条**。
//!
//! 方法名兼容 ≠ 交易结构兼容。本框架 `sm_crypto=true` 已冻结,所以
//! `assert_submit_method_allowed()` 对 `eth_sendRawTransaction` 一律拒绝。
//! 本次核对还钉死了合约内验签预编译的形状:
//! `bcos-executor/src/precompiled/CryptoPrecompiled.cpp:45` 的
//! `sm2Verify(bytes32,bytes,bytes32,bytes32)` —— **4 个入参**,
//! `message` 是 32 字节摘要(`fromString32` → `HashType`),`r`/`s` 各 32 字节;
//! selector 由节点 `hashImpl` 计算(国密链 SM3)。内部走
//! `SM2Crypto::verify()` → `wedpr_sm2_verify`,入参只有
//! `公钥 / msgHash / 签名`,**distid 不是 ABI 入参**:链上这处不可配置,
//! 只能让链下与节点内实现一致并用真机 `sm2Verify` 对拍确认。
//!
//! # ★ HTTP 200 ≠ 成功
//!
@@ -25,15 +40,56 @@ use reqwest::redirect::Policy;
use serde_json::{Map, Value};
use std::time::Duration;
/// 依据:`bcos-rpc/bcos-rpc/web3jsonrpc/endpoints/EthMethods.h`(3.x)。
/// 国密链提交交易的**自有** RPC。依据 `JsonRpcInterface.cpp:18` / `JsonRpcImpl_2_0.cpp:477`。
pub const METHOD_SEND_TRANSACTION: &str = "sendTransaction";
/// web3 兼容端点,**仅标准版 secp256k1 + keccak256 交易**;国密链禁用。
/// 依据 `web3jsonrpc/endpoints/EthMethods.h:54`。
pub const METHOD_SEND_RAW_TX: &str = "eth_sendRawTransaction";
pub const METHOD_GET_RECEIPT: &str = "eth_getTransactionReceipt";
pub const METHOD_CALL: &str = "eth_call";
/// 合约内验签预编译的 ABI(`CryptoPrecompiled.cpp:45`),4 个入参。
pub const CRYPTO_SM2_VERIFY_ABI: &str = "sm2Verify(bytes32,bytes,bytes32,bytes32)";
const CONNECT_TIMEOUT_SECS: u64 = 10;
const REQUEST_TIMEOUT_SECS: u64 = 30;
const MAX_RESPONSE_BYTES: usize = 4 * 1024 * 1024;
/// 按链类型给出**正确**的提交方法名。国密链不是 `eth_sendRawTransaction`。
pub fn submit_method_for(sm_crypto: bool) -> &'static str {
if sm_crypto {
METHOD_SEND_TRANSACTION
} else {
METHOD_SEND_RAW_TX
}
}
/// ★ 国密链禁止把交易塞进 web3 端点。这不是「待实测」了:
/// `Web3Transaction.cpp` 的 keccak256 + secp256k1 是硬编码的,改不了。
/// 在真正落地 FISCO 交易编码(`tx.rs`)之前,这条守卫先挡住方向错误。
pub fn assert_submit_method_allowed(method: &str, sm_crypto: bool) -> Result<(), ChainError> {
if sm_crypto && method == METHOD_SEND_RAW_TX {
return Err(ChainError::Config(format!(
"国密链(sm_crypto=true)禁止用 {METHOD_SEND_RAW_TX} 提交交易:\
web3 端点固定 secp256k1 + keccak256 RLP,与 SM2/SM3 国密交易结构不兼容;\
必须走 {METHOD_SEND_TRANSACTION}(4 参)"
)));
}
Ok(())
}
/// `sendTransaction` 的参数形状,顺序与 `JsonRpcInterface.h:171` 一致:
/// `[groupID, nodeName, data(hex), requireProof]`。缺一个都会被节点拒。
/// 注意 `data` 必须是 **FISCO 自有交易编码**;链上对象规范字节不是交易,
/// 传进去只会得到解码失败 —— 本函数只负责形状,不假装能发真交易。
pub fn send_transaction_params(
group_id: &str,
node_name: &str,
data_hex: &str,
require_proof: bool,
) -> Value {
serde_json::json!([group_id, node_name, data_hex, require_proof])
}
/// 构造 JSON-RPC 2.0 请求体。`id` 由调用方给,响应必须回同一个 id。
pub fn request_json(id: u64, method: &str, params: Value) -> String {
let mut m = Map::new();
@@ -285,9 +341,49 @@ mod tests {
#[test]
fn method_names_match_upstream_3x_enum() {
// 改这里就等于改协议,必须同步改文档与桩服务。
assert_eq!(METHOD_SEND_TRANSACTION, "sendTransaction");
assert_eq!(METHOD_SEND_RAW_TX, "eth_sendRawTransaction");
assert_eq!(METHOD_GET_RECEIPT, "eth_getTransactionReceipt");
assert_eq!(METHOD_CALL, "eth_call");
// sendTransaction 曾因搜索假阴性被误判为「不存在」,钉死防止回退。
assert_eq!(submit_method_for(true), METHOD_SEND_TRANSACTION);
assert_eq!(submit_method_for(false), METHOD_SEND_RAW_TX);
}
#[test]
fn guomi_chain_rejects_web3_raw_tx_method_with_reason() {
// ★ 判据必须带期望特征:只判 is_err() 会放过「因为别的原因拒绝」。
let e = assert_submit_method_allowed(METHOD_SEND_RAW_TX, true).unwrap_err();
assert!(matches!(e, ChainError::Config(_)), "必须是配置层拒绝: {e:?}");
let msg = e.to_string();
assert!(msg.contains("secp256k1"), "必须点名不兼容的算法: {msg}");
assert!(msg.contains("keccak256"), "必须点名不兼容的哈希: {msg}");
assert!(msg.contains(METHOD_SEND_TRANSACTION), "必须给出正确方法: {msg}");
// 正向:标准版 web3 与国密链自有方法都允许。
assert!(assert_submit_method_allowed(METHOD_SEND_RAW_TX, false).is_ok());
assert!(assert_submit_method_allowed(METHOD_SEND_TRANSACTION, true).is_ok());
}
#[test]
fn send_transaction_params_match_upstream_four_slots() {
let p = send_transaction_params("group0", "node0", "0xabcd", false);
let a = p.as_array().expect("params 必须是数组");
assert_eq!(a.len(), 4, "sendTransaction 是 4 参,不是 eth 的 1 参");
assert_eq!(a[0], serde_json::json!("group0"));
assert_eq!(a[1], serde_json::json!("node0"));
assert_eq!(a[2], serde_json::json!("0xabcd"));
assert_eq!(a[3], serde_json::json!(false), "requireProof 必须是布尔");
}
#[test]
fn sm2_verify_abi_is_four_args_not_three() {
assert_eq!(
CRYPTO_SM2_VERIFY_ABI,
"sm2Verify(bytes32,bytes,bytes32,bytes32)"
);
// message 是 bytes32 摘要、r/s 各 bytes32:链上验签的 distid
// 不在 ABI 入参里,不许照旧文档写成「三入参」或「可设 distid」。
assert!(CRYPTO_SM2_VERIFY_ABI.contains("bytes32,bytes,bytes32,bytes32"));
}
#[test]
+147 -45
View File
@@ -1,18 +1,30 @@
//! 客户端 → `bcos-rpc` 的**国密 TLCP 通道契约**。
//!
//! # 用户拍板与本机实测
//! # 用户拍板与本机实测(2026-11-07,GmSSL 加入后更新)
//!
//! 2026-11-07 用户拍板「bcos-rpc 做国密 TLS / TLCP」。同日本机实测:
//! `OpenSSL 4.0.3` 有 SM2 实现,但 `openssl ciphers -v` **没有任何 TLCP
//! 套件**,也没有 `tongsuo` / `gmssl` 二进制。也就是说:
//! 用户拍板「bcos-rpc 做国密 TLS / TLCP」,并指出**可以用 GmSSL**(开源
//! 免费、Apache-2.0)。本机实测:
//!
//! - SM2 **签名**可以真做真测(`sm2.rs`);
//! - TLCP **字节流**不能假装可用 —— 标准 OpenSSL 不提供 TLCP,需要
//! Tongsuo ≥ 8.4(OpenSSL 3.0 基线)的 FFI 与国密链真机。
//! - `OpenSSL 4.0.3` 有 SM2,但 `openssl ciphers -v` **没有任何 TLCP 套件**;
//! - 无 `tongsuo`;
//! - `brew install gmssl` 装到 **GmSSL 3.2.0**,`gmssl tlcp_server` /
//! `tlcp_client` 齐备,本机环回**真的跑通了 TLCP 握手**:
//! `Protocol: TLCP` / `Version: TLCP (0101)` /
//! `CipherSuite: TLS_ECC_SM4_CBC_SM3` / 双证书 / 应用数据往返
//! (可回归判据在 `tools/selftest-tlcp-gmssl.py`)。
//!
//! ★ 但**这套能力不等于「客户端到 bcos-rpc 的通道已通」**:
//! ① GmSSL 3.x 移除了核心的 OpenSSL 兼容 API,**不能**作为 OpenSSL
//! provider 直接喂给 `reqwest`;② 本机握手是环回 `tlcp_server`,
//! 服务端不是 FISCO 节点,也没验证 `bcos-rpc` 是否启用 TLCP;
//! ③ Rust 侧把 JSON-RPC 请求经 TLCP 发出去的 FFI / 进程通道**未落地**,
//! 可用的候选是 `gmssl tlcp_client -in file`,但尚未接入 `HttpChainClient`。
//! 所以 `TlcpReadiness::Ready` 仍然到不了,生产路径继续 fail-closed。
//!
//! 另一条独立证据:`gmssl certgen -help` 明写默认 `-sm2_id` 是
//! `1234567812345678`,与 `mpc_core::domain::SM2_DISTID` 同值;GmSSL 侧
//! 可用 `-sm2_id` 显式指定,但链上验签那侧不可配,只能实测对拍。
//!
//! 所以本期落地的是**可被独立验证的那一半**:TLCP 配置形状、双证书真校验、
//! 环境探测、以及「环境不具备就拒绝、且点名原因」的 fail-closed 准入。
//! 真握手 / 双证书加载进 FFI / 国密链对拍**未落地**,见 `TlcpReadiness`。
//! 明文或标准 TLS 都不得冒充这一跳 —— 那会让「客户端到 bcos-rpc 是否需要
//! 国密 TLCP」的实测结论整个失效(TLS 终止点被偷偷换掉)。
@@ -23,15 +35,44 @@ use openssl::x509::X509;
use serde_json::Value;
use std::process::Command;
/// Tongsuo TLCP 套件白名单。名称**待真机对拍**:写白名单是为了不让
/// Tongsuo / OpenSSL 风格套件名。名称**待真机对拍**:写白名单是为了不让
/// 「随便填一个字符串」通过配置校验,不是宣称这些名字已实测。
pub const TLCP_CIPHER_SUITES: &[&str] = &[
pub const TONGSUO_TLCP_CIPHER_SUITES: &[&str] = &[
"ECC-SM2-SM4-CBC-SM3",
"ECDHE-SM2-SM4-CBC-SM3",
"ECC-SM2-SM4-GCM-SM3",
"ECDHE-SM2-SM4-GCM-SM3",
];
/// GmSSL 3.2.0 实测支持的两个套件(`gmssl tlcp_server -help` 的
/// "Supported cipher suites")。`TLS_ECC_SM4_CBC_SM3` 已在本机环回握手跑通。
/// ★ 名字与 Tongsuo 那套**不同**,别把 OpenSSL 风格的 `ECC-SM2-...`
/// 填进 GmSSL 命令 —— 会静默握手失败。
pub const GMSSL_TLCP_CIPHER_SUITES: &[&str] =
&["TLS_ECC_SM4_CBC_SM3", "TLS_ECC_SM4_GCM_SM3"];
/// 配置校验用的合并白名单。两个后端任一的名字都算合法,
/// 但「合法名字」不等于「该后端已装」,后者由 `TlcpProbe` 真探测。
pub const TLCP_CIPHER_SUITES: &[&str] = &[
"ECC-SM2-SM4-CBC-SM3",
"ECDHE-SM2-SM4-CBC-SM3",
"ECC-SM2-SM4-GCM-SM3",
"ECDHE-SM2-SM4-GCM-SM3",
"TLS_ECC_SM4_CBC_SM3",
"TLS_ECC_SM4_GCM_SM3",
];
/// 本机可用的 TLCP 实现后端。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TlcpBackend {
/// 没有可用实现:不允许发真交易。
None,
/// Tongsuo ≥ 8.4(OpenSSL 3.0 基线,可作为 provider)。
Tongsuo,
/// GmSSL ≥ 3.2(独立实现,CLI / libgmssl,不与 OpenSSL ABI 兼容)。
GmSSL,
}
/// TLCP 双证书配置。**每个字段都必须显式给**,缺一个就拒绝。
///
/// TLCP 与普通 TLS 的结构差异:需要**签名证书 + 加密证书两张**,且两张
@@ -95,7 +136,8 @@ impl TlcpConfig {
pub fn validate(&self) -> Result<(), ChainError> {
if !TLCP_CIPHER_SUITES.contains(&self.cipher_suite.as_str()) {
return Err(ChainError::Config(format!(
"TLCP 套件 {:?} 不在白名单(名称待真机对拍),拒绝随便填",
"TLCP 套件 {:?} 不在合并白名单(Tongsuo / GmSSL 两套名字;\
GmSSL 两个已本机实测,Tongsuo 四个待真机对拍),拒绝随便填",
self.cipher_suite
)));
}
@@ -179,42 +221,74 @@ fn assert_sm2_cert(cert: &X509, name: &str) -> Result<(), ChainError> {
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TlcpProbe {
pub openssl_version: String,
/// **仅**指 OpenSSL / Tongsuo 侧 `openssl ciphers -v` 是否列出 TLCP 套件。
/// GmSSL 可用不会把它变成 true —— 两者是不同的 ABI 与命令体系。
pub tlcp_cipher_available: bool,
pub tongsuo_lib: Option<String>,
/// `gmssl version` 的输出;没装就是 None。
pub gmssl_version: Option<String>,
/// `gmssl help` 里 `tlcp_server` 与 `tlcp_client` 是否都在。
pub gmssl_tlcp_commands: bool,
pub backend: TlcpBackend,
}
/// 真探测:跑 `openssl version` 与 `openssl ciphers -v`,并检查是否配置了
/// Tongsuo 库路径。**探测不到就如实报 false**,不写死「本机肯定支持」。
fn command_text(bin: &str, args: &[&str]) -> Option<String> {
Command::new(bin)
.args(args)
.output()
.ok()
.filter(|o| o.status.success())
.map(|o| String::from_utf8_lossy(&o.stdout).to_string())
}
/// 真探测:跑 `openssl version` / `openssl ciphers -v` / `gmssl version` /
/// `gmssl help`,并检查 `MPC_TONGSUO_LIB`。**探测不到就如实报 None/false**,
/// 不写死「本机肯定支持」,也不因为装了 GmSSL 就把 OpenSSL 侧标成可用。
pub fn probe_tlcp_environment() -> TlcpProbe {
let version = Command::new("openssl")
.arg("version")
.output()
.ok()
.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
let openssl_version = command_text("openssl", &["version"])
.map(|s| s.trim().to_string())
.unwrap_or_else(|| String::from("(openssl 不可用)"));
let tlcp_cipher_available = Command::new("openssl")
.args(["ciphers", "-v"])
.output()
.ok()
.map(|o| {
let s = String::from_utf8_lossy(&o.stdout).to_ascii_uppercase();
s.contains("TLCP") || (s.contains("SM2") && s.contains("SM4"))
let tlcp_cipher_available = command_text("openssl", &["ciphers", "-v"])
.map(|s| {
let u = s.to_ascii_uppercase();
u.contains("TLCP") || (u.contains("SM2") && u.contains("SM4"))
})
.unwrap_or(false);
let tongsuo_lib = std::env::var("MPC_TONGSUO_LIB")
.ok()
.filter(|p| !p.is_empty() && std::path::Path::new(p).exists());
TlcpProbe { openssl_version: version, tlcp_cipher_available, tongsuo_lib }
let gmssl_version = command_text("gmssl", &["version"]).map(|s| s.trim().to_string());
let gmssl_tlcp_commands = command_text("gmssl", &["help"])
.map(|s| s.contains("tlcp_server") && s.contains("tlcp_client"))
.unwrap_or(false);
// ★ GmSSL 优先:本机已实测它的 TLCP 握手可用;但 GmSSL 不与 OpenSSL
// ABI 兼容,不能反过来把 tongsuo_lib 当它的前置条件。
let backend = if gmssl_version.is_some() && gmssl_tlcp_commands {
TlcpBackend::GmSSL
} else if tlcp_cipher_available && tongsuo_lib.is_some() {
TlcpBackend::Tongsuo
} else {
TlcpBackend::None
};
TlcpProbe {
openssl_version,
tlcp_cipher_available,
tongsuo_lib,
gmssl_version,
gmssl_tlcp_commands,
backend,
}
}
/// TLCP 通道就绪状态。**只有 `Ready` 才允许发真实交易**,本期永远到不了。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TlcpReadiness {
/// 环境齐备 + FFI 已落地。
/// 环境齐备 + Rust 客户端已接入真实 TLCP 通道。
Ready,
/// 配置与环境齐备,但 Tongsuo FFI 握手未实现。
/// 本机已有可用国密 TLCP 实现(Tongsuo 或 GmSSL),但 Rust 侧把
/// JSON-RPC 请求经 TLCP 发到 `bcos-rpc` 的 FFI / 进程通道未落地。
NeedsFfi,
/// 缺 TLCP 套件 / 缺 Tongsuo 库。
/// 两个后端都不可用。
MissingEnvironment,
}
@@ -222,22 +296,20 @@ pub enum TlcpReadiness {
///
/// ★ 不许用 `|| true` 吞掉失败,也不许把「环境探测不到」当成「跳过」——
/// 最重要那条判据永远没跑 = 假安全感。这里一律返回明确错误并点名缺失项。
/// ★ 也不许因为「GmSSL 本机握手跑通了」就返回 Ready:服务端是环回
/// `tlcp_server`,不是 `bcos-rpc`;Rust 客户端也还没接进去。
pub fn require_tlcp_transport(cfg: &TlcpConfig) -> Result<TlcpReadiness, ChainError> {
cfg.validate()?;
let p = probe_tlcp_environment();
if !p.tlcp_cipher_available {
if p.backend == TlcpBackend::None {
return Err(ChainError::NotConfigured(format!(
"本机 OpenSSL 无 TLCP 加密套件({}),需要 Tongsuo ≥ 8.4;拒绝以明文/标准 TLS 冒充国密通道",
"本机既无 OpenSSL/Tongsuo TLCP 套件({}),也无可用 GmSSL tlcp_client/tlcp_server;\
需要 Tongsuo ≥ 8.4 或 GmSSL ≥ 3.2;拒绝以明文/标准 TLS 冒充国密通道",
p.openssl_version
)));
}
if p.tongsuo_lib.is_none() {
return Err(ChainError::NotConfigured(String::from(
"检测到 TLCP 套件但未配置 MPC_TONGSUO_LIB,拒绝假装已接入 Tongsuo",
)));
}
// 即使环境齐备,Rust 侧 TLCP 握手 FFI 仍未落地 —— 如实报 NeedsFfi,
// 不返回「可用」。调用方据此拒绝发真交易。
// 即使环境齐备,Rust 侧把 JSON-RPC 请求经 TLCP 发到 bcos-rpc 的
// FFI / 进程通道仍未落地 —— 如实报 NeedsFfi,不返回「可用」。
Ok(TlcpReadiness::NeedsFfi)
}
@@ -248,9 +320,26 @@ mod tests {
#[test]
fn cipher_suite_allowlist_is_explicit() {
assert!(TLCP_CIPHER_SUITES.contains(&"ECC-SM2-SM4-CBC-SM3"));
assert!(TLCP_CIPHER_SUITES.contains(&"TLS_ECC_SM4_CBC_SM3"));
assert!(!TLCP_CIPHER_SUITES.contains(&"TLS_AES_128_GCM_SHA256"));
}
#[test]
fn gmssl_suite_names_are_distinct_from_tongsuo() {
// ★ GmSSL 的套件名与 OpenSSL/Tongsuo 风格完全不同。合并白名单
// 必须同时容纳两套,且不许把 GmSSL 名字漏掉后偷偷回退到
// `ECC-SM2-...`(那会在 GmSSL 命令里静默握手失败)。
for s in GMSSL_TLCP_CIPHER_SUITES {
assert!(TLCP_CIPHER_SUITES.contains(s), "合并白名单漏了 GmSSL 套件 {s}");
assert!(
!TONGSUO_TLCP_CIPHER_SUITES.contains(s),
"GmSSL 套件 {s} 被错误归到 Tongsuo 名单"
);
}
assert_eq!(GMSSL_TLCP_CIPHER_SUITES.len(), 2);
assert_eq!(TLCP_CIPHER_SUITES.len(), 6);
}
#[test]
fn config_requires_all_fields_and_rejects_unknown_keys() {
let base = serde_json::json!({
@@ -286,16 +375,29 @@ mod tests {
}
#[test]
fn probe_never_claims_tlcp_on_plain_openssl() {
fn probe_reports_backends_consistently_not_hardcoded() {
// ★ 不写死「本机无 GmSSL」:装了没装都要如实报。否则在另一台
// 机器上判据会变成假红/假绿(环境一变就失真)。
let p = probe_tlcp_environment();
// 本机实测:OpenSSL 4.0.3 无 TLCP 套件。这条断言在装了 Tongsuo
// 的机器上会变,那时候应该改成「探测结果必须与实际一致」的交叉验证。
assert!(!p.openssl_version.is_empty());
assert!(p.tongsuo_lib.is_none(), "本机未配 MPC_TONGSUO_LIB");
let has_gmssl = command_text("gmssl", &["version"]).is_some();
assert_eq!(
p.gmssl_version.is_some(),
has_gmssl,
"gmssl 可用性必须与真实命令一致"
);
if has_gmssl {
assert!(p.gmssl_tlcp_commands, "GmSSL 装了却没有 TLCP 子命令要如实报");
assert_eq!(p.backend, TlcpBackend::GmSSL);
}
// OpenSSL 侧不因装了 GmSSL 就被标成有 TLCP 套件。
if !p.tlcp_cipher_available {
assert_ne!(p.backend, TlcpBackend::Tongsuo);
}
}
#[test]
fn transport_is_fail_closed_without_tongsuo() {
fn bad_cert_is_rejected_before_environment_probe() {
let text = serde_json::json!({
"sign_cert_pem": "a", "sign_key_pem": "b", "enc_cert_pem": "c",
"enc_key_pem": "d", "ca_pem": "e", "cipher_suite": "ECC-SM2-SM4-CBC-SM3"
+50 -18
View File
@@ -5,7 +5,12 @@
//! 2026-11-07 用户拍板后,`mpc chain sign` 已经能用 OpenSSL **真的签出**
//! SM2 签名(raw `r||s` 64B),但它是软件签名器、私钥可导出、密评不可过。
//! `flush` 发出去的 payload **仍是链上对象规范字节,不是已签名的 FISCO 交易**:
//! 国密交易 RLP 结构待真机对拍、Tongsuo TLCP 握手 FFI 未落地。
//! FISCO **自有**交易编码(不是以太坊 RLP)待真机对拍、Tongsuo TLCP 握手
//! FFI 未落地。★ 国密链提交方法是自有 `sendTransaction`(4 参),
//! **不是** `eth_sendRawTransaction` —— web3 端点固定
//! secp256k1 + keccak256(`Web3Transaction.cpp`),与 SM2/SM3 不兼容。
//! `flush` 的假链桩仍用 `eth_sendRawTransaction` 演练补链,输出里带
//! `methodIsStub=true` 与 `guomiSubmitMethod`,绝不把桩方法冒充真链入口。
//! 所以这一层能验证的是「签名 / distid 对齐 / 传输准入 / 幂等补链 /
//! fail-open 与 fail-closed 分离 / JSON-RPC 判定」这些框架自己的契约,
//! **不是「能上链」**。桩自测也只判这些。
@@ -24,7 +29,9 @@ use mpc_chain::sm2::{
aligned_distid, distid_fingerprint, raw_rs_to_der, DistidConsumer, OpenSslSoftwareSigner,
SM2_DISTID,
};
use mpc_chain::tlcp::{probe_tlcp_environment, TlcpConfig, TlcpReadiness};
use mpc_chain::tlcp::{
probe_tlcp_environment, TlcpBackend, TlcpConfig, TlcpReadiness,
};
use mpc_chain::{to_hex, ChainConfig, TransportMode, PLAINTEXT_STUB_WARNING};
use std::collections::HashMap;
use std::fs;
@@ -69,7 +76,9 @@ const CHAIN_USAGE: &str = "用法:
★ --transport 必须显式给:stub 只允许桩自测,tlcp 是生产路径。
★ sign 的 --policy 必须显式给;production-module 会拒绝软件签名器。
★ flush 的 payload 仍是规范字节,不是已签名交易(RLP / TLCP FFI 未落地)。";
★ flush 的 payload 仍是规范字节,不是已签名交易(FISCO 自有交易编码 /
Tongsuo TLCP FFI 未落地);桩方法 eth_sendRawTransaction 不是国密链入口,
真链必须走 sendTransaction(4 参)。";
fn opts(args: &[String], allowed: &[&str]) -> Result<HashMap<String, String>, String> {
let mut m = HashMap::new();
@@ -207,9 +216,18 @@ fn cmd_flush(args: &[String]) -> Result<(), String> {
let client = HttpChainClient::new(&cfg.rpc_endpoint).map_err(|e| e.to_string())?;
let mut boxed = Outbox::open(req(&o, "--outbox")?).map_err(|e| e.to_string())?;
// ★ 守卫真跑一遍并把结论写进输出:桩自测能核对「国密链确实禁用
// eth_sendRawTransaction」,而不是只靠注释声称。cfg.sm_crypto
// 在配置层已冻结为 true,所以正常路径下这里必然是 true。
let guomi_rejects_stub = mpc_chain::rpc::assert_submit_method_allowed(
mpc_chain::rpc::METHOD_SEND_RAW_TX,
cfg.sm_crypto,
)
.is_err();
eprintln!(
"注意: flush 的 payload 仍是链上对象规范字节,不是已签名交易(RLP / TLCP FFI 未落地);\
此处只验证补链、幂等与传输准入契约。"
"注意: flush 的 payload 仍是链上对象规范字节,不是已签名交易(FISCO 自有交易编码 /\
TLCP 握手 FFI 未落地);此处只验证补链、幂等与传输准入契约。\
桩方法 eth_sendRawTransaction 不是国密链入口,真链必须走 sendTransaction(4 参)。"
);
let report = boxed
.flush_with(|entry| {
@@ -224,12 +242,15 @@ fn cmd_flush(args: &[String]) -> Result<(), String> {
.map(|(k, why)| format!("[\"{}\",\"{}\"]", esc(k), esc(why)))
.collect();
println!(
"{{\"attempted\":{},\"confirmed\":{},\"failed\":[{}],\"remaining\":{},\"method\":\"{}\",\"transport\":\"{}\"}}",
"{{\"attempted\":{},\"confirmed\":{},\"failed\":[{}],\"remaining\":{},\"method\":\"{}\",\"methodIsStub\":{},\"guomiSubmitMethod\":\"{}\",\"guomiChainRejectsStubMethod\":{},\"payload\":\"canonical-bytes-not-signed-tx\",\"transport\":\"{}\"}}",
report.attempted,
report.confirmed,
failed.join(","),
report.remaining,
esc(mpc_chain::rpc::METHOD_SEND_RAW_TX),
true,
esc(mpc_chain::rpc::METHOD_SEND_TRANSACTION),
guomi_rejects_stub,
match mode {
TransportMode::PlaintextStub => "plaintext-stub",
TransportMode::Tlcp => "tlcp",
@@ -373,35 +394,46 @@ fn cmd_tlcp(args: &[String]) -> Result<(), String> {
},
None => (false, String::from("未提供 TLCP 双证书配置")),
};
let readiness = if !p.tlcp_cipher_available {
TlcpReadiness::MissingEnvironment
} else if p.tongsuo_lib.is_none() {
let readiness = if p.backend == TlcpBackend::None {
TlcpReadiness::MissingEnvironment
} else {
// ★ 环境齐备(含 GmSSL 本机握手已跑通)也只到 NeedsFfi:
// Rust 侧把 JSON-RPC 经 TLCP 发到 bcos-rpc 的通道还没接。
TlcpReadiness::NeedsFfi
};
let ready = readiness == TlcpReadiness::Ready && config_ok;
let reason = if !p.tlcp_cipher_available {
format!(
"本机 OpenSSL 无 TLCP 加密套件({}),需要 Tongsuo ≥ 8.4;拒绝以明文/标准 TLS 冒充国密通道",
let reason = match p.backend {
TlcpBackend::None => format!(
"本机既无 OpenSSL/Tongsuo TLCP 套件({}),也无可用 GmSSL;\
需要 Tongsuo ≥ 8.4 或 GmSSL ≥ 3.2;拒绝以明文/标准 TLS 冒充国密通道",
p.openssl_version
)
} else if p.tongsuo_lib.is_none() {
String::from("未配置 MPC_TONGSUO_LIB,拒绝假装已接入 Tongsuo")
} else {
String::from("TLCP 环境齐备但 Tongsuo FFI 握手未落地,拒绝宣称能发真交易")
),
TlcpBackend::GmSSL => String::from(
"GmSSL TLCP 本机握手已可用,但 Rust 侧把 JSON-RPC 经 TLCP 发到 bcos-rpc 的\
进程通道 / FFI 未落地,且未验证 bcos-rpc 是否启用 TLCP;拒绝宣称能发真交易",
),
TlcpBackend::Tongsuo => String::from(
"Tongsuo TLCP 环境齐备但 Rust 侧 FFI 握手未落地,拒绝宣称能发真交易",
),
};
println!(
"{{\"ready\":{},\"readiness\":\"{:?}\",\"configOk\":{},\"opensslVersion\":\"{}\",\"tlcpCipherAvailable\":{},\"tongsuoLib\":{},\"detail\":\"{}\",\"reason\":\"{}\"}}",
"{{\"ready\":{},\"readiness\":\"{:?}\",\"configOk\":{},\"backend\":\"{:?}\",\"opensslVersion\":\"{}\",\"tlcpCipherAvailable\":{},\"tongsuoLib\":{},\"gmsslAvailable\":{},\"gmsslVersion\":{},\"gmsslTlcpCommands\":{},\"detail\":\"{}\",\"reason\":\"{}\"}}",
ready,
readiness,
config_ok,
p.backend,
esc(&p.openssl_version),
p.tlcp_cipher_available,
p.tongsuo_lib
.as_deref()
.map(|s| format!("\"{}\"", esc(s)))
.unwrap_or_else(|| String::from("null")),
p.gmssl_version.is_some(),
p.gmssl_version
.as_deref()
.map(|s| format!("\"{}\"", esc(s)))
.unwrap_or_else(|| String::from("null")),
p.gmssl_tlcp_commands,
esc(&detail),
esc(&reason)
);
+55 -2
View File
@@ -229,8 +229,30 @@ use mpc_chain::policy::{HardRuleSet, OpaPolicyBundle, governance_boundary};
let hard = HardRuleSet::from_json(text)?; // **硬规则进合约**,禁 wasm / rego 字段
let opa = OpaPolicyBundle::from_json(text)?; // **业务合规策略走 OPA**,禁 min_tcb 等硬规则字段
# ★ 硬规则进合约 / 业务合规策略走 OPA;Pro 版**不上 TARS**;OP-TEE 只覆盖小隐私计算场景。
# ★ 主门禁 15 条:第 15 条判 SM2 签名、distid 三重对齐、TLCP fail-closed、治理边界。
# ★ 仍未落地:FISCO 国密交易 RLP、Tongsuo TLCP 握手 FFI、硬件模组 provider;flush 仍发规范字节,**不宣称能上链**。
# ★ 主门禁第 15 条判 SM2 签名、distid 三重对齐、TLCP fail-closed、治理边界(总数见下段:16 条)。
# ★ 仍未落地:FISCO 自有交易编码(不是以太坊 RLP)、Rust 侧 TLCP 通道、硬件模组 provider;flush 仍发规范字节,**不宣称能上链**。
# --- 2026-11-07 追加:GmSSL 真 TLCP / 国密链提交方法 / TA 密钥分级(源码事实,非推测) ---
# ★ sendTransaction 是国密链的自有提交方法(4 参);eth_sendRawTransaction 是
# secp256k1+keccak256 的 web3 端点,**国密链禁用**。上一版写「sendTransaction
# 全仓搜不到」是 search_code 带不匹配 path glob 造成的搜索假阴性,已纠正。
use mpc_chain::rpc::{METHOD_SEND_TRANSACTION, METHOD_SEND_RAW_TX, CRYPTO_SM2_VERIFY_ABI, submit_method_for, assert_submit_method_allowed, send_transaction_params};
assert_submit_method_allowed(METHOD_SEND_RAW_TX, true)?; // 国密链必拒,点名 secp256k1/keccak256
let p = send_transaction_params(group, node, data_hex, false); // 4 参:[groupID,nodeName,data,requireProof]
# ★ sm2Verify(bytes32,bytes,bytes32,bytes32) 是 **4 入参**;message 是 32B 摘要;
# distid 不在 ABI,链上不可配,只能链下对齐 + 真机对拍。
use mpc_chain::tlcp::{TlcpBackend, GMSSL_TLCP_CIPHER_SUITES, TONGSUO_TLCP_CIPHER_SUITES};
let backend = probe_tlcp_environment().backend; // None / Tongsuo / GmSSL
# ★ GmSSL 3.2.0 开源免费(Apache-2.0),本机环回 TLCP 真握手已跑通:
# Protocol: TLCP / Version: TLCP (0101) / TLS_ECC_SM4_CBC_SM3 / 双证书。
# 但 3.x 不与 OpenSSL ABI 兼容,不能当 provider 喂给 reqwest;软件实现不能过密评。
# ★ 本机握手通过 ≠ bcos-rpc 通道已通:TlcpReadiness 仍只到 NeedsFfi,ready 恒 false。
# ★ TA 签名密钥三级:dev 仅 QEMU/CI(需显式 MPC_TA_ALLOW_DEV_KEY 或 MPC_SIM_DEV)、
# staging 用 MPC_TA_SIGN_KEY、prod 用 SIGN_KEY 由 OEM 持有;缺生产密钥绝不回落开发密钥。
# build/build_optee.sh --check-only 在 SDK 检查之前硬拒绝,MPC_TA_KEY_FAIL: 独立短行。
# ★ 主门禁 16 条:第 16 条 = GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约;
# 缺环境一律 *_SKIPPED + 逐项缺失(FISCO_REALNODE_SKIPPED / GMSSL_TLCP_SKIPPED),
# 环境齐备也只 NEEDS_IMPL,绝不打印通过。
# 单二进制的两种 profile(mpc-cli)—— ★ guest 静态产物不许带宿主控制面
# 宿主端:默认 feature `control-plane` → mpc hostd / link / chain / tee up|ps|attest|down 可用。
@@ -652,6 +674,37 @@ mod tests {
}
}
/// 2026-11-07 追加的事实钉子:国密链提交方法、GmSSL 边界、TA 密钥分级。
/// 少了这些,模型会照旧结论写出「国密链也发 eth_sendRawTransaction」或
/// 「装了 GmSSL 就等于通道已通」的代码。
#[test]
fn catalog_documents_gmssl_rpc_and_ta_key_facts() {
for key in [
"use mpc_chain::rpc::{METHOD_SEND_TRANSACTION, METHOD_SEND_RAW_TX, CRYPTO_SM2_VERIFY_ABI, submit_method_for, assert_submit_method_allowed, send_transaction_params}",
"assert_submit_method_allowed(METHOD_SEND_RAW_TX, true)?;",
"let p = send_transaction_params(group, node, data_hex, false);",
"use mpc_chain::tlcp::{TlcpBackend, GMSSL_TLCP_CIPHER_SUITES, TONGSUO_TLCP_CIPHER_SUITES}",
] {
assert!(CATALOG.contains(key), "清单缺少真实 API 签名:{key}");
}
for key in [
"国密链禁用",
"sendTransaction",
"sm2Verify(bytes32,bytes,bytes32,bytes32)",
"4 入参",
"GmSSL 3.2.0",
"NeedsFfi",
"TA 签名密钥三级",
"MPC_TA_KEY_FAIL",
"主门禁 16 条",
"FISCO_REALNODE_SKIPPED",
"本机握手通过 ≠ bcos-rpc 通道已通",
"软件实现不能过密评",
] {
assert!(CATALOG.contains(key), "清单缺少关键结论:{key}");
}
}
/// 方向钉子:框架层不许回到容器编排路线。
#[test]
fn catalog_never_offers_container_orchestration_apis() {
+53 -30
View File
@@ -21,7 +21,10 @@
| — | 会话凭据来源 | **管理节点签发,框架不生成** | `easytier-cli credential generate --ttl` 返回 `credential_id` + `credential_secret`;框架只承载 / 传递 / 绑定 / 回收,`CredentialProvider` 未配置即拒绝(见 3.3) |
| — | 国密链参数(2026-11-07 拍板) | **`sm_crypto=true` 已确认** | 建链参数按国密冻结,不可逆;`false` 一律拒 |
| — | 国密签名实现(2026-11-07 拍板) | **先用 OpenSSL 软件实现** | 真能签 SM2(raw `r||s`);私钥可导出、密评不可过,生产仍需硬件模组 provider |
| — | 客户端通道(2026-11-07 拍板) | **`bcos-rpc` 做国密 TLS / TLCP** | 双证书 + Tongsuo ≥ 8.4;本机无 Tongsuo ⇒ fail-closed,明文不许冒充 |
| — | 客户端通道(2026-11-07 拍板) | **`bcos-rpc` 做国密 TLS / TLCP** | 双证书 + Tongsuo ≥ 8.4 或 GmSSL ≥ 3.2;Rust 侧通道未接入 ⇒ fail-closed,明文不许冒充 |
| — | TLCP 实现选型(2026-11-07 用户提点) | **GmSSL 可用(开源免费,Apache-2.0)** | 本机 3.2.0 环回真握手已跑通(第 16 条 19 判据);但 3.x 不与 OpenSSL ABI 兼容、软件实现不能过密评,生产仍需硬件模组 |
| — | 国密链提交方法(2026-11-07 源码核对) | **自有 `sendTransaction`(4 参)** | `eth_sendRawTransaction` 固定 secp256k1+keccak256,国密链禁用;纠正上一版「`sendTransaction` 搜不到」的搜索假阴性(见 4.8) |
| — | TA 密钥分级脚本层(2026-11-07 补) | **硬拒绝已实现,不再只落文档** | `build_optee.sh --check-only` 三级规则,缺 SDK 也能被第 16 条测到;prod 缺密钥绝不回落开发密钥 |
| — | SM2 distid(2026-11-07 拍板) | **三重对齐,唯一值 `1234567812345678`** | 依据 FISCO `fast_sm2.cpp:35` 的 `c_userId`;三处声明任一漂移即点名拒绝 |
| — | TA 密钥 / OP-TEE 范围(2026-11-07 拍板) | **三级密钥 + 只覆盖小隐私计算** | 分级方案与覆盖范围定稿见第 7 节 |
| — | TARS(2026-11-07 拍板) | **先不上** | ssw-mpc 只依赖 `bcos-rpc` 的 HTTP 端点 |
@@ -633,15 +636,17 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交
提示 `--no-default-features`。`tools/check-guest-artifact.py` 三层探针
(依赖树 / 编译期守卫 / ELF 产物标识)进主门禁第 4 条。
**[修正]** 初稿写「3.x 接入面是自有 JSON-RPC(`sendTransaction` / `call` / `getTransactionReceipt`),不是 `eth_` 兼容」—— 用 gitea 镜像核对 `FISCO-BCOS/FISCO-BCOS` 源码后,这是 **2.x 的老结论**:
**[修正]** 初稿写「3.x 接入面是自有 JSON-RPC,不是 `eth_` 兼容」—— 用 gitea 镜像核对 `FISCO-BCOS/FISCO-BCOS` 源码后,这是 **2.x 的老结论**:`bcos-rpc/bcos-rpc/web3jsonrpc/endpoints/EthMethods.h:54` 明确列出 `eth_sendRawTransaction` / `eth_call` / `eth_getTransactionReceipt`,`EndpointsMapping.cpp` 按枚举注册 handler。
- (以下为**上游 FISCO-BCOS 仓库**路径)`bcos-rpc/bcos-rpc/web3jsonrpc/endpoints/EthMethods.h` 的 `EthMethod` 枚举明确列出 `eth_sendRawTransaction`、`eth_call`、`eth_getTransactionReceipt`、`eth_blockNumber` 等;`EndpointsMapping.cpp` 按 `methodString(EthMethod::...)` 注册 handler。
- `sendTransaction` 全仓搜不到。Rust 侧仍没有官方 SDK,所以只做**最小面**:发交易、查回执、call 三个方法。
- 本期 `mpc_chain::rpc` 的三个方法常量按 `eth_*` 写,并同时钉在单测与桩自测里(防止有人照旧文档改回去)。
**[修正 2,2026-11-07 追加]** 上一版还写「`sendTransaction` 全仓搜不到」—— 这是**搜索假阴性**:那次 `search_code` 带了不匹配的 path glob,空结果被当成「不存在」。实际源码把两条路径分得很清楚:
**★ 方法名兼容 ≠ 交易结构兼容**:`sm_crypto=true` 时交易是 SM2 签名 + FISCO 自有 RLP,web3 端点是否接受国密交易**尚未实测**(写进第 7 节)。方法名只解决「怎么调」,没解决「发什么」。
- (以下为**上游 FISCO-BCOS 仓库**路径)`bcos-rpc/bcos-rpc/jsonrpc/JsonRpcInterface.cpp:18` 注册 `m_methodToFunc["sendTransaction"]`;`JsonRpcImpl_2_0.cpp:477` 是实现,`JsonRpcInterface.h:171` 给出参数 `[groupID, nodeName, data(hex FISCO 交易字节), requireProof]` —— **4 个参数**。节点用 `transactionFactory()->decodeTransaction()` 解 **FISCO 自有**交易结构,`cryptoSuite()->hashImpl()` 在国密链是 SM3。
- `EthEndpoint.cpp:419` 把 web3 参数当 RLP `Web3Transaction` 解(`codec::rlp::decode`);`web3jsonrpc/model/Web3Transaction.cpp` include `Secp256k1Crypto.h`,`txHash()` / `hashForSign()` 都是 `keccak256Hash`,`takeToTarsTransaction()` 写死 `SECP256K1_SIGNATURE_LEN` 与 `r||s||v`。**⇒ 国密链 SM2 交易不能走 web3 端点**:这不是「待实测」,是源码判定。方法名兼容 ≠ 交易结构兼容。
- `bcos-executor/src/precompiled/CryptoPrecompiled.cpp:45` 的 `sm2Verify(bytes32,bytes,bytes32,bytes32)` 是 **4 个入参**(不是三个):`message` 是 32B 摘要、`publicKey` 为 bytes、`r`/`s` 各 32B;内部 `SM2Crypto::verify()` → `wedpr_sm2_verify` 的 C 入参只有 `公钥 / msgHash / 签名`,**distid 不是 ABI 入参** —— 链上这处不可配置,只能让链下与节点实现一致并用真机 `sm2Verify` 对拍确认。
**本期诚实边界(2026-11-07 拍板后)**:`mpc chain sign` 已能用 OpenSSL **真的签出** SM2 签名;但 `mpc chain flush` 发出去的 payload **仍是链上对象的规范字节,不是已签名的 FISCO 交易** —— FISCO 国密交易 RLP 结构待真机对拍、Tongsuo TLCP 握手 FFI 未落地。它验证的是签名 / distid 对齐 / 传输准入 / 幂等补链 / fail-open 与 fail-closed 分离 / JSON-RPC 判定这些框架自己的契约,**不宣称能上链**。
因此 `mpc_chain::rpc` 同时保留两组常量:`METHOD_SEND_TRANSACTION`(国密链正确入口)与 `METHOD_SEND_RAW_TX`(web3 端点,标注仅标准版)。`assert_submit_method_allowed(method, sm_crypto)` 对「国密链 + `eth_sendRawTransaction`」一律 `Config` 拒绝并点名 secp256k1/keccak256;`send_transaction_params()` 钉死 4 参顺序。**`flush` 的假链桩仍用 `eth_sendRawTransaction` 演练补链**,但输出带 `methodIsStub=true`、`guomiSubmitMethod=sendTransaction`、`guomiChainRejectsStubMethod=true` 与 `payload=canonical-bytes-not-signed-tx`,绝不把桩方法冒充真链入口(第 14 条 4 条判据钉死)。
**本期诚实边界(2026-11-07 拍板后)**:`mpc chain sign` 已能用 OpenSSL **真的签出** SM2 签名;但 `mpc chain flush` 发出去的 payload **仍是链上对象的规范字节,不是已签名的 FISCO 交易** —— FISCO **自有**交易编码(不是以太坊 RLP)待真机对拍、Rust 侧 TLCP 通道(Tongsuo FFI / GmSSL 进程通道)未接入。它验证的是签名 / distid 对齐 / 传输准入 / 幂等补链 / fail-open 与 fail-closed 分离 / JSON-RPC 判定这些框架自己的契约,**不宣称能上链**。
**★ 配置与准入纪律**:
① `sm_crypto` 必须显式给、`false` 直接拒(标准版链上用 `keccak256Hash`,链下没有 keccak256 实现,放行等于「摘要永远对不上」的假绿);**`true` 已由用户确认**,建链参数按国密冻结。
@@ -650,7 +655,9 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交
**★ distid 三重对齐**:唯一值 `1234567812345678`,真相源 `mpc_core::domain::SM2_DISTID`。依据是 FISCO 上游 `bcos-crypto/bcos-crypto/signature/fastsm2/fast_sm2.cpp:35` 的 `const char* c_userId = "1234567812345678"`,与 OpenSSL SM2 默认 user id 同值;同文件 `c_R_FIELD_LEN=32` / `c_S_FIELD_LEN=32` / `c_PUBLICKEY_LEN=64` 也印证裸 `r||s` 与裸公钥格式。三处消费方(链下签名 / 链上验签 / CSV 证明验签)都必须声明它,`aligned_distid()` 任一漂移即点名拒绝。**硬证据是系统 `openssl dgst -sm3 -verify` 验过框架签出的签名**(门禁第 15 条)—— 只在 Rust 里自签自验是循环自证,测不到 distid 漂移。
**★ TLCP 本机实测(2026-11-07)**:`OpenSSL 4.0.3` 有 SM2 实现,但 `openssl ciphers -v` **无 TLCP 套件**,也没有 `tongsuo` / `gmssl`。本期落的是 TLCP 双证书契约(六字段全显式、SM2 曲线 / 双证书不同 / CA 验签 / 私钥与证书匹配真校验)、环境探测与 fail-closed 准入;**Tongsuo FFI 握手未落地,不假装通道已通**。另:本机 OpenSSL 4 用 CLI 自签 SM2 X509 报 `wrong public key type`,双证书**正向**校验也需到 Tongsuo 环境对拍;负向(非法配置即拒、环境缺失即拒)已在第 15 条真跑。
**★ TLCP 本机实测与 GmSSL(2026-11-07 用户提点后追加)**:`OpenSSL 4.0.3` 的 `openssl ciphers -v` **无 TLCP 套件**、无 `tongsuo`;用户指出可用 **GmSSL**(开源免费、Apache-2.0),`brew install gmssl` 装到 **3.2.0**:`gmssl tlcp_server -help` / `tlcp_client -help` 支持 SM2 双证书,套件名是 `TLS_ECC_SM4_CBC_SM3` / `TLS_ECC_SM4_GCM_SM3`(**与 Tongsuo 的 `ECC-SM2-SM4-CBC-SM3` 命名不同**,`TLCP_CIPHER_SUITES` 合并白名单收两套名字)。`tools/selftest-tlcp-gmssl.py` 现场生成 SM2 根 CA + 签名/加密双证书、真起服务端与客户端,**本机环回握手跑通**:`Protocol: TLCP` / `Version: TLCP (0101)` / 国密套件 / 应用数据往返 / `-certout` 双证书;负向(错误 CA → `tls_cert_chain_verify`、纯非国密套件 → `tls_ctx_set_cipher_suites`)都带期望特征,19 条判据进第 16 条。另:`gmssl certgen -help` 明写默认 `-sm2_id` 就是 `1234567812345678`,与 `SM2_DISTID` 做跨实现对拍(第 16 条判据)。
**★ 但绝不能把「本机握手通过」说成「通道已通」**:① GmSSL 3.x **移除了核心的 OpenSSL 兼容 API**(`libgmssl` 是独立 ABI),不能当 provider 直接喂给 `reqwest`;② 服务端是环回 `tlcp_server`,不是 `bcos-rpc`,也没验证节点是否启用 TLCP;③ Rust 侧把 JSON-RPC 经 TLCP 发出去的 FFI / 进程通道(候选 `gmssl tlcp_client -in file`)**未接入** `HttpChainClient`。所以 `TlcpReadiness` 仍只到 `NeedsFfi`,`require_transport()` 继续 fail-closed;脚本成功只打印 `GMSSL_TLCP_OK` + `BCOS_RPC_NOT_VERIFIED`。GmSSL 是软件实现、私钥可导出,**不能过密评**,不替代硬件国密模组。本机 OpenSSL 4 用 CLI 自签 SM2 X509 报 `wrong public key type`,双证书**正向**校验仍待真机环境对拍;负向(非法配置即拒、环境缺失即拒)已在第 15 / 16 条真跑。
**★ `HttpChainClient` 显式 `.no_proxy()`**:控制面只连配置里的 `host:port`。系统代理会把这一跳的端点换掉 —— 桩测试里表现为回环端口被代理接走后返回 502(而不是 Connection refused),生产里会让国密 TLS 的实测结论整个失效(TLS 终止点变了)。门禁第 14 条有专门回归探针。
@@ -703,14 +710,15 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交
| **3** | 策略:OPA 进 guest + 控制面签发 bundle + decision 上链 | 中(OPA 二进制 + bundle 分发) | 高(bundle 灰度与撤销、TCB 边界) | 2 |
| ~~4~~ | ~~Rego→WASM 上链~~ | — | — | **删除(决策 6)** |
**阶段状态(2026-11-07 拍板后)**:**0a 已完成**(第 12 条)、**1 已完成**(第 13 条)、**2 形状层 + OpenSSL 国密签名已完成**(第 14 / 15 条,主门禁共 15 条);0b 的编排与判据已实现、**QEMU 实跑待有 SDK 的机器**;3 未开工(硬规则 / OPA 的**对象形状**已在第 15 条落地,合约部署与 bundle 执行仍未做)。**阶段 2 仍不含真实交易签名上链** —— RLP / 国密模组 provider / TLCP FFI 未落地,见 4.8。
**阶段状态(2026-11-07 追加 GmSSL 后)**:**0a 已完成**(第 12 条)、**1 已完成**(第 13 条)、**2 形状层 + OpenSSL 国密签名 + GmSSL 本机 TLCP 真握手已完成**(第 14 / 15 / 16 条,主门禁共 **16 条**);0b 的编排与判据已实现、**QEMU 实跑待有 SDK 的机器**;3 未开工(硬规则 / OPA 的**对象形状**已在第 15 条落地,合约部署与 bundle 执行仍未做)。**阶段 2 仍不含真实交易签名上链** —— FISCO 自有交易编码 / 国密模组 provider / Rust 侧 TLCP 通道未落地,见 4.8 与 `tools/fisco-realnode-probe.py`。
**★ 第 4 条门禁本轮补上 guest 产物边界**:`mpc-chain` 引 `openssl` 后 musl 静态产物链接失败,
暴露的是「宿主控制面被编进 guest」而不是环境缺包。现按 feature + target 切分,
`tools/check-guest-artifact.py` 三层探针(依赖树 / 编译期守卫 / ELF 标识)进主门禁;
`deps` 不依赖 musl target 是否安装,避免「跳过目标」把边界判据一起跳掉。
本轮 `./tools/ci.sh` **15 条全绿**:第 4 条新增 guest 探针 22(deps)/ 3(guard)/ 15(binary)
条判据、第 14 条 47 条、第 15 条 33 条,无跳过项。
本轮 `./tools/ci.sh` **16 条全绿**:第 4 条 guest 探针 22(deps)/ 3(guard)/ 15(binary)、
第 14 条 50、第 15 条 36、第 16 条真握手 19 + TA 密钥 16 + 两份零依赖契约判据
11 / 12;真机契约实跑如实输出 `FISCO_REALNODE_SKIPPED` 与 6 项缺失,无静默通过。
**为什么 0a 必须第一**:后三件都要"可编排的对象"。没有 `TeeRuntime` 和 e2b 接口,"给这个会话签 credential""把这轮登记上链"都没有承载点。
@@ -747,10 +755,15 @@ CLI `crates/mpc-cli/src/link.rs`(`mpc link plan|verdict|credential`)。
`Receipt` 四布尔分开、签名不进被签内容)、`rpc`(3.x `eth_*` 方法、HTTP 200 + `error` 判失败、`result:null` 不算成功、
`.no_proxy()`)、`outbox`(复合幂等键、fail-open、坏行拒绝、临时文件 + rename 落盘)、`admission`(fail-closed、
`expires_at` 过期即拒)、`signer` / `sm2` / `tlcp` / `policy`(软件 SM2 真签名、distid 三重对齐、TLCP 双证书准入、
硬规则与 OPA 分域)。**RLP / 模组 provider / Tongsuo FFI 仍未实现**,不宣称能上链。
硬规则与 OPA 分域)。**FISCO 自有交易编码 / 模组 provider / Rust 侧 TLCP 通道仍未实现**,不宣称能上链。
CLI `mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governance`;
`tools/selftest-chain.py` **47 条判据进主门禁第 14 条**、`tools/selftest-chain-gm.py`
**33 条判据进第 15 条**(含系统 openssl CLI 独立验签),均用桩跑完整链路。
`tools/selftest-chain.py` **50 条判据进主门禁第 14 条**(含国密链提交方法纠正的 4 条)、
`tools/selftest-chain-gm.py` **36 条判据进第 15 条**(含系统 openssl CLI 独立验签与
GmSSL 套件名白名单),均用桩跑完整链路。
**第 16 条**新增 `tools/selftest-tlcp-gmssl.py`(真 TLCP 握手 19 条)、
`tools/selftest-ta-key-tier.py`(三级密钥 16 条)与
`tools/fisco-realnode-probe.py`(真机对拍契约 12 条零依赖判据);
前两者的 `--self-test` / TA 探针不依赖 GmSSL 或 SDK,判据永远能被执行到。
**★ fail-open 与 fail-closed 不许混**:链是审计锚(存证侧链挂照算、条目入队等补链),
成员资格与硬规则是安全前提(缓存缺失 / 过期 / 非成员一律拒绝)。两侧各写一份,绝不互相借用策略。
@@ -780,10 +793,10 @@ CLI `mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governanc
1. **`sm_crypto=true` 已确认**。建链参数按国密冻结,不可逆;配置层 `false` 一律拒。
2. **国密签名先用 OpenSSL 软件实现**。真能签 SM2(DER→raw 64B);但私钥可导出、密评不可过,**生产仍要换硬件模组 provider**。采购规格书条件不变:provider 形态、私钥不可导出、distid 可设、Tongsuo ≥ 8.4(建议 8.5);engine 形态不接受。软件实现只是把链路打通,不替代采购。
3. **客户端到 `bcos-rpc` 做国密 TLCP 已定**。本期落双证书契约 + 环境探测 + fail-closed;Tongsuo FFI 握手待环境(本机 OpenSSL 4.0.3 无 TLCP 套件),见 4.8。
3. **客户端到 `bcos-rpc` 做国密 TLCP 已定**。本期落双证书契约 + 环境探测 + fail-closed;用户提点后装了 GmSSL 3.2.0,本机环回**真 TLCP 握手已跑通**(第 16 条 19 判据),但 Rust 侧通道 / `bcos-rpc` 是否启用 TLCP 仍未验证,见 4.8。Tongsuo FFI 不再是唯一路径。
4. **OP-TEE 覆盖范围定稿**:只覆盖**小隐私计算**(两方、设备侧、同域),不进 EasyTier、不进链、不进 `TeeRuntime` 进程生命周期(它是会话级 attach `/dev/tee0`,杀进程会切断别人正在用的 TA)。CI 覆盖 QEMU 五条判据,真板作为上线前一次性验收;两者证明的东西不同,不能互相替代。
5. **SM2 distid 三重对齐已定**:唯一值 `1234567812345678`(FISCO `fast_sm2.cpp:35` 的 `c_userId` 与 OpenSSL 默认同值),真相源 `mpc_core::domain::SM2_DISTID`;三处声明任一漂移即点名拒绝,系统 openssl CLI 独立验签为硬证据(门禁第 15 条)。模组内部若硬编码别的值,采购验收时必须实测对齐。
6. **TA 签名密钥分级定稿**:三级 —— ① **dev**:仓库内 `default_ta.pem`,**仅 QEMU / CI**;② **staging**:`MPC_TA_SIGN_KEY` 指向受控密钥,预发布验收;③ **prod**:由设备厂商 / OEM 持有,**ssw-mpc 不持密钥**。`build_optee.sh` 缺生产 `SIGN_KEY` 时不得回落开发密钥。★ 诚实边界:这条纪律本期只落在文档与 catalog 形状,**脚本层硬拒绝尚未实现**(下一轮,避免与现有 QEMU 判据自测冲突)。
6. **TA 签名密钥分级定稿**:三级 —— ① **dev**:仓库内 `default_ta.pem`,**仅 QEMU / CI**;② **staging**:`MPC_TA_SIGN_KEY` 指向受控密钥,预发布验收;③ **prod**:由设备厂商 / OEM 持有,**ssw-mpc 不持密钥**。`build_optee.sh` 缺生产 `SIGN_KEY` 时不得回落开发密钥。**2026-11-07 补:脚本层硬拒绝已实现,不再只落文档** —— `build/build_optee.sh --check-only` 把三级解析放在 `OPTEE_OS` 检查之前;prod 缺密钥 / 用开发密钥、staging 缺受控密钥、dev 无 QEMU/CI 标记、两个密钥变量同时给、非法 tier 一律以 `MPC_TA_KEY_FAIL:` 独立短行拒绝。`tools/selftest-ta-key-tier.py` 16 条判据进第 16 条,**在没 SDK 的机器上也能被执行到**(守卫不会被前置环境检查抢先)。
**待实测(不阻塞开工,但阻塞上生产)**
@@ -797,12 +810,19 @@ CLI `mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governanc
`peer` 只给 `p2p`/`relay`,不报经的是哪个中继网,所以 `allowlist` 档目前靠
`--relay-network` 的宿主**配置声明**核对,真机要补 RPC / `route` 观测后才能算
「实际路径已核对」。`p2p-only` 档不受影响(见 relay 即拒)。
9c. **FISCO 真机必须补的三处对拍**(本期用桩 + 形状层,别拿"本机没链"当通过):
① `sm_crypto=true` 的国密交易是否走 web3 端点(`eth_sendRawTransaction`)—— 方法名兼容
不等于 RLP / SM2 签名结构兼容;② 客户端到 `bcos-rpc` 是否要求国密 TLCP;
③ `CryptoPrecompiled.sm2Verify` 的三个入参(CSV 公钥编码 / message 是 hash 还是原文 /
distid),见 4.4。**另外**:模组到位后要让 `flush` 发出去的是**已签名交易**
而非规范字节,并补一笔真机交易对拍。
9c. **FISCO 真机必须补的四处对拍**(2026-11-07 已契约化,见
`tools/fisco-realnode-probe.py`,第 16 条 12 条零依赖判据):
① **源码已判定**:国密链交易走自有 `sendTransaction`(4 参),
`eth_sendRawTransaction` 是 secp256k1+keccak256 的 web3 端点、国密链禁用
(见 4.8);真机仍需对拍节点是否接受我们的 `data` 编码。
② 客户端到 `bcos-rpc` 是否真要求国密 TLCP —— 本机环回握手通过**不算**,
服务端是 `gmssl tlcp_server` 不是节点。
③ `CryptoPrecompiled.sm2Verify(bytes32,bytes,bytes32,bytes32)` **四入参**:
`message` 是 32B 摘要、公钥是 bytes、`r`/`s` 各 32B;distid **不在 ABI**,
链上不可配,只能链下对齐 + 真机对拍(见 4.4 / 4.8)。
④ 模组到位后 `flush` 要发**已签名 FISCO 交易**而非规范字节,并补一笔真机交易对拍。
★ 契约纪律:缺环境打印 `FISCO_REALNODE_SKIPPED` + **逐项缺失**;
环境全齐也只报 `FISCO_REALNODE_NEEDS_IMPL`(缺的是实现),**绝不打印通过**。
10. **OP-TEE 在 TA 共享语义下的租户隔离**。TA 是设备级单例,多机构共存时密钥域怎么分——`optee/core.rs` 的 seal 格式是否已带租户维度,要核对。**这条现在是生效的**(OP-TEE 已进本轮,见 1.7)。
**已拍板(2026-11-07)**
@@ -832,20 +852,23 @@ CLI `mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governanc
- `tools/selftest-link.py`(**进主门禁第 13 条**;53 条判据,用 fake-easytier-cli / fake-easytier-core 两个桩跑完整链路;**每条负向带期望特征**;含「混合 peer 假绿」「进程真回收」两条回归探针)
- `crates/mpc-chain/src/lib.rs`(`ChainConfig` 每字段必须显式、`sm_crypto=false` 拒绝并说明 keccak256 未实现、`client_tlcp` 声明 TLCP + `require_transport()` 生产路径 fail-closed;`digest_for_config` 是**全框架唯一** hash 入口)
- `crates/mpc-chain/src/objects.rs`(`ChainObject::canonical_bytes` 唯一实现:域分隔 `TEE_CHAIN_OBJECT` + 类型标签 + 4 字节大端长度前缀;四类对象摘要;`Receipt` 四布尔分开、签名不进被签内容)
- `crates/mpc-chain/src/rpc.rs`(3.x `eth_*` 方法常量;`parse_response` 先判 error 再判 result、缺 result 拒、id 不匹配拒、`result:null` 不算成功;`.no_proxy()`)
- `crates/mpc-chain/src/rpc.rs`(**两组方法常量**:国密链 `METHOD_SEND_TRANSACTION`(4 参)与 web3 端点 `METHOD_SEND_RAW_TX`;`assert_submit_method_allowed()` 对国密链 + `eth_sendRawTransaction` 拒绝;`send_transaction_params()` 钉死 `[groupID,nodeName,data,requireProof]`;`CRYPTO_SM2_VERIFY_ABI` 四入参;`parse_response` 先判 error 再判 result、缺 result 拒、id 不匹配拒、`result:null` 不算成功;`.no_proxy()`)
- `crates/mpc-chain/src/outbox.rs`(`kind:order_id:decision_id` 复合幂等键、重复不覆盖、fail-open、坏行整体拒绝、临时文件 + rename)
- `crates/mpc-chain/src/admission.rs`(fail-closed:缓存缺失 / 过期 / 硬规则失败 / 非成员一律拒;`expires_at` 缺失不当永不过期)
- `crates/mpc-chain/src/signer.rs`(`Signer` trait 形状 + 启动自检三件;**`ModuleSigner` 未实现**,未配置即拒绝,不假装可用)
- `crates/mpc-cli/src/chain.rs`(`mpc chain digest|submit|flush|status|admit`;**flush 输出明确标注 payload 不是已签名交易**)
- `tools/selftest-chain.py`(**进主门禁第 14 条**;44 条判据,Python 假 `bcos-rpc`;每条负向带期望特征;含 `.no_proxy()` 回归探针)
- `crates/mpc-chain/src/signer.rs`(`SignerSecurityProfile::{HardwareModule,SoftwareDev}` + `SignerPolicy`(**无 Default**);`require_self_test(s, policy)` 生产策略拒软件签名器;**硬件模组 `ModuleSigner` 仍未实现**)
- `crates/mpc-chain/src/tlcp.rs`(`TlcpBackend::{None,Tongsuo,GmSSL}`;`Tongsuo` 与 `GmSSL` 两套套件名合并白名单;`probe_tlcp_environment()` 真跑 `openssl`/`gmssl`;环境齐备仍只到 `NeedsFfi`)
- `crates/mpc-cli/src/chain.rs`(`mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governance`;**flush 输出 `methodIsStub` / `guomiSubmitMethod` / `guomiChainRejectsStubMethod` / `payload`,明确标注 payload 不是已签名交易**)
- `tools/selftest-chain.py`(**进主门禁第 14 条**;50 条判据,Python 假 `bcos-rpc`;每条负向带期望特征;含 `.no_proxy()` 与国密链提交方法回归探针)
- `tools/selftest-chain-gm.py`(**第 15 条**;36 条判据;系统 openssl CLI 独立验签、生产策略拒软件签名器、GmSSL 套件名白名单、环境齐备也 `ready=false`)
- `tools/selftest-tlcp-gmssl.py` / `tools/selftest-ta-key-tier.py` / `tools/fisco-realnode-probe.py`(**第 16 条**;真 TLCP 握手 19 / 三级密钥 16 / 真机契约 12 + 两份零依赖 `--self-test`;缺环境一律显式 `*_SKIPPED` + 逐项缺失,绝不静默通过)
- `crates/mpc-core/src/domain.rs`(`TEE_LINK_BIND` / `TEE_CHAIN_OBJECT` 域分隔常量;改一个字节 = 已登记摘要全部对不上)
- `crates/mpc-tee/src/session.rs:75`(`user_data` 两段 sha256 拆分)
- `crates/mpc-tee/src/verify.rs:89`(`CSV_REPORT_LEN = 2548`,真机实测;注释明确 4096 是 hypercall 页不是报告长度)
- `crates/mpc-tee/src/platform.rs`(`PlatformProfile::builtin()` 对 `Optee` / `Tdx` 返回 `None`,有断言钉死;本轮已把该文件开头误写的"CSV 4096 字节"改为 2548)
- `crates/mpc-tee/src/optee/{mod,core,proto}.rs`(CA↔TA 三层范式、seal 格式、命令协议;`ta/`、`ca/` 需 OP-TEE SDK 交叉编译,`build/build_optee.sh` 驱动)
- `build/build_optee.sh`(需要 `OPTEE_OS` + `SDK_DIR` + `arm-linux-gnueabihf-`;`UUID` 硬编码 `a1b2c3d4-…`;`SIGN_KEY` 留空即用开发密钥 `default_ta.pem`;`MPC_SIM_DEV` A/B 跨设备解封失败的机制已串进 `tools/optee-cross-device.sh`,但**QEMU 未实跑**)
- `build/build_optee.sh`(需要 `OPTEE_OS` + `SDK_DIR` + `arm-linux-gnueabihf-`;`UUID` 硬编码 `a1b2c3d4-…`;**`--check-only` 在 SDK 检查之前解析 TA 签名密钥三级**:dev 必须显式 `MPC_TA_ALLOW_DEV_KEY=1` / `MPC_SIM_DEV`,staging 必须 `MPC_TA_SIGN_KEY`,prod 必须 `SIGN_KEY` 且绝不回落 `default_ta.pem`,违规以 `MPC_TA_KEY_FAIL:` 独立短行拒绝;`MPC_SIM_DEV` A/B 跨设备解封失败的机制已串进 `tools/optee-cross-device.sh`,但**QEMU 未实跑**)
- `crates/mpc-tee/Cargo.toml`(**没有 `optee` feature**;TA 走 `default-features = false`,所以 `mpc-tee` 的 no_std 是 OP-TEE 的硬前置)
- `tools/ci.sh`(**十四条**;第 3 条已从"mpc-core no_std"扩展为"mpc-core + mpc-tee no_std + TA UUID 对拍";第 4 条有"跳过:目标未安装"的既有语义,`ci-optee.sh` 的 skip 输出照此设计;**第 11 条 = OP-TEE 判据逻辑自测**,零 SDK 依赖;**第 12 条 = 宿主控制面端到端自测**;**第 13 条 = 会话级链路层端到端自测**;**第 14 条 = 链上层端到端自测**,见下)
- `tools/ci.sh`(**十六条**;第 3 条 = mpc-core + mpc-tee no_std + TA UUID 对拍;第 4 条 = musl 跨目标零告警 + guest 产物三层探针;**第 11 条 = OP-TEE 判据逻辑自测**(零 SDK);第 12 / 13 / 14 条 = hostd / 链路层 / 链上层端到端自测;**第 15 条 = 国密签名 / distid / TLCP 准入 / 治理形状**;**第 16 条 = GmSSL TLCP 真握手 + TA 密钥分级 + FISCO 真机对拍契约**,其中两份 `--self-test` 与 TA 探针零外部依赖,缺环境一律显式 `*_SKIPPED` + 逐项缺失)
- `tools/check-optee-uuid.py`(五处 UUID 对拍,不写死期望值;已做探针回归——改一个字符即 `OPTE_UUID_FAIL` 并指出差异行)
- `tools/ci-optee.sh`(段二独立通道。skip 分支已实测,构建分支待真 SDK;新增 `--cross-device` / `--restart` 两个互斥模式)
- `build/optee-verdict.py`(**判据的唯一真相源**:按 mode / expect / provisioned / require-9p 判定串口日志,兼带 blob 抠取。判据散落多处 = 迟早分叉且分叉了没人知道)
@@ -866,8 +889,8 @@ CLI `mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governanc
- 官方文档:Pro 版部署(`deploy_pro_by_buildchain`、`installation_without_tars`、TARS 依赖)、`[chain] sm_crypto` 不可改、OPCODE 差异表(`KECCAK256` 国密版为 SM3、`CREATE2` 按 SM3 推导地址)
- **gitea 镜像 distid 核对(2026-11-07)**:`FISCO-BCOS/FISCO-BCOS` 的 `bcos-crypto/bcos-crypto/signature/fastsm2/fast_sm2.cpp:35` 写死 `const char* c_userId = "1234567812345678"`,同文件 `c_R_FIELD_LEN = 32` / `c_S_FIELD_LEN = 32` / `c_PUBLICKEY_LEN = 64` ⇒ 国密链要 raw `r||s` 与无 `04` 前缀的裸公钥。以上均为**上游仓库**相对路径,不是 ssw-mpc 本仓库文件。
- **本机国密能力实测(2026-11-07)**:`OpenSSL 4.0.3` 有 SM2 实现(`openssl list -signature-algorithms` 含 `{1.2.156.10197.1.301, SM2} @ default`);`openssl ecparam -name SM2 -genkey` + `openssl dgst -sm3 -sign/-verify` 全通,签名为 DER `ECDSA-Sig-Value`。`openssl ciphers -v` **无 TLCP 套件**、无 `tongsuo` / `gmssl`;CLI 自签 SM2 X509 报 `wrong public key type`。`openssl` crate 在本机 4.0.3 下真能签(`cargo run` 实测)。
- **gitea 镜像 `FISCO-BCOS/FISCO-BCOS` 源码核对(2026-11-07)**:下列路径均为**上游仓库**相对路径,不是 ssw-mpc 本仓库文件。`bcos-rpc/bcos-rpc/web3jsonrpc/endpoints/EthMethods.h` 的 `EthMethod` 枚举含 `eth_sendRawTransaction` / `eth_call` / `eth_getTransactionReceipt`;`EndpointsMapping.cpp` 按枚举注册;`sendTransaction` 全仓搜不到。`FISCO-BCOS/tools/BcosBuilder/pro/conf/config-build-example.toml` 有 `sm_crypto=false`(注释 "use sm-crypto or not");`bcos-tool/bcos-tool/NodeConfig.cpp:664` 从 `chain.sm_crypto` 读创世配置。`bcos-executor/src/precompiled/CryptoPrecompiled.cpp` 确认 `sm3(bytes)` / `keccak256Hash(bytes)` / `sm2Verify(bytes32,bytes,bytes32,bytes32)` 三个选择器。
- **本机国密能力实测(2026-11-07,GmSSL 追加后)**:`OpenSSL 4.0.3` 有 SM2 实现(`openssl list -signature-algorithms` 含 `{1.2.156.10197.1.301, SM2} @ default`);`openssl ecparam -name SM2 -genkey` + `openssl dgst -sm3 -sign/-verify` 全通,签名为 DER `ECDSA-Sig-Value`。`openssl ciphers -v` **无 TLCP 套件**、无 `tongsuo`;CLI 自签 SM2 X509 报 `wrong public key type`。**追加:`brew install gmssl` 装到 GmSSL 3.2.0**(Apache-2.0),`gmssl help` 有 `tlcp_server` / `tlcp_client`,两个命令的 `-help` 列出 `TLS_ECC_SM4_CBC_SM3` / `TLS_ECC_SM4_GCM_SM3`;`gmssl certgen -help` 明写默认 `-sm2_id` 为 `1234567812345678`。本机环回真握手输出 `Protocol: TLCP` / `Version: TLCP (0101)` / 国密套件 / 双证书,判据见 `tools/selftest-tlcp-gmssl.py`。
- **gitea 镜像 `FISCO-BCOS/FISCO-BCOS` 源码核对(2026-11-07,含一次重要的假阴性纠正)**:下列路径均为**上游仓库**相对路径,不是 ssw-mpc 本仓库文件。`web3jsonrpc/endpoints/EthMethods.h:54` 的 `EthMethod` 枚举含 `eth_sendRawTransaction` / `eth_call` / `eth_getTransactionReceipt`,`EndpointsMapping.cpp` 按枚举注册;**`bcos-rpc/bcos-rpc/jsonrpc/JsonRpcInterface.cpp:18` 注册 `m_methodToFunc["sendTransaction"]`,`JsonRpcImpl_2_0.cpp:477` 是实现,`JsonRpcInterface.h:171` 给出 4 参 `[groupID,nodeName,data,requireProof]` —— 上一版写「`sendTransaction` 全仓搜不到」是 `search_code` 带了不匹配 path glob 导致的搜索假阴性,已纠正**。`web3jsonrpc/model/Web3Transaction.cpp` 固定 `Secp256k1Crypto.h` + `keccak256Hash` + `SECP256K1_SIGNATURE_LEN`(`r||s||v`)⇒ 国密链不走 web3 端点。`bcos-executor/src/precompiled/CryptoPrecompiled.cpp:45` 的 `sm2Verify(bytes32,bytes,bytes32,bytes32)` 是 **4 入参**;`bcos-crypto/bcos-crypto/signature/sm2/SM2Crypto.cpp` 走 `wedpr_sm2_verify`,C 入参只有公钥 / msgHash / 签名,**distid 不在 ABI**。`FISCO-BCOS/tools/BcosBuilder/pro/conf/config-build-example.toml` 有 `sm_crypto=false`;`bcos-tool/bcos-tool/NodeConfig.cpp:664` 从 `chain.sm_crypto` 读创世配置。
- `cmake/Options.cmake` 的 `WITH_WASM`(默认 OFF)——决策 6 后不再使用
**EasyTier**
+52 -22
View File
@@ -38,13 +38,24 @@
# fail-open 与 fail-closed 分开 / JSON-RPC 200+error 不当成功 /
# 系统代理不能把这一跳的端点偷偷换掉 / 传输形态必须显式给)。
# 本机没有 FISCO 节点,用桩跑完整链路;
# ★ 不宣称能上链 —— flush 发的是规范字节,不是已签名交易。
# ★ 不宣称能上链 —— flush 发的是规范字节,不是已签名交易;
# ★ 国密链提交方法是自有 sendTransaction(4 参),
# eth_sendRawTransaction 是 secp256k1+keccak256 的 web3 端点,
# 国密链禁用(gitea 镜像源码核对,非推测)。
# 14. 国密签名与治理形状必须端到端自测:OpenSSL SM2 真签名 +
# ★ 系统 openssl CLI 独立验签(distid 三重对齐的硬证据,不是自证)+
# 软件签名器生产策略必拒 + TLCP 环境缺失 fail-closed +
# 软件签名器生产策略必拒 + TLCP 通道准入 fail-closed +
# 硬规则进合约 / OPA 管业务合规两者不混。
# 本机没有 Tongsuo / 国密链,TLCP 双证书正向校验与真交易 RLP
# 仍测不到 —— 如实标成待对拍,不许「环境不支持就跳过」蒙过去。
# 本机无 Tongsuo,但 GmSSL 3.2.0 已可用;双证书正向校验与
# 真交易编码仍待真机对拍,不许「环境不支持就跳过」蒙过去。
# 15. GmSSL 真 TLCP 握手 + TA 密钥分级 + FISCO 真机对拍契约:
# 真握手现场生成 SM2 双证书并起 gmssl tlcp_server/tlcp_client,判
# Protocol: TLCP / Version: TLCP (0101) / 国密套件 / 应用数据往返,
# 负向(错误 CA、纯非国密套件)带期望拒绝特征;
# ★ 本机环回通过 ≠ bcos-rpc 通道已通,输出 BCOS_RPC_NOT_VERIFIED。
# TA 密钥三级(dev/staging/prod)用 --check-only 在**缺 SDK** 时也
# 能被执行到;FISCO 真机契约缺环境必显式 SKIPPED + 逐项缺失,
# 环境全齐也只报 NEEDS_IMPL,**绝不打印通过**。
#
# 用法:tools/ci.sh 正常跑
# tools/ci.sh --fast 跳过测试与示例,只编译(改完想快速确认能编过时用)
@@ -65,19 +76,19 @@ step() { printf '\n\033[1m== %s ==\033[0m\n' "$1"; }
ok() { printf '\033[32m ok\033[0m\n'; }
if [ "$FAST" -eq 0 ]; then
step "1/15 全量测试(含 secure 特性)"
step "1/16 全量测试(含 secure 特性)"
cargo test --workspace --features secure
ok
fi
step "2/15 零告警构建(所有目标)"
step "2/16 零告警构建(所有目标)"
# -Dwarnings 同时作用于本地 crate 的 test / bench / example 目标,
# 所以「测试代码里有 unused」也会被拦下 —— 这正是想要的。
RUSTFLAGS="${RUSTFLAGS:+${RUSTFLAGS} }-Dwarnings" \
cargo build --workspace --all-targets --features secure
ok
step "3/15 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)"
step "3/16 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)"
# 两条 no_std 都要守:
# mpc-core —— TEE / armv7 那条路的底座
# mpc-tee —— OP-TEE 的 TA 就是 default-features = false 构建的
@@ -115,7 +126,7 @@ ok
# 三层判据都在 tools/check-guest-artifact.py:依赖树(必跑)、
# 编译期守卫负向、ELF 产物标识(后两条需已装 musl target)。
CROSS_TARGET=x86_64-unknown-linux-musl
step "4/15 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针"
step "4/16 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针"
# 依赖树与标识串自检不依赖 musl target 是否安装 —— 目标没装也必须跑,
# 否则「跳过」会把最重要的边界判据一起跳掉(闸门不扫自己 = 假安全感)。
python3 tools/check-guest-artifact.py deps --target "$CROSS_TARGET"
@@ -134,7 +145,7 @@ else
fi
if [ "$FAST" -eq 0 ]; then
step "5/15 示例冒烟(12 个场景)"
step "5/16 示例冒烟(12 个场景)"
tools/examples.sh
ok
@@ -153,14 +164,14 @@ if [ "$FAST" -eq 0 ]; then
# bash 把逗号并进变量名 → CI 第 4 条直接 `CROSS_TARGET,: unbound variable`
# 中途挂掉;而 lint 闸门只扫 deploy/tee,**对自己的盲区完全无感**。
# 闸门不扫闸门自己 = 闸门有盲区 = 假安全感。
step "6/15 shell 引号 / 变量名卫生"
step "6/16 shell 引号 / 变量名卫生"
python3 deploy/tee/real-machine/lint-shell-vars.py deploy/tee tools
ok
# 第 6 条:OCI 运行期完整性链自测。
# 这条链是「代码度量 → 活文件内容」的闭链,断了不会有编译错误,
# 只会在真机上表现为篡改活文件照样通过 —— 必须有本地闸门兜住。
step "7/15 OCI 运行期完整性链自测"
step "7/16 OCI 运行期完整性链自测"
python3 deploy/tee/oci/selftest-chain.py
ok
@@ -171,7 +182,7 @@ if [ "$FAST" -eq 0 ]; then
# · 判定断(判定器被顶替 / 输出不是判定结论)→ **假绿**,
# 「通过之后真的会签发 token 并下发密钥」这条路从未被验证过。
# 所以这里必须同时覆盖正向路径与全部拒绝路径。
step "8/15 KBS 先验证明才下发自测"
step "8/16 KBS 先验证明才下发自测"
python3 deploy/tee/kbs/selftest-kbs.py
ok
@@ -179,7 +190,7 @@ if [ "$FAST" -eq 0 ]; then
# guest 的 /init 由 busybox ash 解析,`bash -n` 通过 ≠ ash 能解析。
# 真机上这类错误要等 guest 起来才暴露,排查一轮几分钟;
# 本地闸门用 alpine 的 busybox ash(与 guest 同款解析器)秒级拦住。
step "9/15 guest 脚本 ash 语法"
step "9/16 guest 脚本 ash 语法"
deploy/tee/guest/syntax-check.sh
ok
@@ -189,7 +200,7 @@ if [ "$FAST" -eq 0 ]; then
# 不会有任何编译错误或运行时异常,只会安静地放行。
# 用的是真机采集的真报告 + 真 KDS 证书链(公开信任材料,无私钥),
# 所以本地无网也能验证「验签逻辑对真报告成立」。
step "10/15 SNP 芯片验签器自测(正负向)"
step "10/16 SNP 芯片验签器自测(正负向)"
python3 deploy/tee/real-machine/selftest-snp-verify.py
ok
@@ -210,7 +221,7 @@ if [ "$FAST" -eq 0 ]; then
# 不需要 SDK、不需要 QEMU,秒级完成。
# 它证明的是「给定一份日志,判定器的结论正确」,
# **不**证明 OP-TEE 的 seal/unseal 行为正确(那要跑 QEMU)。
step "11/15 OP-TEE 判据逻辑自测"
step "11/16 OP-TEE 判据逻辑自测"
python3 tools/selftest-optee-verdict.py
ok
@@ -226,7 +237,7 @@ if [ "$FAST" -eq 0 ]; then
# 跑不跑得通。实例回收那条用**心跳文件**判据(实例自己 touch 一个文件,
# 停掉后心跳停止)—— 不依赖 ps / /proc,因为受限环境里 ps 常被禁、
# macOS 也没有 /proc,那时这条判据会被跳过,而它恰恰是最重要的一条。
step "12/15 宿主控制面 mpc-hostd 端到端自测"
step "12/16 宿主控制面 mpc-hostd 端到端自测"
python3 tools/selftest-hostd.py
ok
@@ -241,7 +252,7 @@ if [ "$FAST" -eq 0 ]; then
# 判的是框架自己的契约,不是 EasyTier 的实现。进程真起真回收由
# LinkRuntime 单测判(持 Child + try_wait 收割),此处显式再跑一次,
# 保证这条判据真的进了主门禁的执行路径。
step "13/15 会话级链路层 EasyTier 端到端自测"
step "13/16 会话级链路层 EasyTier 端到端自测"
python3 tools/selftest-link.py
ok
@@ -259,7 +270,7 @@ if [ "$FAST" -eq 0 ]; then
# 未落地),所以这条门禁不证明「能上链」。
# 另:--transport 必须显式给,stub 只供桩自测,tlcp 是生产路径
# (缺双证书配置即拒),传输形态不许有默认值 = 不许留明文后门。
step "14/15 链上层 mpc-chain 端到端自测"
step "14/16 链上层 mpc-chain 端到端自测"
python3 tools/selftest-chain.py
ok
@@ -271,12 +282,31 @@ if [ "$FAST" -eq 0 ]; then
# 自签自验是循环自证,测不到 distid 漂移。
# 软件签名器私钥可导出、密评不可过 —— 生产策略必须拒绝它;
# profile 与「私钥不可导出」交叉校验,防止软件谎报硬件模组。
# 本机无 Tongsuo / TLCP 套件 ⇒ 通道准入必须 fail-closed 且点名原因,
# 不许「没装就跳过」。TLCP 双证书正向校验 / 真交易 RLP 仍测不到,
# 见 tools/selftest-chain-gm.py 的诚实边界。
step "15/15 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测"
# 本机无 Tongsuo,但 GmSSL 3.2.0 可用:通道准入依旧 fail-closed
# (Rust 侧 TLCP 客户端未落地),就绪状态只到 NeedsFfi。
# TLCP 双证书正向校验 / 真交易编码仍待真机对拍,
# 见 tools/selftest-chain-gm.py 与 tools/fisco-realnode-probe.py。
step "15/16 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测"
python3 tools/selftest-chain-gm.py
ok
# 第 16 条:GmSSL 真 TLCP 握手 / TA 密钥分级 / FISCO 真机对拍契约。
#
# ★ 两个 --self-test 与 TA 探针都是**零外部依赖**,本机没装 GmSSL
# 也必须跑:判据逻辑永远测不到 = 假安全感。
# ★ 真握手缺 GmSSL 时打印 GMSSL_TLCP_SKIPPED + 逐项缺失(不算通过);
# 装了就真起 tlcp_server/tlcp_client,成功也只打印 GMSSL_TLCP_OK +
# BCOS_RPC_NOT_VERIFIED,绝不宣称 bcos-rpc 通道已通。
# ★ fisco-realnode-probe.py 环境齐备也只报 NEEDS_IMPL:FISCO 自有
# 交易编码 / Rust 侧 TLCP 通道 / sm2Verify 真机对拍 / 已签名交易
# 都还没落地,凑齐环境变量不等于能上链。
step "16/16 GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约"
python3 tools/selftest-tlcp-gmssl.py --self-test
python3 tools/fisco-realnode-probe.py --self-test
python3 tools/selftest-ta-key-tier.py
python3 tools/selftest-tlcp-gmssl.py
python3 tools/fisco-realnode-probe.py
ok
fi
printf '\n\033[32m\033[1m全部通过\033[0m\n'
+173
View File
@@ -0,0 +1,173 @@
#!/usr/bin/env python3
"""FISCO 国密链**真机对拍契约**(主门禁第 16 条)。
docs/INTEGRATION_ANALYSIS.md 第 7 节 9c 原本只是三行待办文字。这个脚本把
它变成可执行契约:**缺环境必须显式 SKIPPED 并逐项列出缺什么**,环境齐备
也必须报 NEEDS_IMPL(FISCO 自有交易编码 / TLCP 通道 / 真签名交易未落地),
**绝不打印「通过」**。静默跳过和通过长得一样,是这类通道最常见的失真。
★ 与 `selftest-tlcp-gmssl.py` 的分工:那边证明的是「本机环回 TLCP 握手
真的能跑」;这边守的是「客户端到 bcos-rpc + 合约验签 + 真交易」这套
真机链路还差什么。前者通过不能替代后者。
★ 9c 三处对拍(外加一笔真交易):
① 国密链交易走自有 `sendTransaction`(4 参),不是 web3 端点
`eth_sendRawTransaction`(后者固定 secp256k1 + keccak256 RLP);
② 客户端到 `bcos-rpc` 是否真要求国密 TLCP(本机环回不算);
③ `CryptoPrecompiled.sm2Verify(bytes32,bytes,bytes32,bytes32)` 四入参:
公钥编码 / message 是 32B 摘要 / distid 链上不可配只能实测;
④ `flush` 要发的是**已签名 FISCO 交易**而非链上对象规范字节。
用法:
python3 tools/fisco-realnode-probe.py --self-test # 判据逻辑(零依赖)
python3 tools/fisco-realnode-probe.py # 探测本机真机环境
"""
import os
import shutil
import subprocess
import sys
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
# 真机环境必备项。顺序即输出顺序,缺哪项就点名哪项。
REQUIRED = (
("rpc_endpoint", "MPC_CHAIN_RPC", "bcos-rpc 的 host:port 端点"),
("group_id", "MPC_CHAIN_GROUP", "sendTransaction 的 groupID"),
("node_name", "MPC_CHAIN_NODE", "sendTransaction 的 nodeName"),
("sm_crypto", "MPC_CHAIN_SM_CRYPTO", "国密链 sm_crypto=true 的真实链声明"),
("tlcp_backend", "MPC_TLCP_BACKEND", "TLCP 实现后端(gmssl / tongsuo)"),
("signer", "MPC_GM_SIGNER", "生产签名器(硬件模组 provider)"),
)
# 三处真机对拍 + 一笔真交易;这些是**实现缺口**,不是环境缺口。
IMPL_GAPS = (
"① sendTransaction 提交真国密交易:FISCO 自有交易编码(非以太坊 RLP)未落地",
"② 客户端到 bcos-rpc 的国密 TLCP:Rust 侧 FFI / 进程通道未接入,且未验证服务端启用 TLCP",
"③ CryptoPrecompiled.sm2Verify 四入参:公钥编码 / 32B 摘要 / 链上 distid 未做真机对拍",
"④ flush 仍发链上对象规范字节,不是已签名交易",
)
PASS_N = 0
FAIL_N = 0
def check(name, cond, extra=None):
global PASS_N, FAIL_N
if cond:
PASS_N += 1
print(f" ok {name}")
else:
FAIL_N += 1
print(f"FAIL {name}")
if extra is not None:
print(f" -> {str(extra)[:500]}")
def evaluate(env):
"""判据唯一真相源。返回 (decision, missing)。
decision 只有 "SKIPPED" / "NEEDS_IMPL" 两种,**永不返回 "PASS"**:
真机对拍的结果只能由将来实现的 `tx.rs` + 真链实跑给出。
"""
missing = []
for key, var, desc in REQUIRED:
if not env.get(key):
missing.append(f"{var}({desc})")
if missing:
return "SKIPPED", missing
return "NEEDS_IMPL", []
def probe_env():
return {
"rpc_endpoint": os.environ.get("MPC_CHAIN_RPC", "").strip(),
"group_id": os.environ.get("MPC_CHAIN_GROUP", "").strip(),
"node_name": os.environ.get("MPC_CHAIN_NODE", "").strip(),
"sm_crypto": os.environ.get("MPC_CHAIN_SM_CRYPTO", "").strip().lower() == "true",
"tlcp_backend": os.environ.get("MPC_TLCP_BACKEND", "").strip(),
"signer": os.environ.get("MPC_GM_SIGNER", "").strip(),
}
def self_test():
empty = {k: "" for k, _, _ in REQUIRED}
d, m = evaluate(empty)
check("判据逻辑:全缺环境 → SKIPPED", d == "SKIPPED", d)
check("判据逻辑:逐项列出 6 项缺失", len(m) == 6, m)
check("判据逻辑:缺失里点名 MPC_CHAIN_RPC 与 MPC_TLCP_BACKEND",
any("MPC_CHAIN_RPC" in x for x in m)
and any("MPC_TLCP_BACKEND" in x for x in m), m)
partial = dict(empty, rpc_endpoint="127.0.0.1:8545",
group_id="group0", node_name="node0", sm_crypto=True,
tlcp_backend="gmssl")
d2, m2 = evaluate(partial)
check("判据逻辑:缺生产签名器仍 SKIPPED 且只点名这一项",
d2 == "SKIPPED" and len(m2) == 1 and "MPC_GM_SIGNER" in m2[0], (d2, m2))
full = dict(partial, signer="hardware-module")
d3, m3 = evaluate(full)
check("★ 判据逻辑:环境全齐也只到 NEEDS_IMPL,绝不静默 PASS",
d3 == "NEEDS_IMPL" and not m3, (d3, m3))
check("判据逻辑:evaluate 永不返回 PASS",
"PASS" not in (d, d2, d3), (d, d2, d3))
# 漂移探针:把「sm_crypto=false」当成齐备必须仍被拒。
bad = dict(full, sm_crypto=False)
d4, m4 = evaluate(bad)
check("漂移探针:sm_crypto=false 不算国密链,退回 SKIPPED",
d4 == "SKIPPED" and any("MPC_CHAIN_SM_CRYPTO" in x for x in m4), (d4, m4))
src = Path(__file__).read_text()
check("契约脚本仍含 FISCO_REALNODE_SKIPPED 输出(防静默跳过回归)",
"FISCO_REALNODE_SKIPPED" in src)
check("契约脚本仍含 FISCO_REALNODE_NEEDS_IMPL 输出",
"FISCO_REALNODE_NEEDS_IMPL" in src)
check("契约脚本列全 9c 四处缺口", len(IMPL_GAPS) == 4
and all(s in src for s in IMPL_GAPS), IMPL_GAPS)
# 与 rpc.rs 的事实对拍:国密链方法名不许回退到 eth_sendRawTransaction。
rpc = (REPO / "crates/mpc-chain/src/rpc.rs").read_text()
check("★ rpc.rs 仍把 sendTransaction 定为国密链提交方法",
'METHOD_SEND_TRANSACTION: &str = "sendTransaction"' in rpc)
check("★ rpc.rs 仍有国密链禁用 web3 端点的守卫",
"assert_submit_method_allowed" in rpc and "secp256k1" in rpc)
print(f"\n判据 {PASS_N + FAIL_N} 条:通过 {PASS_N},失败 {FAIL_N}")
if FAIL_N:
print("存在失败判据")
return 1
print("判据逻辑全部通过(本模式不依赖真机环境)")
return 0
def run_probe():
env = probe_env()
decision, missing = evaluate(env)
if decision == "SKIPPED":
print(f"FISCO_REALNODE_SKIPPED: 缺 {len(missing)} 项真机环境,本通道未执行")
for m in missing:
print(f" - {m}")
print(" (--self-test 的零依赖契约判据仍在主门禁里跑,不因跳过变成盲区)")
# GmSSL 本机能力如实附带一句,但不能顶替真机环境。
hint = "可用" if shutil.which("gmssl") else "未安装"
print(f" 附注:本机 GmSSL {hint};环回 TLCP 握手通过 ≠ bcos-rpc 已启用 TLCP")
return 0
print("FISCO_REALNODE_NEEDS_IMPL: 真机环境齐备,但以下实现缺口未补,"
"拒绝宣称能上链")
for gap in IMPL_GAPS:
print(f" - {gap}")
print(" (缺的是实现,不是环境;把环境变量凑齐不等于能发真交易)")
return 0
def main():
if "--self-test" in sys.argv:
return self_test()
return run_probe()
if __name__ == "__main__":
sys.exit(main())
+29 -6
View File
@@ -181,15 +181,25 @@ def main():
run("chain", "align", "--csv-distid", "wrong-distid-0001"),
"attestation_csv_sm2")
# --- 6. TLCP 环境 fail-closed ---
# --- 6. TLCP 环境 fail-closed(★ 不写死本机是否装了 GmSSL)---
# 装了 GmSSL 的机器 backend=GmSSL / readiness=NeedsFfi;
# 没装的 backend=None / readiness=MissingEnvironment。
# 两种环境下 ready 都必须恒为 false —— 环境齐备也不许冒充通道已通。
rc, out, _ = run("chain", "tlcp")
tc = json.loads(out) if rc == 0 else {}
check("tlcp 诊断输出合法 JSON 且 ready=false",
gmssl_bin = shutil.which("gmssl") is not None
check("tlcp 诊断输出合法 JSON 且 ready 恒为 false",
rc == 0 and tc.get("ready") is False, (rc, tc))
check("本机无 TLCP 套件被如实上报(不硬编码为可用)",
tc.get("tlcpCipherAvailable") is False, tc)
check("TLCP 拒绝原因点名 Tongsuo",
"Tongsuo" in tc.get("reason", ""), tc)
check("readiness 只能是 NeedsFfi / MissingEnvironment(不许 Ready)",
tc.get("readiness") in ("NeedsFfi", "MissingEnvironment"), tc)
check("GmSSL 可用性与本机真实状态一致(不硬编码为可用/不可用)",
tc.get("gmsslAvailable") is gmssl_bin, (gmssl_bin, tc))
check("backend 与 GmSSL 可用性自洽",
(tc.get("backend") == "GmSSL") == gmssl_bin
or tc.get("backend") == "Tongsuo", tc)
check("TLCP 拒绝原因点名国密实现与未落地项",
("Tongsuo" in tc.get("reason", "") or "GmSSL" in tc.get("reason", ""))
and ("未落地" in tc.get("reason", "") or "需要" in tc.get("reason", "")), tc)
check("未提供双证书配置时 configOk=false",
tc.get("configOk") is False and "未提供" in tc.get("detail", ""), tc)
bad_tlcp = p("tlcp-bad.json")
@@ -202,6 +212,19 @@ def main():
tcb = json.loads(out) if rc == 0 else {}
check("非国密套件被配置校验拒绝且带出原因",
tcb.get("configOk") is False and "白名单" in tcb.get("detail", ""), tcb)
# GmSSL 的套件名与 Tongsuo/OpenSSL 风格不同,合并白名单必须收下它。
gmssl_suite = p("tlcp-gmssl-suite.json")
write(gmssl_suite, {
"sign_cert_pem": "x", "sign_key_pem": "x", "enc_cert_pem": "x",
"enc_key_pem": "x", "ca_pem": "x",
"cipher_suite": "TLS_ECC_SM4_CBC_SM3",
})
rc, out, _ = run("chain", "tlcp", "--file", gmssl_suite)
tgs = json.loads(out) if rc == 0 else {}
check("★ GmSSL 实测套件名被白名单接受(拒绝原因是证书而非套件名)",
tgs.get("configOk") is False
and "白名单" not in tgs.get("detail", "")
and "PEM 证书" in tgs.get("detail", ""), tgs)
# --- 7. 治理形状:硬规则进合约 / OPA 管业务合规 ---
hard = p("hard-rule.json")
+9 -2
View File
@@ -347,8 +347,15 @@ def main():
check("假链恢复后补链成功", rc == 0 and fr.get("confirmed") == 2 and fr.get("remaining") == 0, fr)
check("flush 明确上报走的是明文桩(不是悄悄走 TLCP)",
fr.get("transport") == "plaintext-stub", fr)
check("方法名是 3.x 的 eth_sendRawTransaction",
fr.get("method") == "eth_sendRawTransaction", fr)
check("桩方法仍是 eth_sendRawTransaction 但明确标注为桩(不冒充真链入口)",
fr.get("method") == "eth_sendRawTransaction"
and fr.get("methodIsStub") is True, fr)
check("★ 输出同时给出国密链真提交方法 sendTransaction(4 参)",
fr.get("guomiSubmitMethod") == "sendTransaction", fr)
check("★ 守卫确认国密链禁用 eth_sendRawTransaction(web3 端点 secp256k1+keccak256)",
fr.get("guomiChainRejectsStubMethod") is True, fr)
check("输出如实标注 payload 不是已签名交易",
fr.get("payload") == "canonical-bytes-not-signed-tx", fr)
check("服务端只收到 2 次(每条一次)", len(STATE.calls) == 2, STATE.calls)
check("请求参数带 0x 前缀的 payload",
all(isinstance(c[1], list) and str(c[1][0]).startswith("0x") for c in STATE.calls),
+148
View File
@@ -0,0 +1,148 @@
#!/usr/bin/env python3
"""TA 签名密钥三级分级的脚本层硬拒绝对拍(主门禁第 16 条)。
docs/INTEGRATION_ANALYSIS.md 第 7 节第 6 条定稿:
dev 仓库 / SDK 自带 default_ta.pem,**仅 QEMU / CI**
staging MPC_TA_SIGN_KEY 指向受控密钥
prod SIGN_KEY 由设备厂商 / OEM 持有,ssw-mpc 不持密钥;
缺生产密钥时**不得回落开发密钥**
★ 判据必须能在没有 OP-TEE SDK 的机器上被执行到。`build/build_optee.sh
--check-only` 把密钥解析放在 `OPTEE_OS` / `SDK_DIR` 检查之前,本脚本
就是不设这些环境变量跑的 —— 若哪天顺序被改回去,守卫会被前置环境
检查抢先,这里会立刻变红(「永远测不到的判据」= 假安全感)。
每条负向都带**期望拒绝特征**,只判 rc != 0 不算数。
"""
import json
import os
import subprocess
import sys
import tempfile
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
BUILD = REPO / "build/build_optee.sh"
PASS_N = 0
FAIL_N = 0
def check(name, cond, extra=None):
global PASS_N, FAIL_N
if cond:
PASS_N += 1
print(f" ok {name}")
else:
FAIL_N += 1
print(f"FAIL {name}")
if extra is not None:
print(f" -> {str(extra)[:500]}")
def run_tier(**kwargs):
# ★ 只保留最小环境,显式不带 OPTEE_OS / SDK_DIR / 交叉工具链变量。
env = {"PATH": os.environ.get("PATH", "/usr/bin:/bin"),
"HOME": os.environ.get("HOME", "/tmp"),
"LANG": "C.UTF-8"}
for k, v in kwargs.items():
if v is not None:
env[k] = str(v)
return subprocess.run(["bash", str(BUILD), "--check-only"],
env=env, capture_output=True, text=True, timeout=30)
def allow(name, r, tier, key):
try:
d = json.loads(r.stdout.strip())
except json.JSONDecodeError as e:
check(name, False, (e, r.returncode, r.stdout, r.stderr))
return
check(name, r.returncode == 0 and d.get("tier") == tier
and d.get("key") == key and d.get("allowed") is True,
(r.returncode, d, r.stderr[:300]))
def reject(name, r, *needles):
txt = r.stderr + r.stdout
check(name, r.returncode != 0
and "MPC_TA_KEY_FAIL:" in txt
and all(n in txt for n in needles)
# ★ 守卫必须真被执行到,而不是被缺 SDK 的前置检查抢先。
and "需要指向 optee_os" not in txt,
(r.returncode, r.stdout[:200], r.stderr[:400]))
def main():
src = BUILD.read_text()
check("build_optee.sh 有 --check-only 分支(守卫可被测到)",
"--check-only" in src)
check("build_optee.sh 明确写有 default_ta.pem 与三级 tier",
"default_ta.pem" in src
and all(t in src for t in ("dev|staging|prod", "MPC_TA_SIGN_KEY")))
check("拒绝走独立短行标识 MPC_TA_KEY_FAIL(串口单通道可抓)",
"MPC_TA_KEY_FAIL:" in src)
with tempfile.TemporaryDirectory(prefix="mpc-ta-key-") as td:
controlled = str(Path(td) / "controlled_ta_key.pem")
Path(controlled).write_text("-----BEGIN FAKE KEY-----\nnot-a-real-key\n")
dev_key = str(Path(td) / "default_ta.pem")
Path(dev_key).write_text("-----BEGIN FAKE DEV KEY-----\n")
# --- prod ---
reject("prod 缺 SIGN_KEY 必须硬拒且点名不得回落开发密钥",
run_tier(MPC_TA_KEY_TIER="prod"), "prod 必须给 SIGN_KEY",
"不得回落开发密钥")
reject("prod 给开发密钥必须硬拒",
run_tier(MPC_TA_KEY_TIER="prod", SIGN_KEY=dev_key),
"不得使用开发密钥")
reject("prod 给的密钥文件不存在必须硬拒",
run_tier(MPC_TA_KEY_TIER="prod", SIGN_KEY=str(Path(td) / "missing.pem")),
"不存在")
allow("prod 给受控密钥放行且不回落开发密钥",
run_tier(MPC_TA_KEY_TIER="prod", SIGN_KEY=controlled),
"prod", controlled)
# --- staging ---
reject("staging 缺 MPC_TA_SIGN_KEY 必须硬拒",
run_tier(MPC_TA_KEY_TIER="staging"), "staging 必须给 MPC_TA_SIGN_KEY")
reject("staging 给开发密钥必须硬拒",
run_tier(MPC_TA_KEY_TIER="staging", MPC_TA_SIGN_KEY=dev_key),
"staging 不得使用开发密钥")
allow("staging 给受控密钥放行",
run_tier(MPC_TA_KEY_TIER="staging", MPC_TA_SIGN_KEY=controlled),
"staging", controlled)
# --- dev ---
reject("dev 无 QEMU/CI 显式标记必须硬拒",
run_tier(), "default_ta.pem 只允许 QEMU / CI")
allow("dev + MPC_TA_ALLOW_DEV_KEY=1 放行开发密钥",
run_tier(MPC_TA_ALLOW_DEV_KEY="1"), "dev", "default_ta.pem")
allow("dev + MPC_SIM_DEV 放行开发密钥",
run_tier(MPC_SIM_DEV="mpc-dev-A"), "dev", "default_ta.pem")
# --- 歧义 / 非法输入 ---
reject("非法 tier 必须硬拒",
run_tier(MPC_TA_KEY_TIER="qa"), "只能是 dev|staging|prod")
reject("两个密钥变量同时给必须硬拒(来源歧义)",
run_tier(MPC_TA_KEY_TIER="prod", SIGN_KEY=controlled,
MPC_TA_SIGN_KEY=controlled), "密钥来源歧义")
# --- 关键回归:守卫不被前置环境检查抢先 ---
r = run_tier(MPC_TA_KEY_TIER="prod")
check("★ --check-only 在缺 OPTEE_OS 时仍能执行到密钥守卫",
r.returncode != 0 and "MPC_TA_KEY_FAIL:" in r.stderr
and "需要指向 optee_os" not in r.stderr,
(r.returncode, r.stderr[:300]))
print(f"\n判据 {PASS_N + FAIL_N} 条:通过 {PASS_N},失败 {FAIL_N}")
if FAIL_N:
print("存在失败判据")
return 1
print("全部通过")
return 0
if __name__ == "__main__":
sys.exit(main())
+339
View File
@@ -0,0 +1,339 @@
#!/usr/bin/env python3
"""GmSSL 国密 TLCP **真握手**自测(主门禁第 16 条)。
★ 和桩自测的区别:这里起真的 `gmssl tlcp_server` / `tlcp_client`,现场生成
SM2 双证书,握手输出里出现 `Protocol: TLCP` / `Version: TLCP (0101)` /
`TLS_ECC_SM4_CBC_SM3`。不是把 JSON-RPC 丢给假 HTTP 服务。
★ 诚实边界(不许被这条自测冲掉):
- 本机环回握手通过 **不等于** 客户端到 `bcos-rpc` 的 TLCP 已通。服务端是
`gmssl tlcp_server`(echo),不是 FISCO 节点,也没验证 bcos-rpc 是否启用 TLCP。
- GmSSL 3.x 移除了核心 OpenSSL 兼容 API,**不能**当 OpenSSL provider 喂给
`reqwest`;Rust 侧把 JSON-RPC 经 TLCP 发出去的 FFI / 进程通道仍未落地。
- GmSSL 是软件实现,私钥可导出,**不能过密评**,不替代硬件国密模组。
所以脚本成功时打印的是 `GMSSL_TLCP_OK` + `BCOS_RPC_NOT_VERIFIED`,
绝不是「链上通道已通」。
★ 缺 GmSSL 时必须打印 `GMSSL_TLCP_SKIPPED` 并逐项列出缺什么。
静默跳过和通过长得一样,是这类通道最常见的失真。`--self-test` 是
零依赖的判据逻辑自测:即使没有 GmSSL,判据本身也必须在每台机器上被执行到。
用法:
python3 tools/selftest-tlcp-gmssl.py --self-test # 判据逻辑(零依赖)
python3 tools/selftest-tlcp-gmssl.py # 真握手
"""
import json
import os
import re
import shutil
import socket
import subprocess
import sys
import tempfile
import time
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
PASS = "P@ssw0rd"
GMSSL_SUITE = "TLS_ECC_SM4_CBC_SM3"
UPSTREAM_DISTID = "1234567812345678"
PASS_N = 0
FAIL_N = 0
def check(name, cond, extra=None):
global PASS_N, FAIL_N
if cond:
PASS_N += 1
print(f" ok {name}")
else:
FAIL_N += 1
print(f"FAIL {name}")
if extra is not None:
print(f" -> {str(extra)[:600]}")
def gmssl(*args, cwd=None, timeout=60):
return subprocess.run(
["gmssl", *args], cwd=cwd, capture_output=True, text=True, timeout=timeout
)
def evaluate(env):
"""判据唯一真相源:环境是否够跑真握手。
返回 (decision, missing)。decision 只有 "RUN" / "SKIPPED" 两种;
**永远不返回 "PASS"** —— 通过与否只能由真握手判据决定。
"""
missing = []
if not env.get("gmssl_bin"):
missing.append("gmssl 可执行文件(brew install gmssl,或源码装 GmSSL ≥ 3.2)")
if not env.get("tlcp_commands"):
missing.append("gmssl help 里没有 tlcp_server / tlcp_client")
if not env.get("version"):
missing.append("gmssl version 不可用")
return ("SKIPPED" if missing else "RUN"), missing
def probe_env():
if shutil.which("gmssl") is None:
return {"gmssl_bin": False, "tlcp_commands": False, "version": None,
"help": "", "certgen_help": ""}
try:
v = gmssl("version")
h = gmssl("help")
cg = gmssl("certgen", "-help")
return {
"gmssl_bin": True,
"version": v.stdout.strip() if v.returncode == 0 else None,
"tlcp_commands": ("tlcp_server" in h.stdout and "tlcp_client" in h.stdout),
"help": h.stdout,
"certgen_help": cg.stdout + cg.stderr,
}
except (OSError, subprocess.TimeoutExpired):
return {"gmssl_bin": True, "tlcp_commands": False, "version": None,
"help": "", "certgen_help": ""}
def self_test():
"""零依赖:把「缺项必 SKIPPED、齐备必 RUN、绝不静默 PASS」钉死。"""
decision, missing = evaluate({"gmssl_bin": False, "tlcp_commands": False,
"version": None})
check("判据逻辑:全缺环境 → SKIPPED", decision == "SKIPPED", decision)
check("判据逻辑:逐项列出缺失(3 项,不是笼统一句)", len(missing) == 3, missing)
check("判据逻辑:缺 gmssl 二进制被点名",
any("gmssl 可执行文件" in m for m in missing), missing)
d2, m2 = evaluate({"gmssl_bin": True, "tlcp_commands": False, "version": "GmSSL 3.2.0"})
check("判据逻辑:有二进制但缺 TLCP 子命令仍 SKIPPED",
d2 == "SKIPPED" and any("tlcp_server" in m for m in m2), (d2, m2))
d3, m3 = evaluate({"gmssl_bin": True, "tlcp_commands": True, "version": "GmSSL 3.2.0"})
check("判据逻辑:环境齐备 → RUN(不是直接 PASS)",
d3 == "RUN" and not m3, (d3, m3))
check("判据逻辑:evaluate 永不返回 PASS",
"PASS" not in (d3, d2, decision), (d3, d2, decision))
# ★ 漂移探针:把套件名改成非国密,判据必须红(防判据恒真)。
check("漂移探针:非国密套件不在 GmSSL 白名单里",
"TLS_AES_128_GCM_SHA256" not in ("TLS_ECC_SM4_CBC_SM3", "TLS_ECC_SM4_GCM_SM3"))
check("漂移探针:国密套件名必须带 SM4/SM3 语义",
"SM4" in GMSSL_SUITE and "SM3" in GMSSL_SUITE)
# 判据逻辑不能退化:脚本里必须真有 SKIPPED 输出与真握手调用。
src = Path(__file__).read_text()
check("探针源码仍含 GMSSL_TLCP_SKIPPED 输出(防止静默跳过回归)",
"GMSSL_TLCP_SKIPPED" in src)
check("探针源码仍真的 spawn tlcp_server / tlcp_client",
"tlcp_server" in src and "tlcp_client" in src)
check("探针源码仍写有诚实边界标识 BCOS_RPC_NOT_VERIFIED",
"BCOS_RPC_NOT_VERIFIED" in src)
return finish("判据逻辑自测")
def project_distid():
"""从 `mpc_core::domain::SM2_DISTID` 读唯一真相源,做跨实现对拍。"""
text = (REPO / "crates/mpc-core/src/domain.rs").read_text()
m = re.search(r'pub\s+const\s+SM2_DISTID\s*:\s*&\[u8\]\s*=\s*b"([^"]+)"', text)
return m.group(1) if m else None
def make_certs(w):
"""生成一级根 CA + 服务端签名/加密双证书(GmSSL 官方示例的精简版)。"""
def g(*args):
p = gmssl(*args, cwd=w)
if p.returncode != 0:
raise RuntimeError(f"gmssl {' '.join(args)}: rc={p.returncode} "
f"out={p.stdout[-400:]} err={p.stderr[-600:]}")
return p
g("sm2keygen", "-pass", PASS, "-out", "root_key.pem")
g("certgen", "-C", "CN", "-ST", "Beijing", "-L", "Haidian",
"-O", "ssw-mpc", "-OU", "SelfTest", "-CN", "ssw-mpc TLCP Root CA",
"-days", "365", "-key", "root_key.pem", "-pass", PASS,
"-out", "root_cert.pem", "-key_usage", "keyCertSign",
"-key_usage", "cRLSign", "-ca")
for role, usage in (("sign", "digitalSignature"), ("enc", "keyEncipherment")):
g("sm2keygen", "-pass", PASS, "-out", f"{role}_key.pem")
g("reqgen", "-C", "CN", "-ST", "Beijing", "-L", "Haidian",
"-O", "ssw-mpc", "-OU", "SelfTest", "-CN", "localhost",
"-key", f"{role}_key.pem", "-pass", PASS, "-out", f"{role}_req.pem")
g("reqsign", "-in", f"{role}_req.pem", "-days", "365",
"-key_usage", usage, "-ext_key_usage", "serverAuth",
"-subject_dns_name", "localhost", "-cacert", "root_cert.pem",
"-key", "root_key.pem", "-pass", PASS, "-out", f"{role}_cert.pem")
# 服务端链:签名证书在前、加密证书在后(顺序不可颠倒),再附 CA。
for out, parts in (
("server_certs.pem", ("sign_cert.pem", "enc_cert.pem", "root_cert.pem")),
("server_keys.pem", ("sign_key.pem", "enc_key.pem")),
("fake_ca.pem", ("sign_cert.pem",)), # 负向用:拿服务端证书当 CA
):
(w / out).write_bytes(b"".join((w / x).read_bytes() for x in parts))
return True
def free_port():
s = socket.socket()
s.bind(("127.0.0.1", 0))
port = s.getsockname()[1]
s.close()
return port
def start_server(w, port):
return subprocess.Popen(
["gmssl", "tlcp_server", "-port", str(port),
"-cert", "server_certs.pem", "-key", "server_keys.pem",
"-pass", PASS, "-cipher_suite", GMSSL_SUITE, "-verbose"],
cwd=w, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
)
def client(w, port, *extra, ca="root_cert.pem", suite=GMSSL_SUITE,
payload="hello tlcp\n"):
"""★ ca / suite 用参数替换而不是再追加一个同名 flag:
GmSSL 的 -cipher_suite / -cacert 都允许重复出现,追加只会测到
「列表里混了个非法值」,而不是「纯非国密套件被拒」——判据就虚了。
"""
(w / "message.txt").write_text(payload)
args = ["gmssl", "tlcp_client", "-host", "127.0.0.1", "-port", str(port),
"-server_name", "localhost", "-cacert", ca,
"-cipher_suite", suite, "-in", "message.txt", *extra]
try:
return subprocess.run(args, cwd=w, capture_output=True, text=True, timeout=25)
except subprocess.TimeoutExpired as e:
return subprocess.CompletedProcess(args, 124, e.stdout or "", e.stderr or "")
def stop(srv):
if srv.poll() is None:
srv.terminate()
try:
return srv.communicate(timeout=5)[0]
except subprocess.TimeoutExpired:
srv.kill()
return srv.communicate()[0]
def run_real():
env = probe_env()
decision, missing = evaluate(env)
if decision == "SKIPPED":
print(f"GMSSL_TLCP_SKIPPED: 缺 {len(missing)} 项环境,本通道未执行")
for m in missing:
print(f" - {m}")
print(" (--self-test 的零依赖判据仍在主门禁里跑,不因跳过而变成盲区)")
return 0 if FAIL_N == 0 else 1
check("gmssl version 可用", bool(env["version"]), env["version"])
check("★ GmSSL help 列出 tlcp_server / tlcp_client", env["tlcp_commands"])
# ★ 跨实现对拍:GmSSL 的 SM2 默认 distid 必须与项目唯一真相源一致。
check("★ GmSSL certgen 帮助明写默认 sm2_id = 1234567812345678",
UPSTREAM_DISTID in env["certgen_help"], env["certgen_help"][-400:])
distid = project_distid()
check("项目 domain::SM2_DISTID 能读到且与 GmSSL 默认值一致",
distid == UPSTREAM_DISTID, (distid, UPSTREAM_DISTID))
# 与 CLI 诊断交叉验证:不许 Rust 侧把装了的 GmSSL 报成没有。
cli = subprocess.run([str(REPO / "target/debug/mpc"), "chain", "tlcp"],
capture_output=True, text=True, timeout=30)
if cli.returncode == 0:
try:
view = json.loads(cli.stdout)
check("mpc chain tlcp 如实上报 GmSSL 可用",
view.get("gmsslAvailable") is True and view.get("backend") == "GmSSL",
view)
check("mpc chain tlcp 仍 fail-closed(ready 恒 false)",
view.get("ready") is False, view)
except json.JSONDecodeError as e:
check("mpc chain tlcp 输出合法 JSON", False, (e, cli.stdout[:300]))
else:
check("mpc chain tlcp 可运行(需先 cargo build -p mpc-cli)",
False, (cli.returncode, cli.stderr[:300]))
with tempfile.TemporaryDirectory(prefix="mpc-tlcp-") as td:
w = Path(td)
try:
make_certs(w)
check("现场生成 SM2 根 CA 与签名/加密双证书", True)
except Exception as e:
check("现场生成 SM2 根 CA 与签名/加密双证书", False, e)
return finish("真握手")
check("服务端证书链确实是双证书 + CA(3 张 PEM)",
(w / "server_certs.pem").read_text().count("-----BEGIN CERTIFICATE-----") == 3)
check("服务端密钥文件是两把(签名 + 加密)",
(w / "server_keys.pem").read_text().count("-----BEGIN ENCRYPTED PRIVATE KEY-----") == 2
or (w / "server_keys.pem").read_text().count("PRIVATE KEY-----") >= 2)
port = free_port()
srv = start_server(w, port)
time.sleep(0.8)
server_log = ""
try:
check("tlcp_server 启动后未被立刻拒绝", srv.poll() is None)
ok = client(w, port, "-certout", "server_certout.pem")
txt = ok.stdout + ok.stderr
check("★ 客户端握手成功(rc=0)", ok.returncode == 0,
(ok.returncode, txt[:600]))
check("★ 握手确是 TLCP 协议", "Protocol: TLCP" in txt, txt[:600])
check("★ 套件是国密 TLS_ECC_SM4_CBC_SM3",
GMSSL_SUITE in txt, txt[:600])
check("★ 应用数据经 TLCP 往返一致(echo)",
ok.stdout.strip() == "hello tlcp", repr(ok.stdout))
certout = (w / "server_certout.pem")
n = certout.read_text().count("-----BEGIN CERTIFICATE-----") if certout.exists() else 0
check("★ -certout 拿到服务端 ≥2 张证书(双证书证据)", n >= 2, n)
# --- 负向判据:每条都带**期望拒绝特征**,不许只判 rc != 0 ---
# 实测特征来自 GmSSL 3.2.0:错误 CA → x509_certs_verify_tlcp() /
# tls_cert_chain_verify();非法套件 → tls_ctx_set_cipher_suites()。
# 报错里带的是编译机源码绝对路径,判据只认函数名,不认路径。
bad_ca = client(w, port, ca="fake_ca.pem")
bad_ca_txt = bad_ca.stdout + bad_ca.stderr
check("★ 负向:错误 CA 失败且点名证书链校验(不是超时或串包)",
bad_ca.returncode != 0 and bad_ca.returncode != 124
and "Connection established" not in bad_ca_txt
and ("cert_chain_verify" in bad_ca_txt
or "x509_certs_verify_tlcp" in bad_ca_txt),
(bad_ca.returncode, bad_ca_txt[:400]))
bad_suite = client(w, port, suite="TLS_AES_128_GCM_SHA256")
bad_suite_txt = bad_suite.stdout + bad_suite.stderr
check("★ 负向:纯非国密套件失败且点名 cipher_suites",
bad_suite.returncode != 0 and bad_suite.returncode != 124
and "Connection established" not in bad_suite_txt
and "cipher_suites" in bad_suite_txt,
(bad_suite.returncode, bad_suite_txt[:400]))
finally:
server_log = stop(srv)
check("★ 服务端握手日志出现 Version: TLCP (0101)",
"Version: TLCP (0101)" in server_log, server_log[:300])
check("服务端日志确认收到 ClientHello 里的国密套件",
GMSSL_SUITE in server_log, server_log[:300])
return finish("真握手")
def finish(label):
print(f"\n{label} 判据 {PASS_N + FAIL_N} 条:通过 {PASS_N},失败 {FAIL_N}")
if FAIL_N:
print("存在失败判据")
return 1
if label == "真握手":
print("GMSSL_TLCP_OK")
print("BCOS_RPC_NOT_VERIFIED: 本机环回握手通过,不代表 bcos-rpc 已启用 TLCP,"
"也不代表 Rust 客户端已接入国密通道")
else:
print("判据逻辑全部通过(本模式不依赖 GmSSL 是否安装)")
return 0
def main():
if "--self-test" in sys.argv:
return self_test()
return run_real()
if __name__ == "__main__":
sys.exit(main())