VNOX-Server/hub/tests/email_auth.rs

1024 lines
32 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

//! 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<Vec<(String, Email)>>,
fail: bool,
}
impl CodeSender for Recorder {
fn send<'a>(
&'a self,
recipient: &'a str,
email: Email,
) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + 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<HubState>,
app: Router,
mail: Arc<Recorder>,
}
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<Body> {
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<Body>) -> (StatusCode, Vec<String>, String) {
let response: Response<Body> = 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>, 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-email.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<tokio::task::JoinHandle<StatusCode>>) -> Vec<StatusCode> {
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<String> = 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<String>) {
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
);
}