diff --git a/CLAUDE.md b/CLAUDE.md index ff1b398..3a09ebc 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -40,17 +40,20 @@ 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 与本地同一份闸门(17 条) +./tools/ci.sh # CI 与本地同一份闸门(18 条) ``` -主门禁 `./tools/ci.sh` 共 17 条:全量测试(**必须带 `--features secure`**)、 +主门禁 `./tools/ci.sh` 共 18 条:全量测试(**必须带 `--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 / 链路层 / 链上层端到端桩自测、国密签名与治理形状自测、 **GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约**(第 16 条)、 **阶段 3 OPA bundle 签发 / 真判定 / decision 存证**(第 17 条; -缺环境一律显式 `*_SKIPPED` + 逐项缺失,绝不静默通过)。 +缺环境一律显式 `*_SKIPPED` + 逐项缺失,绝不静默通过)、 +**TLCP 进程通道环回实证**(第 18 条;Rust 侧 spawn `gmssl tlcp_client` +经 TLCP 收发真实 JSON-RPC 给环回 echo 服务端,断言往返一致; +`realChainVerified` 恒 false,输出 `BCOS_RPC_NOT_VERIFIED`)。 明细以脚本自身为准(**闸门不扫自己就是盲区**)。 ## crate 分层 @@ -106,10 +109,12 @@ mpc-chain 链上层:对象规范编码 / SM3 / JSON-RPC / 幂等 outbox / ★ sm2:OpenSSL 软件 SM2 真签名(DER→raw r||s 64B);distid 唯一真相源在 mpc-core ★ signer:SoftwareDev / HardwareModule 两档;生产策略只认硬件模组, 软件签名器密评不可过、必须显式选 DevelopmentSoftware 并透出警告 - ★ tlcp:双证书契约 + 环境探测 + fail-closed;本机无 Tongsuo,**通道未通** + ★ tlcp:双证书契约 + 环境探测 + fail-closed;本机 GmSSL 环回通道已实证可达 + (LoopbackReachable,gate 18 进程通道),但真实 bcos-rpc 通道未通 ★ policy:硬规则进合约 / 业务合规策略走 OPA,域分隔不同、字段互相禁止 - ★ RLP / Tongsuo TLCP 握手 FFI / 硬件模组 provider **未落地**:flush 仍发 - 规范字节,不是已签名交易。本期不宣称能上链。 + ★ RLP 编码 / 真实 bcos-rpc TLCP 通道 / 硬件模组 provider **未落地**:Rust 侧 + TLCP 进程通道环回实证已落地(gate 18,服务端是环回 echo 不是真节点); + flush 仍发规范字节,不是已签名交易。本期不宣称能上链。 serde_json + reqwest + openssl 只落在本 crate(见「依赖」) ─────────── mpc-proto 帧协议:12 字节头 + 定长消息体,手写编解码(不引 protobuf/serde) @@ -235,7 +240,9 @@ SM2 签名走系统 OpenSSL 的 EVP 接口(`openssl` crate 链接系统库, - **GmSSL 3.2.0 让本机 TLCP 环回真握手跑通**(第 16 条 19 判据: `Protocol: TLCP` / `Version: TLCP (0101)` / 双证书)。但 3.x **不与 OpenSSL ABI 兼容**,不能当 provider 喂给 `reqwest`;本机握手通过 **≠** `bcos-rpc` 通道已通, - `TlcpReadiness` 仍只到 `NeedsFfi`、`ready` 恒 false。软件实现不能过密评。 + `TlcpReadiness` 已从 `NeedsFfi` 推进到 `LoopbackReachable`(第 18 条进程通道: + Rust 侧 spawn `gmssl tlcp_client` 经 TLCP 收发真实 JSON-RPC,环回 echo 实证可达), + 但仍**非 `Ready`**、`ready` 恒 false、发真交易仍 fail-closed。软件实现不能过密评。 - **TA 签名密钥三级硬拒绝已落地**:`build_optee.sh --check-only` 在 SDK 检查之前 解析,prod 缺密钥绝不回落 `default_ta.pem`;第 16 条 16 判据在没 SDK 时也测得到。 - **阶段 3 第一段已落地,但不是「阶段 3 完成」**:`mpc_chain::opa` 对真的 diff --git a/crates/mpc-chain/src/lib.rs b/crates/mpc-chain/src/lib.rs index 8948203..f26ad5d 100644 --- a/crates/mpc-chain/src/lib.rs +++ b/crates/mpc-chain/src/lib.rs @@ -217,10 +217,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 / GmSSL)本机可用,但 Rust 侧把 JSON-RPC 经 TLCP \ - 发到 bcos-rpc 的 FFI / 进程通道未落地,且未验证 bcos-rpc 是否启用 TLCP;\ - 拒绝宣称能发真交易", + tlcp::TlcpReadiness::LoopbackReachable => Err(ChainError::NotConfigured(String::from( + "TLCP 通道层(环回)已可达,但本机服务端是 gmssl 环回 echo,不是 bcos-rpc 真机;\ + 未验证 bcos-rpc 启用 TLCP,也无硬件国密模组;拒绝宣称能发真交易", ))), tlcp::TlcpReadiness::MissingEnvironment => Err(ChainError::NotConfigured( String::from("TLCP 环境缺失,拒绝发真交易"), diff --git a/crates/mpc-chain/src/tlcp.rs b/crates/mpc-chain/src/tlcp.rs index f053fc2..d7540a4 100644 --- a/crates/mpc-chain/src/tlcp.rs +++ b/crates/mpc-chain/src/tlcp.rs @@ -17,9 +17,19 @@ //! ① 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。 +//! ③ 直连 FFI 到 `libgmssl` 的 `tls.h` 缺少稳定绑定,本期未做。 +//! +//! 这一轮把**进程通道**落地了:`TlcpTunnel` 用 `gmssl tlcp_client -in`(响应走 +//! stdout)把一段字节(JSON-RPC 请求)经 TLCP 发给一个 endpoint 并读回响应,复用 +//! 现有「spawn 外部国密二进制」的风格(参考 `mpc_hostd::link` 对 EasyTier)。 +//! 这让 `TlcpReadiness` 从 `NeedsFfi` 推进到 `LoopbackReachable`:**通道层** +//! 在本机环回 echo 服务端上真可达、能收发 JSON。 +//! +//! ★ 但 `LoopbackReachable` **仍然不是** `Ready`:① 环回服务端是 +//! `gmssl tlcp_server` 不是 `bcos-rpc`;② 未验证 `bcos-rpc` 启用 TLCP; +//! ③ 软件实现不能过密评、不替代硬件国密模组。所以发真实国密交易由 +//! `require_transport` 继续 fail-closed(它只认 `Ready`,而 `Ready` +//! 本期到不了)。 //! //! 另一条独立证据:`gmssl certgen -help` 明写默认 `-sm2_id` 是 //! `1234567812345678`,与 `mpc_core::domain::SM2_DISTID` 同值;GmSSL 侧 @@ -33,7 +43,10 @@ use openssl::nid::Nid; use openssl::pkey::PKey; use openssl::x509::X509; use serde_json::Value; +use std::path::PathBuf; use std::process::Command; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::time::{SystemTime, UNIX_EPOCH}; /// Tongsuo / OpenSSL 风格套件名。名称**待真机对拍**:写白名单是为了不让 /// 「随便填一个字符串」通过配置校验,不是宣称这些名字已实测。 @@ -283,21 +296,25 @@ pub fn probe_tlcp_environment() -> TlcpProbe { /// TLCP 通道就绪状态。**只有 `Ready` 才允许发真实交易**,本期永远到不了。 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum TlcpReadiness { - /// 环境齐备 + Rust 客户端已接入真实 TLCP 通道。 - Ready, - /// 本机已有可用国密 TLCP 实现(Tongsuo 或 GmSSL),但 Rust 侧把 - /// JSON-RPC 请求经 TLCP 发到 `bcos-rpc` 的 FFI / 进程通道未落地。 - NeedsFfi, - /// 两个后端都不可用。 + /// 通道层真可达:环境齐备 + Rust 侧已接入 TLCP 进程通道(`TlcpTunnel`) + /// + 本机环回 echo 服务端上能收发 JSON。 + /// ★ **不是**「bcos-rpc 通道已通」:环回服务端不是 FISCO 节点、未验证 + /// bcos-rpc 启用 TLCP、软件实现不替代硬件国密模组。发真实交易仍由 + /// `require_transport` fail-closed(它只认 `Ready`)。 + LoopbackReachable, + /// 两个后端都不可用:拒绝以明文 / 标准TLS 冒充国密通道。 MissingEnvironment, + /// ★ 目标态(本期永不返回):通道已接入 + 真机 `bcos-rpc` 验证 TLCP 启用 + /// + 硬件国密模组 provider 到位。只有它才允许发真实国密交易。 + Ready, } -/// 生产路径的 fail-closed 准入。 +/// 通道层就绪度探测(**不是** 发真实交易的准入)。 /// -/// ★ 不许用 `|| true` 吞掉失败,也不许把「环境探测不到」当成「跳过」—— -/// 最重要那条判据永远没跑 = 假安全感。这里一律返回明确错误并点名缺失项。 -/// ★ 也不许因为「GmSSL 本机握手跑通了」就返回 Ready:服务端是环回 -/// `tlcp_server`,不是 `bcos-rpc`;Rust 客户端也还没接进去。 +/// ★ 与 `require_transport` 区分:`require_transport` 是发真交易的 +/// fail-closed 准入,只认 `Ready`;本函数是「通道层代码 + 环境」的就绪度, +/// 环境齐备即返回 `LoopbackReachable`(进程通道已接入、环回能收发 JSON)。 +/// ★ 不许返回 `Ready`:那需要真机 `bcos-rpc` 验证 + 硬件模组,本期没有。 pub fn require_tlcp_transport(cfg: &TlcpConfig) -> Result { cfg.validate()?; let p = probe_tlcp_environment(); @@ -308,9 +325,232 @@ pub fn require_tlcp_transport(cfg: &TlcpConfig) -> Result, + pub cipher_suite: String, + /// TLS SNI / 证书校验用的服务器名。默认 = `host`;当 `host` 是 IP 而证书 + /// 是 DNS 名(如环回用 `127.0.0.1` 连 `localhost` 证书)时必须显式给。 + pub server_name: Option, + /// 客户端认证(可选):签名证书 + 私钥。双证书场景在此扩展即可。 + pub client_sign_cert_pem: Option>, + pub client_sign_key_pem: Option>, + pub client_key_pass: Option, +} + +fn endpoint_str<'a>(obj: &'a serde_json::Map, key: &str) -> Result<&'a str, ChainError> { + obj.get(key) + .ok_or_else(|| ChainError::BadInput(format!("TLCP endpoint 缺少 {key}")))? + .as_str() + .ok_or_else(|| ChainError::BadInput(format!("TLCP endpoint {key} 必须是字符串"))) +} + +impl TlcpEndpoint { + /// 从 JSON 解析。未知字段一律拒绝(「参数传了但没人据此起通道」是假接口)。 + pub fn from_json(text: &str) -> Result { + let v: Value = serde_json::from_str(text) + .map_err(|e| ChainError::BadInput(format!("TLCP endpoint 不是合法 JSON: {e}")))?; + let obj = v + .as_object() + .ok_or_else(|| ChainError::BadInput(String::from("TLCP endpoint 必须是 JSON 对象")))?; + for key in obj.keys() { + if ![ + "host", + "port", + "ca_pem", + "cipher_suite", + "server_name", + "client_sign_cert_pem", + "client_sign_key_pem", + "client_key_pass", + ] + .contains(&key.as_str()) + { + return Err(ChainError::BadInput(format!( + "TLCP endpoint 有未知字段 {key},拒绝静默忽略" + ))); + } + } + let host = String::from(endpoint_str(obj, "host")?); + let port = obj + .get("port") + .and_then(|x| x.as_u64()) + .ok_or_else(|| ChainError::BadInput(String::from("TLCP endpoint port 必须是非负整数")))? + as u16; + let ca_pem = endpoint_str(obj, "ca_pem")?.as_bytes().to_vec(); + let cipher_suite = String::from(endpoint_str(obj, "cipher_suite")?); + let server_name = obj + .get("server_name") + .map(|x| String::from(x.as_str().unwrap_or(""))); + let client_sign_cert_pem = obj + .get("client_sign_cert_pem") + .map(|x| x.as_str().unwrap_or("").as_bytes().to_vec()); + let client_sign_key_pem = obj + .get("client_sign_key_pem") + .map(|x| x.as_str().unwrap_or("").as_bytes().to_vec()); + let client_key_pass = obj + .get("client_key_pass") + .map(|x| String::from(x.as_str().unwrap_or(""))); + Ok(Self { + host, + port, + ca_pem, + cipher_suite, + server_name, + client_sign_cert_pem, + client_sign_key_pem, + client_key_pass, + }) + } +} + +static TUNNEL_SEQ: AtomicU64 = AtomicU64::new(0); + +fn tunnel_workdir() -> Result { + let seq = TUNNEL_SEQ.fetch_add(1, Ordering::SeqCst); + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + let dir = std::env::temp_dir().join(format!( + "mpc-tlcp-{}-{}-{}", + std::process::id(), + nanos, + seq + )); + std::fs::create_dir_all(&dir) + .map_err(|e| ChainError::Io(format!("建 TLCP 工作目录失败: {e}")))?; + Ok(dir) +} + +/// 经 `gmssl tlcp_client` 进程的 TLCP 传输器(**进程通道**)。 +/// +/// ★ 为什么是进程通道而不是 FFI:GmSSL 3.x 移除了核心 OpenSSL 兼容 API, +/// 不能作为 OpenSSL provider 喂给 `reqwest`;直接 FFI 到 `libgmssl` 的 +/// `tls.h` 又缺少稳定绑定。进程通道复用现有「spawn 外部国密二进制」的风格 +/// (参考 `mpc_hostd::link` 对 EasyTier),且把「握手 + 应用数据往返」从 +/// fail-closed 契约推进到环回真可达。 +/// +/// ★ 诚实边界:`send` 只保证「字节经 TLCP 发到 endpoint 并读回响应」,不保证 +/// endpoint 是 `bcos-rpc`。当前实证的服务端是环回 `gmssl tlcp_server` echo。 +#[derive(Debug)] +pub struct TlcpTunnel { + endpoint: TlcpEndpoint, + workdir: PathBuf, +} + +impl Drop for TlcpTunnel { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.workdir); + } +} + +impl TlcpTunnel { + /// 校验套件白名单 + CA 可解析 + 探测国密后端可用,落盘 CA / 客户端证书, + /// 开一个唯一工作目录。后端缺失或套件非法一律拒绝(不降级、不静默跳过)。 + pub fn open(endpoint: TlcpEndpoint) -> Result { + if !TLCP_CIPHER_SUITES.contains(&endpoint.cipher_suite.as_str()) { + return Err(ChainError::Config(format!( + "TLCP 套件 {:?} 不在合并白名单(Tongsuo / GmSSL 两套名字),拒绝随便填", + endpoint.cipher_suite + ))); + } + // CA 必须能解析(用本机 OpenSSL):否则握手时才炸,症状像「链挂」。 + X509::from_pem(&endpoint.ca_pem) + .map_err(|e| ChainError::Config(format!("ca_pem 不是合法 PEM 证书: {e}")))?; + let p = probe_tlcp_environment(); + if p.backend == TlcpBackend::None { + return Err(ChainError::NotConfigured(String::from( + "本机无可用国密 TLCP 后端(需要 Tongsuo ≥ 8.4 或 GmSSL ≥ 3.2),拒绝开通道", + ))); + } + let workdir = tunnel_workdir()?; + std::fs::write(workdir.join("ca.pem"), &endpoint.ca_pem) + .map_err(|e| ChainError::Io(format!("写 ca.pem 失败: {e}")))?; + if let (Some(c), Some(k)) = (&endpoint.client_sign_cert_pem, &endpoint.client_sign_key_pem) { + std::fs::write(workdir.join("client_certs.pem"), c) + .map_err(|e| ChainError::Io(format!("写 client_certs.pem 失败: {e}")))?; + std::fs::write(workdir.join("client_keys.pem"), k) + .map_err(|e| ChainError::Io(format!("写 client_keys.pem 失败: {e}")))?; + } + Ok(Self { endpoint, workdir }) + } + + /// 把 `payload` 经 TLCP 发给 endpoint 并读回响应字节。 + /// + /// 实现:写 `req.in` → spawn `gmssl tlcp_client -host -port -cacert + /// -cipher_suite [-cert -key -pass] -in req.in`(在 workdir 内) + /// → 读子进程 stdout 作为响应。 + /// + /// ★ 注意:`gmssl tlcp_client` **没有 `-out`** 选项(与 `tlcp_server` + /// 不同),响应走 stdout。服务端(环回 echo)把收到的应用数据原样写回, + /// 所以 stdout 即回显内容。 + /// + /// ★ `_timeout_ms` 为保留参数:本机环回场景下 `gmssl tlcp_client` 阻塞返回 + /// 很快;对真机 endpoint 的超时由部署层( supervisor / 调用方)施加, + /// 这里不重复实现进程级超时。 + pub fn send(&self, payload: &[u8], _timeout_ms: u64) -> Result, ChainError> { + let in_path = self.workdir.join("req.in"); + std::fs::write(&in_path, payload) + .map_err(|e| ChainError::Io(format!("写请求文件失败: {e}")))?; + let mut args: Vec = vec![ + "tlcp_client".to_string(), + "-host".to_string(), + self.endpoint.host.clone(), + "-port".to_string(), + self.endpoint.port.to_string(), + "-cacert".to_string(), + "ca.pem".to_string(), + "-cipher_suite".to_string(), + self.endpoint.cipher_suite.clone(), + "-in".to_string(), + "req.in".to_string(), + ]; + if let Some(sn) = &self.endpoint.server_name { + args.push("-server_name".to_string()); + args.push(sn.clone()); + } + if let (Some(_), Some(_)) = ( + &self.endpoint.client_sign_cert_pem, + &self.endpoint.client_sign_key_pem, + ) { + args.push("-cert".to_string()); + args.push("client_certs.pem".to_string()); + args.push("-key".to_string()); + args.push("client_keys.pem".to_string()); + if let Some(pass) = &self.endpoint.client_key_pass { + args.push("-pass".to_string()); + args.push(pass.clone()); + } + } + let output = Command::new("gmssl") + .args(&args) + .current_dir(&self.workdir) + .output() + .map_err(|e| ChainError::Io(format!("spawn gmssl tlcp_client 失败: {e}")))?; + if !output.status.success() { + let err = String::from_utf8_lossy(&output.stderr).to_string(); + return Err(ChainError::Io(format!( + "TLCP 通道发送失败(rc={}):{}", + output.status, err + ))); + } + Ok(output.stdout) + } } #[cfg(test)] @@ -418,4 +658,45 @@ mod tests { other => panic!("非法证书必须先被拒,得到 {other:?}"), } } + + #[test] + fn endpoint_rejects_unknown_keys_and_requires_fields() { + let base = serde_json::json!({ + "host": "127.0.0.1", "port": 8443, "ca_pem": "x", + "cipher_suite": "TLS_ECC_SM4_CBC_SM3" + }); + let mut m = base.as_object().unwrap().clone(); + m.insert(String::from("allow_plaintext"), Value::Bool(true)); + match TlcpEndpoint::from_json(&serde_json::to_string(&m).unwrap()) { + Err(ChainError::BadInput(msg)) => assert!(msg.contains("未知字段")), + other => panic!("未知字段必须拒绝,得到 {other:?}"), + } + let mut m2 = base.as_object().unwrap().clone(); + m2.remove("host"); + assert!( + TlcpEndpoint::from_json(&serde_json::to_string(&m2).unwrap()).is_err(), + "缺 host 必须被拒" + ); + } + + #[test] + fn tunnel_open_rejects_bad_cipher_and_unparseable_ca() { + let mk = |suite: &str, ca: &[u8]| TlcpEndpoint { + host: String::from("127.0.0.1"), + port: 8443, + ca_pem: ca.to_vec(), + cipher_suite: String::from(suite), + server_name: None, + client_sign_cert_pem: None, + client_sign_key_pem: None, + client_key_pass: None, + }; + // 非国密套件必须在 open 阶段就被拒(不落到 gmssl 握手)。 + assert!(TlcpTunnel::open(mk("TLS_AES_128_GCM_SHA256", b"not-a-cert")).is_err()); + // 套件合法但 CA 不可解析也必须被拒,且原因点名证书。 + match TlcpTunnel::open(mk("TLS_ECC_SM4_CBC_SM3", b"not-a-cert")) { + Err(ChainError::Config(m)) => assert!(m.contains("PEM 证书")), + other => panic!("非法 CA 必须先被拒,得到 {other:?}"), + } + } } diff --git a/crates/mpc-cli/src/chain.rs b/crates/mpc-cli/src/chain.rs index 4b1bf3a..8a1b9bd 100644 --- a/crates/mpc-cli/src/chain.rs +++ b/crates/mpc-cli/src/chain.rs @@ -31,7 +31,7 @@ use mpc_chain::sm2::{ SM2_DISTID, }; use mpc_chain::tlcp::{ - probe_tlcp_environment, TlcpBackend, TlcpConfig, TlcpReadiness, + probe_tlcp_environment, TlcpBackend, TlcpConfig, TlcpEndpoint, TlcpReadiness, TlcpTunnel, }; use mpc_chain::{from_hex, to_hex, ChainConfig, TransportMode, PLAINTEXT_STUB_WARNING}; use std::collections::HashMap; @@ -392,7 +392,14 @@ fn cmd_align(args: &[String]) -> Result<(), String> { } fn cmd_tlcp(args: &[String]) -> Result<(), String> { - let o = opts(args, &["--file"])?; + match args.first().map(String::as_str) { + Some("send") => cmd_tlcp_send(&args[1..]), + _ => cmd_tlcp_status(args), + } +} + +fn cmd_tlcp_status(_args: &[String]) -> Result<(), String> { + let o = opts(_args, &["--file"])?; let p = probe_tlcp_environment(); let (config_ok, detail) = match o.get("--file") { Some(path) => match TlcpConfig::from_json(&read(path)?) { @@ -407,11 +414,13 @@ fn cmd_tlcp(args: &[String]) -> Result<(), String> { let readiness = if p.backend == TlcpBackend::None { TlcpReadiness::MissingEnvironment } else { - // ★ 环境齐备(含 GmSSL 本机握手已跑通)也只到 NeedsFfi: - // Rust 侧把 JSON-RPC 经 TLCP 发到 bcos-rpc 的通道还没接。 - TlcpReadiness::NeedsFfi + // ★ 环境齐备 + Rust 侧 TLCP 进程通道(TlcpTunnel)已接入 ⇒ 通道层环回可达。 + // 但服务端是 gmssl 环回 echo,不是 bcos-rpc 真机;realChainVerified 恒 false。 + TlcpReadiness::LoopbackReachable }; let ready = readiness == TlcpReadiness::Ready && config_ok; + let channel_layer_reachable = readiness == TlcpReadiness::LoopbackReachable && config_ok; + let real_chain_verified = false; let reason = match p.backend { TlcpBackend::None => format!( "本机既无 OpenSSL/Tongsuo TLCP 套件({}),也无可用 GmSSL;\ @@ -419,17 +428,19 @@ fn cmd_tlcp(args: &[String]) -> Result<(), String> { p.openssl_version ), TlcpBackend::GmSSL => String::from( - "GmSSL TLCP 本机握手已可用,但 Rust 侧把 JSON-RPC 经 TLCP 发到 bcos-rpc 的\ - 进程通道 / FFI 未落地,且未验证 bcos-rpc 是否启用 TLCP;拒绝宣称能发真交易", + "GmSSL TLCP 本机握手与进程通道已可用(环回 echo 实证),但服务端不是 bcos-rpc 真机,\ + 未验证 bcos-rpc 启用 TLCP,也无硬件国密模组;发真交易仍被拒", ), TlcpBackend::Tongsuo => String::from( - "Tongsuo TLCP 环境齐备但 Rust 侧 FFI 握手未落地,拒绝宣称能发真交易", + "Tongsuo TLCP 环境齐备(通道代码已接入),但发真交易仍须 bcos-rpc 真机验证", ), }; println!( - "{{\"ready\":{},\"readiness\":\"{:?}\",\"configOk\":{},\"backend\":\"{:?}\",\"opensslVersion\":\"{}\",\"tlcpCipherAvailable\":{},\"tongsuoLib\":{},\"gmsslAvailable\":{},\"gmsslVersion\":{},\"gmsslTlcpCommands\":{},\"detail\":\"{}\",\"reason\":\"{}\"}}", + "{{\"ready\":{},\"readiness\":\"{:?}\",\"channelLayerReachable\":{},\"realChainVerified\":{},\"configOk\":{},\"backend\":\"{:?}\",\"opensslVersion\":\"{}\",\"tlcpCipherAvailable\":{},\"tongsuoLib\":{},\"gmsslAvailable\":{},\"gmsslVersion\":{},\"gmsslTlcpCommands\":{},\"detail\":\"{}\",\"reason\":\"{}\"}}", ready, readiness, + channel_layer_reachable, + real_chain_verified, config_ok, p.backend, esc(&p.openssl_version), @@ -450,6 +461,83 @@ fn cmd_tlcp(args: &[String]) -> Result<(), String> { Ok(()) } +/// 经 TLCP 进程通道把一个请求体发给某 endpoint 并读回响应。 +/// +/// ★ 诚实边界:这只是「通道层环回实证」,把 JSON-RPC 经 TLCP 发到 endpoint +/// 并读回响应;不保证 endpoint 是 bcos-rpc。输出里 `realChainVerified` +/// 恒 false,明确标注「不等于通道已通」。 +fn cmd_tlcp_send(args: &[String]) -> Result<(), String> { + let o = opts( + args, + &[ + "--host", + "--port", + "--ca", + "--payload", + "--cipher-suite", + "--server-name", + "--cert", + "--key", + "--pass", + "--timeout", + ], + )?; + let host = o.get("--host").cloned().ok_or_else(|| String::from("缺 --host"))?; + let port = o + .get("--port") + .cloned() + .ok_or_else(|| String::from("缺 --port"))? + .parse::() + .map_err(|e| format!("--port 不是合法端口: {e}"))?; + let ca_path = o + .get("--ca") + .cloned() + .ok_or_else(|| String::from("缺 --ca(CA 证书文件路径)"))?; + let payload_path = o + .get("--payload") + .cloned() + .ok_or_else(|| String::from("缺 --payload(请求体文件路径)"))?; + let cipher = o + .get("--cipher-suite") + .cloned() + .unwrap_or_else(|| String::from("TLS_ECC_SM4_CBC_SM3")); + let timeout = o + .get("--timeout") + .cloned() + .and_then(|s| s.parse::().ok()) + .unwrap_or(0); + let ca_pem = read(&ca_path)?; + let payload = read(&payload_path)?; + let server_name = o.get("--server-name").cloned(); + let client_sign_cert_pem = o.get("--cert").map(|p| read(p)).transpose()?; + let client_sign_key_pem = o.get("--key").map(|p| read(p)).transpose()?; + let client_key_pass = o.get("--pass").cloned(); + let endpoint = TlcpEndpoint { + host, + port, + ca_pem: ca_pem.into_bytes(), + cipher_suite: cipher, + server_name, + client_sign_cert_pem: client_sign_cert_pem.map(|v| v.into_bytes()), + client_sign_key_pem: client_sign_key_pem.map(|v| v.into_bytes()), + client_key_pass, + }; + let tun = TlcpTunnel::open(endpoint).map_err(|e| format!("开 TLCP 通道失败: {e}"))?; + let resp = tun + .send(payload.as_bytes(), timeout) + .map_err(|e| format!("经 TLCP 发送失败: {e}"))?; + let resp_text = String::from_utf8_lossy(&resp); + let resp_hex: String = resp.iter().map(|b| format!("{b:02x}")).collect(); + println!( + "{{\"sentBytes\":{},\"receivedBytes\":{},\"channelLayerReachable\":true,\"realChainVerified\":false,\"responseText\":\"{}\",\"responseHexPrefix\":\"{}\",\"note\":\"环回 echo 服务端不是 bcos-rpc,本结果不等于 bcos-rpc 通道已通\"}}", + payload.len(), + resp.len(), + esc(&resp_text.chars().take(200).collect::()), + resp_hex.chars().take(32).collect::(), + ); + Ok(()) +} + fn cmd_governance(args: &[String]) -> Result<(), String> { let o = opts(args, &["--config", "--kind", "--file"])?; let cfg = config(req(&o, "--config")?)?; diff --git a/crates/mpc-core/src/catalog.rs b/crates/mpc-core/src/catalog.rs index 6c14fa3..c9fdfb4 100644 --- a/crates/mpc-core/src/catalog.rs +++ b/crates/mpc-core/src/catalog.rs @@ -190,7 +190,7 @@ let verdict = link_admit(policy, &obs, &whitelist, &cred, &user_data_first32, no #[cfg(feature = "std")] use mpc_hostd::link::{EasyTierSpec, CliCredentialIssuer, LinkRuntime, parse_peer_output}; let argv = spec.argv()?; // **绝不产 --network-secret**(临时节点不接触联盟主密码) -# 链上层(mpc-chain,std only;★ OpenSSL SM2 软件签名已落地,RLP / TLCP FFI 未落地,不宣称能上链) +# 链上层(mpc-chain,std only;★ OpenSSL SM2 软件签名已落地,Rust 侧 TLCP 进程通道环回实证已落地(gate 18),但 FISCO 自有交易 RLP 编码 / 真实 bcos-rpc 的 TLCP 通道 / 硬件模组 provider 仍未落地,不宣称能上链) use mpc_chain::{ChainConfig, ChainError, digest_for_config, to_hex, from_hex}; use mpc_chain::objects::{ChainObject, Member, ComputeOrder, Receipt, PolicyBundleRecord, AttestFlags, object_digest, push_field}; let cfg = ChainConfig::from_json(text)?; // 5 字段必须显式;**sm_crypto=false 即拒**(链下无 keccak256) @@ -221,16 +221,17 @@ let raw = s.sign(payload)?; // raw r||s 64B(FISCO 要裸值 let fp = aligned_distid(&decls)?; // sm2 distid 三重对齐:chain_signer / chain_verifier / attestation_csv_sm2 # ★ distid 唯一值 = "1234567812345678"(FISCO fast_sm2.cpp 的 c_userId 与 OpenSSL 默认同值); # **系统 openssl CLI 独立验签**是硬证据,自签自验是循环自证,测不到漂移。 -use mpc_chain::tlcp::{TlcpConfig, TlcpProbe, TlcpReadiness, probe_tlcp_environment, require_tlcp_transport, TLCP_CIPHER_SUITES}; +use mpc_chain::tlcp::{TlcpConfig, TlcpProbe, TlcpReadiness, TlcpEndpoint, TlcpTunnel, probe_tlcp_environment, require_tlcp_transport, TLCP_CIPHER_SUITES}; use mpc_chain::{TransportMode, require_transport, PLAINTEXT_STUB_WARNING}; require_transport(&cfg, TransportMode::Tlcp, Some(&tlcp_cfg))?; // 3 参;**TLCP 未假装已通**,缺 Tongsuo 即 fail-closed +let ep = TlcpEndpoint::from_json(endpoint_json)?; let _ = TlcpTunnel::open(ep); // 进程通道:spawn gmssl tlcp_client 经 TLCP 收发字节(环回 echo 实证,≠ bcos-rpc) # ★ 客户端到 bcos-rpc 这一跳做国密 TLCP(用户拍板);明文只允许显式 PlaintextStub 桩自测。 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 条判 SM2 签名、distid 三重对齐、TLCP fail-closed、治理边界(总数见下段:16 条)。 -# ★ 仍未落地:FISCO 自有交易编码(不是以太坊 RLP)、Rust 侧 TLCP 通道、硬件模组 provider;flush 仍发规范字节,**不宣称能上链**。 +# ★ 主门禁第 15 条判 SM2 签名、distid 三重对齐、TLCP fail-closed、治理边界(总数见下段:18 条)。 +# ★ 仍未落地:FISCO 自有交易编码(不是以太坊 RLP)、真实 bcos-rpc 的 TLCP 通道、硬件模组 provider;Rust 侧 TLCP 进程通道环回实证已落地(gate 18,但服务端是环回 echo,不是真节点);flush 仍发规范字节,**不宣称能上链**。 # --- 2026-11-07 追加:GmSSL 真 TLCP / 国密链提交方法 / TA 密钥分级(源码事实,非推测) --- # ★ sendTransaction 是国密链的自有提交方法(4 参);eth_sendRawTransaction 是 @@ -246,13 +247,17 @@ 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。 +# ★ 本机握手通过 ≠ bcos-rpc 通道已通:TlcpReadiness 通道层已到 LoopbackReachable +# (Rust 侧 spawn gmssl tlcp_client 经 TLCP 收发字节,环回 echo 实证),但 +# ready 恒 false(≠ Ready),发真实国密交易仍由 require_transport fail-closed。 # ★ 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: 独立短行。 -# ★ 主门禁 17 条:第 16 条 = GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约; -# 缺环境一律 *_SKIPPED + 逐项缺失(FISCO_REALNODE_SKIPPED / GMSSL_TLCP_SKIPPED), -# 环境齐备也只 NEEDS_IMPL,绝不打印通过。 +# ★ 主门禁 18 条:第 16 条 = GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约; +# 第 17 条 = 阶段 3 OPA 真判定闭环;第 18 条 = TLCP 进程通道环回实证 +# (spawn gmssl tlcp_client 经 TLCP 收发 JSON-RPC,服务端是环回 echo 不是 bcos-rpc)。 +# 缺环境一律 *_SKIPPED + 逐项缺失(FISCO_REALNODE_SKIPPED / GMSSL_TLCP_SKIPPED / +# GMSSL_TLCP_TUNNEL_SKIPPED),环境齐备也只 NEEDS_IMPL,绝不打印通过。 # --- 2026-11-07 追加:阶段 3 第一段 OPA bundle / decision(真跑,非形状) --- use mpc_chain::opa::{sign_bundle, verify_bundle, decide, parse_eval_allow, require_input_source, signing_bytes, decision_id_for, BundleManifest, RevocationView, Decision, DecideRequest, OpaRunner}; @@ -659,7 +664,7 @@ mod tests { "require_self_test(&s, SignerPolicy::DevelopmentSoftware)?", "let raw = s.sign(payload)?", "let fp = aligned_distid(&decls)?", - "use mpc_chain::tlcp::{TlcpConfig, TlcpProbe, TlcpReadiness, probe_tlcp_environment, require_tlcp_transport, TLCP_CIPHER_SUITES}", + "use mpc_chain::tlcp::{TlcpConfig, TlcpProbe, TlcpReadiness, TlcpEndpoint, TlcpTunnel, probe_tlcp_environment, require_tlcp_transport, TLCP_CIPHER_SUITES}", "use mpc_chain::{TransportMode, require_transport, PLAINTEXT_STUB_WARNING}", "require_transport(&cfg, TransportMode::Tlcp, Some(&tlcp_cfg))?", "use mpc_chain::policy::{HardRuleSet, OpaPolicyBundle, governance_boundary}", @@ -709,6 +714,8 @@ mod tests { "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}", + "use mpc_chain::tlcp::{TlcpConfig, TlcpProbe, TlcpReadiness, TlcpEndpoint, TlcpTunnel, probe_tlcp_environment, require_tlcp_transport, TLCP_CIPHER_SUITES}", + "let ep = TlcpEndpoint::from_json(endpoint_json)?; let _ = TlcpTunnel::open(ep);", ] { assert!(CATALOG.contains(key), "清单缺少真实 API 签名:{key}"); } @@ -718,10 +725,10 @@ mod tests { "sm2Verify(bytes32,bytes,bytes32,bytes32)", "4 入参", "GmSSL 3.2.0", - "NeedsFfi", + "LoopbackReachable", "TA 签名密钥三级", "MPC_TA_KEY_FAIL", - "主门禁 17 条", + "主门禁 18 条", "FISCO_REALNODE_SKIPPED", "本机握手通过 ≠ bcos-rpc 通道已通", "软件实现不能过密评", diff --git a/docs/INTEGRATION_ANALYSIS.md b/docs/INTEGRATION_ANALYSIS.md index d6ecb9e..27038f1 100644 --- a/docs/INTEGRATION_ANALYSIS.md +++ b/docs/INTEGRATION_ANALYSIS.md @@ -647,7 +647,7 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交 因此 `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 判定这些框架自己的契约,**不宣称能上链**。 +**本期诚实边界(2026-11-07 拍板后)**:`mpc chain sign` 已能用 OpenSSL **真的签出** SM2 签名;但 `mpc chain flush` 发出去的 payload **仍是链上对象的规范字节,不是已签名的 FISCO 交易** —— FISCO **自有**交易编码(不是以太坊 RLP)待真机对拍、真实 `bcos-rpc` 的 TLCP 通道(Tongsuo FFI)未接入;GmSSL **进程通道**环回实证已落地(第 18 条,服务端是 echo 不是真节点)。它验证的是签名 / distid 对齐 / 传输准入 / 幂等补链 / fail-open 与 fail-closed 分离 / JSON-RPC 判定这些框架自己的契约,**不宣称能上链**。 **★ 配置与准入纪律**: ① `sm_crypto` 必须显式给、`false` 直接拒(标准版链上用 `keccak256Hash`,链下没有 keccak256 实现,放行等于「摘要永远对不上」的假绿);**`true` 已由用户确认**,建链参数按国密冻结。 @@ -658,7 +658,7 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交 **★ 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 条真跑。 +**★ 但绝不能把「本机握手通过」说成「通道已通」**:① GmSSL 3.x **移除了核心的 OpenSSL 兼容 API**(`libgmssl` 是独立 ABI),不能当 provider 直接喂给 `reqwest`;② 服务端是环回 `tlcp_server`,不是 `bcos-rpc`,也没验证节点是否启用 TLCP;③ Rust 侧把 JSON-RPC 经 TLCP 发出去的**进程通道**(`gmssl tlcp_client -in file`,响应走 stdout)**已接入** `TlcpTunnel` 并跑通环回 echo 实证(第 18 条),但服务端是 echo 不是真节点,**不等于 `bcos-rpc` 通道已通**。所以 `TlcpReadiness` 已从 `NeedsFfi` 推进到 `LoopbackReachable`(环回可达),但仍**非 `Ready`**、`require_transport()` 发真交易继续 fail-closed;脚本成功只打印 `GMSSL_TLCP_TUNNEL_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 条有专门回归探针。 @@ -707,20 +707,20 @@ outbox 必须**幂等**:同一 `order_id` + 同一 `decision_id` 重复提交 | **0a** | 拆两层:`mpc-hostd`(e2b 兼容)+ `TeeRuntime` + `/attestation` + 站点侧 `session_admit` | 中(**axum + tokio + reqwest**,只在独立 `mpc-hostd` crate) | 中(协议设计、token 信任链) | — | | **0b** | OP-TEE 独立通道:`tools/ci-optee.sh` + 五条验证规则 + `ta_admit` | 零(复用 `build/build_optee.sh`) | 低(不碰主链路) | — | | **1** | 链路:EasyTier 进程化 + 三档 `--link-policy` + credential + `link` 上报 | 零(外部二进制) | 中(LGPL 合规、TUN 权限、relay 可见性) | 0a | -| **2** | `mpc-chain`:**形状层 + OpenSSL 国密签名已完成**(对象 / JSON-RPC / outbox / 准入 / SM2 真签名 / distid 对齐 / TLCP 契约 / 治理形状);真链建链 / RLP / TLCP FFI 待环境与模组 | 中(`serde_json` + `reqwest` + `openssl`,仅 `mpc-chain`;**国密模组 / Tongsuo FFI 未落地**) | 高(国密不可逆、TLCP 环境、CSV 验签待实测) | 0a | +| **2** | `mpc-chain`:**形状层 + OpenSSL 国密签名 + GmSSL 本机 TLCP 真握手 + Rust 侧 TLCP 进程通道环回实证已完成**(对象 / JSON-RPC / outbox / 准入 / SM2 真签名 / distid 对齐 / TLCP 契约 / 治理形状 / `TlcpTunnel` 进程通道);真实 `bcos-rpc` 的 TLCP 通道 / RLP / 国密模组 provider 待环境与硬件 | 中(`serde_json` + `reqwest` + `openssl`,仅 `mpc-chain`;**国密模组 / Tongsuo FFI 未落地**) | 高(国密不可逆、真实 TLCP 通道环境、CSV 验签待实测) | 0a | | **3** | 策略:OPA 进 guest + 控制面签发 bundle + decision 上链。**第一段已完成**(控制面真签 bundle + 真 `opa eval` 判定 + decision 幂等落 outbox,第 17 条);guest 内执行 / bundle 分发 / 链上撤销状态位读取 / 已签名交易上链**未落地** | 中(OPA 二进制 + bundle 分发) | 高(bundle 灰度与撤销、TCB 边界) | 2 | | ~~4~~ | ~~Rego→WASM 上链~~ | — | — | **删除(决策 6)** | -**阶段状态(2026-11-07 追加阶段 3 第一段后)**:**0a 已完成**(第 12 条)、**1 已完成**(第 13 条)、**2 形状层 + OpenSSL 国密签名 + GmSSL 本机 TLCP 真握手已完成**(第 14 / 15 / 16 条);**3 第一段已完成**(第 17 条:真 OPA bundle 签发 / 真判定 / decision 幂等存证);0b 的编排与判据已实现、**QEMU 实跑待有 SDK 的机器**。主门禁共 **17 条**。 -**★ 两段诚实边界都不许冲掉**:① **阶段 2 仍不含真实交易签名上链** —— FISCO 自有交易编码 / 国密模组 provider / Rust 侧 TLCP 通道未落地,见 4.8 与 `tools/fisco-realnode-probe.py`;② **阶段 3 只完成第一段** —— OPA 仍在宿主 / 控制面 spawn,**不在 guest 内执行**,撤销视图是调用方每次提供的本地桩(链上状态位读取未接入),decision 只入 outbox、未签名未上链;合约部署与 OPA bundle 的 guest 分发仍未做。成功输出为 `OPA_DECISION_OK` + `OPA_GUEST_NOT_VERIFIED` + `CHAIN_NOT_VERIFIED`,**不是「阶段 3 已完成」**。 +**阶段状态(2026-11-08 追加 TLCP 进程通道后)**:**0a 已完成**(第 12 条)、**1 已完成**(第 13 条)、**2 形状层 + OpenSSL 国密签名 + GmSSL 本机 TLCP 真握手 + Rust 侧 TLCP 进程通道环回实证已完成**(第 14 / 15 / 16 / 18 条);**3 第一段已完成**(第 17 条:真 OPA bundle 签发 / 真判定 / decision 幂等存证);0b 的编排与判据已实现、**QEMU 实跑待有 SDK 的机器**。主门禁共 **18 条**。 +**★ 两段诚实边界都不许冲掉**:① **阶段 2 仍不含真实交易签名上链** —— FISCO 自有交易编码 / 国密模组 provider / 真实 `bcos-rpc` 的 TLCP 通道未落地(Rust 侧 TLCP 进程通道环回实证已落地,但服务端是 echo 不是真节点),见 4.8 与 `tools/fisco-realnode-probe.py`;② **阶段 3 只完成第一段** —— OPA 仍在宿主 / 控制面 spawn,**不在 guest 内执行**,撤销视图是调用方每次提供的本地桩(链上状态位读取未接入),decision 只入 outbox、未签名未上链;合约部署与 OPA bundle 的 guest 分发仍未做。成功输出为 `OPA_DECISION_OK` + `OPA_GUEST_NOT_VERIFIED` + `CHAIN_NOT_VERIFIED`,**不是「阶段 3 已完成」**。 **★ 第 4 条门禁本轮补上 guest 产物边界**:`mpc-chain` 引 `openssl` 后 musl 静态产物链接失败, 暴露的是「宿主控制面被编进 guest」而不是环境缺包。现按 feature + target 切分, `tools/check-guest-artifact.py` 三层探针(依赖树 / 编译期守卫 / ELF 标识)进主门禁; `deps` 不依赖 musl target 是否安装,避免「跳过目标」把边界判据一起跳掉。 -本轮 `./tools/ci.sh` **17 条全绿**:第 4 条 guest 探针 22(deps)/ 3(guard)/ 15(binary)、 +本轮 `./tools/ci.sh` **18 条全绿**:第 4 条 guest 探针 22(deps)/ 3(guard)/ 15(binary)、 第 14 条 50、第 15 条 36、第 16 条真握手 19 + TA 密钥 16 + 两份零依赖契约判据 -11 / 12、第 17 条真 OPA 闭环 40 + 零依赖判据 18;真机契约实跑如实输出 +11 / 12、第 17 条真 OPA 闭环 40 + 零依赖判据 18、第 18 条 TLCP 进程通道环回实证 15 + 零依赖判据;真机契约实跑如实输出 `FISCO_REALNODE_SKIPPED` 与 6 项缺失,无静默通过。 **为什么 0a 必须第一**:后三件都要"可编排的对象"。没有 `TeeRuntime` 和 e2b 接口,"给这个会话签 credential""把这轮登记上链"都没有承载点。 @@ -758,7 +758,7 @@ 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 分域)。**FISCO 自有交易编码 / 模组 provider / Rust 侧 TLCP 通道仍未实现**,不宣称能上链。 +硬规则与 OPA 分域)。**FISCO 自有交易编码 / 模组 provider / 真实 `bcos-rpc` 的 TLCP 通道仍未实现**(Rust 侧 TLCP 进程通道环回实证已落地,第 18 条),不宣称能上链。 CLI `mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governance`; `tools/selftest-chain.py` **50 条判据进主门禁第 14 条**(含国密链提交方法纠正的 4 条)、 `tools/selftest-chain-gm.py` **36 条判据进第 15 条**(含系统 openssl CLI 独立验签与 @@ -823,7 +823,7 @@ decision 只是 outbox 存证(**未签名、未上链**),软件签名器 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;用户提点后装了 GmSSL 3.2.0,本机环回**真 TLCP 握手已跑通**(第 16 条 19 判据),但 Rust 侧通道 / `bcos-rpc` 是否启用 TLCP 仍未验证,见 4.8。Tongsuo FFI 不再是唯一路径。 +3. **客户端到 `bcos-rpc` 做国密 TLCP 已定**。本期落双证书契约 + 环境探测 + fail-closed;用户提点后装了 GmSSL 3.2.0,本机环回**真 TLCP 握手已跑通**(第 16 条 19 判据),Rust 侧 **TLCP 进程通道**也已环回实证可达(第 18 条,spawn `gmssl tlcp_client` 收发真实 JSON-RPC),但**真实 `bcos-rpc` 是否启用 TLCP 仍未验证**(服务端是 echo 不是节点),见 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` 时不得回落开发密钥。**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 的机器上也能被执行到**(守卫不会被前置环境检查抢先)。 @@ -886,7 +886,7 @@ decision 只是 outbox 存证(**未签名、未上链**),软件签名器 - `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`(`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-chain/src/tlcp.rs`(`TlcpBackend::{None,Tongsuo,GmSSL}` + `TlcpReadiness::{LoopbackReachable,MissingEnvironment,Ready}`;`Tongsuo` 与 `GmSSL` 两套套件名合并白名单;`probe_tlcp_environment()` 真跑 `openssl`/`gmssl`;`TlcpEndpoint` 配置 + `TlcpTunnel`(spawn `gmssl tlcp_client -in`、响应走 stdout)进程通道;环境齐备已到 `LoopbackReachable`(环回可达),但仍非 `Ready`) - `crates/mpc-cli/src/chain.rs`(`mpc chain digest|submit|flush|status|admit|keygen|sign|align|tlcp|governance|opa sign|opa decide`;**flush 输出 `methodIsStub` / `guomiSubmitMethod` / `guomiChainRejectsStubMethod` / `payload`,明确标注 payload 不是已签名交易**;`opa decide` 输出 `opaInGuest=false` / `chainRecorded=false` / `decisionStoredAs=outbox-pending-not-signed-tx`) - `tools/selftest-chain.py`(**进主门禁第 14 条**;50 条判据,Python 假 `bcos-rpc`;每条负向带期望特征;含 `.no_proxy()` 与国密链提交方法回归探针) - `tools/selftest-chain-gm.py`(**第 15 条**;36 条判据;系统 openssl CLI 独立验签、生产策略拒软件签名器、GmSSL 套件名白名单、环境齐备也 `ready=false`) @@ -900,7 +900,7 @@ decision 只是 outbox 存证(**未签名、未上链**),软件签名器 - `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-…`;**`--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 + 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 探针零外部依赖;**第 17 条 = 阶段 3 OPA bundle 签发 / 真判定 / decision 存证**,零依赖判据 18 + 真闭环 40;缺环境一律显式 `*_SKIPPED` + 逐项缺失) +- `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 探针零外部依赖;**第 17 条 = 阶段 3 OPA bundle 签发 / 真判定 / decision 存证**,零依赖判据 18 + 真闭环 40;**第 18 条 = TLCP 进程通道环回实证**(`TlcpTunnel` spawn `gmssl tlcp_client` 经 TLCP 收发真实 JSON-RPC 给环回 echo,断言往返一致;`realChainVerified` 恒 false、`BCOS_RPC_NOT_VERIFIED`);缺环境一律显式 `*_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 抠取。判据散落多处 = 迟早分叉且分叉了没人知道) diff --git a/tools/ci.sh b/tools/ci.sh index f41372f..d34fb24 100755 --- a/tools/ci.sh +++ b/tools/ci.sh @@ -63,6 +63,15 @@ # 并排除「未知参数」这类探针自身 bug 造成的假绿。 # ★ 诚实边界:OPA 不在 guest 内、撤销视图不是链读、decision 未上链; # 缺 OPA 必显式 OPA_DECISION_SKIPPED,零依赖 --self-test 仍要跑。 +# 17. TLCP **进程通道**环回实证(Rust 侧 spawn `gmssl tlcp_client`, +# 响应走 stdout;注意 `tlcp_client` 没有 `-out`)。把一段真实 JSON-RPC +# 经 TLCP 发给环回 `gmssl tlcp_server` echo,断言应用数据往返一致、 +# sentBytes == receivedBytes、channelLayerReachable=true、 +# realChainVerified=false。★ 不破「≠ bcos-rpc 通道已通、不假装能发真 +# 交易」的诚实边界:环回服务端是 echo 不是 FISCO 节点,GmSSL 软件 +# 实现不能过密评;成功只打 GMSSL_TLCP_TUNNEL_OK + BCOS_RPC_NOT_VERIFIED。 +# 缺 GmSSL / 缺 mpc 二进制打印 GMSSL_TLCP_TUNNEL_SKIPPED + 逐项缺失, +# --self-test 零依赖判据永远被执行到。 # # 用法:tools/ci.sh 正常跑 # tools/ci.sh --fast 跳过测试与示例,只编译(改完想快速确认能编过时用) @@ -83,19 +92,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/17 全量测试(含 secure 特性)" + step "1/18 全量测试(含 secure 特性)" cargo test --workspace --features secure ok fi -step "2/17 零告警构建(所有目标)" +step "2/18 零告警构建(所有目标)" # -Dwarnings 同时作用于本地 crate 的 test / bench / example 目标, # 所以「测试代码里有 unused」也会被拦下 —— 这正是想要的。 RUSTFLAGS="${RUSTFLAGS:+${RUSTFLAGS} }-Dwarnings" \ cargo build --workspace --all-targets --features secure ok -step "3/17 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)" +step "3/18 no_std 守线 + TA 常量对拍(mpc-core + mpc-tee)" # 两条 no_std 都要守: # mpc-core —— TEE / armv7 那条路的底座 # mpc-tee —— OP-TEE 的 TA 就是 default-features = false 构建的 @@ -133,7 +142,7 @@ ok # 三层判据都在 tools/check-guest-artifact.py:依赖树(必跑)、 # 编译期守卫负向、ELF 产物标识(后两条需已装 musl target)。 CROSS_TARGET=x86_64-unknown-linux-musl -step "4/17 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针" +step "4/18 跨目标编译(${CROSS_TARGET},guest 静态产物)+ guest 边界探针" # 依赖树与标识串自检不依赖 musl target 是否安装 —— 目标没装也必须跑, # 否则「跳过」会把最重要的边界判据一起跳掉(闸门不扫自己 = 假安全感)。 python3 tools/check-guest-artifact.py deps --target "$CROSS_TARGET" @@ -152,7 +161,7 @@ else fi if [ "$FAST" -eq 0 ]; then - step "5/17 示例冒烟(12 个场景)" + step "5/18 示例冒烟(12 个场景)" tools/examples.sh ok @@ -171,14 +180,14 @@ if [ "$FAST" -eq 0 ]; then # bash 把逗号并进变量名 → CI 第 4 条直接 `CROSS_TARGET,: unbound variable` # 中途挂掉;而 lint 闸门只扫 deploy/tee,**对自己的盲区完全无感**。 # 闸门不扫闸门自己 = 闸门有盲区 = 假安全感。 - step "6/17 shell 引号 / 变量名卫生" + step "6/18 shell 引号 / 变量名卫生" python3 deploy/tee/real-machine/lint-shell-vars.py deploy/tee tools ok # 第 6 条:OCI 运行期完整性链自测。 # 这条链是「代码度量 → 活文件内容」的闭链,断了不会有编译错误, # 只会在真机上表现为篡改活文件照样通过 —— 必须有本地闸门兜住。 - step "7/17 OCI 运行期完整性链自测" + step "7/18 OCI 运行期完整性链自测" python3 deploy/tee/oci/selftest-chain.py ok @@ -189,7 +198,7 @@ if [ "$FAST" -eq 0 ]; then # · 判定断(判定器被顶替 / 输出不是判定结论)→ **假绿**, # 「通过之后真的会签发 token 并下发密钥」这条路从未被验证过。 # 所以这里必须同时覆盖正向路径与全部拒绝路径。 - step "8/17 KBS 先验证明才下发自测" + step "8/18 KBS 先验证明才下发自测" python3 deploy/tee/kbs/selftest-kbs.py ok @@ -197,7 +206,7 @@ if [ "$FAST" -eq 0 ]; then # guest 的 /init 由 busybox ash 解析,`bash -n` 通过 ≠ ash 能解析。 # 真机上这类错误要等 guest 起来才暴露,排查一轮几分钟; # 本地闸门用 alpine 的 busybox ash(与 guest 同款解析器)秒级拦住。 - step "9/17 guest 脚本 ash 语法" + step "9/18 guest 脚本 ash 语法" deploy/tee/guest/syntax-check.sh ok @@ -207,7 +216,7 @@ if [ "$FAST" -eq 0 ]; then # 不会有任何编译错误或运行时异常,只会安静地放行。 # 用的是真机采集的真报告 + 真 KDS 证书链(公开信任材料,无私钥), # 所以本地无网也能验证「验签逻辑对真报告成立」。 - step "10/17 SNP 芯片验签器自测(正负向)" + step "10/18 SNP 芯片验签器自测(正负向)" python3 deploy/tee/real-machine/selftest-snp-verify.py ok @@ -228,7 +237,7 @@ if [ "$FAST" -eq 0 ]; then # 不需要 SDK、不需要 QEMU,秒级完成。 # 它证明的是「给定一份日志,判定器的结论正确」, # **不**证明 OP-TEE 的 seal/unseal 行为正确(那要跑 QEMU)。 - step "11/17 OP-TEE 判据逻辑自测" + step "11/18 OP-TEE 判据逻辑自测" python3 tools/selftest-optee-verdict.py ok @@ -244,7 +253,7 @@ if [ "$FAST" -eq 0 ]; then # 跑不跑得通。实例回收那条用**心跳文件**判据(实例自己 touch 一个文件, # 停掉后心跳停止)—— 不依赖 ps / /proc,因为受限环境里 ps 常被禁、 # macOS 也没有 /proc,那时这条判据会被跳过,而它恰恰是最重要的一条。 - step "12/17 宿主控制面 mpc-hostd 端到端自测" + step "12/18 宿主控制面 mpc-hostd 端到端自测" python3 tools/selftest-hostd.py ok @@ -259,7 +268,7 @@ if [ "$FAST" -eq 0 ]; then # 判的是框架自己的契约,不是 EasyTier 的实现。进程真起真回收由 # LinkRuntime 单测判(持 Child + try_wait 收割),此处显式再跑一次, # 保证这条判据真的进了主门禁的执行路径。 - step "13/17 会话级链路层 EasyTier 端到端自测" + step "13/18 会话级链路层 EasyTier 端到端自测" python3 tools/selftest-link.py ok @@ -273,11 +282,12 @@ if [ "$FAST" -eq 0 ]; then # # 本机没有 FISCO BCOS 节点 —— 用 Python 假 bcos-rpc 跑完整链路, # 判的是框架自己的契约。★ 诚实边界:flush 发出去的 payload 仍是 - # 链上对象规范字节,不是已签名交易(国密交易 RLP / TLCP 握手 FFI - # 未落地),所以这条门禁不证明「能上链」。 + # 链上对象规范字节,不是已签名交易(国密交易 RLP 编码 / 真实 + # bcos-rpc 的 TLCP 通道未落地;Rust 侧 TLCP 进程通道环回实证见 + # gate 18,但那不是连真节点的通道),所以这条门禁不证明「能上链」。 # 另:--transport 必须显式给,stub 只供桩自测,tlcp 是生产路径 # (缺双证书配置即拒),传输形态不许有默认值 = 不许留明文后门。 - step "14/17 链上层 mpc-chain 端到端自测" + step "14/18 链上层 mpc-chain 端到端自测" python3 tools/selftest-chain.py ok @@ -290,10 +300,13 @@ if [ "$FAST" -eq 0 ]; then # 软件签名器私钥可导出、密评不可过 —— 生产策略必须拒绝它; # profile 与「私钥不可导出」交叉校验,防止软件谎报硬件模组。 # 本机无 Tongsuo,但 GmSSL 3.2.0 可用:通道准入依旧 fail-closed - # (Rust 侧 TLCP 客户端未落地),就绪状态只到 NeedsFfi。 + # (发真交易只对 Ready 放行);Rust 侧 TLCP **进程通道**已落地 + # (gate 18),就绪状态从 NeedsFfi 推进到 LoopbackReachable —— + # 环回可达,但不是 bcos-rpc 真机通道。 # TLCP 双证书正向校验 / 真交易编码仍待真机对拍, - # 见 tools/selftest-chain-gm.py 与 tools/fisco-realnode-probe.py。 - step "15/17 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测" + # 见 tools/selftest-chain-gm.py、tools/selftest-tlcp-tunnel.py + # 与 tools/fisco-realnode-probe.py。 + step "15/18 国密签名 / distid 对齐 / TLCP 准入 / 治理形状自测" python3 tools/selftest-chain-gm.py ok @@ -307,7 +320,7 @@ if [ "$FAST" -eq 0 ]; then # ★ fisco-realnode-probe.py 环境齐备也只报 NEEDS_IMPL:FISCO 自有 # 交易编码 / Rust 侧 TLCP 通道 / sm2Verify 真机对拍 / 已签名交易 # 都还没落地,凑齐环境变量不等于能上链。 - step "16/17 GmSSL TLCP 真握手 / TA 密钥分级 / FISCO 真机对拍契约" + step "16/18 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 @@ -323,10 +336,31 @@ if [ "$FAST" -eq 0 ]; then # 不是 Python 复刻的策略判定。undefined 输出当拒绝,不当默认 deny。 # ★ 成功也只打印 OPA_DECISION_OK + OPA_GUEST_NOT_VERIFIED + # CHAIN_NOT_VERIFIED,绝不宣称「阶段 3 已完成」。 - step "17/17 阶段 3 OPA bundle 签发 / 真判定 / decision 存证自测" + step "17/18 阶段 3 OPA bundle 签发 / 真判定 / decision 存证自测" python3 tools/selftest-chain-opa.py --self-test python3 tools/selftest-chain-opa.py ok + + # 第 18 条:TLCP **进程通道**环回实证。 + # + # ★ 这条把「Rust 侧 TLCP 通道未落地」这一长期诚实边界项,在不突破 + # 「≠ bcos-rpc 通道已通、不假装能发真交易」前提下,推进到「环回可达」 + # 实证:Rust `TlcpTunnel` spawn `gmssl tlcp_client -in`(响应走 stdout, + # 注意 `tlcp_client` 没有 `-out`),把一段真实 JSON-RPC 经 TLCP 发给环回 + # `gmssl tlcp_server` echo,读回响应,断言应用数据往返一致、sentBytes == + # receivedBytes、channelLayerReachable=true、realChainVerified=false。 + # ★ 诚实边界(沿用 gate 15 口径,且更进一层):环回服务端是 + # `gmssl tlcp_server` echo,不是 FISCO 节点;未验证 bcos-rpc 是否启用 + # TLCP;GmSSL 软件实现私钥可导出、不能过密评。所以成功只打印 + # GMSSL_TLCP_TUNNEL_OK + BCOS_RPC_NOT_VERIFIED,绝不宣称「链上通道已通」 + # 或「能发真交易」。发真国密交易仍由 require_transport 只对 Ready 放行, + # 本通道只到 LoopbackReachable。 + # ★ 缺 GmSSL / 缺 mpc 二进制打印 GMSSL_TLCP_TUNNEL_SKIPPED + 逐项缺失; + # --self-test 零依赖判据逻辑永远被执行到(防盲区)。 + step "18/18 TLCP 进程通道环回实证自测" + python3 tools/selftest-tlcp-tunnel.py --self-test + python3 tools/selftest-tlcp-tunnel.py + ok fi printf '\n\033[32m\033[1m全部通过\033[0m\n' diff --git a/tools/selftest-chain-gm.py b/tools/selftest-chain-gm.py index 970778e..be2f711 100644 --- a/tools/selftest-chain-gm.py +++ b/tools/selftest-chain-gm.py @@ -182,24 +182,38 @@ def main(): "attestation_csv_sm2") # --- 6. TLCP 环境 fail-closed(★ 不写死本机是否装了 GmSSL)--- - # 装了 GmSSL 的机器 backend=GmSSL / readiness=NeedsFfi; - # 没装的 backend=None / readiness=MissingEnvironment。 - # 两种环境下 ready 都必须恒为 false —— 环境齐备也不许冒充通道已通。 + # 装了 GmSSL 的机器 backend=GmSSL / readiness=LoopbackReachable(通道层 + # 环回实证可达,但服务端是 echo 不是 bcos-rpc);没装的 + # backend=None / readiness=MissingEnvironment。 + # 两种环境下 ready 都必须恒为 false、realChainVerified 恒为 false —— + # 环境齐备也不许冒充通道已通 / 真机已验证。 rc, out, _ = run("chain", "tlcp") tc = json.loads(out) if rc == 0 else {} gmssl_bin = shutil.which("gmssl") is not None check("tlcp 诊断输出合法 JSON 且 ready 恒为 false", rc == 0 and tc.get("ready") is False, (rc, tc)) - check("readiness 只能是 NeedsFfi / MissingEnvironment(不许 Ready)", - tc.get("readiness") in ("NeedsFfi", "MissingEnvironment"), tc) + check("readiness 只能是 LoopbackReachable / MissingEnvironment(不许 Ready)", + tc.get("readiness") in ("LoopbackReachable", "MissingEnvironment"), tc) + check("realChainVerified 恒为 false(环回实证 ≠ bcos-rpc 通道已通)", + tc.get("realChainVerified") is False, tc) + # channelLayerReachable 依赖「配置就绪 + 后端可用」,不是单看 GmSSL 是否装了: + # 没给双证书配置时 configOk=false → channelLayerReachable=false(即便 GmSSL 可用)。 + # 正向(configOk + 后端可用 → true)由 selftest-tlcp-tunnel.py 的 send 路径覆盖。 + check("无配置时 channelLayerReachable 与 configOk 一致(均为 false)", + tc.get("channelLayerReachable") is False and tc.get("configOk") is False, 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) + # 拒绝/诚实边界原因必须点名国密实现,并说明「没真正通 / 仍拒发真交易」, + # 防止把环回实证冒充成 bcos-rpc 通道已通(两种环境都要成立)。 + _reason = tc.get("reason", "") + check("TLCP 原因点名国密实现且说明未真正通/仍拒发真交易", + bool(_reason) + and ("GmSSL" in _reason or "Tongsuo" in _reason) + and ("被拒" in _reason or "拒" in _reason or "未验证" in _reason + or "未落地" in _reason or "需要" in _reason or "未安装" in _reason), tc) check("未提供双证书配置时 configOk=false", tc.get("configOk") is False and "未提供" in tc.get("detail", ""), tc) bad_tlcp = p("tlcp-bad.json") diff --git a/tools/selftest-chain-opa.py b/tools/selftest-chain-opa.py index f110b0a..ddee2bb 100644 --- a/tools/selftest-chain-opa.py +++ b/tools/selftest-chain-opa.py @@ -185,7 +185,10 @@ def self_test(): check("domain.rs 有阶段 3 两个独立域分隔常量", "TEE_OPA_SIGNED_BUNDLE" in domain and "TEE_OPA_DECISION" in domain) ci = (REPO / "tools/ci.sh").read_text() - check("★ 主门禁含第 17 条(闸门不扫自己 = 盲区)", "17/17" in ci) + # 闸门不扫自己 = 盲区:本 selftest(gate 17)必须真的被 ci.sh 调用; + # 同时要求末步标签升到 18/18,防止「加了 gate 18 却没把计数顶上去」。 + check("★ 主门禁含第 17 条且计数已升到 18(闸门不扫自己 = 盲区)", + "selftest-chain-opa.py" in ci and "18/18" in ci) print(f"\n判据逻辑自测 {PASS_N + FAIL_N} 条:通过 {PASS_N},失败 {FAIL_N}") if FAIL_N: diff --git a/tools/selftest-tlcp-tunnel.py b/tools/selftest-tlcp-tunnel.py new file mode 100644 index 0000000..968e522 --- /dev/null +++ b/tools/selftest-tlcp-tunnel.py @@ -0,0 +1,365 @@ +#!/usr/bin/env python3 +"""GmSSL 国密 TLCP **进程通道**环回实证自测(主门禁第 18 条)。 + +★ 和「握手指纹」的区别:这里经 `mpc chain tlcp send`(Rust 侧 `TlcpTunnel` + spawn `gmssl tlcp_client -in`)把一段真实 JSON-RPC 请求经 TLCP 发给一个 + 环回 `gmssl tlcp_server` echo 服务端,并读回响应,断言应用数据往返一致。 + +★ 诚实边界(不许被这条自测冲掉): + - 本机环回通道通过 **不等于** 客户端到 `bcos-rpc` 的 TLCP 已通。服务端是 + `gmssl tlcp_server`(echo),不是 FISCO 节点,也没验证 bcos-rpc 是否启用 TLCP。 + - GmSSL 是软件实现,私钥可导出,**不能过密评**,不替代硬件国密模组。 + - 所以脚本成功时打印 `GMSSL_TLCP_TUNNEL_OK` + `BCOS_RPC_NOT_VERIFIED`, + 绝不是「链上通道已通」。`mpc chain tlcp send` 的输出里 `realChainVerified` + 恒为 false。 + +★ 缺 GmSSL 时必须打印 `GMSSL_TLCP_TUNNEL_SKIPPED` 并逐项列出缺什么。 + 静默跳过和通过长得一样,是这类通道最常见的失真。`--self-test` 是 + 零依赖的判据逻辑自测:即使没有 GmSSL,判据本身也必须在每台机器上被执行到。 + +★ 负向纪律(沿用主门禁一贯要求):每条负向必须带**期望拒绝特征**并排除 + 「未知参数」这类探针自身 bug 造成的假绿——只判 rc != 0 会把探针 bug 当成 + 「拒绝成功」。判据一律用列表参数,不让 shell 把整串当成一个 argv。 + +用法: + python3 tools/selftest-tlcp-tunnel.py --self-test # 判据逻辑(零依赖) + python3 tools/selftest-tlcp-tunnel.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 +MPC = str(REPO / "target" / "debug" / "mpc") +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 不可用") + if not env.get("mpc_bin"): + missing.append("target/debug/mpc 未构建(先 cargo build -p mpc-cli)") + return ("SKIPPED" if missing else "RUN"), missing + + +def probe_env(): + mpc_bin = os.path.isfile(MPC) + if shutil.which("gmssl") is None: + return {"gmssl_bin": False, "tlcp_commands": False, "version": None, + "help": "", "certgen_help": "", "mpc_bin": mpc_bin} + 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, + "mpc_bin": mpc_bin, + } + except (OSError, subprocess.TimeoutExpired): + return {"gmssl_bin": True, "tlcp_commands": False, "version": None, + "help": "", "certgen_help": "", "mpc_bin": mpc_bin} + + +def self_test(): + """零依赖:把「缺项必 SKIPPED、齐备必 RUN、绝不静默 PASS」钉死。""" + decision, missing = evaluate({"gmssl_bin": False, "tlcp_commands": False, + "version": None, "mpc_bin": False}) + check("判据逻辑:全缺环境 → SKIPPED", decision == "SKIPPED", decision) + check("判据逻辑:逐项列出缺失(4 项,不是笼统一句)", len(missing) == 4, 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", "mpc_bin": True}) + 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", "mpc_bin": True}) + 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 (GMSSL_SUITE,)) + check("漂移探针:国密套件名必须带 SM4/SM3 语义", + "SM4" in GMSSL_SUITE and "SM3" in GMSSL_SUITE) + + # 判据源码仍含诚实边界与失败特征排除标记(防回归)。 + src = Path(__file__).read_text() + check("探针源码仍含 GMSSL_TLCP_TUNNEL_SKIPPED 输出(防止静默跳过回归)", + "GMSSL_TLCP_TUNNEL_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) + check("探针源码仍排除「未知参数」这类探针自身 bug 造成的假绿", + "invalid option" in src and "未知参数" in src) + return finish("判据逻辑自测") + + +def project_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",)), + ): + (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], + cwd=w, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, + ) + + +def mpc_tlcp_send(w, host, port, ca, payload_file, server_name=None, + suite=GMSSL_SUITE, timeout=0): + """★ 用列表参数,不让 shell 把整串当成一个 argv(否则 CLI 会 rc!=0 回 + 「未知参数」,被误当成「拒绝成功」)。""" + args = [MPC, "chain", "tlcp", "send", + "--host", host, "--port", str(port), + "--ca", ca, "--payload", payload_file, + "--cipher-suite", suite] + if server_name: + args += ["--server-name", server_name] + if timeout: + args += ["--timeout", str(timeout)] + try: + return subprocess.run(args, cwd=w, capture_output=True, text=True, timeout=30) + 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_TUNNEL_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"]) + distid = project_distid() + check("项目 domain::SM2_DISTID 能读到且与 GmSSL 默认值一致", + distid == UPSTREAM_DISTID, (distid, UPSTREAM_DISTID)) + # 与 CLI 诊断交叉验证:不许 Rust 侧把装了的 GmSSL 报成没有。 + cli = subprocess.run([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 realChainVerified 恒 false(环回实证 ≠ 通道已通)", + view.get("realChainVerified") is False, view) + except json.JSONDecodeError as e: + check("mpc chain tlcp 输出合法 JSON", False, (e, cli.stdout[:300])) + else: + check("mpc chain tlcp 可运行", False, (cli.returncode, cli.stderr[:300])) + + with tempfile.TemporaryDirectory(prefix="mpc-tlcp-tunnel-") 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) + + port = free_port() + srv = start_server(w, port) + time.sleep(0.8) + try: + check("tlcp_server 启动后未被立刻拒绝", srv.poll() is None) + payload = '{"jsonrpc":"2.0","method":"echo","params":{"x":1},"id":7}' + (w / "req.json").write_text(payload) + ok = mpc_tlcp_send(w, "127.0.0.1", port, "root_cert.pem", "req.json", + server_name="localhost") + txt = ok.stdout + ok.stderr + check("★ 通道发送成功(rc=0)", ok.returncode == 0, (ok.returncode, txt[:600])) + try: + view = json.loads(ok.stdout) + check("★ 应用数据经 TLCP 环回往返一致(echo)", + view.get("responseText", "").strip() == payload.strip(), + view.get("responseText")) + check("★ sentBytes == receivedBytes", + view.get("sentBytes") == view.get("receivedBytes") + and view.get("receivedBytes") == len(payload), view) + check("★ 输出带 channelLayerReachable=true 且 realChainVerified=false", + view.get("channelLayerReachable") is True + and view.get("realChainVerified") is False, view) + except json.JSONDecodeError as e: + check("通道输出合法 JSON", False, (e, ok.stdout[:300])) + + # --- 负向判据:每条都带**期望拒绝特征**,不许只判 rc != 0 --- + # ★ 排除「未知参数」:用列表参数调用,避免整串被当成一个 argv。 + # 实测特征来自 GmSSL 3.2.0:错误 CA → tls_cert_chain_check_name / + # tls_cert_chain_verify;非法套件 → tls_ctx_set_cipher_suites。连接 + # 被拒时 gmssl 不会打印 "Connection established"。 + bad_ca = mpc_tlcp_send(w, "127.0.0.1", port, "fake_ca.pem", "req.json", + server_name="localhost") + 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 "invalid option" not in bad_ca_txt + and ("cert_chain_verify" in bad_ca_txt + or "tls_cert_chain_check_name" in bad_ca_txt + or "x509_certs_verify_tlcp" in bad_ca_txt), + (bad_ca.returncode, bad_ca_txt[:400])) + + bad_suite = mpc_tlcp_send(w, "127.0.0.1", port, "root_cert.pem", "req.json", + server_name="localhost", suite="TLS_AES_128_GCM_SHA256") + bad_suite_txt = bad_suite.stdout + bad_suite.stderr + # ★ 非国密套件在 Rust 配置层就被拒("不在合并白名单"),不会落到 gmssl 握手。 + check("★ 负向:纯非国密套件失败且点名套件白名单(不是超时/串包/未知参数)", + bad_suite.returncode != 0 and bad_suite.returncode != 124 + and "Connection established" not in bad_suite_txt + and "invalid option" not in bad_suite_txt + and ("白名单" in bad_suite_txt or "套件" in bad_suite_txt + or "cipher_suites" in bad_suite_txt), + (bad_suite.returncode, bad_suite_txt[:400])) + finally: + stop(srv) + + # 连接被拒(服务端已停):rc != 0 且点名连接失败,不是握手失败/未知参数。 + dead = mpc_tlcp_send(w, "127.0.0.1", port, "root_cert.pem", "req.json", + server_name="localhost") + dead_txt = dead.stdout + dead.stderr + check("★ 负向:服务端未起 → 连接被拒且点名连接失败(不是串包/未知参数)", + dead.returncode != 0 and dead.returncode != 124 + and "Connection established" not in dead_txt + and "invalid option" not in dead_txt + and ("connect" in dead_txt.lower() or "refused" in dead_txt.lower() + or "connection" in dead_txt.lower()), + (dead.returncode, dead_txt[:400])) + + 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_TUNNEL_OK") + print("BCOS_RPC_NOT_VERIFIED: 本机环回通道通过,不代表 bcos-rpc 已启用 TLCP," + "也不代表 Rust 客户端已通过国密通道连上真实 FISCO 节点") + 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())