1use crate::api::{ApiResponse, ApiState, extract_bearer_token, validate_api_token};
21use axum::{Json, extract::State, http::HeaderMap};
22use ring::rand::SecureRandom;
23use serde::{Deserialize, Serialize};
24use std::time::Duration;
25
26#[async_trait::async_trait]
33pub trait EmailVerificationSender: Send + Sync {
34 async fn send_verification_token(
36 &self,
37 email: &str,
38 user_id: &str,
39 token: &str,
40 ) -> crate::errors::Result<()>;
41}
42
43const VERIFICATION_TOKEN_TTL: Duration = Duration::from_secs(24 * 60 * 60);
45
46const VERIFY_KEY_PREFIX: &str = "email_verify:";
48
49#[derive(Debug, Serialize)]
51pub struct VerificationSentResponse {
52 pub sent: bool,
54 pub message: String,
56}
57
58const GENERIC_SENT_MESSAGE: &str = "If an account with that email exists and is not yet verified, a verification message has been sent.";
59
60fn generic_sent() -> ApiResponse<VerificationSentResponse> {
61 ApiResponse::success(VerificationSentResponse {
62 sent: true,
63 message: GENERIC_SENT_MESSAGE.to_string(),
64 })
65}
66
67async fn issue_and_deliver(
70 state: &ApiState,
71 user_id: &str,
72 email: &str,
73) -> Result<(), &'static str> {
74 let token = generate_verification_token().map_err(|_| "token generation failed")?;
75 let verify_key = format!("{VERIFY_KEY_PREFIX}{token}");
76 let binding = serde_json::json!({ "user_id": user_id, "email": email });
79 state
80 .auth_framework
81 .storage()
82 .store_kv(
83 &verify_key,
84 binding.to_string().as_bytes(),
85 Some(VERIFICATION_TOKEN_TTL),
86 )
87 .await
88 .map_err(|_| "token storage failed")?;
89 match &state.email_verification_sender {
90 Some(sender) => {
91 let sender = sender.clone();
94 let (email, user_id) = (email.to_string(), user_id.to_string());
95 tokio::spawn(async move {
96 if sender
97 .send_verification_token(&email, &user_id, &token)
98 .await
99 .is_err()
100 {
101 tracing::error!(user_id, "Verification message could not be delivered");
103 }
104 });
105 }
106 None => tracing::warn!(
107 user_id,
108 "No EmailVerificationSender configured; verification token cannot be delivered"
109 ),
110 }
111 Ok(())
112}
113
114#[derive(Deserialize)]
116pub struct VerifyEmailRequest {
117 pub token: String,
119}
120
121impl std::fmt::Debug for VerifyEmailRequest {
122 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
123 let mut d = f.debug_struct("VerifyEmailRequest");
124 d.field("token", &crate::utils::redact::redacted(&self.token));
125 d.finish()
126 }
127}
128
129#[derive(Debug, Deserialize)]
131pub struct ResendVerificationRequest {
132 pub email: String,
134}
135
136fn generate_verification_token() -> Result<String, crate::errors::AuthError> {
138 let rng = ring::rand::SystemRandom::new();
139 let mut buf = [0u8; 32];
140 rng.fill(&mut buf)
141 .map_err(|_| crate::errors::AuthError::crypto("Failed to generate verification token"))?;
142 Ok(base64::Engine::encode(
143 &base64::engine::general_purpose::URL_SAFE_NO_PAD,
144 buf,
145 ))
146}
147
148pub async fn send_verification(
153 State(state): State<ApiState>,
154 headers: HeaderMap,
155) -> ApiResponse<VerificationSentResponse> {
156 let token = match extract_bearer_token(&headers) {
157 Some(t) => t,
158 None => {
159 return ApiResponse::error_typed("AUTH_REQUIRED", "Bearer token required");
160 }
161 };
162
163 let auth_token = match validate_api_token(&state.auth_framework, &token).await {
164 Ok(t) => t,
165 Err(_) => {
166 return ApiResponse::error_typed("INVALID_TOKEN", "Invalid or expired token");
167 }
168 };
169
170 let user_id = &auth_token.user_id;
171
172 let user_key = format!("user:{user_id}");
174 let user_bytes = match state.auth_framework.storage().get_kv(&user_key).await {
175 Ok(Some(b)) => b,
176 _ => {
177 return ApiResponse::error_typed("USER_NOT_FOUND", "User not found");
178 }
179 };
180 let user_json: serde_json::Value = match serde_json::from_slice(&user_bytes) {
181 Ok(v) => v,
182 Err(_) => {
183 return ApiResponse::error_typed("INTERNAL_ERROR", "Failed to read user record");
184 }
185 };
186
187 if user_json
188 .get("email_verified")
189 .and_then(|v| v.as_bool())
190 .unwrap_or(false)
191 {
192 return ApiResponse::success(VerificationSentResponse {
193 sent: false,
194 message: "Email is already verified".to_string(),
195 });
196 }
197
198 let email = match user_json.get("email").and_then(|v| v.as_str()) {
199 Some(e) if !e.is_empty() => e.to_string(),
200 _ => return ApiResponse::error_typed("INTERNAL_ERROR", "User has no email address"),
201 };
202 if issue_and_deliver(&state, user_id, &email).await.is_err() {
203 return ApiResponse::error_typed("INTERNAL_ERROR", "Failed to create verification token");
204 }
205 generic_sent()
206}
207
208pub async fn verify_email(
214 State(state): State<ApiState>,
215 Json(body): Json<VerifyEmailRequest>,
216) -> ApiResponse<serde_json::Value> {
217 if body.token.is_empty() {
218 return ApiResponse::error_typed("VALIDATION_ERROR", "Verification token is required");
219 }
220
221 let verify_key = format!("{VERIFY_KEY_PREFIX}{}", body.token);
223 let binding_bytes = match state.auth_framework.storage().get_kv(&verify_key).await {
224 Ok(Some(b)) => b,
225 Ok(None) => {
226 return ApiResponse::error_typed(
227 "INVALID_TOKEN",
228 "Verification token is invalid or expired",
229 );
230 }
231 Err(_) => {
232 return ApiResponse::error_typed("INTERNAL_ERROR", "Failed to look up token");
233 }
234 };
235
236 let binding: serde_json::Value = match serde_json::from_slice(&binding_bytes) {
239 Ok(v) => v,
240 Err(_) => {
241 return ApiResponse::error_typed(
242 "INVALID_TOKEN",
243 "Verification token is invalid or expired",
244 );
245 }
246 };
247 let (Some(user_id), Some(bound_email)) = (
248 binding["user_id"].as_str().map(String::from),
249 binding["email"].as_str().map(String::from),
250 ) else {
251 return ApiResponse::error_typed(
252 "INVALID_TOKEN",
253 "Verification token is invalid or expired",
254 );
255 };
256
257 let user_key = format!("user:{user_id}");
259 let user_bytes = match state.auth_framework.storage().get_kv(&user_key).await {
260 Ok(Some(b)) => b,
261 _ => {
262 return ApiResponse::error_typed("USER_NOT_FOUND", "User not found");
263 }
264 };
265
266 let mut user_json: serde_json::Value = match serde_json::from_slice(&user_bytes) {
267 Ok(v) => v,
268 Err(_) => {
269 return ApiResponse::error_typed("INTERNAL_ERROR", "Failed to read user record");
270 }
271 };
272
273 if user_json["email"].as_str() != Some(bound_email.as_str()) {
275 let _ = state.auth_framework.storage().delete_kv(&verify_key).await;
276 return ApiResponse::error_typed(
277 "INVALID_TOKEN",
278 "Verification token is invalid or expired",
279 );
280 }
281
282 user_json["email_verified"] = serde_json::Value::Bool(true);
283
284 if state
285 .auth_framework
286 .storage()
287 .store_kv(&user_key, user_json.to_string().as_bytes(), None)
288 .await
289 .is_err()
290 {
291 return ApiResponse::error_typed("INTERNAL_ERROR", "Failed to update user record");
292 }
293
294 let _ = state.auth_framework.storage().delete_kv(&verify_key).await;
296
297 ApiResponse::success(serde_json::json!({
298 "verified": true,
299 "user_id": user_id,
300 "message": "Email address verified successfully"
301 }))
302}
303
304pub async fn resend_verification(
310 State(state): State<ApiState>,
311 Json(body): Json<ResendVerificationRequest>,
312) -> ApiResponse<VerificationSentResponse> {
313 if body.email.is_empty() {
314 return ApiResponse::error_typed("VALIDATION_ERROR", "Email address is required");
315 }
316
317 let email_key = format!("user:email:{}", body.email);
320 let Ok(Some(id_bytes)) = state.auth_framework.storage().get_kv(&email_key).await else {
321 return generic_sent();
322 };
323 let Ok(user_id) = String::from_utf8(id_bytes) else {
324 return generic_sent();
325 };
326 let Ok(Some(user_bytes)) = state
327 .auth_framework
328 .storage()
329 .get_kv(&format!("user:{user_id}"))
330 .await
331 else {
332 return generic_sent();
333 };
334 let Ok(user_json) = serde_json::from_slice::<serde_json::Value>(&user_bytes) else {
335 return generic_sent();
336 };
337 if user_json
338 .get("email_verified")
339 .and_then(|v| v.as_bool())
340 .unwrap_or(false)
341 {
342 return generic_sent();
343 }
344
345 if user_json.get("email").and_then(|v| v.as_str()) != Some(body.email.as_str()) {
348 return generic_sent();
349 }
350 if issue_and_deliver(&state, &user_id, &body.email)
351 .await
352 .is_err()
353 {
354 tracing::error!(user_id, "Could not create a verification token");
355 }
356 generic_sent()
357}
358
359#[cfg(test)]
360mod tests {
361 use super::*;
362
363 #[test]
364 fn test_generate_verification_token() {
365 let token1 = generate_verification_token().expect("should generate token");
366 let token2 = generate_verification_token().expect("should generate token");
367 assert_ne!(token1, token2);
369 assert_eq!(token1.len(), 43);
371 assert!(!token1.contains('+'));
373 assert!(!token1.contains('/'));
374 }
375
376 #[test]
377 fn test_verification_token_ttl() {
378 assert_eq!(VERIFICATION_TOKEN_TTL.as_secs(), 86400);
379 }
380}