Skip to main content

yang_base/token/
revocation.rs

1//! Token 撤销 / 黑名单机制(H-4)
2//!
3//! JWT 一经签发,在过期前本身无法失效。对登出、改密、强制下线等场景,
4//! 需要一个额外的撤销层。本模块基于 `ToolsBuilder` 显式注入的 Redis 客户端提供两层撤销能力:
5//!
6//! 1. **按单个 Token 撤销(jti 黑名单)**:用于登出。撤销时把 Token 的 `jti`
7//!    写入 Redis,TTL 设为 Token 剩余有效期(过期后 key 自动消失,黑名单不会
8//!    无限增长)。校验时在标准签名/过期校验之外,额外查一次该黑名单。
9//! 2. **按用户批量撤销(subject 时间水位线)**:用于改密、强制下线。撤销时把
10//!    "当前时间戳"写入 `token:user:{hex(sub)}:min_iat`(sub 经 hex 编码,避免特殊
11//!    字符导致 Redis key 歧义),TTL 取 Refresh Token 有效期。
12//!    校验时若该用户存在水位线且 Token 的 `iat` 早于或等于水位线,则视为已撤销——
13//!    一次写入即可让该用户在此之前签发的所有 Token 全部失效。
14//!
15//! 设计约束:**不修改** [`TokenManager::verify_token`] 的现有签名与行为,
16//! 撤销校验通过 [`TokenManager::verify_token_checked`] 提供,保持向后兼容。
17
18use crate::error::BaseError;
19use crate::token::manager::current_unix_timestamp;
20use crate::token::{TokenClaims, TokenManager, TokenType};
21use yang_db::RedisValue;
22
23/// Redis 黑名单 key 前缀。最终 key 形如 `token:blacklist:{jti}`。
24const BLACKLIST_PREFIX: &str = "token:blacklist:";
25
26/// 根据 jti 构造黑名单 Redis key。
27fn blacklist_key(jti: &str) -> String {
28    format!("{BLACKLIST_PREFIX}{jti}")
29}
30
31/// 按用户撤销的时间水位线 key 前缀。最终 key 形如 `token:user:{hex(sub)}:min_iat`。
32const SUBJECT_MIN_IAT_PREFIX: &str = "token:user:";
33
34/// 将字节切片编码为小写 hex 字符串(无外部依赖)。
35fn hex_encode(bytes: &[u8]) -> String {
36    let mut s = String::with_capacity(bytes.len() * 2);
37    for b in bytes {
38        s.push_str(&format!("{b:02x}"));
39    }
40    s
41}
42
43/// 根据 subject 构造"最小签发时间水位线"Redis key。
44///
45/// `sub` 经 hex 编码后嵌入 key,避免含 `:` 等特殊字符导致 Redis key 歧义。
46fn subject_min_iat_key(sub: &str) -> String {
47    format!(
48        "{SUBJECT_MIN_IAT_PREFIX}{}:min_iat",
49        hex_encode(sub.as_bytes())
50    )
51}
52
53/// 判定一个 Token 的签发时间 `iat` 是否被用户水位线 `min_iat` 撤销。
54///
55/// 采用 `iat <= min_iat`(含等号)而非严格小于:撤销与签发都是**秒级**时间戳,
56/// 若用 `<`,则在改密/强制下线那一秒内签发的 Token(`iat == min_iat`)会逃过
57/// 撤销,留下 1 秒旁路窗口(NEW-6)。安全取「过撤一侧」——同秒签发的 Token 一并
58/// 撤销(用户至多需在该秒后重新登录一次),杜绝旁路。
59fn iat_revoked_by_watermark(iat: u64, min_iat: u64) -> bool {
60    iat <= min_iat
61}
62
63fn invalid_revocation_state(message: &str) -> BaseError {
64    BaseError::TokenRevocationStateInvalid(message.to_string())
65}
66
67/// 解析撤销水位线的唯一入口。损坏原值不进入错误文本,避免日志注入和敏感数据回显。
68fn parse_subject_min_iat(raw: &str) -> Result<u64, BaseError> {
69    raw.parse::<u64>()
70        .map_err(|_| invalid_revocation_state("用户撤销水位线不是有效的 u64 时间戳"))
71}
72
73/// 解析 Redis GET 水位线结果;只有 Nil 和 UTF-8 String 属于合法协议形态。
74fn parse_subject_min_iat_value(value: &RedisValue) -> Result<Option<u64>, BaseError> {
75    match value {
76        RedisValue::Nil => Ok(None),
77        RedisValue::String(raw) => parse_subject_min_iat(raw).map(Some),
78        _ => Err(invalid_revocation_state(
79            "用户撤销水位线的 Redis 类型不是 nil/string",
80        )),
81    }
82}
83
84/// 解析单条 GET pipeline 结果,避免高层字符串 API 将非 UTF-8 值折叠为 None。
85fn parse_subject_min_iat_pipeline_results(
86    results: &[RedisValue],
87) -> Result<Option<u64>, BaseError> {
88    let [value] = results else {
89        return Err(invalid_revocation_state(
90            "用户撤销水位线 GET pipeline 返回数量不是 1",
91        ));
92    };
93    parse_subject_min_iat_value(value)
94}
95
96/// 原子读取「jti 黑名单 + subject 水位线」的 Lua 脚本。
97///
98/// 单条脚本避免了 EXISTS + GET 两条命令之间的 TOCTOU 窗口(NEW-44)。
99const REVOCATION_LOOKUP_SCRIPT: &str = r#"
100local blacklisted = redis.call('EXISTS', KEYS[1])
101local watermark = redis.call('GET', KEYS[2])
102local has_watermark = redis.call('EXISTS', KEYS[2])
103if not watermark then
104    watermark = ''
105end
106return {blacklisted, has_watermark, watermark}
107"#;
108
109/// 解析 Lua 脚本返回值(blacklisted, has_watermark, watermark 原值)。
110///
111/// 必须用 EXISTS 单独区分「key 不存在」与「key 存在但值为空字符串」:
112/// 后者是损坏状态,必须失败关闭,不能当作无水位线放行。
113fn parse_revocation_script_results(
114    blacklisted: i64,
115    has_watermark: i64,
116    watermark: String,
117) -> Result<(bool, Option<u64>), BaseError> {
118    let blacklisted = match blacklisted {
119        0 => false,
120        1 => true,
121        _ => {
122            return Err(invalid_revocation_state(
123                "Token 黑名单 EXISTS 结果不是 0/1 整数",
124            ))
125        }
126    };
127    let min_iat = match has_watermark {
128        0 => None,
129        1 => Some(parse_subject_min_iat(&watermark)?),
130        _ => {
131            return Err(invalid_revocation_state(
132                "Token 水位线 EXISTS 结果不是 0/1 整数",
133            ))
134        }
135    };
136    Ok((blacklisted, min_iat))
137}
138
139impl TokenManager {
140    /// 撤销一个 Token(写入 Redis 黑名单)。
141    ///
142    /// 先验证 Token(确保 `jti`/`exp` 合法且签名有效),再按 `exp - now` 计算
143    /// 剩余 TTL 写入黑名单。若 Token 已过期则无需撤销,直接返回 `Ok(())`。
144    ///
145    /// # 参数
146    ///
147    /// - `token`: 待撤销的 Token 字符串
148    ///
149    /// # 返回
150    ///
151    /// - `Ok(())`: 撤销成功,或 Token 已过期无需撤销
152    /// - `Err(BaseError::TokenVerifyFailed)`: Token 签名/声明校验失败
153    /// - `Err(BaseError::TokenExpired)`: Token 已过期(无需撤销,返回 `Ok(())`)
154    /// - `Err(BaseError::RedisOperationFailed)`: 写黑名单失败
155    pub async fn revoke_token(&self, token: &str) -> Result<(), BaseError> {
156        let claims = self.verify_token(token)?;
157        self.revoke_claims(&claims).await
158    }
159
160    /// 按已验证的 [`TokenClaims`] 撤销 Token。
161    ///
162    /// 当调用方手头已有验证过的 claims 时,可避免重复验证。
163    ///
164    /// # 参数
165    ///
166    /// - `claims`: 已通过验证的 Token 声明
167    pub async fn revoke_claims(&self, claims: &TokenClaims) -> Result<(), BaseError> {
168        let now = current_unix_timestamp()?;
169        // 剩余有效期;已过期则无需写黑名单
170        let remaining = claims.exp.saturating_sub(now);
171        if remaining == 0 {
172            return Ok(());
173        }
174        let ttl = i64::try_from(remaining)
175            .map_err(|_| BaseError::ConfigError("Token 剩余有效期超出 i64 范围".to_string()))?;
176
177        self.revocation_cache()?
178            .setex(blacklist_key(&claims.jti), ttl, "1")
179            .await
180            .map_err(BaseError::RedisOperationFailed)?;
181        Ok(())
182    }
183
184    /// 按 jti 直接写入撤销黑名单(按给定 TTL 保留)。
185    ///
186    /// 用于「踢出单个会话」等场景:调用方已知会话的当前 refresh jti,
187    /// 但手上没有完整 claims(无法计算 exp)。TTL 由调用方提供,
188    /// 应覆盖对应 refresh token 的剩余有效期(保守取完整 refresh TTL)。
189    pub async fn revoke_by_jti_with_ttl(
190        &self,
191        jti: &str,
192        ttl_seconds: u64,
193    ) -> Result<(), BaseError> {
194        let ttl = i64::try_from(ttl_seconds)
195            .map_err(|_| BaseError::ConfigError("jti 黑名单 TTL 超出 i64 范围".to_string()))?;
196        self.revocation_cache()?
197            .setex(blacklist_key(jti), ttl, "1")
198            .await
199            .map_err(BaseError::RedisOperationFailed)?;
200        Ok(())
201    }
202
203    /// 查询某个 `jti` 是否已被撤销。
204    ///
205    /// # 参数
206    ///
207    /// - `jti`: Token 的唯一标识
208    ///
209    /// # 返回
210    ///
211    /// - `Ok(true)`: 已撤销(命中黑名单)
212    /// - `Ok(false)`: 未撤销
213    /// - `Err(BaseError::RedisOperationFailed)`: Redis 查询失败
214    pub async fn is_revoked(&self, jti: &str) -> Result<bool, BaseError> {
215        let count = self
216            .revocation_cache()?
217            .exists(&[blacklist_key(jti)])
218            .await
219            .map_err(BaseError::RedisOperationFailed)?;
220        Ok(count > 0)
221    }
222
223    /// 按用户(subject)批量撤销该用户在此刻之前签发的所有 Token(token-3)。
224    ///
225    /// 在 Redis 中将 `token:user:{hex(sub)}:min_iat` 写为当前时间戳,作为该用户的
226    /// "最小有效签发时间"水位线。此后 [`TokenManager::verify_token_checked`]
227    /// 会拒绝任何 `iat` 早于或等于该水位线的 Token,从而让此前签发的全部 Token 一次性失效。
228    ///
229    /// 适用于**改密、强制下线**等需要让某用户全部会话立即失效的场景。
230    /// 水位线 TTL 取 Access / Refresh 有效期的较大值(`TokenManager::revocation_watermark_ttl`),
231    /// 确保覆盖撤销前签发的最长寿命 Token,避免 key 过早过期导致已撤销会话「复活」。
232    ///
233    /// # 调用约束(架构门禁)
234    ///
235    /// 本方法设置 subject 水位线,立即杀死该用户全部已签发 Token(含 Access 与
236    /// Refresh),代价是该用户所有设备同时失效。**禁止在批量撤销路径中使用**——
237    /// 批量操作必须走 Outbox + 版本传播,参考 `batch_revoke_permissions.rs` 头部注释。
238    ///
239    /// yang-system 生产代码中仅允许以下两处调用(由 `scripts/check_architecture.py`
240    /// 的 `check_revoke_by_subject_placement` 门禁机械强制执行):
241    ///
242    /// 1. `src/addon/access/grants/actions/revoke_permission.rs` — 单条撤销路径,
243    ///    事务提交后即时收敛 Redis;
244    /// 2. `src/addon/account/domain/context.rs` — `converge_revocation` 集中封装,
245    ///    供 logout / disable_self / change_password 等账号安全事件共享。
246    ///
247    /// 新增调用点前请先确认语义等价于「让该用户全部会话立即失效」,而非仅仅
248    /// 「撤销某条授权记录」;后者应走 Outbox 异步传播。
249    ///
250    /// # 参数
251    ///
252    /// - `sub`: 用户主题标识(即 Token 的 `sub`)
253    ///
254    /// # 返回
255    ///
256    /// - `Ok(())`: 水位线写入成功
257    /// - `Err(BaseError::RedisOperationFailed)`: Redis 写入失败
258    ///
259    /// # 依赖
260    ///
261    /// 依赖 `ToolsBuilder` 已为 TokenManager 连接 Redis 撤销存储。
262    pub async fn revoke_by_subject(&self, sub: &str) -> Result<(), BaseError> {
263        let now = current_unix_timestamp()?;
264        let ttl = i64::try_from(self.revocation_watermark_ttl()).map_err(|_| {
265            BaseError::ConfigError("Token 撤销水位线 TTL 超出 i64 范围".to_string())
266        })?;
267        self.revocation_cache()?
268            .setex(subject_min_iat_key(sub), ttl, now.to_string())
269            .await
270            .map_err(BaseError::RedisOperationFailed)?;
271        Ok(())
272    }
273
274    /// 查询某用户的"最小有效签发时间"水位线(若不存在返回 `None`)。
275    ///
276    /// # 参数
277    ///
278    /// - `sub`: 用户主题标识
279    ///
280    /// # 返回
281    ///
282    /// - `Ok(Some(ts))`: 该用户已被批量撤销,水位线时间戳为 `ts`
283    /// - `Ok(None)`: 该用户无批量撤销记录
284    /// - `Err(BaseError::RedisOperationFailed)`: Redis 查询失败
285    /// - `Err(BaseError::TokenRevocationStateInvalid)`: 水位线值损坏
286    pub async fn subject_min_iat(&self, sub: &str) -> Result<Option<u64>, BaseError> {
287        let mut pipeline = self.revocation_cache()?.pipeline();
288        pipeline.get(subject_min_iat_key(sub));
289        let results = pipeline
290            .execute()
291            .await
292            .map_err(BaseError::RedisOperationFailed)?;
293        parse_subject_min_iat_pipeline_results(&results)
294    }
295
296    /// 尝试原子撤销一次(SET key val NX EX ttl)。
297    ///
298    /// 与 `revoke_claims`(无条件 SETEX)不同,本方法仅在黑名单中尚不存在该 jti
299    /// 时执行写入。为轮换流程 [`TokenManager::rotate_refresh_token`] 提供竞态保护:
300    /// 并发请求中仅第一个能成功写入,后续返回 `false`。
301    ///
302    /// # 参数
303    ///
304    /// - `jti`: Token 唯一标识
305    /// - `ttl`: 黑名单过期时间(秒),源自 Token 剩余有效期。为 `0` 时直接返回
306    ///   `false`,避免向 Redis 发送 `EX 0`(非法参数)。
307    ///   注意:调用方若需要区分「Token 已过期」与「jti 已被消费(重放)」,
308    ///   必须在调用前自行判断 `exp`,本方法对两者统一返回 `false`。
309    ///
310    /// # 返回
311    ///
312    /// - `Ok(true)`: 成功将 jti 写入黑名单(本次是第一个到达的)
313    /// - `Ok(false)`: jti 已在黑名单中(竞态中落败),或 ttl 为 0(Token 已过期)
314    pub(crate) async fn try_revoke_once(&self, jti: &str, ttl: u64) -> Result<bool, BaseError> {
315        if ttl == 0 {
316            return Ok(false);
317        }
318        let ttl = i64::try_from(ttl)
319            .map_err(|_| BaseError::ConfigError("jti 黑名单 TTL 超出 i64 范围".to_string()))?;
320        self.revocation_cache()?
321            .set_nx_ex(blacklist_key(jti), "1", ttl)
322            .await
323            .map_err(BaseError::RedisOperationFailed)
324    }
325
326    /// 验证 Token,并额外检查黑名单。
327    ///
328    /// 在 [`TokenManager::verify_token`] 的全部校验之上,再做两层撤销检查:
329    /// 1. 查 `jti` 黑名单(单 Token 撤销 / 登出);
330    /// 2. 查该用户的 `min_iat` 水位线(按用户批量撤销 / 改密、强制下线):
331    ///    若存在水位线且 Token 的 `iat` 早于或等于它,则视为已撤销。
332    ///
333    /// 鉴权路径若需支持登出/撤销,应使用本方法替代 `verify_token`。
334    ///
335    /// # 参数
336    ///
337    /// - `token`: 待验证的 Token 字符串
338    /// - `expected`: 期望的 Token 类型(下沉校验:签名验证通过后、Redis 查询之前
339    ///   比对 `token_type`,鉴权路径不再依赖调用点自行比对)
340    ///
341    /// # 返回
342    ///
343    /// - `Ok(TokenClaims)`: 验证通过且未被撤销
344    /// - `Err(BaseError::TokenVerifyFailed)`: 签名/过期/声明校验失败
345    /// - `Err(BaseError::TokenTypeInvalid)`: Token 类型与 `expected` 不匹配
346    /// - `Err(BaseError::TokenRevoked)`: Token 已被撤销(命中黑名单或不晚于用户水位线)
347    /// - `Err(BaseError::RedisOperationFailed)`: 黑名单查询失败
348    /// - `Err(BaseError::TokenRevocationStateInvalid)`: 撤销查询结果或水位线损坏
349    ///
350    /// # Cluster
351    ///
352    /// Cluster 拓扑下两个 key 通常不同槽,无法用单条 Lua 原子读取;本方法会退化
353    /// 为两次单 key 读(接受亚毫秒 TOCTOU 窗口),不会因 CROSSSLOT 让鉴权整体失败。
354    pub async fn verify_token_checked(
355        &self,
356        token: &str,
357        expected: TokenType,
358    ) -> Result<TokenClaims, BaseError> {
359        let claims = self.verify_token(token)?;
360        // 下沉 token_type 校验:鉴权路径不再依赖调用点自行比对,防止遗漏。
361        if claims.token_type != expected {
362            return Err(BaseError::TokenTypeInvalid("Token 类型不匹配".to_string()));
363        }
364
365        // PERF-2 + NEW-44:EXISTS 与 GET 必须原子读取,避免两条命令之间的
366        // TOCTOU 窗口;单条 Lua 脚本同时完成两次读,只有 1 RTT。
367        let cache = self.revocation_cache()?;
368        let (blacklisted, min_iat) = if cache.is_cluster() {
369            // Cluster 下两个 key 通常不在同一槽,跨槽 EVAL 会被 CROSSSLOT 拒绝。
370            // 退化为两次单 key 读(各自原子),接受这段 TOCTOU 窗口;不再多 key 脚本。
371            let blacklisted = cache
372                .exists(&[blacklist_key(&claims.jti)])
373                .await
374                .map_err(BaseError::RedisOperationFailed)?
375                > 0;
376            let min_iat = self.subject_min_iat(&claims.sub).await?;
377            (blacklisted, min_iat)
378        } else {
379            let script = cache.script(REVOCATION_LOOKUP_SCRIPT);
380            let (blacklisted, has_watermark, watermark): (i64, i64, String) = cache
381                .eval_script(
382                    &script,
383                    &[blacklist_key(&claims.jti), subject_min_iat_key(&claims.sub)],
384                    &[],
385                )
386                .await
387                .map_err(|error| match error {
388                    yang_db::DbError::RedisTypeConversionError(_) => {
389                        invalid_revocation_state("Token 撤销查询返回非法类型")
390                    }
391                    other => BaseError::RedisOperationFailed(other),
392                })?;
393            parse_revocation_script_results(blacklisted, has_watermark, watermark)?
394        };
395        if blacklisted {
396            return Err(BaseError::TokenRevoked);
397        }
398
399        if min_iat.is_some_and(|watermark| iat_revoked_by_watermark(claims.iat, watermark)) {
400            return Err(BaseError::TokenRevoked);
401        }
402
403        Ok(claims)
404    }
405}
406
407#[cfg(test)]
408mod tests {
409    use super::*;
410
411    #[test]
412    fn test_blacklist_key_format() {
413        assert_eq!(blacklist_key("abc-123"), "token:blacklist:abc-123");
414    }
415
416    #[test]
417    fn test_subject_min_iat_key_format() {
418        // sub 经 hex 编码,避免特殊字符导致 key 歧义
419        assert_eq!(
420            subject_min_iat_key("user_42"),
421            "token:user:757365725f3432:min_iat"
422        );
423    }
424
425    #[test]
426    fn test_subject_min_iat_key_colon_safe() {
427        // sub 含冒号时 hex 编码后不再产生歧义
428        let key = subject_min_iat_key("user:admin");
429        assert_eq!(key, "token:user:757365723a61646d696e:min_iat");
430        // 确保 key 中不会出现未转义的冒号(除固定分隔符外)
431        let after_prefix = key.strip_prefix("token:user:").unwrap();
432        let (hex_part, rest) = after_prefix.split_once(':').unwrap();
433        assert_eq!(rest, "min_iat");
434        // hex 部分只含 0-9a-f
435        assert!(hex_part.chars().all(|c| c.is_ascii_hexdigit()));
436    }
437
438    /// NEW-6:同秒签发(iat == min_iat)必须被撤销,杜绝 1 秒旁路窗口。
439    #[test]
440    fn test_iat_revoked_by_watermark_same_second() {
441        // 早于水位线:撤销
442        assert!(iat_revoked_by_watermark(100, 200));
443        // 同秒签发:必须撤销(含等号,这是修复点)
444        assert!(iat_revoked_by_watermark(200, 200));
445        // 晚于水位线:放行
446        assert!(!iat_revoked_by_watermark(201, 200));
447    }
448
449    #[test]
450    fn watermark_parser_accepts_only_absent_or_valid_u64_string() {
451        assert_eq!(
452            parse_subject_min_iat_value(&yang_db::RedisValue::Nil).expect("缺少水位线是合法状态"),
453            None
454        );
455        assert_eq!(
456            parse_subject_min_iat_value(&yang_db::RedisValue::String("0".to_string()))
457                .expect("u64 下界应有效"),
458            Some(0)
459        );
460        assert_eq!(
461            parse_subject_min_iat_value(&yang_db::RedisValue::String(u64::MAX.to_string()))
462                .expect("u64 上界应有效"),
463            Some(u64::MAX)
464        );
465    }
466
467    #[test]
468    fn watermark_parser_rejects_corrupt_strings_and_wrong_redis_types() {
469        let invalid_values = [
470            yang_db::RedisValue::String(String::new()),
471            yang_db::RedisValue::String("-1".to_string()),
472            yang_db::RedisValue::String("18446744073709551616".to_string()),
473            yang_db::RedisValue::String("secret-corrupt-watermark".to_string()),
474            yang_db::RedisValue::Bytes(vec![0xff]),
475            yang_db::RedisValue::Int(42),
476            yang_db::RedisValue::Bool(false),
477            yang_db::RedisValue::Array(Vec::new()),
478        ];
479
480        for value in invalid_values {
481            let error = parse_subject_min_iat_value(&value)
482                .expect_err("损坏或错误类型的水位线必须失败关闭");
483            assert!(
484                matches!(&error, BaseError::TokenRevocationStateInvalid(_)),
485                "损坏水位线必须返回结构化错误,实际为: {error:?}"
486            );
487            assert_eq!(error.code(), 400008);
488            assert!(error.is_server_error());
489            assert!(
490                !error.to_string().contains("secret-corrupt-watermark"),
491                "错误不得回显 Redis 中的损坏原值"
492            );
493        }
494    }
495
496    #[test]
497    fn subject_watermark_pipeline_parser_requires_exactly_one_result() {
498        for values in [
499            vec![],
500            vec![yang_db::RedisValue::Nil, yang_db::RedisValue::Nil],
501        ] {
502            assert!(
503                matches!(
504                    parse_subject_min_iat_pipeline_results(&values),
505                    Err(BaseError::TokenRevocationStateInvalid(_))
506                ),
507                "水位线 GET 必须恰好返回一个结果: {values:?}"
508            );
509        }
510
511        assert_eq!(
512            parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::Nil])
513                .expect("缺少水位线是合法状态"),
514            None
515        );
516        assert_eq!(
517            parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::String(
518                "42".to_string()
519            )])
520            .expect("合法水位线应通过"),
521            Some(42)
522        );
523    }
524
525    #[test]
526    fn revocation_script_parser_accepts_valid_and_rejects_corrupt() {
527        assert_eq!(
528            parse_revocation_script_results(0, 0, String::new())
529                .expect("黑名单未命中且无水位线是合法状态"),
530            (false, None)
531        );
532        assert_eq!(
533            parse_revocation_script_results(1, 1, "42".to_string())
534                .expect("黑名单命中且水位线合法"),
535            (true, Some(42))
536        );
537
538        for (blacklisted, has_watermark, watermark) in [
539            (-1, 0, String::new()),
540            (2, 0, String::new()),
541            (0, 2, String::new()),
542            // key 存在但值为空字符串:损坏状态,必须失败关闭
543            (0, 1, String::new()),
544            (0, 1, "secret-corrupt-watermark".to_string()),
545        ] {
546            let error = parse_revocation_script_results(blacklisted, has_watermark, watermark)
547                .expect_err("非法脚本结果必须失败关闭");
548            assert!(matches!(error, BaseError::TokenRevocationStateInvalid(_)));
549            assert!(
550                !error.to_string().contains("secret-corrupt-watermark"),
551                "错误不得回显 Redis 中的损坏原值"
552            );
553        }
554    }
555}