1use crate::error::BaseError;
19use crate::token::manager::current_unix_timestamp;
20use crate::token::{TokenClaims, TokenManager};
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 is_revoked(&self, jti: &str) -> Result<bool, BaseError> {
172 let count = self
173 .revocation_cache()?
174 .exists(&[blacklist_key(jti)])
175 .await
176 .map_err(BaseError::RedisOperationFailed)?;
177 Ok(count > 0)
178 }
179
180 pub async fn revoke_by_subject(&self, sub: &str) -> Result<(), BaseError> {
203 let now = current_unix_timestamp()?;
204 let ttl = self.refresh_token_expiry();
205 self.revocation_cache()?
206 .setex(subject_min_iat_key(sub), ttl as i64, now.to_string())
207 .await
208 .map_err(BaseError::RedisOperationFailed)?;
209 Ok(())
210 }
211
212 pub async fn subject_min_iat(&self, sub: &str) -> Result<Option<u64>, BaseError> {
225 let mut pipeline = self.revocation_cache()?.pipeline();
226 pipeline.get(subject_min_iat_key(sub));
227 let results = pipeline
228 .execute()
229 .await
230 .map_err(BaseError::RedisOperationFailed)?;
231 parse_subject_min_iat_pipeline_results(&results)
232 }
233
234 pub(crate) async fn try_revoke_once(&self, jti: &str, ttl: u64) -> Result<bool, BaseError> {
251 if ttl == 0 {
252 return Ok(false);
253 }
254 self.revocation_cache()?
255 .set_nx_ex(blacklist_key(jti), "1", ttl as i64)
256 .await
257 .map_err(BaseError::RedisOperationFailed)
258 }
259
260 pub async fn verify_token_checked(&self, token: &str) -> Result<TokenClaims, BaseError> {
281 let claims = self.verify_token(token)?;
282
283 let mut pipeline = self.revocation_cache()?.pipeline();
286 pipeline
287 .exists(blacklist_key(&claims.jti))
288 .get(subject_min_iat_key(&claims.sub));
289 let results = pipeline
290 .execute()
291 .await
292 .map_err(BaseError::RedisOperationFailed)?;
293
294 let (blacklisted, min_iat) = parse_revocation_pipeline_results(&results)?;
295 if blacklisted {
296 return Err(BaseError::TokenRevoked);
297 }
298
299 if min_iat.is_some_and(|watermark| iat_revoked_by_watermark(claims.iat, watermark)) {
300 return Err(BaseError::TokenRevoked);
301 }
302
303 Ok(claims)
304 }
305}
306
307#[cfg(test)]
308mod tests {
309 use super::*;
310
311 #[test]
312 fn test_blacklist_key_format() {
313 assert_eq!(blacklist_key("abc-123"), "token:blacklist:abc-123");
314 }
315
316 #[test]
317 fn test_subject_min_iat_key_format() {
318 assert_eq!(
320 subject_min_iat_key("user_42"),
321 "token:user:757365725f3432:min_iat"
322 );
323 }
324
325 #[test]
326 fn test_subject_min_iat_key_colon_safe() {
327 let key = subject_min_iat_key("user:admin");
329 assert_eq!(key, "token:user:757365723a61646d696e:min_iat");
330 let after_prefix = key.strip_prefix("token:user:").unwrap();
332 let (hex_part, rest) = after_prefix.split_once(':').unwrap();
333 assert_eq!(rest, "min_iat");
334 assert!(hex_part.chars().all(|c| c.is_ascii_hexdigit()));
336 }
337
338 #[test]
340 fn test_iat_revoked_by_watermark_same_second() {
341 assert!(iat_revoked_by_watermark(100, 200));
343 assert!(iat_revoked_by_watermark(200, 200));
345 assert!(!iat_revoked_by_watermark(201, 200));
347 }
348
349 #[test]
350 fn watermark_parser_accepts_only_absent_or_valid_u64_string() {
351 assert_eq!(
352 parse_subject_min_iat_value(&yang_db::RedisValue::Nil).expect("缺少水位线是合法状态"),
353 None
354 );
355 assert_eq!(
356 parse_subject_min_iat_value(&yang_db::RedisValue::String("0".to_string()))
357 .expect("u64 下界应有效"),
358 Some(0)
359 );
360 assert_eq!(
361 parse_subject_min_iat_value(&yang_db::RedisValue::String(u64::MAX.to_string()))
362 .expect("u64 上界应有效"),
363 Some(u64::MAX)
364 );
365 }
366
367 #[test]
368 fn watermark_parser_rejects_corrupt_strings_and_wrong_redis_types() {
369 let invalid_values = [
370 yang_db::RedisValue::String(String::new()),
371 yang_db::RedisValue::String("-1".to_string()),
372 yang_db::RedisValue::String("18446744073709551616".to_string()),
373 yang_db::RedisValue::String("secret-corrupt-watermark".to_string()),
374 yang_db::RedisValue::Bytes(vec![0xff]),
375 yang_db::RedisValue::Int(42),
376 yang_db::RedisValue::Bool(false),
377 yang_db::RedisValue::Array(Vec::new()),
378 ];
379
380 for value in invalid_values {
381 let error = parse_subject_min_iat_value(&value)
382 .expect_err("损坏或错误类型的水位线必须失败关闭");
383 assert!(
384 matches!(&error, BaseError::TokenRevocationStateInvalid(_)),
385 "损坏水位线必须返回结构化错误,实际为: {error:?}"
386 );
387 assert_eq!(error.code(), 400008);
388 assert!(error.is_server_error());
389 assert!(
390 !error.to_string().contains("secret-corrupt-watermark"),
391 "错误不得回显 Redis 中的损坏原值"
392 );
393 }
394 }
395
396 #[test]
397 fn subject_watermark_pipeline_parser_requires_exactly_one_result() {
398 for values in [
399 vec![],
400 vec![yang_db::RedisValue::Nil, yang_db::RedisValue::Nil],
401 ] {
402 assert!(
403 matches!(
404 parse_subject_min_iat_pipeline_results(&values),
405 Err(BaseError::TokenRevocationStateInvalid(_))
406 ),
407 "水位线 GET 必须恰好返回一个结果: {values:?}"
408 );
409 }
410
411 assert_eq!(
412 parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::Nil])
413 .expect("缺少水位线是合法状态"),
414 None
415 );
416 assert_eq!(
417 parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::String(
418 "42".to_string()
419 )])
420 .expect("合法水位线应通过"),
421 Some(42)
422 );
423 }
424
425 #[test]
426 fn revocation_pipeline_parser_rejects_ambiguous_results() {
427 for values in [
428 vec![],
429 vec![yang_db::RedisValue::Int(0)],
430 vec![
431 yang_db::RedisValue::Int(0),
432 yang_db::RedisValue::Nil,
433 yang_db::RedisValue::Nil,
434 ],
435 vec![
436 yang_db::RedisValue::String("0".to_string()),
437 yang_db::RedisValue::Nil,
438 ],
439 vec![yang_db::RedisValue::Int(-1), yang_db::RedisValue::Nil],
440 vec![yang_db::RedisValue::Int(2), yang_db::RedisValue::Nil],
441 ] {
442 assert!(
443 matches!(
444 parse_revocation_pipeline_results(&values),
445 Err(BaseError::TokenRevocationStateInvalid(_))
446 ),
447 "不明确的撤销查询结果必须失败关闭: {values:?}"
448 );
449 }
450
451 assert_eq!(
452 parse_revocation_pipeline_results(&[
453 yang_db::RedisValue::Int(0),
454 yang_db::RedisValue::String("42".to_string()),
455 ])
456 .expect("固定合法结果应通过"),
457 (false, Some(42))
458 );
459 assert_eq!(
460 parse_revocation_pipeline_results(&[
461 yang_db::RedisValue::Int(1),
462 yang_db::RedisValue::Nil,
463 ])
464 .expect("黑名单命中且无水位线是合法状态"),
465 (true, None)
466 );
467 }
468}