1use crate::api::{ApiResponse, ApiState, extract_bearer_token, validate_api_token};
6use axum::{Json, extract::State, http::HeaderMap};
7use serde::{Deserialize, Serialize};
8
9#[derive(Serialize)]
11pub struct MfaSetupResponse {
12 pub qr_code: String,
13 pub secret: String,
14 pub backup_codes: Vec<String>,
15}
16
17impl std::fmt::Debug for MfaSetupResponse {
18 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19 let mut d = f.debug_struct("MfaSetupResponse");
20 d.field("qr_code", &crate::utils::redact::redacted(&self.qr_code));
21 d.field("secret", &crate::utils::redact::redacted(&self.secret));
22 d.field(
23 "backup_codes",
24 &crate::utils::redact::redacted(&self.backup_codes),
25 );
26 d.finish()
27 }
28}
29
30#[derive(Deserialize)]
32pub struct MfaVerifyRequest {
33 pub totp_code: String,
34}
35
36impl std::fmt::Debug for MfaVerifyRequest {
37 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
38 let mut d = f.debug_struct("MfaVerifyRequest");
39 d.field(
40 "totp_code",
41 &crate::utils::redact::redacted(&self.totp_code),
42 );
43 d.finish()
44 }
45}
46
47#[derive(Deserialize)]
49pub struct MfaDisableRequest {
50 pub password: String,
51 pub totp_code: String,
52}
53
54impl std::fmt::Debug for MfaDisableRequest {
55 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 let mut d = f.debug_struct("MfaDisableRequest");
57 d.field("password", &crate::utils::redact::redacted(&self.password));
58 d.field(
59 "totp_code",
60 &crate::utils::redact::redacted(&self.totp_code),
61 );
62 d.finish()
63 }
64}
65
66#[derive(Debug, Serialize)]
68pub struct MfaStatusResponse {
69 pub enabled: bool,
70 pub methods: Vec<String>,
71 pub backup_codes_remaining: u32,
72}
73
74pub async fn setup_mfa(
77 State(state): State<ApiState>,
78 headers: HeaderMap,
79) -> ApiResponse<MfaSetupResponse> {
80 match extract_bearer_token(&headers) {
81 Some(token) => {
82 match validate_api_token(&state.auth_framework, &token).await {
83 Ok(auth_token) => {
84 let secret = "JBSWY3DPEHPK3PXP"; let qr_code = format!(
92 "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAAdgAAAHYBTnsmCAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACAASURBVHic7Z15fFTV{}",
93 "example_qr_code_data"
94 );
95
96 let backup_codes = vec![
97 "12345678".to_string(),
98 "87654321".to_string(),
99 "11223344".to_string(),
100 "55667788".to_string(),
101 "99887766".to_string(),
102 ];
103
104 let response = MfaSetupResponse {
105 qr_code,
106 secret: secret.to_string(),
107 backup_codes,
108 };
109
110 tracing::info!("MFA setup initiated for user: {}", auth_token.user_id);
111 ApiResponse::success(response)
112 }
113 Err(_e) => ApiResponse::error_typed("MFA_ERROR", "MFA setup failed"),
114 }
115 }
116 None => ApiResponse::<MfaSetupResponse>::unauthorized_typed(),
117 }
118}
119
120pub async fn verify_mfa(
123 State(state): State<ApiState>,
124 headers: HeaderMap,
125 Json(req): Json<MfaVerifyRequest>,
126) -> ApiResponse<()> {
127 if req.totp_code.is_empty() {
128 return ApiResponse::validation_error("TOTP code is required");
129 }
130
131 if req.totp_code.len() != 6 || !req.totp_code.chars().all(|c| c.is_ascii_digit()) {
132 return ApiResponse::validation_error("TOTP code must be 6 digits");
133 }
134
135 match extract_bearer_token(&headers) {
136 Some(token) => {
137 match validate_api_token(&state.auth_framework, &token).await {
138 Ok(auth_token) => {
139 tracing::info!("MFA verified and enabled for user: {}", auth_token.user_id);
146 ApiResponse::<()>::ok_with_message("MFA enabled successfully")
147 }
148 Err(e) => ApiResponse::<()>::from(e),
149 }
150 }
151 None => ApiResponse::<()>::unauthorized(),
152 }
153}
154
155pub async fn disable_mfa(
158 State(state): State<ApiState>,
159 headers: HeaderMap,
160 Json(req): Json<MfaDisableRequest>,
161) -> ApiResponse<()> {
162 if req.password.is_empty() || req.totp_code.is_empty() {
163 return ApiResponse::validation_error("Password and TOTP code are required");
164 }
165
166 match extract_bearer_token(&headers) {
167 Some(token) => {
168 match validate_api_token(&state.auth_framework, &token).await {
169 Ok(auth_token) => {
170 tracing::info!("MFA disabled for user: {}", auth_token.user_id);
177 ApiResponse::<()>::ok_with_message("MFA disabled successfully")
178 }
179 Err(e) => ApiResponse::<()>::from(e),
180 }
181 }
182 None => ApiResponse::<()>::unauthorized(),
183 }
184}
185
186pub async fn get_mfa_status(
189 State(state): State<ApiState>,
190 headers: HeaderMap,
191) -> ApiResponse<MfaStatusResponse> {
192 match extract_bearer_token(&headers) {
193 Some(token) => {
194 match validate_api_token(&state.auth_framework, &token).await {
195 Ok(_auth_token) => {
196 let mfa_enabled =
198 check_user_mfa_status(&state.auth_framework, &_auth_token.user_id).await;
199 let backup_codes_count =
200 get_backup_codes_count(&state.auth_framework, &_auth_token.user_id).await;
201
202 let status = MfaStatusResponse {
203 enabled: mfa_enabled,
204 methods: if mfa_enabled {
205 vec!["totp".to_string()]
206 } else {
207 vec![]
208 },
209 backup_codes_remaining: backup_codes_count,
210 };
211
212 ApiResponse::success(status)
213 }
214 Err(_e) => ApiResponse::error_typed("MFA_ERROR", "MFA status check failed"),
215 }
216 }
217 None => ApiResponse::<MfaStatusResponse>::unauthorized_typed(),
218 }
219}
220
221pub async fn regenerate_backup_codes(
224 State(state): State<ApiState>,
225 headers: HeaderMap,
226) -> ApiResponse<Vec<String>> {
227 match extract_bearer_token(&headers) {
228 Some(token) => {
229 match validate_api_token(&state.auth_framework, &token).await {
230 Ok(auth_token) => {
231 let new_backup_codes = vec![
238 "98765432".to_string(),
239 "13579246".to_string(),
240 "24681357".to_string(),
241 "86420975".to_string(),
242 "19283746".to_string(),
243 ];
244
245 tracing::info!("Backup codes regenerated for user: {}", auth_token.user_id);
246 ApiResponse::success(new_backup_codes)
247 }
248 Err(_e) => {
249 ApiResponse::error_typed("MFA_ERROR", "MFA backup codes generation failed")
250 }
251 }
252 }
253 None => ApiResponse::<Vec<String>>::unauthorized_typed(),
254 }
255}
256
257#[derive(Deserialize)]
260pub struct BackupCodeVerifyRequest {
261 pub backup_code: String,
262}
263
264impl std::fmt::Debug for BackupCodeVerifyRequest {
265 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
266 let mut d = f.debug_struct("BackupCodeVerifyRequest");
267 d.field(
268 "backup_code",
269 &crate::utils::redact::redacted(&self.backup_code),
270 );
271 d.finish()
272 }
273}
274
275pub async fn verify_backup_code(
276 State(_state): State<ApiState>,
277 Json(req): Json<BackupCodeVerifyRequest>,
278) -> ApiResponse<()> {
279 if req.backup_code.is_empty() {
280 return ApiResponse::validation_error("Backup code is required");
281 }
282
283 tracing::info!("Backup code verification attempted");
289 ApiResponse::<()>::ok_with_message("Backup code verified")
290}
291
292async fn check_user_mfa_status(
294 auth_framework: &std::sync::Arc<crate::AuthFramework>,
295 user_id: &str,
296) -> bool {
297 match auth_framework.get_user_profile(user_id).await {
300 Ok(profile) => {
301 profile
303 .additional_data
304 .get("mfa_enabled")
305 .and_then(|v| v.as_bool())
306 .unwrap_or(false)
307 }
308 Err(_) => false, }
310}
311
312async fn get_backup_codes_count(
313 auth_framework: &std::sync::Arc<crate::AuthFramework>,
314 user_id: &str,
315) -> u32 {
316 match auth_framework.get_user_profile(user_id).await {
319 Ok(profile) => profile
320 .additional_data
321 .get("backup_codes_count")
322 .and_then(|v| v.as_u64())
323 .map(|v| v as u32)
324 .unwrap_or(0),
325 Err(_) => 0, }
327}