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
96fn parse_revocation_pipeline_results(
98 results: &[RedisValue],
99) -> Result<(bool, Option<u64>), BaseError> {
100 let [blacklist_result, watermark_result] = results else {
101 return Err(invalid_revocation_state(
102 "Token 撤销查询 pipeline 返回数量不是 2",
103 ));
104 };
105 let blacklisted = match blacklist_result {
106 RedisValue::Int(0) => false,
107 RedisValue::Int(1) => true,
108 _ => {
109 return Err(invalid_revocation_state(
110 "Token 黑名单 EXISTS 结果不是 0/1 整数",
111 ))
112 }
113 };
114 Ok((blacklisted, parse_subject_min_iat_value(watermark_result)?))
115}
116
117impl TokenManager {
118 pub async fn revoke_token(&self, token: &str) -> Result<(), BaseError> {
134 let claims = self.verify_token(token)?;
135 self.revoke_claims(&claims).await
136 }
137
138 pub async fn revoke_claims(&self, claims: &TokenClaims) -> Result<(), BaseError> {
146 let now = current_unix_timestamp()?;
147 let ttl = claims.exp.saturating_sub(now);
149 if ttl == 0 {
150 return Ok(());
151 }
152
153 self.revocation_cache()?
154 .setex(blacklist_key(&claims.jti), ttl as i64, "1")
155 .await
156 .map_err(BaseError::RedisOperationFailed)?;
157 Ok(())
158 }
159
160 pub async fn revoke_by_jti_with_ttl(
166 &self,
167 jti: &str,
168 ttl_seconds: u64,
169 ) -> Result<(), BaseError> {
170 let ttl = i64::try_from(ttl_seconds)
171 .map_err(|_| BaseError::ConfigError("jti 黑名单 TTL 超出 i64 范围".to_string()))?;
172 self.revocation_cache()?
173 .setex(blacklist_key(jti), ttl, "1")
174 .await
175 .map_err(BaseError::RedisOperationFailed)?;
176 Ok(())
177 }
178
179 pub async fn is_revoked(&self, jti: &str) -> Result<bool, BaseError> {
191 let count = self
192 .revocation_cache()?
193 .exists(&[blacklist_key(jti)])
194 .await
195 .map_err(BaseError::RedisOperationFailed)?;
196 Ok(count > 0)
197 }
198
199 pub async fn revoke_by_subject(&self, sub: &str) -> Result<(), BaseError> {
239 let now = current_unix_timestamp()?;
240 let ttl = self.revocation_watermark_ttl();
241 self.revocation_cache()?
242 .setex(subject_min_iat_key(sub), ttl as i64, now.to_string())
243 .await
244 .map_err(BaseError::RedisOperationFailed)?;
245 Ok(())
246 }
247
248 pub async fn subject_min_iat(&self, sub: &str) -> Result<Option<u64>, BaseError> {
261 let mut pipeline = self.revocation_cache()?.pipeline();
262 pipeline.get(subject_min_iat_key(sub));
263 let results = pipeline
264 .execute()
265 .await
266 .map_err(BaseError::RedisOperationFailed)?;
267 parse_subject_min_iat_pipeline_results(&results)
268 }
269
270 pub(crate) async fn try_revoke_once(&self, jti: &str, ttl: u64) -> Result<bool, BaseError> {
289 if ttl == 0 {
290 return Ok(false);
291 }
292 self.revocation_cache()?
293 .set_nx_ex(blacklist_key(jti), "1", ttl as i64)
294 .await
295 .map_err(BaseError::RedisOperationFailed)
296 }
297
298 pub async fn verify_token_checked(
322 &self,
323 token: &str,
324 expected: TokenType,
325 ) -> Result<TokenClaims, BaseError> {
326 let claims = self.verify_token(token)?;
327 if claims.token_type != expected {
329 return Err(BaseError::TokenTypeInvalid("Token 类型不匹配".to_string()));
330 }
331
332 let mut pipeline = self.revocation_cache()?.pipeline();
335 pipeline
336 .exists(blacklist_key(&claims.jti))
337 .get(subject_min_iat_key(&claims.sub));
338 let results = pipeline
339 .execute()
340 .await
341 .map_err(BaseError::RedisOperationFailed)?;
342
343 let (blacklisted, min_iat) = parse_revocation_pipeline_results(&results)?;
344 if blacklisted {
345 return Err(BaseError::TokenRevoked);
346 }
347
348 if min_iat.is_some_and(|watermark| iat_revoked_by_watermark(claims.iat, watermark)) {
349 return Err(BaseError::TokenRevoked);
350 }
351
352 Ok(claims)
353 }
354}
355
356#[cfg(test)]
357mod tests {
358 use super::*;
359
360 #[test]
361 fn test_blacklist_key_format() {
362 assert_eq!(blacklist_key("abc-123"), "token:blacklist:abc-123");
363 }
364
365 #[test]
366 fn test_subject_min_iat_key_format() {
367 assert_eq!(
369 subject_min_iat_key("user_42"),
370 "token:user:757365725f3432:min_iat"
371 );
372 }
373
374 #[test]
375 fn test_subject_min_iat_key_colon_safe() {
376 let key = subject_min_iat_key("user:admin");
378 assert_eq!(key, "token:user:757365723a61646d696e:min_iat");
379 let after_prefix = key.strip_prefix("token:user:").unwrap();
381 let (hex_part, rest) = after_prefix.split_once(':').unwrap();
382 assert_eq!(rest, "min_iat");
383 assert!(hex_part.chars().all(|c| c.is_ascii_hexdigit()));
385 }
386
387 #[test]
389 fn test_iat_revoked_by_watermark_same_second() {
390 assert!(iat_revoked_by_watermark(100, 200));
392 assert!(iat_revoked_by_watermark(200, 200));
394 assert!(!iat_revoked_by_watermark(201, 200));
396 }
397
398 #[test]
399 fn watermark_parser_accepts_only_absent_or_valid_u64_string() {
400 assert_eq!(
401 parse_subject_min_iat_value(&yang_db::RedisValue::Nil).expect("缺少水位线是合法状态"),
402 None
403 );
404 assert_eq!(
405 parse_subject_min_iat_value(&yang_db::RedisValue::String("0".to_string()))
406 .expect("u64 下界应有效"),
407 Some(0)
408 );
409 assert_eq!(
410 parse_subject_min_iat_value(&yang_db::RedisValue::String(u64::MAX.to_string()))
411 .expect("u64 上界应有效"),
412 Some(u64::MAX)
413 );
414 }
415
416 #[test]
417 fn watermark_parser_rejects_corrupt_strings_and_wrong_redis_types() {
418 let invalid_values = [
419 yang_db::RedisValue::String(String::new()),
420 yang_db::RedisValue::String("-1".to_string()),
421 yang_db::RedisValue::String("18446744073709551616".to_string()),
422 yang_db::RedisValue::String("secret-corrupt-watermark".to_string()),
423 yang_db::RedisValue::Bytes(vec![0xff]),
424 yang_db::RedisValue::Int(42),
425 yang_db::RedisValue::Bool(false),
426 yang_db::RedisValue::Array(Vec::new()),
427 ];
428
429 for value in invalid_values {
430 let error = parse_subject_min_iat_value(&value)
431 .expect_err("损坏或错误类型的水位线必须失败关闭");
432 assert!(
433 matches!(&error, BaseError::TokenRevocationStateInvalid(_)),
434 "损坏水位线必须返回结构化错误,实际为: {error:?}"
435 );
436 assert_eq!(error.code(), 400008);
437 assert!(error.is_server_error());
438 assert!(
439 !error.to_string().contains("secret-corrupt-watermark"),
440 "错误不得回显 Redis 中的损坏原值"
441 );
442 }
443 }
444
445 #[test]
446 fn subject_watermark_pipeline_parser_requires_exactly_one_result() {
447 for values in [
448 vec![],
449 vec![yang_db::RedisValue::Nil, yang_db::RedisValue::Nil],
450 ] {
451 assert!(
452 matches!(
453 parse_subject_min_iat_pipeline_results(&values),
454 Err(BaseError::TokenRevocationStateInvalid(_))
455 ),
456 "水位线 GET 必须恰好返回一个结果: {values:?}"
457 );
458 }
459
460 assert_eq!(
461 parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::Nil])
462 .expect("缺少水位线是合法状态"),
463 None
464 );
465 assert_eq!(
466 parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::String(
467 "42".to_string()
468 )])
469 .expect("合法水位线应通过"),
470 Some(42)
471 );
472 }
473
474 #[test]
475 fn revocation_pipeline_parser_rejects_ambiguous_results() {
476 for values in [
477 vec![],
478 vec![yang_db::RedisValue::Int(0)],
479 vec![
480 yang_db::RedisValue::Int(0),
481 yang_db::RedisValue::Nil,
482 yang_db::RedisValue::Nil,
483 ],
484 vec![
485 yang_db::RedisValue::String("0".to_string()),
486 yang_db::RedisValue::Nil,
487 ],
488 vec![yang_db::RedisValue::Int(-1), yang_db::RedisValue::Nil],
489 vec![yang_db::RedisValue::Int(2), yang_db::RedisValue::Nil],
490 ] {
491 assert!(
492 matches!(
493 parse_revocation_pipeline_results(&values),
494 Err(BaseError::TokenRevocationStateInvalid(_))
495 ),
496 "不明确的撤销查询结果必须失败关闭: {values:?}"
497 );
498 }
499
500 assert_eq!(
501 parse_revocation_pipeline_results(&[
502 yang_db::RedisValue::Int(0),
503 yang_db::RedisValue::String("42".to_string()),
504 ])
505 .expect("固定合法结果应通过"),
506 (false, Some(42))
507 );
508 assert_eq!(
509 parse_revocation_pipeline_results(&[
510 yang_db::RedisValue::Int(1),
511 yang_db::RedisValue::Nil,
512 ])
513 .expect("黑名单命中且无水位线是合法状态"),
514 (true, None)
515 );
516 }
517}