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> {
222 let now = current_unix_timestamp()?;
223 let ttl = self.revocation_watermark_ttl();
224 self.revocation_cache()?
225 .setex(subject_min_iat_key(sub), ttl as i64, now.to_string())
226 .await
227 .map_err(BaseError::RedisOperationFailed)?;
228 Ok(())
229 }
230
231 pub async fn subject_min_iat(&self, sub: &str) -> Result<Option<u64>, BaseError> {
244 let mut pipeline = self.revocation_cache()?.pipeline();
245 pipeline.get(subject_min_iat_key(sub));
246 let results = pipeline
247 .execute()
248 .await
249 .map_err(BaseError::RedisOperationFailed)?;
250 parse_subject_min_iat_pipeline_results(&results)
251 }
252
253 pub(crate) async fn try_revoke_once(&self, jti: &str, ttl: u64) -> Result<bool, BaseError> {
272 if ttl == 0 {
273 return Ok(false);
274 }
275 self.revocation_cache()?
276 .set_nx_ex(blacklist_key(jti), "1", ttl as i64)
277 .await
278 .map_err(BaseError::RedisOperationFailed)
279 }
280
281 pub async fn verify_token_checked(
305 &self,
306 token: &str,
307 expected: TokenType,
308 ) -> Result<TokenClaims, BaseError> {
309 let claims = self.verify_token(token)?;
310 if claims.token_type != expected {
312 return Err(BaseError::TokenTypeInvalid("Token 类型不匹配".to_string()));
313 }
314
315 let mut pipeline = self.revocation_cache()?.pipeline();
318 pipeline
319 .exists(blacklist_key(&claims.jti))
320 .get(subject_min_iat_key(&claims.sub));
321 let results = pipeline
322 .execute()
323 .await
324 .map_err(BaseError::RedisOperationFailed)?;
325
326 let (blacklisted, min_iat) = parse_revocation_pipeline_results(&results)?;
327 if blacklisted {
328 return Err(BaseError::TokenRevoked);
329 }
330
331 if min_iat.is_some_and(|watermark| iat_revoked_by_watermark(claims.iat, watermark)) {
332 return Err(BaseError::TokenRevoked);
333 }
334
335 Ok(claims)
336 }
337}
338
339#[cfg(test)]
340mod tests {
341 use super::*;
342
343 #[test]
344 fn test_blacklist_key_format() {
345 assert_eq!(blacklist_key("abc-123"), "token:blacklist:abc-123");
346 }
347
348 #[test]
349 fn test_subject_min_iat_key_format() {
350 assert_eq!(
352 subject_min_iat_key("user_42"),
353 "token:user:757365725f3432:min_iat"
354 );
355 }
356
357 #[test]
358 fn test_subject_min_iat_key_colon_safe() {
359 let key = subject_min_iat_key("user:admin");
361 assert_eq!(key, "token:user:757365723a61646d696e:min_iat");
362 let after_prefix = key.strip_prefix("token:user:").unwrap();
364 let (hex_part, rest) = after_prefix.split_once(':').unwrap();
365 assert_eq!(rest, "min_iat");
366 assert!(hex_part.chars().all(|c| c.is_ascii_hexdigit()));
368 }
369
370 #[test]
372 fn test_iat_revoked_by_watermark_same_second() {
373 assert!(iat_revoked_by_watermark(100, 200));
375 assert!(iat_revoked_by_watermark(200, 200));
377 assert!(!iat_revoked_by_watermark(201, 200));
379 }
380
381 #[test]
382 fn watermark_parser_accepts_only_absent_or_valid_u64_string() {
383 assert_eq!(
384 parse_subject_min_iat_value(&yang_db::RedisValue::Nil).expect("缺少水位线是合法状态"),
385 None
386 );
387 assert_eq!(
388 parse_subject_min_iat_value(&yang_db::RedisValue::String("0".to_string()))
389 .expect("u64 下界应有效"),
390 Some(0)
391 );
392 assert_eq!(
393 parse_subject_min_iat_value(&yang_db::RedisValue::String(u64::MAX.to_string()))
394 .expect("u64 上界应有效"),
395 Some(u64::MAX)
396 );
397 }
398
399 #[test]
400 fn watermark_parser_rejects_corrupt_strings_and_wrong_redis_types() {
401 let invalid_values = [
402 yang_db::RedisValue::String(String::new()),
403 yang_db::RedisValue::String("-1".to_string()),
404 yang_db::RedisValue::String("18446744073709551616".to_string()),
405 yang_db::RedisValue::String("secret-corrupt-watermark".to_string()),
406 yang_db::RedisValue::Bytes(vec![0xff]),
407 yang_db::RedisValue::Int(42),
408 yang_db::RedisValue::Bool(false),
409 yang_db::RedisValue::Array(Vec::new()),
410 ];
411
412 for value in invalid_values {
413 let error = parse_subject_min_iat_value(&value)
414 .expect_err("损坏或错误类型的水位线必须失败关闭");
415 assert!(
416 matches!(&error, BaseError::TokenRevocationStateInvalid(_)),
417 "损坏水位线必须返回结构化错误,实际为: {error:?}"
418 );
419 assert_eq!(error.code(), 400008);
420 assert!(error.is_server_error());
421 assert!(
422 !error.to_string().contains("secret-corrupt-watermark"),
423 "错误不得回显 Redis 中的损坏原值"
424 );
425 }
426 }
427
428 #[test]
429 fn subject_watermark_pipeline_parser_requires_exactly_one_result() {
430 for values in [
431 vec![],
432 vec![yang_db::RedisValue::Nil, yang_db::RedisValue::Nil],
433 ] {
434 assert!(
435 matches!(
436 parse_subject_min_iat_pipeline_results(&values),
437 Err(BaseError::TokenRevocationStateInvalid(_))
438 ),
439 "水位线 GET 必须恰好返回一个结果: {values:?}"
440 );
441 }
442
443 assert_eq!(
444 parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::Nil])
445 .expect("缺少水位线是合法状态"),
446 None
447 );
448 assert_eq!(
449 parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::String(
450 "42".to_string()
451 )])
452 .expect("合法水位线应通过"),
453 Some(42)
454 );
455 }
456
457 #[test]
458 fn revocation_pipeline_parser_rejects_ambiguous_results() {
459 for values in [
460 vec![],
461 vec![yang_db::RedisValue::Int(0)],
462 vec![
463 yang_db::RedisValue::Int(0),
464 yang_db::RedisValue::Nil,
465 yang_db::RedisValue::Nil,
466 ],
467 vec![
468 yang_db::RedisValue::String("0".to_string()),
469 yang_db::RedisValue::Nil,
470 ],
471 vec![yang_db::RedisValue::Int(-1), yang_db::RedisValue::Nil],
472 vec![yang_db::RedisValue::Int(2), yang_db::RedisValue::Nil],
473 ] {
474 assert!(
475 matches!(
476 parse_revocation_pipeline_results(&values),
477 Err(BaseError::TokenRevocationStateInvalid(_))
478 ),
479 "不明确的撤销查询结果必须失败关闭: {values:?}"
480 );
481 }
482
483 assert_eq!(
484 parse_revocation_pipeline_results(&[
485 yang_db::RedisValue::Int(0),
486 yang_db::RedisValue::String("42".to_string()),
487 ])
488 .expect("固定合法结果应通过"),
489 (false, Some(42))
490 );
491 assert_eq!(
492 parse_revocation_pipeline_results(&[
493 yang_db::RedisValue::Int(1),
494 yang_db::RedisValue::Nil,
495 ])
496 .expect("黑名单命中且无水位线是合法状态"),
497 (true, None)
498 );
499 }
500}