use super::rate_limiter::validate_phone;
use super::{GarrisonDao, GarrisonResult, SmsRateLimiter, SmsSender, SmsVerificationService};
use crate::error::GarrisonError;
use std::sync::Arc;
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);
}
self.rate_limiter.check_and_increment(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 {
self.rate_limiter.rollback(phone).await?;
return Err(e);
}
let unverified_key = format!("sms:unverified:{}", phone);
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(phone).await {
tracing::error!(error = %e, 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 = %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 {
self.rate_limiter.rollback(phone).await?;
self.dao.delete(&code_key).await?;
if let Err(e) = SmsRateLimiter::decrement_counter(&*self.dao, &unverified_key).await {
tracing::error!(error = %e, 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)?;
if constant_time_eq(&stored, code) {
self.dao.delete(&code_key).await?;
let unverified_key = format!("sms:unverified:{}", phone);
self.dao.delete(&unverified_key).await?;
let attempts_key = format!("sms:attempts:{}", phone);
self.dao.delete(&attempts_key).await?;
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(
"secure-sms-code-wrong::".to_string(),
))
}
}
}
}
pub(super) fn generate_code() -> GarrisonResult<String> {
use rand::rngs::OsRng;
use rand::Rng;
let code: u32 = OsRng.gen_range(100000..1000000);
Ok(format!("{:06}", code))
}
pub(super) fn constant_time_eq(a: &str, b: &str) -> bool {
if a.len() != b.len() {
return false;
}
let mut result: u8 = 0;
for (x, y) in a.bytes().zip(b.bytes()) {
result |= x ^ y;
}
result == 0
}