use super::rate_limiter::{normalize_email, validate_email};
use super::{EmailRateLimiter, EmailSender, EmailVerificationService, GarrisonDao, GarrisonResult};
use crate::error::GarrisonError;
use crate::secure::ct_eq::constant_time_eq;
use std::sync::Arc;
pub const ERR_EMAIL_CODE_WRONG: &str = "secure-email-code-wrong";
impl EmailVerificationService {
pub fn new(
rate_limiter: EmailRateLimiter,
sender: Arc<dyn EmailSender>,
dao: Arc<dyn GarrisonDao>,
max_verify_attempts: u32,
unverified_threshold: u32,
code_ttl: u64,
) -> Self {
Self {
rate_limiter,
sender,
dao,
max_verify_attempts,
unverified_threshold,
code_ttl,
}
}
pub async fn send_code(&self, email: &str) -> GarrisonResult<()> {
let normalized = normalize_email(email);
validate_email(&normalized)?;
let recycled_key = format!("email:recycled:{}", normalized);
if self.dao.get(&recycled_key).await?.is_some() {
return Err(GarrisonError::EmailChannelRecycled);
}
let windows = self
.rate_limiter
.check_and_increment_inner(&normalized)
.await?;
let code = generate_code()?;
let code_key = format!("email:code:{}", normalized);
let ttl = self.code_ttl;
if let Err(e) = self.dao.set(&code_key, &code, ttl).await {
if let Err(re) = self
.rate_limiter
.rollback_inner_with(&normalized, &windows)
.await
{
tracing::error!(
error = %re,
email = mask_email_for_log(&normalized),
"rollback rate limiter counter failed after code store failure"
);
}
return Err(e);
}
let unverified_key = format!("email:unverified:{}", normalized);
let unverified_count = self.dao.incr(&unverified_key, 86400).await?;
if unverified_count > self.unverified_threshold as u64 {
if let Err(e) = self
.rate_limiter
.rollback_inner_with(&normalized, &windows)
.await
{
tracing::error!(error = %e, email = mask_email_for_log(&normalized), "rollback rate limiter counter failed during channel recycling");
}
if let Err(e) = EmailRateLimiter::decrement_counter(&*self.dao, &unverified_key).await {
tracing::error!(error = %e, key = %unverified_key, "rollback unverified counter failed");
}
self.dao.set(&recycled_key, "1", 86400).await?;
return Err(GarrisonError::EmailChannelRecycled);
}
let subject = crate::i18n::translate_detail("secure-email-code-mail-subject", &[]);
let minutes = (self.code_ttl / 60).to_string();
let body = crate::i18n::translate_detail(
"secure-email-code-mail-body",
&[("code", code.as_str()), ("minutes", minutes.as_str())],
);
if let Err(e) = self.sender.send(&normalized, &subject, &body).await {
if let Err(re) = self
.rate_limiter
.rollback_inner_with(&normalized, &windows)
.await
{
tracing::error!(error = %re, email = mask_email_for_log(&normalized), "rollback rate limiter counter failed after send failure");
}
if let Err(re) = self.dao.delete(&code_key).await {
tracing::error!(error = %re, key = %code_key, "delete code failed after send failure");
}
if let Err(re) = EmailRateLimiter::decrement_counter(&*self.dao, &unverified_key).await
{
tracing::error!(error = %re, key = %unverified_key, "rollback unverified counter failed after send failure");
}
return Err(e);
}
Ok(())
}
pub async fn verify_code(&self, email: &str, code: &str) -> GarrisonResult<()> {
let normalized = normalize_email(email);
validate_email(&normalized)?;
let code_key = format!("email:code:{}", normalized);
let stored = self.dao.get(&code_key).await?;
let stored = stored.ok_or(GarrisonError::EmailCodeNotFound)?;
let matched = code.len() == 6 && constant_time_eq(stored.as_bytes(), code.as_bytes());
if matched {
self.dao.delete(&code_key).await?;
let unverified_key = format!("email:unverified:{}", normalized);
self.dao.delete(&unverified_key).await?;
let attempts_key = format!("email:attempts:{}", normalized);
self.dao.delete(&attempts_key).await?;
Ok(())
} else {
let attempts_key = format!("email:attempts:{}", normalized);
let attempts = self.dao.incr(&attempts_key, self.code_ttl).await?;
if attempts > self.max_verify_attempts as u64 {
self.dao.delete(&code_key).await?;
self.dao.delete(&attempts_key).await?;
Err(GarrisonError::EmailVerifyMaxAttempts)
} else {
Err(GarrisonError::InvalidParam(format!(
"{ERR_EMAIL_CODE_WRONG}::"
)))
}
}
}
}
pub(super) fn generate_code() -> GarrisonResult<String> {
use rand::RngExt;
let code: u32 = rand::rng().random_range(100000..1000000);
Ok(format!("{:06}", code))
}
fn mask_email_for_log(email: &str) -> String {
match email.find('@') {
Some(at_pos) if at_pos > 0 => {
let first = email[..at_pos].chars().next().unwrap_or('*');
format!("{first}***{}", &email[at_pos..])
},
_ => "*".repeat(email.chars().count()),
}
}