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};
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
))
})
}
pub struct TokenManager {
encoding_key: EncodingKey,
decoding_key: DecodingKey,
algorithm: Algorithm,
issuer: String,
audience: String,
access_token_expiry: u64,
refresh_token_expiry: u64,
}
impl TokenManager {
pub fn new_symmetric(
secret: &str,
algorithm: Algorithm,
issuer: String,
audience: String,
access_token_expiry: u64,
refresh_token_expiry: u64,
) -> Self {
Self {
encoding_key: EncodingKey::from_secret(secret.as_bytes()),
decoding_key: DecodingKey::from_secret(secret.as_bytes()),
algorithm,
issuer,
audience,
access_token_expiry,
refresh_token_expiry,
}
}
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)))?;
Ok(Self {
encoding_key,
decoding_key,
algorithm,
issuer,
audience,
access_token_expiry,
refresh_token_expiry,
})
}
pub fn generate_access_token(
&self,
subject: &str,
custom_claims: serde_json::Value,
) -> Result<String, BaseError> {
let now = current_unix_timestamp()?;
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: "access".to_string(),
custom: custom_claims,
};
let mut header = Header::new(self.algorithm);
header.typ = Some("JWT".to_string());
encode(&header, &claims, &self.encoding_key)
.map_err(BaseError::TokenGenerateFailed)
}
pub fn generate_refresh_token(&self, subject: &str) -> Result<String, BaseError> {
let now = current_unix_timestamp()?;
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: "refresh".to_string(),
custom: serde_json::Value::Null,
};
let mut header = Header::new(self.algorithm);
header.typ = Some("JWT".to_string());
encode(&header, &claims, &self.encoding_key)
.map_err(BaseError::TokenGenerateFailed)
}
pub fn generate_token_pair(
&self,
subject: &str,
custom_claims: serde_json::Value,
) -> Result<(String, String), BaseError> {
let access_token = self.generate_access_token(subject, custom_claims)?;
let refresh_token = self.generate_refresh_token(subject)?;
Ok((access_token, refresh_token))
}
pub fn verify_token(&self, token: &str) -> Result<TokenClaims, BaseError> {
let mut validation = Validation::new(self.algorithm);
validation.algorithms = vec![self.algorithm];
validation.set_issuer(&[&self.issuer]);
validation.set_audience(&[&self.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;
let token_data = decode::<TokenClaims>(token, &self.decoding_key, &validation)
.map_err(BaseError::TokenVerifyFailed)?;
Ok(token_data.claims)
}
pub fn parse_token_unsafe(&self, token: &str) -> Result<TokenClaims, BaseError> {
let token_data = jsonwebtoken::dangerous::insecure_decode::<TokenClaims>(token)
.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 fn refresh_access_token(
&self,
refresh_token: &str,
custom_claims: serde_json::Value,
) -> Result<String, BaseError> {
let claims = self.verify_token(refresh_token)?;
if claims.token_type != "refresh" {
return Err(BaseError::TokenTypeInvalid(
"期望 refresh token".to_string(),
));
}
self.generate_access_token(&claims.sub, custom_claims)
}
}
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)
.finish_non_exhaustive()
}
}