//! Email one-time-code sign-in. Delivery is replaced by an in-memory recorder: no SMTP //! connection is opened and no message ever leaves the process. use axum::{ Router, body::{Body, to_bytes}, http::{Request, Response, StatusCode}, }; use serde_json::{Value, json}; use std::{ future::Future, pin::Pin, sync::{Arc, Mutex}, }; use tower::ServiceExt; use vnox_hub::{ auth::{ self, email::{CodeSender, EmailAuth, EmailLimits}, provider::GitHubProfile, store, }, database, identity::Issuer, mail::templates::Email, web::{self, HubState}, }; const ORIGIN: &str = "https://central.loki-code.dev"; #[derive(Default)] struct Recorder { sent: Mutex>, fail: bool, } impl CodeSender for Recorder { fn send<'a>( &'a self, recipient: &'a str, email: Email, ) -> Pin> + Send + 'a>> { Box::pin(async move { if self.fail { anyhow::bail!("simulated outage"); } self.sent .lock() .unwrap() .push((recipient.to_owned(), email)); Ok(()) }) } } impl Recorder { fn last_code(&self) -> String { let sent = self.sent.lock().unwrap(); let text = &sent.last().expect("a message was recorded").1.text; let digits: Vec<&str> = text .split(|c: char| !c.is_ascii_digit()) .filter(|part| part.len() == 8) .collect(); assert_eq!(digits.len(), 1, "exactly one code in the message"); digits[0].to_owned() } fn count(&self) -> usize { self.sent.lock().unwrap().len() } } struct Harness { _dir: tempfile::TempDir, state: Arc, app: Router, mail: Arc, } async fn harness_with(limits: EmailLimits, fail: bool, enabled: bool) -> Harness { let dir = tempfile::tempdir().unwrap(); #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(dir.path(), std::fs::Permissions::from_mode(0o700)).unwrap(); } let issuer = Issuer::load_or_create(dir.path()).unwrap(); let pool = database::open(dir.path(), &issuer).await.unwrap(); let mail = Arc::new(Recorder { fail, ..Default::default() }); let mut auth = auth::AuthService::with_provider(pool.clone(), url::Url::parse(ORIGIN).unwrap(), None); if enabled { let mut email = EmailAuth::new([42; 32], mail.clone()); email.limits = limits; auth = auth.with_email(email); } let state = Arc::new(HubState { database: pool, auth: Arc::new(auth), issuer, smtp_configured: enabled, started: std::time::Instant::now(), }); Harness { _dir: dir, app: web::router(state.clone()), state, mail, } } fn relaxed() -> EmailLimits { EmailLimits { address_cooldown: 0, per_address_hour: 1000, per_source_hour: 1000, global_hour: 1000, global_resend_reserve: 0, } } async fn harness() -> Harness { harness_with(relaxed(), false, true).await } struct Post<'a> { path: &'a str, body: Value, cookie: Option<&'a str>, origin: Option<&'a str>, ip: &'a str, } fn post<'a>(path: &'a str, body: Value) -> Post<'a> { Post { path, body, cookie: None, origin: Some(ORIGIN), ip: "198.51.100.7", } } impl Post<'_> { fn request(&self) -> Request { let mut builder = Request::builder() .method("POST") .uri(self.path) .header("content-type", "application/json") .header("x-forwarded-for", self.ip); if let Some(origin) = self.origin { builder = builder.header("origin", origin); } if let Some(cookie) = self.cookie { builder = builder.header("cookie", cookie); } builder.body(Body::from(self.body.to_string())).unwrap() } } async fn send(app: &Router, request: Request) -> (StatusCode, Vec, String) { let response: Response = app.clone().oneshot(request).await.unwrap(); let status = response.status(); let cookies = response .headers() .get_all("set-cookie") .iter() .map(|v| v.to_str().unwrap().to_owned()) .collect(); let body = String::from_utf8( to_bytes(response.into_body(), 65536) .await .unwrap() .to_vec(), ) .unwrap(); (status, cookies, body) } fn pair(cookies: &[String], name: &str) -> String { cookies .iter() .find(|c| c.starts_with(&format!("{name}="))) .unwrap_or_else(|| panic!("{name} cookie missing")) .split(';') .next() .unwrap() .to_owned() } /// Requests a code; returns the browser-binding cookie pair. async fn start(h: &Harness, email: &str) -> String { let (status, cookies, _) = send( &h.app, post("/v1/auth/email/start", json!({"email": email})).request(), ) .await; assert_eq!(status, StatusCode::ACCEPTED); pair(&cookies, "__Host-vnox_email") } async fn verify( h: &Harness, cookie: Option<&str>, email: &str, code: &str, ) -> (StatusCode, Vec, String) { let mut request = post( "/v1/auth/email/verify", json!({"email": email, "code": code}), ); request.cookie = cookie; send(&h.app, request.request()).await } #[tokio::test] async fn full_flow_creates_neutral_account_and_session() { let h = harness().await; let (status, cookies, body) = send( &h.app, post( "/v1/auth/email/start", json!({"email": " Alice.Secret@Example.COM "}), ) .request(), ) .await; assert_eq!(status, StatusCode::ACCEPTED); let browser_cookie = cookies .iter() .find(|c| c.starts_with("__Host-vnox_email=")) .unwrap(); for attribute in [ "Secure", "HttpOnly", "SameSite=Lax", "Path=/", "Max-Age=600", ] { assert!(browser_cookie.contains(attribute), "{attribute}"); } assert!(!browser_cookie.contains("Domain")); let browser = pair(&cookies, "__Host-vnox_email"); let code = h.mail.last_code(); // The code reaches the user only by mail, never in any part of the HTTP response. assert!(!body.contains(&code)); assert!(!cookies.iter().any(|c| c.contains(&code))); { let sent = h.mail.sent.lock().unwrap(); assert_eq!(sent[0].0, "alice.secret@example.com"); // Only the bare site origin appears (footer); no link carries a path, query or code. let html = &sent[0].1.html; assert_eq!(html.matches("href=\"").count(), 1); assert!(html.contains(&format!("href=\"{ORIGIN}\""))); for url in sent[0] .1 .text .split_whitespace() .filter(|w| w.starts_with("http")) { assert_eq!(url, ORIGIN); } assert!(!html.contains(&format!("{ORIGIN}/")) || html.contains("/assets/vnox-mark.png")); } // Only keyed MACs are stored. let row: (String, String) = sqlx::query_as("SELECT email_mac,code_mac FROM email_attempts") .fetch_one(&h.state.database) .await .unwrap(); assert_ne!(row.1, store::hash(&code)); assert_ne!(row.1, code); assert!(!row.0.contains("alice")); let (status, cookies, body) = verify(&h, Some(&browser), "alice.secret@example.com ", &code).await; assert_eq!(status, StatusCode::OK, "{body}"); let session_cookie = cookies .iter() .find(|c| c.starts_with("__Host-vnox_session=")) .unwrap(); for attribute in [ "Secure", "HttpOnly", "SameSite=Lax", "Path=/", "Max-Age=604800", ] { assert!(session_cookie.contains(attribute), "{attribute}"); } let json: Value = serde_json::from_str(&body).unwrap(); assert_eq!(json["authenticated"], true); assert_eq!(json["user"]["display_name"], "Vnox user"); let handle = json["user"]["handle"].as_str().unwrap(); assert!(handle.starts_with("u_") && !handle.contains("alice")); assert!(!body.to_lowercase().contains("alice")); assert!(!json["csrf_token"].as_str().unwrap().is_empty()); // The same session endpoint now reports the user, with the same format. let (status, _, session_body) = send( &h.app, Request::builder() .uri("/v1/auth/session") .header("cookie", pair(&cookies, "__Host-vnox_session")) .body(Body::empty()) .unwrap(), ) .await; assert_eq!(status, StatusCode::OK); let session: Value = serde_json::from_str(&session_body).unwrap(); assert_eq!(session, json); let identity: (String, String) = sqlx::query_as("SELECT provider,subject FROM external_identities") .fetch_one(&h.state.database) .await .unwrap(); assert_eq!( identity, ("email".into(), "alice.secret@example.com".into()) ); let ttl: i64 = sqlx::query_scalar("SELECT expires_at-created_at FROM web_sessions") .fetch_one(&h.state.database) .await .unwrap(); assert_eq!(ttl, 7 * 24 * 60 * 60); // Same address signs in again to the same account. let again = start(&h, "ALICE.secret@example.com").await; let code = h.mail.last_code(); let (_, _, body) = verify(&h, Some(&again), "alice.secret@example.com", &code).await; let second: Value = serde_json::from_str(&body).unwrap(); assert_eq!(second["user"]["user_id"], json["user"]["user_id"]); } #[tokio::test] async fn wrong_code_is_rejected_and_attempts_are_exhausted() { let h = harness().await; let browser = start(&h, "a@example.com").await; let code = h.mail.last_code(); let wrong = if code == "00000000" { "11111111" } else { "00000000" }; for _ in 0..4 { let (status, cookies, body) = verify(&h, Some(&browser), "a@example.com", wrong).await; assert_eq!(status, StatusCode::BAD_REQUEST); assert!(body.contains("invalid_code")); assert!(!cookies.iter().any(|c| c.starts_with("__Host-vnox_session"))); } // The fifth try uses the last allowed attempt; a wrong guess burns it ... let (status, ..) = verify(&h, Some(&browser), "a@example.com", wrong).await; assert_eq!(status, StatusCode::BAD_REQUEST); // ... so even the correct code is now refused, with the same answer. let (status, _, body) = verify(&h, Some(&browser), "a@example.com", &code).await; assert_eq!(status, StatusCode::BAD_REQUEST); assert!(body.contains("invalid_code")); assert_eq!( sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM accounts") .fetch_one(&h.state.database) .await .unwrap(), 0 ); } #[tokio::test] async fn correct_code_still_works_after_some_failures() { let h = harness().await; let browser = start(&h, "a@example.com").await; let code = h.mail.last_code(); let wrong = if code == "00000000" { "11111111" } else { "00000000" }; for _ in 0..4 { verify(&h, Some(&browser), "a@example.com", wrong).await; } let (status, ..) = verify(&h, Some(&browser), "a@example.com", &code).await; assert_eq!(status, StatusCode::OK); } #[tokio::test] async fn code_is_single_use_and_wrong_address_does_not_pass() { let h = harness().await; let browser = start(&h, "a@example.com").await; let code = h.mail.last_code(); let (status, ..) = verify(&h, Some(&browser), "other@example.com", &code).await; assert_eq!(status, StatusCode::BAD_REQUEST); let (status, ..) = verify(&h, Some(&browser), "a@example.com", &code).await; assert_eq!(status, StatusCode::OK); let (status, ..) = verify(&h, Some(&browser), "a@example.com", &code).await; assert_eq!(status, StatusCode::BAD_REQUEST, "replay"); assert_eq!( sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM email_attempts") .fetch_one(&h.state.database) .await .unwrap(), 0 ); } #[tokio::test] async fn parallel_redemption_of_one_code_has_exactly_one_winner() { let h = harness().await; let browser = start(&h, "a@example.com").await; let code = h.mail.last_code(); let results = futures_join( (0..4) .map(|_| { let app = h.app.clone(); let browser = browser.clone(); let code = code.clone(); tokio::spawn(async move { let mut request = post( "/v1/auth/email/verify", json!({"email": "a@example.com", "code": code}), ); request.cookie = Some(&browser); send(&app, request.request()).await.0 }) }) .collect(), ) .await; assert_eq!(results.iter().filter(|s| **s == StatusCode::OK).count(), 1); assert_eq!( sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM accounts") .fetch_one(&h.state.database) .await .unwrap(), 1 ); } async fn futures_join(handles: Vec>) -> Vec { let mut out = Vec::new(); for handle in handles { out.push(handle.await.unwrap()); } out } #[tokio::test] async fn expired_code_is_rejected() { let h = harness().await; let browser = start(&h, "a@example.com").await; let code = h.mail.last_code(); sqlx::query("UPDATE email_attempts SET expires_at=0") .execute(&h.state.database) .await .unwrap(); let (status, ..) = verify(&h, Some(&browser), "a@example.com", &code).await; assert_eq!(status, StatusCode::BAD_REQUEST); } #[tokio::test] async fn code_is_bound_to_the_requesting_browser() { let h = harness().await; let browser = start(&h, "a@example.com").await; let code = h.mail.last_code(); let stranger = format!("__Host-vnox_email={}", "ab".repeat(32)); assert_eq!( verify(&h, None, "a@example.com", &code).await.0, StatusCode::BAD_REQUEST ); assert_eq!( verify(&h, Some(&stranger), "a@example.com", &code).await.0, StatusCode::BAD_REQUEST ); // Strangers neither consumed the code nor spent its tries. assert_eq!( verify(&h, Some(&browser), "a@example.com", &code).await.0, StatusCode::OK ); } #[tokio::test] async fn resend_replaces_the_previous_code_of_that_browser() { let h = harness().await; let first_browser = start(&h, "a@example.com").await; let first = h.mail.last_code(); let mut request = post("/v1/auth/email/start", json!({"email": "a@example.com"})); request.cookie = Some(&first_browser); let (status, cookies, _) = send(&h.app, request.request()).await; assert_eq!(status, StatusCode::ACCEPTED); let second_browser = pair(&cookies, "__Host-vnox_email"); let second = h.mail.last_code(); assert_eq!(h.mail.count(), 2); if first != second { assert_eq!( verify(&h, Some(&first_browser), "a@example.com", &first) .await .0, StatusCode::BAD_REQUEST ); } assert_eq!( verify(&h, Some(&second_browser), "a@example.com", &second) .await .0, StatusCode::OK ); } #[tokio::test] async fn start_responds_identically_for_existing_and_new_addresses() { let h = harness().await; let browser = start(&h, "known@example.com").await; let code = h.mail.last_code(); assert_eq!( verify(&h, Some(&browser), "known@example.com", &code) .await .0, StatusCode::OK ); let mut shapes = Vec::new(); for address in ["known@example.com", "stranger@example.com"] { let (status, cookies, body) = send( &h.app, post("/v1/auth/email/start", json!({"email": address})).request(), ) .await; let attributes: Vec = cookies .iter() .map(|c| c.split_once('=').unwrap().0.to_owned() + &c[c.find(';').unwrap()..]) .collect(); shapes.push((status, body, attributes)); } assert_eq!(shapes[0], shapes[1]); assert_eq!(shapes[0].0, StatusCode::ACCEPTED); // Both addresses really did receive a code message. assert_eq!(h.mail.count(), 3); } #[tokio::test] async fn start_rejects_bad_addresses_and_cross_site_or_malformed_requests() { let h = harness().await; for bad in [ "", "no-at", "a@b", "a b@example.com", "x@y.com\r\nBcc: z@y.com", ] { let (status, cookies, body) = send( &h.app, post("/v1/auth/email/start", json!({"email": bad})).request(), ) .await; assert_eq!(status, StatusCode::BAD_REQUEST); assert!(body.contains("invalid_email")); assert!(cookies.is_empty()); } let mut request = post("/v1/auth/email/start", json!({"email": "a@example.com"})); request.origin = None; assert_eq!( send(&h.app, request.request()).await.0, StatusCode::FORBIDDEN ); let mut request = post("/v1/auth/email/start", json!({"email": "a@example.com"})); request.origin = Some("https://evil.example"); assert_eq!( send(&h.app, request.request()).await.0, StatusCode::FORBIDDEN ); let mut request = post( "/v1/auth/email/verify", json!({"email": "a@example.com", "code": "12345678"}), ); request.origin = Some("https://evil.example"); assert_eq!( send(&h.app, request.request()).await.0, StatusCode::FORBIDDEN ); // Form posts, unknown fields and oversized bodies never reach the handler logic. let form = Request::builder() .method("POST") .uri("/v1/auth/email/start") .header("origin", ORIGIN) .header("content-type", "application/x-www-form-urlencoded") .body(Body::from("email=a@example.com")) .unwrap(); assert_eq!(send(&h.app, form).await.0, StatusCode::BAD_REQUEST); let extra = post( "/v1/auth/email/start", json!({"email": "a@example.com", "x": 1}), ); assert_eq!( send(&h.app, extra.request()).await.0, StatusCode::BAD_REQUEST ); let big = post("/v1/auth/email/start", json!({"email": "a".repeat(5000)})); assert_eq!(send(&h.app, big.request()).await.0, StatusCode::BAD_REQUEST); assert_eq!(h.mail.count(), 0); // Malformed code shape is refused before touching any attempt. let browser = start(&h, "a@example.com").await; for bad in ["1234567", "123456789", "1234abcd", "12345678"] { assert_eq!( verify(&h, Some(&browser), "a@example.com", bad).await.0, StatusCode::BAD_REQUEST ); } let failures: i64 = sqlx::query_scalar("SELECT failures FROM email_attempts") .fetch_one(&h.state.database) .await .unwrap(); assert_eq!(failures, 0); } #[tokio::test] async fn address_cooldown_and_hourly_limits() { let h = harness_with(EmailLimits::default(), false, true).await; start(&h, "a@example.com").await; let (status, ..) = send( &h.app, post("/v1/auth/email/start", json!({"email": "A@Example.com"})).request(), ) .await; assert_eq!( status, StatusCode::TOO_MANY_REQUESTS, "cooldown applies to the normalized address" ); assert_eq!(h.mail.count(), 1); // Hourly cap: pretend the earlier sends happened a few minutes ago. sqlx::query("UPDATE email_send_log SET sent_at=sent_at-120") .execute(&h.state.database) .await .unwrap(); for i in 0..4 { let (status, ..) = send( &h.app, post("/v1/auth/email/start", json!({"email": "a@example.com"})).request(), ) .await; assert_eq!(status, StatusCode::ACCEPTED, "send {i}"); sqlx::query("UPDATE email_send_log SET sent_at=sent_at-120") .execute(&h.state.database) .await .unwrap(); } let (status, ..) = send( &h.app, post("/v1/auth/email/start", json!({"email": "a@example.com"})).request(), ) .await; assert_eq!(status, StatusCode::TOO_MANY_REQUESTS); assert_eq!(h.mail.count(), 5); } #[tokio::test] async fn source_and_global_limits() { let h = harness_with( EmailLimits { address_cooldown: 0, per_address_hour: 100, per_source_hour: 3, global_hour: 5, global_resend_reserve: 0, }, false, true, ) .await; let attempt = |i: usize, ip: &'static str| { let app = h.app.clone(); async move { let mut request = post( "/v1/auth/email/start", json!({"email": format!("user{i}@example.com")}), ); request.ip = ip; send(&app, request.request()).await.0 } }; for i in 0..3 { assert_eq!(attempt(i, "203.0.113.1").await, StatusCode::ACCEPTED); } assert_eq!( attempt(3, "203.0.113.1").await, StatusCode::TOO_MANY_REQUESTS ); assert_eq!(attempt(4, "203.0.113.2").await, StatusCode::ACCEPTED); assert_eq!(attempt(5, "203.0.113.2").await, StatusCode::ACCEPTED); assert_eq!( attempt(6, "203.0.113.3").await, StatusCode::TOO_MANY_REQUESTS, "global budget" ); assert_eq!(h.mail.count(), 5); } #[tokio::test] async fn source_hashes_not_addresses_are_ledgered() { let h = harness().await; start(&h, "private.person@example.com").await; let row: (String, String) = sqlx::query_as("SELECT email_mac,source_mac FROM email_send_log") .fetch_one(&h.state.database) .await .unwrap(); assert!(!row.0.contains("private") && !row.1.contains("198.51")); assert_eq!(row.0.len(), 64); } #[tokio::test] async fn delivery_failure_reports_unavailable_and_leaves_no_attempt() { let h = harness_with(relaxed(), true, true).await; let (status, cookies, _) = send( &h.app, post("/v1/auth/email/start", json!({"email": "a@example.com"})).request(), ) .await; assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE); assert!(cookies.is_empty()); assert_eq!( sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM email_attempts") .fetch_one(&h.state.database) .await .unwrap(), 0 ); } #[tokio::test] async fn capability_follows_configuration_and_disabled_endpoints_refuse() { let enabled = harness().await; let disabled = harness_with(relaxed(), false, false).await; for (h, expected) in [(&enabled, "enabled"), (&disabled, "not_enabled")] { let (_, _, body) = send( &h.app, Request::builder() .uri("/v1/info") .body(Body::empty()) .unwrap(), ) .await; let info: Value = serde_json::from_str(&body).unwrap(); assert_eq!(info["capabilities"]["email_auth"], expected); assert_eq!(info["smtp"]["public_send_endpoint"], false); } let (status, ..) = send( &disabled.app, post("/v1/auth/email/start", json!({"email": "a@example.com"})).request(), ) .await; assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE); assert_eq!(disabled.mail.count(), 0); } #[tokio::test] async fn email_never_merges_with_a_github_account() { let h = harness().await; let github = store::upsert_identity( &h.state.database, &GitHubProfile { id: 77, login: "same-person".into(), name: Some("Same Person".into()), avatar_url: None, }, ) .await .unwrap(); let browser = start(&h, "same-person@example.com").await; let code = h.mail.last_code(); let (_, _, body) = verify(&h, Some(&browser), "same-person@example.com", &code).await; let json: Value = serde_json::from_str(&body).unwrap(); assert_ne!(json["user"]["user_id"].as_str().unwrap(), github.user_id); assert_eq!( sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM accounts") .fetch_one(&h.state.database) .await .unwrap(), 2 ); } #[tokio::test] async fn new_login_replaces_an_existing_session() { let h = harness().await; let user = store::upsert_email_identity(&h.state.database, "old@example.com") .await .unwrap(); let (old, _) = store::create_session(&h.state.database, &user.user_id) .await .unwrap(); let browser = start(&h, "new@example.com").await; let code = h.mail.last_code(); let mut request = post( "/v1/auth/email/verify", json!({"email": "new@example.com", "code": code}), ); let cookie = format!("{browser}; __Host-vnox_session={old}"); request.cookie = Some(&cookie); assert_eq!(send(&h.app, request.request()).await.0, StatusCode::OK); assert!( store::get_session(&h.state.database, &old) .await .unwrap() .is_none() ); } #[tokio::test] async fn expired_attempts_and_old_ledger_rows_are_pruned() { let h = harness().await; start(&h, "a@example.com").await; sqlx::query("UPDATE email_attempts SET expires_at=0") .execute(&h.state.database) .await .unwrap(); sqlx::query("UPDATE email_send_log SET sent_at=0") .execute(&h.state.database) .await .unwrap(); store::cleanup(&h.state.database).await.unwrap(); for sql in [ "SELECT COUNT(*) FROM email_attempts", "SELECT COUNT(*) FROM email_send_log", ] { let n: i64 = sqlx::query_scalar(sql) .fetch_one(&h.state.database) .await .unwrap(); assert_eq!(n, 0, "{sql}"); } } #[tokio::test] async fn ipv6_sources_are_limited_per_slash_64() { let h = harness_with( EmailLimits { address_cooldown: 0, per_address_hour: 100, per_source_hour: 2, global_hour: 100, global_resend_reserve: 0, }, false, true, ) .await; let go = |i: usize, ip: &'static str| { let app = h.app.clone(); async move { let mut request = post( "/v1/auth/email/start", json!({"email": format!("v6user{i}@example.com")}), ); request.ip = ip; send(&app, request.request()).await.0 } }; assert_eq!(go(0, "2001:db8:1:2::1").await, StatusCode::ACCEPTED); assert_eq!( go(1, "2001:db8:1:2:ffff:aaaa:bbbb:cccc").await, StatusCode::ACCEPTED ); assert_eq!( go(2, "2001:db8:1:2:1234::9").await, StatusCode::TOO_MANY_REQUESTS ); // A different /64 has its own budget; mapped IPv4 shares the IPv4 bucket. assert_eq!(go(3, "2001:db8:1:3::1").await, StatusCode::ACCEPTED); assert_eq!(go(4, "::ffff:192.0.2.9").await, StatusCode::ACCEPTED); assert_eq!(go(5, "192.0.2.9").await, StatusCode::ACCEPTED); assert_eq!( go(6, "::ffff:192.0.2.9").await, StatusCode::TOO_MANY_REQUESTS ); } #[tokio::test] async fn global_reserve_serves_only_resends_from_a_live_attempt() { let h = harness_with( EmailLimits { address_cooldown: 0, per_address_hour: 100, per_source_hour: 100, global_hour: 2, global_resend_reserve: 2, }, false, true, ) .await; let browser = start(&h, "a@example.com").await; start(&h, "b@example.com").await; // Fresh starts are now refused, including with a bogus or missing browser cookie. let fresh = post("/v1/auth/email/start", json!({"email": "c@example.com"})); assert_eq!( send(&h.app, fresh.request()).await.0, StatusCode::TOO_MANY_REQUESTS ); let mut bogus = post("/v1/auth/email/start", json!({"email": "c@example.com"})); let stranger = format!("__Host-vnox_email={}", "cd".repeat(32)); bogus.cookie = Some(&stranger); assert_eq!( send(&h.app, bogus.request()).await.0, StatusCode::TOO_MANY_REQUESTS ); // A browser mid sign-in can still resend from the reserve, until it is used up. let mut resend = post("/v1/auth/email/start", json!({"email": "a@example.com"})); resend.cookie = Some(&browser); let (status, cookies, _) = send(&h.app, resend.request()).await; assert_eq!(status, StatusCode::ACCEPTED); let browser = pair(&cookies, "__Host-vnox_email"); let mut resend = post("/v1/auth/email/start", json!({"email": "a@example.com"})); resend.cookie = Some(&browser); assert_eq!(send(&h.app, resend.request()).await.0, StatusCode::ACCEPTED); let mut resend = post("/v1/auth/email/start", json!({"email": "a@example.com"})); resend.cookie = Some(&browser); let (status, cookies, _) = send(&h.app, resend.request()).await; assert_eq!(status, StatusCode::TOO_MANY_REQUESTS); assert!(cookies.is_empty()); } fn reserve_limits() -> EmailLimits { EmailLimits { address_cooldown: 0, per_address_hour: 1000, per_source_hour: 1000, global_hour: 1, global_resend_reserve: 100, } } async fn resend(h: &Harness, cookie: &str, email: &str) -> (StatusCode, Vec) { let mut request = post("/v1/auth/email/start", json!({"email": email})); request.cookie = Some(cookie); let (status, cookies, _) = send(&h.app, request.request()).await; (status, cookies) } #[tokio::test] async fn reserve_is_not_available_for_a_different_address() { let h = harness_with(reserve_limits(), false, true).await; let browser = start(&h, "a@example.com").await; // The normal budget (1) is spent. A live attempt for a@ must not open the reserve // for sending to anyone else. assert_eq!( resend(&h, &browser, "victim@example.com").await.0, StatusCode::TOO_MANY_REQUESTS ); assert_eq!( resend(&h, &browser, "a@example.com").await.0, StatusCode::ACCEPTED ); assert_eq!(h.mail.count(), 2); } #[tokio::test] async fn resend_chain_is_bounded() { let h = harness_with(reserve_limits(), false, true).await; let mut browser = start(&h, "a@example.com").await; for i in 0..3 { let (status, cookies) = resend(&h, &browser, "a@example.com").await; assert_eq!(status, StatusCode::ACCEPTED, "resend {i}"); browser = pair(&cookies, "__Host-vnox_email"); } // Reserve is still plentiful, but the chain has used its three resends. assert_eq!( resend(&h, &browser, "a@example.com").await.0, StatusCode::TOO_MANY_REQUESTS ); assert_eq!(h.mail.count(), 4); // The refused request rolled back: the live attempt still verifies. let code = h.mail.last_code(); assert_eq!( verify(&h, Some(&browser), "a@example.com", &code).await.0, StatusCode::OK ); } #[tokio::test] async fn old_chains_and_attempts_with_spent_tries_lose_the_reserve() { let h = harness_with(reserve_limits(), false, true).await; let browser = start(&h, "a@example.com").await; sqlx::query("UPDATE email_attempts SET failures=5") .execute(&h.state.database) .await .unwrap(); assert_eq!( resend(&h, &browser, "a@example.com").await.0, StatusCode::TOO_MANY_REQUESTS ); sqlx::query("UPDATE email_attempts SET failures=0, chain_started=chain_started-3600") .execute(&h.state.database) .await .unwrap(); assert_eq!( resend(&h, &browser, "a@example.com").await.0, StatusCode::TOO_MANY_REQUESTS ); } #[tokio::test] async fn parallel_resends_claim_a_live_attempt_only_once() { let h = harness_with(reserve_limits(), false, true).await; let browser = start(&h, "a@example.com").await; let mut tasks = Vec::new(); for _ in 0..6 { let app = h.app.clone(); let browser = browser.clone(); tasks.push(tokio::spawn(async move { let mut request = post("/v1/auth/email/start", json!({"email": "a@example.com"})); request.cookie = Some(&browser); send(&app, request.request()).await.0 })); } let mut accepted = 0; for task in tasks { if task.await.unwrap() == StatusCode::ACCEPTED { accepted += 1; } } assert_eq!(accepted, 1); assert_eq!(h.mail.count(), 2); assert_eq!( sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM email_attempts") .fetch_one(&h.state.database) .await .unwrap(), 1 ); }