use crate::database::GlobalRedis;
use crate::error::BaseError;
use crate::token::manager::current_unix_timestamp;
use crate::token::{TokenClaims, TokenManager};
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
}
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(());
}
GlobalRedis::set(blacklist_key(&claims.jti), "1", Some(ttl as i64)).await?;
Ok(())
}
pub async fn is_revoked(&self, jti: &str) -> Result<bool, BaseError> {
let count = GlobalRedis::exists(&[blacklist_key(jti)]).await?;
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();
GlobalRedis::set(subject_min_iat_key(sub), now.to_string(), Some(ttl as i64)).await?;
Ok(())
}
pub async fn subject_min_iat(&self, sub: &str) -> Result<Option<u64>, BaseError> {
match GlobalRedis::get(subject_min_iat_key(sub)).await? {
Some(raw) => {
if let Ok(ts) = raw.parse::<u64>() {
Ok(Some(ts))
} else {
tracing::warn!(sub, raw, "水位线解析失败,视为无水位线");
Ok(None)
}
}
None => Ok(None),
}
}
pub(crate) async fn try_revoke_once(jti: &str, ttl: u64) -> Result<bool, BaseError> {
if ttl == 0 {
return Ok(false);
}
GlobalRedis::set_nx_ex(blacklist_key(jti), "1", ttl as i64).await
}
pub async fn verify_token_checked(&self, token: &str) -> Result<TokenClaims, BaseError> {
let claims = self.verify_token(token)?;
let mut pipeline = GlobalRedis::client()?.pipeline();
pipeline
.exists(blacklist_key(&claims.jti))
.get(subject_min_iat_key(&claims.sub));
let results = pipeline.execute().await?;
let revoked_count = results[0].as_i64().unwrap_or(0);
if revoked_count > 0 {
return Err(BaseError::TokenRevoked);
}
if let Some(raw) = results[1].as_str() {
if let Ok(min_iat) = raw.parse::<u64>() {
if iat_revoked_by_watermark(claims.iat, min_iat) {
return Err(BaseError::TokenRevoked);
}
} else {
tracing::warn!(sub = %claims.sub, raw, "水位线解析失败,视为无水位线");
}
}
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));
}
}