use crate::error::BaseError;
use crate::token::manager::current_unix_timestamp;
use crate::token::{TokenClaims, TokenManager};
use yang_db::RedisValue;
const BLACKLIST_PREFIX: &str = "token:blacklist:";
fn blacklist_key(jti: &str) -> String {
format!("{BLACKLIST_PREFIX}{jti}")
}
const SUBJECT_MIN_IAT_PREFIX: &str = "token:user:";
fn hex_encode(bytes: &[u8]) -> String {
let mut s = String::with_capacity(bytes.len() * 2);
for b in bytes {
s.push_str(&format!("{b:02x}"));
}
s
}
fn subject_min_iat_key(sub: &str) -> String {
format!(
"{SUBJECT_MIN_IAT_PREFIX}{}:min_iat",
hex_encode(sub.as_bytes())
)
}
fn iat_revoked_by_watermark(iat: u64, min_iat: u64) -> bool {
iat <= min_iat
}
fn invalid_revocation_state(message: &str) -> BaseError {
BaseError::TokenRevocationStateInvalid(message.to_string())
}
fn parse_subject_min_iat(raw: &str) -> Result<u64, BaseError> {
raw.parse::<u64>()
.map_err(|_| invalid_revocation_state("用户撤销水位线不是有效的 u64 时间戳"))
}
fn parse_subject_min_iat_value(value: &RedisValue) -> Result<Option<u64>, BaseError> {
match value {
RedisValue::Nil => Ok(None),
RedisValue::String(raw) => parse_subject_min_iat(raw).map(Some),
_ => Err(invalid_revocation_state(
"用户撤销水位线的 Redis 类型不是 nil/string",
)),
}
}
fn parse_subject_min_iat_pipeline_results(
results: &[RedisValue],
) -> Result<Option<u64>, BaseError> {
let [value] = results else {
return Err(invalid_revocation_state(
"用户撤销水位线 GET pipeline 返回数量不是 1",
));
};
parse_subject_min_iat_value(value)
}
fn parse_revocation_pipeline_results(
results: &[RedisValue],
) -> Result<(bool, Option<u64>), BaseError> {
let [blacklist_result, watermark_result] = results else {
return Err(invalid_revocation_state(
"Token 撤销查询 pipeline 返回数量不是 2",
));
};
let blacklisted = match blacklist_result {
RedisValue::Int(0) => false,
RedisValue::Int(1) => true,
_ => {
return Err(invalid_revocation_state(
"Token 黑名单 EXISTS 结果不是 0/1 整数",
))
}
};
Ok((blacklisted, parse_subject_min_iat_value(watermark_result)?))
}
impl TokenManager {
pub async fn revoke_token(&self, token: &str) -> Result<(), BaseError> {
let claims = self.verify_token(token)?;
self.revoke_claims(&claims).await
}
pub async fn revoke_claims(&self, claims: &TokenClaims) -> Result<(), BaseError> {
let now = current_unix_timestamp()?;
let ttl = claims.exp.saturating_sub(now);
if ttl == 0 {
return Ok(());
}
self.revocation_cache()?
.setex(blacklist_key(&claims.jti), ttl as i64, "1")
.await
.map_err(BaseError::RedisOperationFailed)?;
Ok(())
}
pub async fn is_revoked(&self, jti: &str) -> Result<bool, BaseError> {
let count = self
.revocation_cache()?
.exists(&[blacklist_key(jti)])
.await
.map_err(BaseError::RedisOperationFailed)?;
Ok(count > 0)
}
pub async fn revoke_by_subject(&self, sub: &str) -> Result<(), BaseError> {
let now = current_unix_timestamp()?;
let ttl = self.refresh_token_expiry();
self.revocation_cache()?
.setex(subject_min_iat_key(sub), ttl as i64, now.to_string())
.await
.map_err(BaseError::RedisOperationFailed)?;
Ok(())
}
pub async fn subject_min_iat(&self, sub: &str) -> Result<Option<u64>, BaseError> {
let mut pipeline = self.revocation_cache()?.pipeline();
pipeline.get(subject_min_iat_key(sub));
let results = pipeline
.execute()
.await
.map_err(BaseError::RedisOperationFailed)?;
parse_subject_min_iat_pipeline_results(&results)
}
pub(crate) async fn try_revoke_once(&self, jti: &str, ttl: u64) -> Result<bool, BaseError> {
if ttl == 0 {
return Ok(false);
}
self.revocation_cache()?
.set_nx_ex(blacklist_key(jti), "1", ttl as i64)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn verify_token_checked(&self, token: &str) -> Result<TokenClaims, BaseError> {
let claims = self.verify_token(token)?;
let mut pipeline = self.revocation_cache()?.pipeline();
pipeline
.exists(blacklist_key(&claims.jti))
.get(subject_min_iat_key(&claims.sub));
let results = pipeline
.execute()
.await
.map_err(BaseError::RedisOperationFailed)?;
let (blacklisted, min_iat) = parse_revocation_pipeline_results(&results)?;
if blacklisted {
return Err(BaseError::TokenRevoked);
}
if min_iat.is_some_and(|watermark| iat_revoked_by_watermark(claims.iat, watermark)) {
return Err(BaseError::TokenRevoked);
}
Ok(claims)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_blacklist_key_format() {
assert_eq!(blacklist_key("abc-123"), "token:blacklist:abc-123");
}
#[test]
fn test_subject_min_iat_key_format() {
assert_eq!(
subject_min_iat_key("user_42"),
"token:user:757365725f3432:min_iat"
);
}
#[test]
fn test_subject_min_iat_key_colon_safe() {
let key = subject_min_iat_key("user:admin");
assert_eq!(key, "token:user:757365723a61646d696e:min_iat");
let after_prefix = key.strip_prefix("token:user:").unwrap();
let (hex_part, rest) = after_prefix.split_once(':').unwrap();
assert_eq!(rest, "min_iat");
assert!(hex_part.chars().all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn test_iat_revoked_by_watermark_same_second() {
assert!(iat_revoked_by_watermark(100, 200));
assert!(iat_revoked_by_watermark(200, 200));
assert!(!iat_revoked_by_watermark(201, 200));
}
#[test]
fn watermark_parser_accepts_only_absent_or_valid_u64_string() {
assert_eq!(
parse_subject_min_iat_value(&yang_db::RedisValue::Nil).expect("缺少水位线是合法状态"),
None
);
assert_eq!(
parse_subject_min_iat_value(&yang_db::RedisValue::String("0".to_string()))
.expect("u64 下界应有效"),
Some(0)
);
assert_eq!(
parse_subject_min_iat_value(&yang_db::RedisValue::String(u64::MAX.to_string()))
.expect("u64 上界应有效"),
Some(u64::MAX)
);
}
#[test]
fn watermark_parser_rejects_corrupt_strings_and_wrong_redis_types() {
let invalid_values = [
yang_db::RedisValue::String(String::new()),
yang_db::RedisValue::String("-1".to_string()),
yang_db::RedisValue::String("18446744073709551616".to_string()),
yang_db::RedisValue::String("secret-corrupt-watermark".to_string()),
yang_db::RedisValue::Bytes(vec![0xff]),
yang_db::RedisValue::Int(42),
yang_db::RedisValue::Bool(false),
yang_db::RedisValue::Array(Vec::new()),
];
for value in invalid_values {
let error = parse_subject_min_iat_value(&value)
.expect_err("损坏或错误类型的水位线必须失败关闭");
assert!(
matches!(&error, BaseError::TokenRevocationStateInvalid(_)),
"损坏水位线必须返回结构化错误,实际为: {error:?}"
);
assert_eq!(error.code(), 400008);
assert!(error.is_server_error());
assert!(
!error.to_string().contains("secret-corrupt-watermark"),
"错误不得回显 Redis 中的损坏原值"
);
}
}
#[test]
fn subject_watermark_pipeline_parser_requires_exactly_one_result() {
for values in [
vec![],
vec![yang_db::RedisValue::Nil, yang_db::RedisValue::Nil],
] {
assert!(
matches!(
parse_subject_min_iat_pipeline_results(&values),
Err(BaseError::TokenRevocationStateInvalid(_))
),
"水位线 GET 必须恰好返回一个结果: {values:?}"
);
}
assert_eq!(
parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::Nil])
.expect("缺少水位线是合法状态"),
None
);
assert_eq!(
parse_subject_min_iat_pipeline_results(&[yang_db::RedisValue::String(
"42".to_string()
)])
.expect("合法水位线应通过"),
Some(42)
);
}
#[test]
fn revocation_pipeline_parser_rejects_ambiguous_results() {
for values in [
vec![],
vec![yang_db::RedisValue::Int(0)],
vec![
yang_db::RedisValue::Int(0),
yang_db::RedisValue::Nil,
yang_db::RedisValue::Nil,
],
vec![
yang_db::RedisValue::String("0".to_string()),
yang_db::RedisValue::Nil,
],
vec![yang_db::RedisValue::Int(-1), yang_db::RedisValue::Nil],
vec![yang_db::RedisValue::Int(2), yang_db::RedisValue::Nil],
] {
assert!(
matches!(
parse_revocation_pipeline_results(&values),
Err(BaseError::TokenRevocationStateInvalid(_))
),
"不明确的撤销查询结果必须失败关闭: {values:?}"
);
}
assert_eq!(
parse_revocation_pipeline_results(&[
yang_db::RedisValue::Int(0),
yang_db::RedisValue::String("42".to_string()),
])
.expect("固定合法结果应通过"),
(false, Some(42))
);
assert_eq!(
parse_revocation_pipeline_results(&[
yang_db::RedisValue::Int(1),
yang_db::RedisValue::Nil,
])
.expect("黑名单命中且无水位线是合法状态"),
(true, None)
);
}
}