Files
tdc-rs/tests/upstream_guard_parity.rs
T
adminandClaude Code 1a0fdbf879 feat(upstream-parity): 移植上游测试用例 —— 29 条对位用例 + 第五把尺子
**影响**
- 生产档弱密钥守卫从「只比默认值」升级为上游 `ProdGuard` 的**六条判据**(纯函数),
  弱令牌用「默认值加后缀」绕过、弱标记词、长度下限三类都拦得住;`CIPHER_KEY`(协议共享值)**不受管**。
- 出向 TDS 超时**外置到 env**(`SSW_TDS_CONNECT_TIMEOUT_MS` / `SSW_TDS_READ_TIMEOUT_MS`),
  且**只有 cause 链里真有超时**才改写文案 ⇒ 连接被拒 / DNS 失败不再被误报成「超时」(排查方向不被带偏)。
- 上游 15 个测试类全部**登记在册**:3 个已移植(29 条对位用例)、12 个判定超范围(逐条记理由)。
- 新增第五把尺子 `scripts/check-upstream-tests.sh`:台账 ⇄ 代码 ⇄ 上游测试类集合三向对账,
  上游新增测试类而台账没登记 ⇒ **红**(不靠"记得看"防漂移)。
- 回归网:`cargo test` 246 → **278**(+32),其余四把尺子与引用自检**全绿**。

**改动**
- `src/platform/guard.rs`(新):上游 `ProdGuard.violations` 的纯函数移植(弱值清单 / 弱标记词整体词匹配 / `MIN_LEN=12` / 逐条点名)。
- `src/platform/config.rs`:`check_secret_guard` 改走守卫判据;新增 `guard_values`(只放本部署真有的键)
  与出向超时两项配置(非法值回落默认,不让连接器起不来)。
- `src/tdc/client/tds.rs`:新增 `cause_chain_has_timeout` / `timeout_text_or_null`(cause 链遍历**有界** `depth<16`),
  `TdsClient::with_timeouts` 接受超时。
- `tests/upstream_guard_parity.rs`(新 · 19 条)+ `tests/upstream_tds_timeout_parity.rs`(新 · 10 条)。
- `scripts/upstream-test-ledger.tsv`(台账真源)+ `scripts/upstream-test-census.py`(上游测试类普查/对账)
  + `scripts/check-upstream-tests.sh`(第五把尺子)。
- 文档:`docs/UPSTREAM-TEST-PARITY.md`(新)+ `docs/known-limitations.md` L8 + `docs/decisions.md` D22/D23
  + `CLAUDE.md` 同步(尺子表 / 目录树 / 命令速查 / 实现细节 22–23 / 坑位表)。

**设计**
- 上游 hop 1 的「反射读 socket 工厂」**抄不了**(`reqwest::Client` 不暴露超时 getter)⇒ 改用**行为级**判别
  (同一延迟 TCP 服务器:短超时⇒超时错、长超时⇒成功)⇒ 结论等价且更强(真跑 socket 层)。
- 上游 `*SelfTest.java` **surefire 不跑**(无统一入口)⇒ 判据落成 `cargo test` 常规用例(纯函数 ⇒ 可离线断言)。
- 超范围判定原则:**本仓没有对应功能 ⇒ 不搬**(硬搬只会是假绿);「机制」已覆盖的(P2P 那条)按机制记账。

Co-Authored-By: Claude Code <[email protected]>
2026-10-27 09:04:08 +08:00

376 lines
15 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! **上游测试用例移植**:生产档弱密钥守卫(`ProdGuard` / `SswProdRuntimeGuard`)。
//!
//! ## 上游真源(只读克隆)
//!
//! | 上游类 | 路径 | 关键断言 |
//! |---|---|---|
//! | `ssw.common.guard.ProdGuardSelfTest` | `/tmp/sswtdc-probe/boot/ssw-common/ssw-common-biz/src/test/java/ssw/common/guard/ProdGuardSelfTest.java` | ⓪–⑦(7 条,**双向断言**) |
//! | `ssw.tds.controller.SswProdRuntimeGuardSelfTest` | `/tmp/sswtds-probe/boot/ssw-tds/ssw-tds-controller/src/test/java/ssw/tds/controller/SswProdRuntimeGuardSelfTest.java` | ①–⑩(10 条) |
//! | 判据本体 `ssw.common.guard.ProdGuard` | `/tmp/sswtdc-probe/boot/ssw-common/ssw-common-biz/src/main/java/ssw/common/guard/ProdGuard.java` | `violations(...)` 六条判据 |
//!
//! ## 为什么这样移植
//!
//! 上游这两个类**没有 runner 接线**(surefire 不跑非 junit 的 `main` ⇒ 需人工跑),
//! 但判据本身**纯函数** ⇒ 可离线逐组断言 ⇒ 本仓把它们落成 `cargo test` 的常规用例。
//!
//! 🔴 **双向断言**(上游自测的立意:防"恒绿"/"恒红"):
//! 既断言"弱值必被拦",也断言"强值必放行",还断言**判别性**(只翻开关一位 ⇒ 结论必须翻转)。
//!
//! ## 键名映射
//!
//! 上游一个 `ssw.internal-token` 双向通用;本仓拆成**入向 / 出向**两个 ⇒ **两个都受管**。
//! 其余上游受管键本仓**没有对应配置项** ⇒ 属"本应用没有该键" ⇒ 跳过(上游判据①)。
use std::collections::BTreeMap;
use tdc_connector::platform::cipher::CIPHER_KEY;
use tdc_connector::platform::config::{
Config, StandaloneMode, DEFAULT_INTERNAL_TOKEN, DEFAULT_PORT, DEFAULT_TDS_CONNECT_TIMEOUT_MS,
DEFAULT_TDS_INTERNAL_TOKEN, DEFAULT_TDS_READ_TIMEOUT_MS,
};
use tdc_connector::platform::guard::{
guard_violations, has_weak_marker, violation_message, GUARDED, GUARD_KEY_INTERNAL_TOKEN,
GUARD_KEY_TDS_INTERNAL_TOKEN, MIN_LEN, WEAK_VALUES,
};
/// 32 位强随机串(上游自测同款):无弱值片段、无弱标记词、长度 ≥ [`MIN_LEN`]。
const STRONG: &str = "K7fQ2mZx9vLp4RtW8nYs3Ba6Hd1Jc5Ge";
/// 组装给守卫判据的 map(键 → 值;`None` = 值为 null)。
fn map<'a>(pairs: &[(&'a str, Option<&'a str>)]) -> BTreeMap<&'a str, Option<&'a str>> {
pairs.iter().copied().collect()
}
/// 构造一个可改的 [`Config`](字段全 pub ⇒ 直接造,不读进程 env)。
fn base_config() -> Config {
Config {
port: DEFAULT_PORT,
project_dir: std::path::PathBuf::from("/tmp/proj"),
data_dir: std::path::PathBuf::from("/tmp/proj/data"),
internal_token: DEFAULT_INTERNAL_TOKEN.to_string(),
tds_internal_token: DEFAULT_TDS_INTERNAL_TOKEN.to_string(),
tds_base_url: None,
tds_connect_timeout: std::time::Duration::from_millis(DEFAULT_TDS_CONNECT_TIMEOUT_MS),
tds_read_timeout: std::time::Duration::from_millis(DEFAULT_TDS_READ_TIMEOUT_MS),
standalone: StandaloneMode::Auto,
strict_secrets: false,
}
}
// ============================================================================
// 上游 `ProdGuardSelfTest`(7 条,逐条移植)
// ============================================================================
/// 上游 ⓪(`ProdGuardSelfTest.java:39`):`security.security-key` 取默认值**不再被拦**。
///
/// 🔴 上游 chg_0020 的立意:那是**协议共享值**(必须发给浏览器)⇒ 构造上不可保密。
/// 本仓的对位物 = [`CIPHER_KEY`](登录口令加解密密钥,随上游前端产物公开)
/// ⇒ **同样不得进受管清单**,否则"保持默认同值"这种正常部署会被判红(恒假红)。
#[test]
fn prod_guard_cipher_key_is_not_guarded() {
// ⓪-1:`CIPHER_KEY` **不在**受管清单里
assert!(
!GUARDED.iter().any(|(k, _)| k.contains("CIPHER")),
"CIPHER_KEY 是协议共享值,不得进受管清单(上游 chg_0020 同款裁定),实得:{:?}",
GUARDED
);
// ⓪-2:把它的**默认值**喂进一个**非受管键** ⇒ 不产生违规
// (判据①:键不在 map 里 ⇒ 跳过;这里额外确认值本身也不该被当成"弱值")
let v = guard_violations(&map(&[("CIPHER_KEY", Some(CIPHER_KEY))]));
assert!(v.is_empty(), "非受管键不得被误拦(实得:{:?})", v);
// ⓪-3:🔴 **即便**误把它塞进受管键,它**仍然**是公开值 ⇒ 应被拦
// (这正是上游把它移出清单的理由:它不可保密 ⇒ 拿来当令牌就是事故)
let v = guard_violations(&map(&[(GUARD_KEY_INTERNAL_TOKEN, Some(CIPHER_KEY))]));
assert_eq!(v.len(), 1, "公开的加解密密钥不得被当作可用令牌,实得:{:?}", v);
}
/// 上游 ①(`:59`):默认弱值**逐个仍被拦**(防"顺手把守卫整体弱化")。
#[test]
fn prod_guard_default_weak_values_are_still_blocked() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some("ssw-internal-token-e2e")),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some("ssw-internal-token-e2e")),
]));
assert_eq!(
v.len(),
GUARDED.len(),
"每个受管键都该被点名,实得:{:?}",
v
);
assert!(v.iter().any(|s| s.contains(GUARD_KEY_INTERNAL_TOKEN)));
assert!(v.iter().any(|s| s.contains(GUARD_KEY_TDS_INTERNAL_TOKEN)));
}
/// 上游 ②(`:72`):**强值全部放行**(防"守卫恒红"——那会挡住合法部署)。
#[test]
fn prod_guard_strong_values_are_all_allowed() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some(STRONG)),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some(STRONG)),
]));
assert!(v.is_empty(), "强值不得被拦(实得:{:?})", v);
}
/// 上游 ③(`:81`):**空白**键被点名("配了但空"也是违规)。
#[test]
fn prod_guard_blank_value_is_named() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some(STRONG)),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some("")),
]));
assert_eq!(v.len(), 1, "实得:{:?}", v);
assert!(
v[0].starts_with(GUARD_KEY_TDS_INTERNAL_TOKEN),
"空白键必须被点名,实得:{:?}",
v
);
}
/// 上游 ④(`:91`):🔴 **反绕过** —— 默认值后面加一个字符仍须被拦。
#[test]
fn prod_guard_default_value_with_suffix_is_blocked() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some("ssw-internal-token-e2e1")),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some(STRONG)),
]));
assert_eq!(v.len(), 1, "实得:{:?}", v);
assert!(
v[0].starts_with(GUARD_KEY_INTERNAL_TOKEN),
"反绕过用例必须点名入向键,实得:{:?}",
v
);
}
/// 上游 ⑤(`:101`):**过短**口令被拦(可猜解)。
#[test]
fn prod_guard_too_short_value_is_blocked() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some(STRONG)),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some("abc123")),
]));
assert_eq!(v.len(), 1, "实得:{:?}", v);
assert!(
v[0].starts_with(GUARD_KEY_TDS_INTERNAL_TOKEN),
"过短用例必须点名出向键,实得:{:?}",
v
);
}
/// 上游 ⑥(`:106`):报错正文**点名第一条违规**(运维要照着改)。
#[test]
fn prod_guard_violation_message_names_the_key() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some("ssw-internal-token-e2e")),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some(STRONG)),
]));
let msg = violation_message(&v);
assert!(
msg.contains(GUARD_KEY_INTERNAL_TOKEN),
"报错正文未点名,实得:{}",
msg
);
assert!(
msg.contains("拒绝启动"),
"报错正文须写明后果,实得:{}",
msg
);
}
/// 上游 ⑦(`:116`):🔴 "**本应用没有该键**"不得误拦(fail-closed 的误拦 = 停机)。
#[test]
fn prod_guard_absent_key_is_not_falsely_blocked() {
// map 里只有入向键 ⇒ 出向键缺席 ⇒ 出向默认值不构成违规
let v = guard_violations(&map(&[(
GUARD_KEY_INTERNAL_TOKEN,
Some(STRONG),
)]));
assert!(v.is_empty(), "实得:{:?}", v);
}
// ============================================================================
// 上游 `ProdGuard` 判据里**自测没单独断言**、但必须一起搬的两条(③/⑤)
// ============================================================================
/// 上游判据③+⑤(`ProdGuard.java:140-150`):**含**弱值片段 / **含**弱标记词 ⇒ 违规。
///
/// 🔴 上游自测只断言了"精确等于默认值"与"反绕过",**没单独**断言弱标记词
/// ⇒ 本仓补上(判据在实现里,就得被钉住)。
#[test]
fn prod_guard_weak_marker_word_is_blocked() {
let v = guard_violations(&map(&[
(GUARD_KEY_INTERNAL_TOKEN, Some("my-test-token-value")),
(GUARD_KEY_TDS_INTERNAL_TOKEN, Some(STRONG)),
]));
assert_eq!(v.len(), 1, "含弱标记词的值必须被拦,实得:{:?}", v);
assert!(
v[0].contains("弱标记词"),
"报错须说明是弱标记词,实得:{:?}",
v
);
}
/// 上游判据③(`:132`):值**精确等于**某个已知弱值 ⇒ 违规(与反绕过分开报错)。
#[test]
fn prod_guard_exact_weak_value_is_blocked() {
for w in WEAK_VALUES {
let v = guard_violations(&map(&[(
GUARD_KEY_INTERNAL_TOKEN,
Some(*w),
)]));
assert_eq!(
v.len(),
1,
"已知弱值 {:?} 必须被拦,实得:{:?}",
w,
v
);
}
}
/// 弱标记词的**整体词**语义(上游正则 `(?i)(^|[\-_.])(…)([\-_.]|$)`)。
#[test]
fn prod_guard_weak_marker_is_whole_word_only() {
// 命中
assert_eq!(has_weak_marker("e2e"), Some("e2e"));
assert_eq!(has_weak_marker("a-e2e-b"), Some("e2e"));
assert_eq!(has_weak_marker("E2E"), Some("e2e"));
// 🔴 不命中(否则会误拦合法部署 —— 强随机串里偶然出现 test 是可能的)
assert_eq!(has_weak_marker("device"), None);
assert_eq!(has_weak_marker("contest"), None);
assert_eq!(has_weak_marker(STRONG), None);
}
/// 上游 `MIN_LEN`(`:96`):低于 12 判弱。
#[test]
fn prod_guard_min_len_is_enforced() {
assert_eq!(MIN_LEN, 12);
let v = guard_violations(&map(&[(
GUARD_KEY_INTERNAL_TOKEN,
Some("abcdefghij"), // 10 位(🔴 不含任何弱值片段 ⇒ 只可能命中「过短」这一条)
)]));
assert_eq!(v.len(), 1, "过短必须被拦,实得:{:?}", v);
assert!(v[0].contains("过短"), "实得:{:?}", v);
}
// ============================================================================
// 上游 `SswProdRuntimeGuardSelfTest`(可移植的那几条)
// ============================================================================
/// 上游 ①(`:45`):**非 prod** ⇒ 一律不报违规(哪怕令牌是默认值)。
///
/// 本仓的对位开关 = `TDC_STRICT_SECRETS`(= 上游 profile 含 prod)。
#[test]
fn runtime_guard_non_prod_never_violates() {
let mut c = base_config();
c.strict_secrets = false;
assert!(
c.check_secret_guard().is_ok(),
"非生产档不得有副作用(实得:{:?})",
c.check_secret_guard()
);
}
/// 上游 ③(`:53`):**prod** + 令牌为空 ⇒ 报违规并点名。
#[test]
fn runtime_guard_prod_with_empty_token_violates() {
let mut c = base_config();
c.strict_secrets = true;
c.internal_token = String::new();
let err = c.check_secret_guard().unwrap_err();
assert!(
err.contains(GUARD_KEY_INTERNAL_TOKEN),
"实得:{}",
err
);
}
/// 上游 ④(`:57`):**prod** + token 为 null(等价于缺键)⇒ 报违规,**不得抛异常**。
///
/// 本仓的「null」落在守卫入参的 `Option<&str>` 上(`None` = 键在、值为 null)。
#[test]
fn runtime_guard_prod_with_null_token_violates_without_panic() {
let v = guard_violations(&map(&[(
GUARD_KEY_INTERNAL_TOKEN,
None::<&str>, // 键在、值为 null
)]));
assert_eq!(v.len(), 1, "实得:{:?}", v);
assert!(
v[0].starts_with(GUARD_KEY_INTERNAL_TOKEN),
"null 令牌必须被点名,实得:{:?}",
v
);
assert!(v[0].contains("未配置"), "实得:{:?}", v);
}
/// 上游 ⑤(`:61`):**prod** + 仓库默认弱值 ⇒ 报违规并点名。
#[test]
fn runtime_guard_prod_with_default_token_violates() {
let mut c = base_config();
c.strict_secrets = true;
let err = c.check_secret_guard().unwrap_err();
assert!(
err.contains(GUARD_KEY_INTERNAL_TOKEN),
"实得:{}",
err
);
}
/// 上游 ⑥(`:65`):**prod** + 全强值 ⇒ 不报违规。
#[test]
fn runtime_guard_prod_with_strong_token_passes() {
let mut c = base_config();
c.strict_secrets = true;
c.internal_token = STRONG.to_string();
assert!(
c.check_secret_guard().is_ok(),
"实得:{:?}",
c.check_secret_guard()
);
}
/// 上游 ⑦(`:69`):🔴 **判别性** —— 只翻 prod 一位,结论必须**翻转**
/// (否则判据可能是"恒绿",那正是守卫看着在、其实永不触发的成因)。
#[test]
fn runtime_guard_is_discriminable_on_the_prod_switch() {
let mut c = base_config();
c.internal_token = DEFAULT_INTERNAL_TOKEN.to_string();
c.strict_secrets = true;
let with_prod = c.check_secret_guard();
c.strict_secrets = false;
let without_prod = c.check_secret_guard();
assert!(
with_prod.is_err() && without_prod.is_ok(),
"只翻生产开关一位 ⇒ 结论必须翻转(prod 档:{:?} / 非 prod 档:{:?})",
with_prod,
without_prod
);
}
/// 上游 ⑩(`:97`):🔴 **测试环境声明不得解锁 internal-token**。
///
/// 上游:`ssw.portal.test-env=true` 只放行固定验证码,**不解锁**内部令牌。
/// 本仓**没有**任何"测试环境声明"能解锁令牌 ⇒ 这条以「更强的形式」成立:
/// 连"单机模式"这种部署档位都**不能**让弱令牌过关。
#[test]
fn runtime_guard_no_deployment_flag_unlocks_a_weak_token() {
let mut c = base_config();
c.strict_secrets = true;
// 单机模式(= 本地单机,不出网)
c.standalone = StandaloneMode::On;
// 出向通道也配上了(⇒ 出向令牌同样进受管清单)
c.tds_base_url = Some("http://127.0.0.1:30041".to_string());
let err = c.check_secret_guard().unwrap_err();
assert!(
err.contains(GUARD_KEY_INTERNAL_TOKEN),
"没有任何部署档位能解锁弱令牌,实得:{}",
err
);
assert!(
err.contains(GUARD_KEY_TDS_INTERNAL_TOKEN),
"出向令牌同样不得被部署档位解锁,实得:{}",
err
);
}