auth_framework/auth_modular/mfa/
backup_codes.rs1use crate::errors::Result;
4use crate::storage::AuthStorage;
5use std::sync::Arc;
6use subtle::ConstantTimeEq;
7use tracing::{debug, info};
8
9pub struct BackupCodesManager {
11 storage: Arc<dyn AuthStorage>,
12}
13
14impl BackupCodesManager {
15 pub fn new(storage: Arc<dyn AuthStorage>) -> Self {
17 Self { storage }
18 }
19
20 pub async fn generate_codes(&self, user_id: &str, count: usize) -> Result<Vec<String>> {
22 debug!("Generating {} backup codes for user '{}'", count, user_id);
23
24 let codes: Vec<String> = (0..count)
25 .map(|_| format!("{:08}", rand::random::<u32>() % 100000000))
26 .collect();
27
28 let backup_key = format!("user:{}:backup_codes", user_id);
30 let codes_json = serde_json::to_string(&codes).unwrap_or("[]".to_string());
31 self.storage
32 .store_kv(&backup_key, codes_json.as_bytes(), None)
33 .await?;
34
35 info!("Generated {} backup codes for user '{}'", count, user_id);
36 Ok(codes)
37 }
38
39 pub async fn verify_code(&self, user_id: &str, code: &str) -> Result<bool> {
41 debug!("Verifying backup code for user '{}'", user_id);
42
43 if code.len() != 8 || !code.chars().all(|c| c.is_ascii_digit()) {
45 return Ok(false);
46 }
47
48 let backup_key = format!("user:{}:backup_codes", user_id);
50 if let Some(codes_data) = self.storage.get_kv(&backup_key).await? {
51 let codes_str = std::str::from_utf8(&codes_data).unwrap_or("[]");
52 let mut backup_codes: Vec<String> = serde_json::from_str(codes_str).unwrap_or_default();
53
54 if let Some(index) = backup_codes
55 .iter()
56 .position(|c| bool::from(c.as_bytes().ct_eq(code.as_bytes())))
57 {
58 backup_codes.remove(index);
60 let updated_codes =
61 serde_json::to_string(&backup_codes).unwrap_or("[]".to_string());
62 self.storage
63 .store_kv(&backup_key, updated_codes.as_bytes(), None)
64 .await?;
65
66 info!("Backup code verified and consumed for user '{}'", user_id);
67 Ok(true)
68 } else {
69 Ok(false)
70 }
71 } else {
72 Ok(false)
73 }
74 }
75
76 pub async fn get_remaining_count(&self, user_id: &str) -> Result<usize> {
78 debug!("Getting remaining backup codes for user '{}'", user_id);
79
80 let backup_key = format!("user:{}:backup_codes", user_id);
81 if let Some(codes_data) = self.storage.get_kv(&backup_key).await? {
82 let codes_str = std::str::from_utf8(&codes_data).unwrap_or("[]");
83 let backup_codes: Vec<String> = serde_json::from_str(codes_str).unwrap_or_default();
84 Ok(backup_codes.len())
85 } else {
86 Ok(0)
87 }
88 }
89
90 pub async fn has_backup_codes(&self, user_id: &str) -> Result<bool> {
92 let count = self.get_remaining_count(user_id).await?;
93 Ok(count > 0)
94 }
95
96 pub async fn regenerate_codes(&self, user_id: &str, count: usize) -> Result<Vec<String>> {
98 info!("Regenerating backup codes for user '{}'", user_id);
99
100 self.generate_codes(user_id, count).await
102 }
103
104 pub async fn verify_login_code(&self, user_id: &str, code: &str) -> Result<bool> {
108 use crate::security::secure_utils::constant_time_compare;
109 use sha2::Digest as _;
110
111 if code.trim().is_empty() {
112 return Ok(false);
113 }
114
115 let backup_key = format!("mfa_backup_codes:{}", user_id);
116 let codes: Vec<String> = match self.storage.get_kv(&backup_key).await? {
117 Some(data) => serde_json::from_slice(&data).unwrap_or_default(),
118 None => return Ok(false),
119 };
120
121 let provided_bytes = sha2::Sha256::digest(code.trim().as_bytes()).to_vec();
122
123 let mut found_idx: Option<usize> = None;
124 for (index, stored_hex) in codes.iter().enumerate() {
125 let stored_bytes = hex::decode(stored_hex).unwrap_or_default();
126 if stored_bytes.len() == provided_bytes.len()
127 && constant_time_compare(&stored_bytes, &provided_bytes)
128 {
129 found_idx = Some(index);
130 }
131 }
132
133 match found_idx {
134 Some(index) => {
135 let mut remaining = codes;
136 remaining.remove(index);
137 let updated = serde_json::to_vec(&remaining).unwrap_or_default();
138 self.storage.store_kv(&backup_key, &updated, None).await?;
139 Ok(true)
140 }
141 None => Ok(false),
142 }
143 }
144}