use crate::error::{GarrisonError, GarrisonResult};
use crate::protocol::jwt::JwtHandler;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
pub const PURPOSE_PASSWORD_RESET: &str = "password_reset";
pub const DEFAULT_TOKEN_TTL_SECS: i64 = 900;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionTokenClaims {
pub sub: String,
pub purpose: String,
pub jti: String,
pub iat: i64,
pub exp: i64,
}
#[derive(Debug, Clone)]
pub struct IssuedActionToken {
pub token: String,
pub claims: ActionTokenClaims,
}
#[derive(Clone)]
pub struct ActionTokenService {
jwt: Arc<JwtHandler>,
ttl_secs: i64,
}
impl std::fmt::Debug for ActionTokenService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ActionTokenService")
.field("ttl_secs", &self.ttl_secs)
.finish_non_exhaustive()
}
}
impl ActionTokenService {
pub fn new(jwt: Arc<JwtHandler>) -> Self {
Self {
jwt,
ttl_secs: DEFAULT_TOKEN_TTL_SECS,
}
}
pub fn with_ttl(mut self, ttl_secs: i64) -> GarrisonResult<Self> {
if ttl_secs < 0 {
return Err(GarrisonError::InvalidParam(format!(
"pwdreset-ttl-negative::{}",
ttl_secs
)));
}
self.ttl_secs = ttl_secs;
Ok(self)
}
pub fn issue(&self, subject: &str) -> GarrisonResult<IssuedActionToken> {
let now = unix_now()?;
let exp = now.checked_add(self.ttl_secs).ok_or_else(|| {
GarrisonError::InvalidParam(format!("pwdreset-ttl-overflow::{}", self.ttl_secs))
})?;
let claims = ActionTokenClaims {
sub: subject.to_string(),
purpose: PURPOSE_PASSWORD_RESET.to_string(),
jti: uuid::Uuid::new_v4().to_string(),
iat: now,
exp,
};
let token = self.jwt.sign_custom(&claims)?;
Ok(IssuedActionToken { token, claims })
}
pub fn verify(&self, token: &str) -> GarrisonResult<ActionTokenClaims> {
let claims: ActionTokenClaims = self.jwt.verify_custom(token)?;
if claims.purpose != PURPOSE_PASSWORD_RESET {
return Err(GarrisonError::InvalidToken(format!(
"action-token-purpose-mismatch::{}",
claims.purpose
)));
}
validate_jti(&claims.jti)?;
Ok(claims)
}
}
pub(crate) fn validate_jti(jti: &str) -> GarrisonResult<()> {
if jti.is_empty() || jti.len() > 64 || jti.contains(':') {
return Err(GarrisonError::InvalidToken(format!(
"action-token-jti-invalid::{}",
jti.len()
)));
}
Ok(())
}
pub(crate) fn unix_now() -> GarrisonResult<i64> {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.map_err(|e| GarrisonError::Internal(format!("pwdreset-system-clock::{}", e)))
}