use crate::error::BaseError;
use crate::token::TokenClaims;
use jsonwebtoken::{decode, encode, Algorithm, DecodingKey, EncodingKey, Header, Validation};
use std::collections::HashSet;
use std::time::{SystemTime, UNIX_EPOCH};
use yang_db::RedisClient;
pub(crate) fn current_unix_timestamp() -> Result<u64, BaseError> {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.map_err(|e| BaseError::ConfigError(format!("系统时钟异常,早于 UNIX_EPOCH: {}", e)))
}
fn build_validation(algorithm: Algorithm, issuer: &str, audience: &str) -> Validation {
let mut validation = Validation::new(algorithm);
validation.algorithms = vec![algorithm];
validation.set_issuer(&[issuer]);
validation.set_audience(&[audience]);
let mut required_claims = HashSet::new();
required_claims.insert("exp".to_string());
required_claims.insert("iss".to_string());
required_claims.insert("aud".to_string());
validation.required_spec_claims = required_claims;
validation.leeway = 0;
validation
}
pub struct TokenManager {
encoding_key: EncodingKey,
decoding_key: DecodingKey,
algorithm: Algorithm,
issuer: String,
audience: String,
access_token_expiry: u64,
refresh_token_expiry: u64,
validation: Validation,
jwt_header: Header,
revocation_cache: Option<RedisClient>,
}
impl TokenManager {
pub fn new_symmetric(
secret: &str,
algorithm: Algorithm,
issuer: String,
audience: String,
access_token_expiry: u64,
refresh_token_expiry: u64,
) -> Self {
matches!(
algorithm,
Algorithm::HS256 | Algorithm::HS384 | Algorithm::HS512
)
.then_some(())
.expect("new_symmetric 仅支持 HMAC 算法 (HS256/HS384/HS512),请使用 new_asymmetric 处理非对称算法");
let mut jwt_header = Header::new(algorithm);
jwt_header.typ = Some("JWT".to_string());
Self {
encoding_key: EncodingKey::from_secret(secret.as_bytes()),
decoding_key: DecodingKey::from_secret(secret.as_bytes()),
algorithm,
validation: build_validation(algorithm, &issuer, &audience),
issuer,
audience,
access_token_expiry,
refresh_token_expiry,
jwt_header,
revocation_cache: None,
}
}
pub fn new_asymmetric(
private_key: &str,
public_key: &str,
algorithm: Algorithm,
issuer: String,
audience: String,
access_token_expiry: u64,
refresh_token_expiry: u64,
) -> Result<Self, BaseError> {
let encoding_key = EncodingKey::from_rsa_pem(private_key.as_bytes())
.map_err(|e| BaseError::TokenKeyInvalid(format!("私钥无效: {}", e)))?;
let decoding_key = DecodingKey::from_rsa_pem(public_key.as_bytes())
.map_err(|e| BaseError::TokenKeyInvalid(format!("公钥无效: {}", e)))?;
let mut jwt_header = Header::new(algorithm);
jwt_header.typ = Some("JWT".to_string());
Ok(Self {
encoding_key,
decoding_key,
algorithm,
validation: build_validation(algorithm, &issuer, &audience),
issuer,
audience,
access_token_expiry,
refresh_token_expiry,
jwt_header,
revocation_cache: None,
})
}
pub(crate) fn attach_revocation_cache(&mut self, cache: RedisClient) {
self.revocation_cache = Some(cache);
}
pub(crate) fn revocation_cache(&self) -> Result<&RedisClient, BaseError> {
self.revocation_cache
.as_ref()
.ok_or(BaseError::RedisNotInitialized)
}
pub fn generate_access_token(
&self,
subject: &str,
custom_claims: serde_json::Value,
) -> Result<String, BaseError> {
let now = current_unix_timestamp()?;
self.generate_access_token_at(subject, custom_claims, now)
}
pub fn generate_refresh_token(&self, subject: &str) -> Result<String, BaseError> {
let now = current_unix_timestamp()?;
self.generate_refresh_token_at(subject, now)
}
pub fn generate_token_pair(
&self,
subject: &str,
custom_claims: serde_json::Value,
) -> Result<(String, String), BaseError> {
let now = current_unix_timestamp()?;
self.generate_token_pair_at(subject, custom_claims, now)
}
pub(crate) fn generate_token_pair_at(
&self,
subject: &str,
custom_claims: serde_json::Value,
now: u64,
) -> Result<(String, String), BaseError> {
let access_token = self.generate_access_token_at(subject, custom_claims, now)?;
let refresh_token = self.generate_refresh_token_at(subject, now)?;
Ok((access_token, refresh_token))
}
fn generate_access_token_at(
&self,
subject: &str,
custom_claims: serde_json::Value,
now: u64,
) -> Result<String, BaseError> {
let claims = TokenClaims {
iss: self.issuer.clone(),
sub: subject.to_string(),
aud: self.audience.clone(),
exp: now + self.access_token_expiry,
nbf: now,
iat: now,
jti: uuid::Uuid::new_v4().to_string(),
token_type: crate::token::TokenType::Access,
custom: custom_claims,
};
encode(&self.jwt_header, &claims, &self.encoding_key)
.map_err(BaseError::TokenGenerateFailed)
}
fn generate_refresh_token_at(&self, subject: &str, now: u64) -> Result<String, BaseError> {
let claims = TokenClaims {
iss: self.issuer.clone(),
sub: subject.to_string(),
aud: self.audience.clone(),
exp: now + self.refresh_token_expiry,
nbf: now,
iat: now,
jti: uuid::Uuid::new_v4().to_string(),
token_type: crate::token::TokenType::Refresh,
custom: serde_json::Value::Null,
};
encode(&self.jwt_header, &claims, &self.encoding_key)
.map_err(BaseError::TokenGenerateFailed)
}
pub(crate) fn refresh_token_expiry(&self) -> u64 {
self.refresh_token_expiry
}
pub fn verify_token(&self, token: &str) -> Result<TokenClaims, BaseError> {
let token_data = decode::<TokenClaims>(token, &self.decoding_key, &self.validation)?;
Ok(token_data.claims)
}
#[deprecated(
since = "0.1.0",
note = "此方法跳过所有 JWT 安全验证(签名/过期/签发者),仅可用于调试日志和单元测试。鉴权路径必须使用 verify_token 或 verify_token_checked。"
)]
pub fn parse_token_unsafe(&self, token: &str) -> Result<TokenClaims, BaseError> {
let header = jsonwebtoken::decode_header(token).map_err(BaseError::TokenParseFailed)?;
let mut validation = jsonwebtoken::Validation::new(header.alg);
validation.insecure_disable_signature_validation();
validation.validate_exp = false;
validation.validate_nbf = false;
validation.validate_aud = false;
validation.required_spec_claims.clear();
let token_data = jsonwebtoken::decode::<TokenClaims>(
token,
&jsonwebtoken::DecodingKey::from_secret(&[]),
&validation,
)
.map_err(BaseError::TokenParseFailed)?;
Ok(token_data.claims)
}
pub fn is_token_expiring_soon(
&self,
token: &str,
threshold_secs: u64,
) -> Result<bool, BaseError> {
let claims = self.verify_token(token)?;
let now = current_unix_timestamp()?;
let remaining = claims.exp.saturating_sub(now);
Ok(remaining < threshold_secs)
}
pub async fn refresh_access_token(
&self,
refresh_token: &str,
custom_claims: serde_json::Value,
) -> Result<String, BaseError> {
let claims = self.verify_token_checked(refresh_token).await?;
if claims.token_type != crate::token::TokenType::Refresh {
return Err(BaseError::TokenTypeInvalid(
"期望 refresh token".to_string(),
));
}
self.generate_access_token(&claims.sub, custom_claims)
}
pub async fn rotate_refresh_token(
&self,
old_refresh: &str,
custom_claims: serde_json::Value,
) -> Result<(String, String), BaseError> {
let old_claims = self.verify_token_checked(old_refresh).await?;
self.rotate_refresh_token_from_claims(&old_claims, custom_claims)
.await
}
pub async fn rotate_refresh_token_from_claims(
&self,
old_claims: &TokenClaims,
custom_claims: serde_json::Value,
) -> Result<(String, String), BaseError> {
if old_claims.token_type != crate::token::TokenType::Refresh {
return Err(BaseError::TokenTypeInvalid(
"期望 refresh token".to_string(),
));
}
let now = current_unix_timestamp()?;
let ttl = old_claims.exp.saturating_sub(now);
if !self.try_revoke_once(&old_claims.jti, ttl).await? {
return Err(BaseError::TokenRevoked);
}
self.generate_token_pair_at(&old_claims.sub, custom_claims, now)
}
}
impl std::fmt::Debug for TokenManager {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TokenManager")
.field("algorithm", &self.algorithm)
.field("issuer", &self.issuer)
.field("audience", &self.audience)
.field("access_token_expiry", &self.access_token_expiry)
.field("refresh_token_expiry", &self.refresh_token_expiry)
.field("validation", &self.validation)
.finish_non_exhaustive()
}
}