use super::rate_limiter::validate_phone;
use super::{GarrisonDao, GarrisonResult, SmsRateLimiter, SmsSender, SmsVerificationService};
use crate::error::GarrisonError;
use crate::secure::ct_eq::constant_time_eq;
use std::sync::Arc;
pub const ERR_SMS_CODE_WRONG: &str = "secure-sms-code-wrong";
impl SmsVerificationService {
pub fn new(
rate_limiter: SmsRateLimiter,
sender: Arc<dyn SmsSender>,
dao: Arc<dyn GarrisonDao>,
max_verify_attempts: u32,
unverified_threshold: u32,
) -> Self {
Self {
rate_limiter,
sender,
dao,
max_verify_attempts,
unverified_threshold,
}
}
pub async fn send_code(&self, phone: &str) -> GarrisonResult<()> {
validate_phone(phone)?;
let recycled_key = format!("sms:recycled:{}", phone);
if self.dao.get(&recycled_key).await?.is_some() {
return Err(GarrisonError::SmsChannelRecycled);
}
let windows = self.rate_limiter.check_and_increment_with(phone).await?;
let code = generate_code()?;
let code_key = format!("sms:code:{}", phone);
if let Err(e) = self.dao.set(&code_key, &code, 300).await {
if let Err(re) = self.rate_limiter.rollback_with(phone, &windows).await {
tracing::error!(
error = %re,
phone = %mask_phone(phone),
"rollback rate limiter counter failed after code store failure"
);
}
return Err(e);
}
let unverified_key = format!("sms:unverified:{}", phone);
let unverified_count = match self.dao.incr(&unverified_key, 86400).await {
Ok(count) => count,
Err(e) => {
if let Err(re) = self.rate_limiter.rollback_with(phone, &windows).await {
tracing::error!(
error = %re,
phone = %mask_phone(phone),
"rollback rate limiter counter failed after unverified incr failure"
);
}
if let Err(re) = self.dao.delete(&code_key).await {
tracing::error!(
error = %re,
key = %code_key,
"delete stored code failed after unverified incr failure"
);
}
return Err(e);
},
};
if unverified_count > self.unverified_threshold as u64 {
if let Err(e) = self.rate_limiter.rollback_with(phone, &windows).await {
tracing::error!(
error = %e,
phone = %mask_phone(phone),
"rollback rate limiter counter failed during channel recycling"
);
}
if let Err(e) = SmsRateLimiter::decrement_counter(&*self.dao, &unverified_key).await {
tracing::error!(
error = %e,
key = %mask_phone_in_key(&unverified_key),
"rollback unverified counter failed"
);
}
self.dao.set(&recycled_key, "1", 86400).await?;
return Err(GarrisonError::SmsChannelRecycled);
}
if let Err(e) = self.sender.send(phone, &code).await {
if let Err(re) = self.rate_limiter.rollback_with(phone, &windows).await {
tracing::error!(
error = %re,
phone = %mask_phone(phone),
"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) = SmsRateLimiter::decrement_counter(&*self.dao, &unverified_key).await {
tracing::error!(
error = %re,
key = %mask_phone_in_key(&unverified_key),
"rollback unverified counter failed after send failure"
);
}
return Err(e);
}
Ok(())
}
pub async fn verify_code(&self, phone: &str, code: &str) -> GarrisonResult<()> {
validate_phone(phone)?;
let code_key = format!("sms:code:{}", phone);
let stored = self.dao.get(&code_key).await?;
let stored = stored.ok_or(GarrisonError::SmsCodeNotFound)?;
let matched = code.len() == 6 && constant_time_eq(stored.as_bytes(), code.as_bytes());
if matched {
let mut first_err: Option<GarrisonError> = None;
if let Err(e) = self.dao.delete(&code_key).await {
first_err.get_or_insert(e);
}
let unverified_key = format!("sms:unverified:{}", phone);
if let Err(e) = self.dao.delete(&unverified_key).await {
first_err.get_or_insert(e);
}
let attempts_key = format!("sms:attempts:{}", phone);
if let Err(e) = self.dao.delete(&attempts_key).await {
first_err.get_or_insert(e);
}
match first_err {
Some(e) => Err(e),
None => Ok(()),
}
} else {
let attempts_key = format!("sms:attempts:{}", phone);
let attempts = self.dao.incr(&attempts_key, 300).await?;
if attempts > self.max_verify_attempts as u64 {
self.dao.delete(&code_key).await?;
self.dao.delete(&attempts_key).await?;
Err(GarrisonError::SmsVerifyMaxAttempts)
} else {
Err(GarrisonError::InvalidParam(format!(
"{ERR_SMS_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))
}
pub(super) fn mask_phone(phone: &str) -> String {
let chars: Vec<char> = phone.chars().collect();
if chars.len() < 7 {
return "*".repeat(chars.len());
}
let prefix: String = chars[..3].iter().collect();
let suffix: String = chars[chars.len() - 4..].iter().collect();
let stars = "*".repeat(chars.len() - 7);
format!("{prefix}{stars}{suffix}")
}
pub(super) fn mask_phone_in_key(key: &str) -> String {
match key.rsplit_once(':') {
Some((prefix, phone)) => format!("{}:{}", prefix, mask_phone(phone)),
None => mask_phone(key),
}
}