**影响** - 生产档弱密钥守卫从「只比默认值」升级为上游 `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]>
376 lines
15 KiB
Rust
376 lines
15 KiB
Rust
//! **上游测试用例移植**:生产档弱密钥守卫(`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
|
||
);
|
||
}
|