diff --git a/CLAUDE.md b/CLAUDE.md index d41d1af..fdf849d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -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`)才有 diff --git a/build/build_optee.sh b/build/build_optee.sh index 05f499b..2ab92d9 100755 --- a/build/build_optee.sh +++ b/build/build_optee.sh @@ -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="" diff --git a/crates/mpc-chain/src/lib.rs b/crates/mpc-chain/src/lib.rs index 45f2579..c7960ad 100644 --- a/crates/mpc-chain/src/lib.rs +++ b/crates/mpc-chain/src/lib.rs @@ -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 环境缺失,拒绝发真交易"), diff --git a/crates/mpc-chain/src/rpc.rs b/crates/mpc-chain/src/rpc.rs index 0ee81a9..829347d 100644 --- a/crates/mpc-chain/src/rpc.rs +++ b/crates/mpc-chain/src/rpc.rs @@ -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] diff --git a/crates/mpc-chain/src/tlcp.rs b/crates/mpc-chain/src/tlcp.rs index 8cabbd0..f053fc2 100644 --- a/crates/mpc-chain/src/tlcp.rs +++ b/crates/mpc-chain/src/tlcp.rs @@ -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, + /// `gmssl version` 的输出;没装就是 None。 + pub gmssl_version: Option, + /// `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 { + 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 { 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" diff --git a/crates/mpc-cli/src/chain.rs b/crates/mpc-cli/src/chain.rs index 0f08abb..46b277a 100644 --- a/crates/mpc-cli/src/chain.rs +++ b/crates/mpc-cli/src/chain.rs @@ -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, 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) ); diff --git a/crates/mpc-core/src/catalog.rs b/crates/mpc-core/src/catalog.rs index e3e1877..dae56a2 100644 --- a/crates/mpc-core/src/catalog.rs +++ b/crates/mpc-core/src/catalog.rs @@ -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() { diff --git a/docs/INTEGRATION_ANALYSIS.md b/docs/INTEGRATION_ANALYSIS.md index 84964d9..a47a21d 100644 --- a/docs/INTEGRATION_ANALYSIS.md +++ b/docs/INTEGRATION_ANALYSIS.md @@ -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** diff --git a/tools/ci.sh b/tools/ci.sh index 07f2828..71e4550 100755 --- a/tools/ci.sh +++ b/tools/ci.sh @@ -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' diff --git a/tools/fisco-realnode-probe.py b/tools/fisco-realnode-probe.py new file mode 100755 index 0000000..0d91824 --- /dev/null +++ b/tools/fisco-realnode-probe.py @@ -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()) diff --git a/tools/selftest-chain-gm.py b/tools/selftest-chain-gm.py index bd895ec..970778e 100644 --- a/tools/selftest-chain-gm.py +++ b/tools/selftest-chain-gm.py @@ -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") diff --git a/tools/selftest-chain.py b/tools/selftest-chain.py index ea5176c..7957a48 100644 --- a/tools/selftest-chain.py +++ b/tools/selftest-chain.py @@ -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), diff --git a/tools/selftest-ta-key-tier.py b/tools/selftest-ta-key-tier.py new file mode 100755 index 0000000..6b17259 --- /dev/null +++ b/tools/selftest-ta-key-tier.py @@ -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()) diff --git a/tools/selftest-tlcp-gmssl.py b/tools/selftest-tlcp-gmssl.py new file mode 100755 index 0000000..2194364 --- /dev/null +++ b/tools/selftest-tlcp-gmssl.py @@ -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())