1use crate::error::BaseError;
19use crate::token::manager::current_unix_timestamp;
20use crate::token::{TokenClaims, TokenManager, TokenType};
21use yang_db::RedisValue;
22
23const BLACKLIST_PREFIX: &str = "token:blacklist:";
25
26fn blacklist_key(jti: &str) -> String {
28 format!("{BLACKLIST_PREFIX}{jti}")
29}
30
31const SUBJECT_MIN_IAT_PREFIX: &str = "token:user:";
33
34fn 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
43fn 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
53fn 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
67fn parse_subject_min_iat(raw: &str) -> Result<u64, BaseError> {
69 raw.parse::<u64>()
70 .map_err(|_| invalid_revocation_state("用户撤销水位线不是有效的 u64 时间戳"))
71}
72
73fn 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
84fn 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
96const 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
109fn 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 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 pub async fn revoke_claims(&self, claims: &TokenClaims) -> Result<(), BaseError> {
168 let now = current_unix_timestamp()?;
169 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 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 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 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 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 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 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 if claims.token_type != expected {
362 return Err(BaseError::TokenTypeInvalid("Token 类型不匹配".to_string()));
363 }
364
365 let cache = self.revocation_cache()?;
368 let (blacklisted, min_iat) = if cache.is_cluster() {
369 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 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 let key = subject_min_iat_key("user:admin");
429 assert_eq!(key, "token:user:757365723a61646d696e:min_iat");
430 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 assert!(hex_part.chars().all(|c| c.is_ascii_hexdigit()));
436 }
437
438 #[test]
440 fn test_iat_revoked_by_watermark_same_second() {
441 assert!(iat_revoked_by_watermark(100, 200));
443 assert!(iat_revoked_by_watermark(200, 200));
445 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 (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}