use crate::error::BaseError;
use crate::token::manager::current_unix_timestamp;
use crate::token::{TokenClaims, TokenManager, TokenType};
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)
}
const REVOCATION_LOOKUP_SCRIPT: &str = r#"
local blacklisted = redis.call('EXISTS', KEYS[1])
local watermark = redis.call('GET', KEYS[2])
local has_watermark = redis.call('EXISTS', KEYS[2])
if not watermark then
watermark = ''
end
return {blacklisted, has_watermark, watermark}
"#;
fn parse_revocation_script_results(
blacklisted: i64,
has_watermark: i64,
watermark: String,
) -> Result<(bool, Option<u64>), BaseError> {
let blacklisted = match blacklisted {
0 => false,
1 => true,
_ => {
return Err(invalid_revocation_state(
"Token 黑名单 EXISTS 结果不是 0/1 整数",
))
}
};
let min_iat = match has_watermark {
0 => None,
1 => Some(parse_subject_min_iat(&watermark)?),
_ => {
return Err(invalid_revocation_state(
"Token 水位线 EXISTS 结果不是 0/1 整数",
))
}
};
Ok((blacklisted, min_iat))
}
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 remaining = claims.exp.saturating_sub(now);
if remaining == 0 {
return Ok(());
}
let ttl = i64::try_from(remaining)
.map_err(|_| BaseError::ConfigError("Token 剩余有效期超出 i64 范围".to_string()))?;
self.revocation_cache()?
.setex(blacklist_key(&claims.jti), ttl, "1")
.await
.map_err(BaseError::RedisOperationFailed)?;
Ok(())
}
pub async fn revoke_by_jti_with_ttl(
&self,
jti: &str,
ttl_seconds: u64,
) -> Result<(), BaseError> {
let ttl = i64::try_from(ttl_seconds)
.map_err(|_| BaseError::ConfigError("jti 黑名单 TTL 超出 i64 范围".to_string()))?;
self.revocation_cache()?
.setex(blacklist_key(jti), ttl, "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 = i64::try_from(self.revocation_watermark_ttl()).map_err(|_| {
BaseError::ConfigError("Token 撤销水位线 TTL 超出 i64 范围".to_string())
})?;
self.revocation_cache()?
.setex(subject_min_iat_key(sub), ttl, 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);
}
let ttl = i64::try_from(ttl)
.map_err(|_| BaseError::ConfigError("jti 黑名单 TTL 超出 i64 范围".to_string()))?;
self.revocation_cache()?
.set_nx_ex(blacklist_key(jti), "1", ttl)
.await
.map_err(BaseError::RedisOperationFailed)
}
pub async fn verify_token_checked(
&self,
token: &str,
expected: TokenType,
) -> Result<TokenClaims, BaseError> {
let claims = self.verify_token(token)?;
if claims.token_type != expected {
return Err(BaseError::TokenTypeInvalid("Token 类型不匹配".to_string()));
}
let cache = self.revocation_cache()?;
let (blacklisted, min_iat) = if cache.is_cluster() {
let blacklisted = cache
.exists(&[blacklist_key(&claims.jti)])
.await
.map_err(BaseError::RedisOperationFailed)?
> 0;
let min_iat = self.subject_min_iat(&claims.sub).await?;
(blacklisted, min_iat)
} else {
let script = cache.script(REVOCATION_LOOKUP_SCRIPT);
let (blacklisted, has_watermark, watermark): (i64, i64, String) = cache
.eval_script(
&script,
&[blacklist_key(&claims.jti), subject_min_iat_key(&claims.sub)],
&[],
)
.await
.map_err(|error| match error {
yang_db::DbError::RedisTypeConversionError(_) => {
invalid_revocation_state("Token 撤销查询返回非法类型")
}
other => BaseError::RedisOperationFailed(other),
})?;
parse_revocation_script_results(blacklisted, has_watermark, watermark)?
};
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_script_parser_accepts_valid_and_rejects_corrupt() {
assert_eq!(
parse_revocation_script_results(0, 0, String::new())
.expect("黑名单未命中且无水位线是合法状态"),
(false, None)
);
assert_eq!(
parse_revocation_script_results(1, 1, "42".to_string())
.expect("黑名单命中且水位线合法"),
(true, Some(42))
);
for (blacklisted, has_watermark, watermark) in [
(-1, 0, String::new()),
(2, 0, String::new()),
(0, 2, String::new()),
(0, 1, String::new()),
(0, 1, "secret-corrupt-watermark".to_string()),
] {
let error = parse_revocation_script_results(blacklisted, has_watermark, watermark)
.expect_err("非法脚本结果必须失败关闭");
assert!(matches!(error, BaseError::TokenRevocationStateInvalid(_)));
assert!(
!error.to_string().contains("secret-corrupt-watermark"),
"错误不得回显 Redis 中的损坏原值"
);
}
}
}