Skip to main content

capy_auth/
runtime.rs

1use crate::{
2    dto::{invalid, validate_password},
3    models::{reset, session, user},
4    secret::{digest, random, valid_token},
5    throttle::Throttle,
6    *,
7};
8use axum::{
9    extract::{ConnectInfo, Request, State},
10    http::{header, HeaderMap, HeaderValue, Method, StatusCode},
11    middleware::{self, Next},
12    response::{IntoResponse, Response},
13    Extension, Router,
14};
15use capy_core::{AppContext, AppError, Result};
16use capy_http::{Json, Routes};
17use cookie::{Cookie, SameSite as CookieSameSite};
18use sea_orm::{
19    sea_query::Expr, ActiveModelTrait, ColumnTrait, ConnectionTrait, DatabaseConnection,
20    EntityTrait, QueryFilter, Set, TransactionTrait,
21};
22use std::{
23    net::SocketAddr,
24    sync::Arc,
25    time::{SystemTime, UNIX_EPOCH},
26};
27use subtle::ConstantTimeEq;
28
29/// Shared auth runtime. One instance per application preserves process-local throttles.
30#[derive(Clone)]
31pub struct AuthService(Arc<Inner>);
32struct Inner {
33    context: AppContext,
34    events: capy_core::Events,
35    delivery: Arc<dyn ResetDelivery>,
36    verification_delivery: Option<Arc<dyn VerificationDelivery>>,
37    throttle: Throttle,
38    passwords: password::PasswordService,
39    client_ip: capy_core::ClientIpResolver,
40}
41impl std::fmt::Debug for AuthService {
42    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
43        f.write_str("AuthService([REDACTED])")
44    }
45}
46
47/// Typed conventional route contracts, mounted by `App::auth` under `/api/auth`.
48pub fn routes() -> Routes {
49    Routes::new()
50        .get("/csrf", csrf)
51        .operation("authCsrf")
52        .response::<CsrfResponse>()
53        .error(403)
54        .error(429)
55        .error(503)
56        .post("/register", register)
57        .operation("authRegister")
58        .body::<RegisterRequest>()
59        .created::<UserResponse>()
60        .error(403)
61        .error(409)
62        .error(429)
63        .error(503)
64        .post("/login", login)
65        .operation("authLogin")
66        .error(409)
67        .body::<LoginRequest>()
68        .response::<UserResponse>()
69        .error(401)
70        .error(403)
71        .error(429)
72        .error(503)
73        .post("/logout", logout)
74        .operation("authLogout")
75        .error(409)
76        .error(422)
77        .error(503)
78        .no_content()
79        .authenticated()
80        .error(403)
81        .get("/me", me)
82        .operation("authMe")
83        .response::<UserResponse>()
84        .authenticated()
85        .post("/forgot-password", forgot)
86        .operation("authForgotPassword")
87        .body::<ForgotPasswordRequest>()
88        .response::<ResetRequestedResponse>()
89        .error(403)
90        .error(429)
91        .error(503)
92        .post("/reset-password", reset_password)
93        .operation("authResetPassword")
94        .error(409)
95        .body::<ResetPasswordRequest>()
96        .no_content()
97        .error(400)
98        .error(403)
99        .error(429)
100        .error(503)
101}
102
103impl AuthService {
104    /// Build a runtime for existing SeaORM state. Tables are migrated explicitly.
105    pub fn new(context: AppContext, delivery: Arc<dyn ResetDelivery>) -> Result<Self> {
106        let production = context.config.app.environment == "production";
107        context.config.auth.validate(production)?;
108        if production && delivery.development_only() {
109            return Err(AppError::Configuration("Install an application-owned password reset delivery adapter before enabling auth in production.".into()));
110        }
111        Ok(Self(Arc::new(Inner {
112            client_ip: capy_core::ClientIpResolver::new(&context.config.http.client_ip)?,
113            passwords: password::PasswordService::new(context.config.auth.password.clone())?,
114            events: capy_core::Events::new(),
115            context,
116            delivery,
117            verification_delivery: None,
118            throttle: Throttle::default(),
119        })))
120    }
121    /// Attach the application's typed transaction listeners before sharing the service.
122    pub fn with_events(mut self, events: capy_core::Events) -> Self {
123        // Build a new runtime snapshot while preserving admission and throttle state.
124        let inner = &self.0;
125        self.0 = Arc::new(Inner {
126            context: inner.context.clone(),
127            delivery: inner.delivery.clone(),
128            verification_delivery: inner.verification_delivery.clone(),
129            throttle: inner.throttle.clone(),
130            passwords: inner.passwords.clone(),
131            client_ip: inner.client_ip.clone(),
132            events,
133        });
134        self
135    }
136    /// Enable framework-owned, user/address-bound email proofs. Register the additional
137    /// verification migration and mount verification_routes before serving requests.
138    pub fn with_email_verification(
139        mut self,
140        delivery: Arc<dyn VerificationDelivery>,
141    ) -> Result<Self> {
142        if self.production() && delivery.development_only() {
143            return Err(AppError::Configuration(
144                "Install a production email verification delivery adapter.".into(),
145            ));
146        }
147        let inner = &self.0;
148        self.0 = Arc::new(Inner {
149            context: inner.context.clone(),
150            events: inner.events.clone(),
151            delivery: inner.delivery.clone(),
152            verification_delivery: Some(delivery),
153            throttle: inner.throttle.clone(),
154            passwords: inner.passwords.clone(),
155            client_ip: inner.client_ip.clone(),
156        });
157        Ok(self)
158    }
159    /// Stop new password work and wake waiting requests. Active hashes finish safely.
160    pub fn close(&self) {
161        self.0.passwords.close();
162    }
163    /// Access this application's shared password pool for custom authentication flows.
164    pub fn passwords(&self) -> &password::PasswordService {
165        &self.0.passwords
166    }
167    /// Mark email verified after the application validates its own verification proof.
168    /// Call only from trusted server code, never with an unchecked client-supplied ID.
169    /// Uses a savepoint so listener errors roll back the verification and listener writes.
170    /// Returns false for an already-verified account; replay queues no additional jobs.
171    /// The outer transaction still owns commit (and should consume the proof atomically).
172    pub async fn verify_email_in(
173        &self,
174        transaction: &sea_orm::DatabaseTransaction,
175        user_id: i64,
176    ) -> Result<bool> {
177        let tx = transaction.begin().await?;
178        let changed = user::Entity::update_many()
179            .col_expr(user::Column::EmailVerifiedAt, Expr::value(now()))
180            .col_expr(user::Column::UpdatedAt, Expr::value(now()))
181            .filter(user::Column::Id.eq(user_id))
182            .filter(user::Column::EmailVerifiedAt.is_null())
183            .exec(&tx)
184            .await?;
185        if changed.rows_affected == 0 {
186            if user::Entity::find_by_id(user_id).one(&tx).await?.is_none() {
187                return Err(AppError::NotFound);
188            }
189            tx.commit().await?;
190            return Ok(false);
191        }
192        self.0
193            .events
194            .dispatch_in(&tx, &self.0.context, EmailVerified { user_id })
195            .await?;
196        tx.commit().await?;
197        Ok(true)
198    }
199    fn db(&self) -> &DatabaseConnection {
200        &self.0.context.db
201    }
202    fn settings(&self) -> &AuthSettings {
203        &self.0.context.config.auth
204    }
205    fn production(&self) -> bool {
206        self.0.context.config.app.environment == "production"
207    }
208    /// Install CSRF enforcement on every unsafe method, plus shared extractor state.
209    /// Call after mounting routes. No CORS layer is enabled.
210    pub fn protect(&self, router: Router) -> Router {
211        router
212            .layer(Extension(self.clone()))
213            .layer(middleware::from_fn_with_state(self.clone(), guard))
214    }
215    pub(crate) fn cookie_token(&self, headers: &HeaderMap) -> Result<Option<Secret>> {
216        let name = self.settings().cookie_name(self.production());
217        let mut token = None;
218        for value in headers.get_all(header::COOKIE) {
219            let value = value.to_str().map_err(|_| AppError::Unauthorized)?;
220            for part in value.split(';') {
221                // Only interpret the auth cookie; unrelated cookie values are application-owned.
222                if part.trim().split('=').next().map(str::trim) != Some(name) {
223                    continue;
224                }
225                let parsed =
226                    Cookie::parse(part.trim().to_owned()).map_err(|_| AppError::Unauthorized)?;
227                if token.is_some() || !valid_token(parsed.value()) {
228                    return Err(AppError::Unauthorized);
229                }
230                token = Some(Secret::new(parsed.value()));
231            }
232        }
233        Ok(token)
234    }
235    pub(crate) async fn session(&self, headers: &HeaderMap) -> Result<Option<session::Model>> {
236        let Some(token) = self.cookie_token(headers)? else {
237            return Ok(None);
238        };
239        let found = session::Entity::find_by_id(digest(token.expose()))
240            .one(self.db())
241            .await?
242            .ok_or(AppError::Unauthorized)?;
243        if found.expires_at <= now() {
244            tracing::info!(event = "auth.session.expired");
245            return Err(AppError::Unauthorized);
246        }
247        Ok(Some(found))
248    }
249    pub(crate) async fn identity(&self, headers: &HeaderMap) -> Result<Option<UserResponse>> {
250        let Some(session) = self.session(headers).await? else {
251            return Ok(None);
252        };
253        let Some(id) = session.user_id else {
254            return Ok(None);
255        };
256        let user = user::Entity::find_by_id(id)
257            .one(self.db())
258            .await?
259            .ok_or(AppError::Unauthorized)?;
260        // Coarse last-seen writes avoid a write for every authenticated read. Never extend expiry.
261        if session.last_seen_at < now() - 300 {
262            session::Entity::update_many()
263                .col_expr(session::Column::LastSeenAt, Expr::value(now()))
264                .filter(session::Column::TokenHash.eq(session.token_hash))
265                .exec(self.db())
266                .await?;
267        }
268        Ok(Some(public_user(&user)))
269    }
270    fn cookie(&self, token: Option<&Secret>, lifetime: u64) -> Result<HeaderValue> {
271        let cookie = Cookie::build((
272            self.settings().cookie_name(self.production()).to_owned(),
273            token.map(|v| v.expose()).unwrap_or("").to_owned(),
274        ))
275        .http_only(true)
276        .secure(self.settings().secure(self.production()))
277        .path("/")
278        .same_site(match self.settings().same_site {
279            SameSite::Lax => CookieSameSite::Lax,
280            SameSite::Strict => CookieSameSite::Strict,
281        })
282        .max_age(cookie::time::Duration::seconds(if token.is_some() {
283            lifetime as i64
284        } else {
285            0
286        }))
287        .build();
288        let mut value = HeaderValue::from_str(&cookie.to_string())
289            .map_err(|_| AppError::Configuration("Invalid auth cookie configuration".into()))?;
290        value.set_sensitive(true);
291        Ok(value)
292    }
293    fn throttle(
294        &self,
295        headers: &HeaderMap,
296        peer: Option<SocketAddr>,
297        action: &str,
298        account: Option<&str>,
299    ) -> Result<()> {
300        let key = self.0.client_ip.resolve(peer, headers)?;
301        let settings = &self.settings().throttle;
302        if !settings.enabled {
303            return Ok(());
304        }
305        self.0
306            .throttle
307            .check(format!("auth:{action}:ip:{key}"), &settings.ip)?;
308        if let Some(account) = account {
309            self.0.throttle.check(
310                format!("auth:{action}:account:{}", digest(account)),
311                &settings.account,
312            )?;
313        }
314        Ok(())
315    }
316}
317
318async fn guard(State(service): State<AuthService>, mut request: Request, next: Next) -> Response {
319    let result = async {
320        if !matches!(
321            *request.method(),
322            Method::GET | Method::HEAD | Method::OPTIONS
323        ) {
324            reject_cross_site(request.headers())?;
325            let session = service
326                .session(request.headers())
327                .await?
328                .ok_or(AppError::Forbidden)?;
329            let supplied = request
330                .headers()
331                .get("x-csrf-token")
332                .and_then(|v| v.to_str().ok())
333                .ok_or(AppError::Forbidden)?;
334            if !valid_token(supplied)
335                || !bool::from(supplied.as_bytes().ct_eq(session.csrf_token.0.as_bytes()))
336            {
337                return Err(AppError::Forbidden);
338            }
339            request.extensions_mut().insert(session);
340        }
341        Ok(())
342    }
343    .await;
344    let mut response = match result {
345        Ok(()) => next.run(request).await,
346        Err(error) => error.into_response(),
347    };
348    // Auth handlers have no explicit cache policy and therefore always become no-store.
349    // Preserve intentional native policies, including Capy's immutable static assets.
350    if !response.headers().contains_key(header::CACHE_CONTROL) {
351        response
352            .headers_mut()
353            .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
354        response
355            .headers_mut()
356            .insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
357    }
358    response
359}
360fn reject_cross_site(headers: &HeaderMap) -> Result<()> {
361    if let Some(value) = headers.get("sec-fetch-site") {
362        if !matches!(value.to_str().unwrap_or(""), "same-origin" | "none") {
363            return Err(AppError::Forbidden);
364        }
365    }
366    // The synchronizer token is the primary control even when fetch metadata is absent.
367    Ok(())
368}
369async fn csrf(
370    Extension(service): Extension<AuthService>,
371    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
372    headers: HeaderMap,
373) -> Result<Response> {
374    reject_cross_site(&headers)?;
375    // Custom header prevents cross-origin simple requests from allocating/replacing sessions.
376    if headers.get("x-capy-csrf").and_then(|v| v.to_str().ok()) != Some("1") {
377        return Err(AppError::Forbidden);
378    }
379    let existing = service.session(&headers).await;
380    if let Ok(Some(session)) = existing {
381        return Ok(Json(CsrfResponse {
382            csrf_token: session.csrf_token.0,
383        })
384        .into_response());
385    }
386    if let Err(error) = existing {
387        if !matches!(error, AppError::Unauthorized) {
388            return Err(error);
389        }
390    }
391    service.throttle(&headers, peer.map(|p| p.0 .0), "csrf", None)?;
392    let (token, session) = insert_session(service.db(), None, 1800).await?;
393    let mut response = Json(CsrfResponse {
394        csrf_token: session.csrf_token.0,
395    })
396    .into_response();
397    response
398        .headers_mut()
399        .insert(header::SET_COOKIE, service.cookie(Some(&token), 1800)?);
400    Ok(response)
401}
402async fn register(
403    Extension(service): Extension<AuthService>,
404    Extension(previous): Extension<session::Model>,
405    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
406    headers: HeaderMap,
407    Json(input): Json<RegisterRequest>,
408) -> Result<Response> {
409    let email = normalize_email(&input.email)?;
410    let name = input.name.trim().to_owned();
411    if !(2..=100).contains(&name.chars().count()) {
412        return Err(invalid("name", "Use 2 to 100 characters."));
413    }
414    validate_password(&input.password, true)?;
415    service.throttle(&headers, peer.map(|p| p.0 .0), "register", Some(&email))?;
416    let password_hash = service.0.passwords.hash(input.password).await?;
417    let txn = service.db().begin().await?;
418    let created = user::ActiveModel {
419        name: Set(name),
420        email: Set(email),
421        password_hash: Set(crate::models::DbSecret(password_hash.expose().to_owned())),
422        email_verified_at: Set(None),
423        created_at: Set(now()),
424        updated_at: Set(now()),
425        ..Default::default()
426    }
427    .insert(&txn)
428    .await;
429    let user = match created {
430        Ok(user) => user,
431        Err(error)
432            if matches!(
433                error.sql_err(),
434                Some(sea_orm::SqlErr::UniqueConstraintViolation(_))
435            ) =>
436        {
437            return Err(AppError::Conflict(
438                "An account with this email already exists.".into(),
439            ))
440        }
441        Err(error) => return Err(error.into()),
442    };
443    let token = rotate(
444        &txn,
445        &previous,
446        user.id,
447        service.settings().session_lifetime_seconds,
448    )
449    .await?;
450    service
451        .0
452        .events
453        .dispatch_in(
454            &txn,
455            &service.0.context,
456            UserRegistered {
457                user: public_user(&user),
458            },
459        )
460        .await?;
461    txn.commit().await?;
462    tracing::info!(event = "auth.register.success");
463    authenticated_response(&service, &user, &token, StatusCode::CREATED)
464}
465async fn login(
466    Extension(service): Extension<AuthService>,
467    Extension(previous): Extension<session::Model>,
468    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
469    headers: HeaderMap,
470    Json(input): Json<LoginRequest>,
471) -> Result<Response> {
472    let email = normalize_email(&input.email)?;
473    validate_password(&input.password, false)?;
474    service.throttle(&headers, peer.map(|p| p.0 .0), "login", Some(&email))?;
475    let user = user::Entity::find()
476        .filter(user::Column::Email.eq(email))
477        .one(service.db())
478        .await?;
479    let verified = service
480        .0
481        .passwords
482        .verify(
483            input.password,
484            user.as_ref().map(|u| Secret::new(&u.password_hash.0)),
485        )
486        .await?;
487    if !verified {
488        tracing::info!(event = "auth.login.failed");
489        return Err(AppError::Unauthorized);
490    }
491    let user = user.ok_or(AppError::Unauthorized)?;
492    let txn = service.db().begin().await?;
493    // Serialize with reset and recheck the verified hash while holding a write lock.
494    let locked = user::Entity::update_many()
495        .col_expr(user::Column::UpdatedAt, Expr::value(now()))
496        .filter(user::Column::Id.eq(user.id))
497        .filter(user::Column::PasswordHash.eq(&user.password_hash.0))
498        .exec(&txn)
499        .await?;
500    if locked.rows_affected != 1 {
501        return Err(AppError::Unauthorized);
502    }
503    let token = rotate(
504        &txn,
505        &previous,
506        user.id,
507        service.settings().session_lifetime_seconds,
508    )
509    .await?;
510    service
511        .0
512        .events
513        .dispatch_in(
514            &txn,
515            &service.0.context,
516            LoginSucceeded { user_id: user.id },
517        )
518        .await?;
519    txn.commit().await?;
520    tracing::info!(event = "auth.login.success");
521    authenticated_response(&service, &user, &token, StatusCode::OK)
522}
523async fn me(AuthUser(user): AuthUser) -> Json<UserResponse> {
524    Json(user)
525}
526
527/// Opt-in routes for the framework-owned email verification flow; mounted under /api/auth.
528pub fn verification_routes() -> Routes {
529    Routes::new()
530        .get("/verification", verification_status)
531        .operation("authVerificationStatus")
532        .response::<VerificationStatus>()
533        .authenticated()
534        .post("/verification", request_verification)
535        .operation("authRequestVerification")
536        .no_content()
537        .authenticated()
538        .error(403)
539        .error(429)
540        .error(503)
541        .post("/verify-email", verify_email)
542        .operation("authVerifyEmail")
543        .body::<VerifyEmailRequest>()
544        .no_content()
545        .authenticated()
546        .error(400)
547        .error(403)
548        .error(409)
549        .error(429)
550        .error(503)
551}
552async fn verification_status(
553    Extension(service): Extension<AuthService>,
554    AuthUser(identity): AuthUser,
555) -> Result<Json<VerificationStatus>> {
556    let user = user::Entity::find_by_id(identity.id)
557        .one(service.db())
558        .await?
559        .ok_or(AppError::Unauthorized)?;
560    Ok(Json(VerificationStatus {
561        verified: user.email_verified_at.is_some(),
562    }))
563}
564async fn request_verification(
565    Extension(service): Extension<AuthService>,
566    AuthUser(identity): AuthUser,
567    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
568    headers: HeaderMap,
569) -> Result<capy_http::NoContent> {
570    use crate::models::verification;
571    service.throttle(
572        &headers,
573        peer.map(|peer| peer.0 .0),
574        "verification-request",
575        Some(&identity.email),
576    )?;
577    let delivery = service
578        .0
579        .verification_delivery
580        .as_ref()
581        .ok_or(AppError::AuthCapacity)?;
582    let tx = service.db().begin().await?;
583    lock_user(&tx, identity.id).await?;
584    let user = user::Entity::find_by_id(identity.id)
585        .one(&tx)
586        .await?
587        .ok_or(AppError::Unauthorized)?;
588    if user.email_verified_at.is_some() {
589        tx.commit().await?;
590        return Ok(capy_http::NoContent);
591    }
592    let token = random()?;
593    let expires_at = now() + 1800;
594    verification::Entity::delete_by_id(user.id)
595        .exec(&tx)
596        .await?;
597    verification::ActiveModel {
598        user_id: Set(user.id),
599        token_hash: Set(crate::models::DbSecret(digest(token.expose()))),
600        email: Set(crate::models::DbSecret(user.email.clone())),
601        expires_at: Set(expires_at),
602    }
603    .insert(&tx)
604    .await?;
605    tx.commit().await?;
606    // External delivery occurs only after commit. A retry replaces the previous proof.
607    delivery
608        .deliver(VerificationMessage {
609            email: user.email,
610            token,
611            expires_at,
612        })
613        .await?;
614    Ok(capy_http::NoContent)
615}
616async fn verify_email(
617    Extension(service): Extension<AuthService>,
618    AuthUser(identity): AuthUser,
619    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
620    headers: HeaderMap,
621    Json(input): Json<VerifyEmailRequest>,
622) -> Result<capy_http::NoContent> {
623    use crate::models::verification;
624    service.throttle(
625        &headers,
626        peer.map(|peer| peer.0 .0),
627        "verification-consume",
628        Some(&identity.email),
629    )?;
630    if !valid_token(input.token.expose()) {
631        return Err(verification_invalid());
632    }
633    let tx = service.db().begin().await?;
634    lock_user(&tx, identity.id).await?;
635    let user = user::Entity::find_by_id(identity.id)
636        .one(&tx)
637        .await?
638        .ok_or(AppError::Unauthorized)?;
639    let consumed = verification::Entity::delete_many()
640        .filter(verification::Column::UserId.eq(user.id))
641        .filter(verification::Column::Email.eq(user.email))
642        .filter(verification::Column::TokenHash.eq(digest(input.token.expose())))
643        .filter(verification::Column::ExpiresAt.gt(now()))
644        .exec(&tx)
645        .await?;
646    if consumed.rows_affected != 1 {
647        return Err(verification_invalid());
648    }
649    service.verify_email_in(&tx, identity.id).await?;
650    tx.commit().await?;
651    Ok(capy_http::NoContent)
652}
653fn verification_invalid() -> AppError {
654    AppError::BadRequest("Invalid or expired email verification token.".into())
655}
656async fn logout(
657    Extension(service): Extension<AuthService>,
658    Extension(session): Extension<session::Model>,
659    AuthUser(user): AuthUser,
660) -> Result<Response> {
661    let txn = service.db().begin().await?;
662    let removed = session::Entity::delete_by_id(session.token_hash)
663        .exec(&txn)
664        .await?;
665    if removed.rows_affected == 1 {
666        service
667            .0
668            .events
669            .dispatch_in(&txn, &service.0.context, LoggedOut { user_id: user.id })
670            .await?;
671    }
672    txn.commit().await?;
673    let mut response = StatusCode::NO_CONTENT.into_response();
674    response
675        .headers_mut()
676        .insert(header::SET_COOKIE, service.cookie(None, 0)?);
677    tracing::info!(event = "auth.logout");
678    Ok(response)
679}
680async fn forgot(
681    Extension(service): Extension<AuthService>,
682    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
683    headers: HeaderMap,
684    Json(input): Json<ForgotPasswordRequest>,
685) -> Result<Json<ResetRequestedResponse>> {
686    let email = normalize_email(&input.email)?;
687    service.throttle(
688        &headers,
689        peer.map(|p| p.0 .0),
690        "reset-request",
691        Some(&email),
692    )?;
693    let token = random()?;
694    let user = user::Entity::find()
695        .filter(user::Column::Email.eq(&email))
696        .one(service.db())
697        .await?;
698    if let Some(user) = user {
699        let txn = service.db().begin().await?;
700        lock_user(&txn, user.id).await?;
701        // One outstanding token per user; a later request supersedes earlier links.
702        reset::Entity::delete_many()
703            .filter(reset::Column::UserId.eq(user.id))
704            .exec(&txn)
705            .await?;
706        let expires_at = now() + service.settings().password_reset_lifetime_seconds as i64;
707        reset::ActiveModel {
708            token_hash: Set(digest(token.expose())),
709            user_id: Set(user.id),
710            created_at: Set(now()),
711            expires_at: Set(expires_at),
712        }
713        .insert(&txn)
714        .await?;
715        txn.commit().await?;
716        // Delivery errors and timeouts must not change the public existence response.
717        // Implementations should hand off quickly to their application-owned mail system.
718        let delivered = tokio::time::timeout(
719            std::time::Duration::from_secs(5),
720            service.0.delivery.deliver(ResetMessage {
721                email,
722                token,
723                expires_at,
724            }),
725        )
726        .await;
727        if !matches!(delivered, Ok(Ok(()))) {
728            tracing::warn!(event = "auth.password_reset.delivery_failed");
729        }
730    }
731    tracing::info!(event = "auth.password_reset.requested");
732    Ok(Json(ResetRequestedResponse {
733        message: "If that account exists, password reset instructions will be delivered.",
734    }))
735}
736async fn reset_password(
737    Extension(service): Extension<AuthService>,
738    peer: Option<Extension<ConnectInfo<SocketAddr>>>,
739    headers: HeaderMap,
740    Json(input): Json<ResetPasswordRequest>,
741) -> Result<Response> {
742    service.throttle(
743        &headers,
744        peer.map(|p| p.0 .0),
745        "reset-complete",
746        Some(input.token.expose()),
747    )?;
748    validate_password(&input.password, true)?;
749    if !valid_token(input.token.expose()) {
750        return Err(reset_invalid());
751    }
752    let digest = digest(input.token.expose());
753    let reset = reset::Entity::find_by_id(&digest)
754        .one(service.db())
755        .await?
756        .filter(|r| r.expires_at > now())
757        .ok_or_else(reset_invalid)?;
758    let password = service.0.passwords.hash(input.password).await?;
759    let txn = service.db().begin().await?;
760    lock_user(&txn, reset.user_id).await?;
761    let consumed = reset::Entity::delete_many()
762        .filter(reset::Column::TokenHash.eq(digest))
763        .filter(reset::Column::ExpiresAt.gt(now()))
764        .exec(&txn)
765        .await?;
766    if consumed.rows_affected != 1 {
767        return Err(reset_invalid());
768    }
769    user::Entity::update_many()
770        .col_expr(user::Column::PasswordHash, Expr::value(password.expose()))
771        .col_expr(user::Column::UpdatedAt, Expr::value(now()))
772        .filter(user::Column::Id.eq(reset.user_id))
773        .exec(&txn)
774        .await?;
775    reset::Entity::delete_many()
776        .filter(reset::Column::UserId.eq(reset.user_id))
777        .exec(&txn)
778        .await?;
779    session::Entity::delete_many()
780        .filter(session::Column::UserId.eq(reset.user_id))
781        .exec(&txn)
782        .await?;
783    service
784        .0
785        .events
786        .dispatch_in(
787            &txn,
788            &service.0.context,
789            PasswordResetCompleted {
790                user_id: reset.user_id,
791            },
792        )
793        .await?;
794    txn.commit().await?;
795    tracing::info!(event = "auth.password_reset.completed");
796    let mut response = StatusCode::NO_CONTENT.into_response();
797    response
798        .headers_mut()
799        .insert(header::SET_COOKIE, service.cookie(None, 0)?);
800    Ok(response)
801}
802fn reset_invalid() -> AppError {
803    AppError::BadRequest("Invalid or expired password reset token.".into())
804}
805async fn lock_user(db: &impl ConnectionTrait, id: i64) -> Result<()> {
806    let result = user::Entity::update_many()
807        .col_expr(user::Column::UpdatedAt, Expr::value(now()))
808        .filter(user::Column::Id.eq(id))
809        .exec(db)
810        .await?;
811    if result.rows_affected != 1 {
812        return Err(AppError::Unauthorized);
813    }
814    Ok(())
815}
816fn authenticated_response(
817    service: &AuthService,
818    user: &user::Model,
819    token: &Secret,
820    status: StatusCode,
821) -> Result<Response> {
822    let mut response = (status, Json(public_user(user))).into_response();
823    response.headers_mut().insert(
824        header::SET_COOKIE,
825        service.cookie(Some(token), service.settings().session_lifetime_seconds)?,
826    );
827    Ok(response)
828}
829fn public_user(user: &user::Model) -> UserResponse {
830    UserResponse {
831        id: user.id,
832        name: user.name.clone(),
833        email: user.email.clone(),
834    }
835}
836async fn rotate(
837    db: &impl ConnectionTrait,
838    previous: &session::Model,
839    user: i64,
840    lifetime: u64,
841) -> Result<Secret> {
842    let removed = session::Entity::delete_many()
843        .filter(session::Column::TokenHash.eq(&previous.token_hash))
844        .filter(session::Column::ExpiresAt.gt(now()))
845        .exec(db)
846        .await?;
847    if removed.rows_affected != 1 {
848        return Err(AppError::Unauthorized);
849    }
850    Ok(insert_session(db, Some(user), lifetime).await?.0)
851}
852async fn insert_session(
853    db: &impl ConnectionTrait,
854    user: Option<i64>,
855    lifetime: u64,
856) -> Result<(Secret, session::Model)> {
857    let token = random()?;
858    let csrf = random()?;
859    let model = session::ActiveModel {
860        token_hash: Set(digest(token.expose())),
861        user_id: Set(user),
862        csrf_token: Set(crate::models::DbSecret(csrf.expose().to_owned())),
863        created_at: Set(now()),
864        last_seen_at: Set(now()),
865        expires_at: Set(now() + lifetime as i64),
866    }
867    .insert(db)
868    .await?;
869    Ok((token, model))
870}
871/// Delete expired sessions and reset credentials. Invoke from a scheduled application/DB job
872/// or `capy auth:prune`; no scheduler is created by Capy.
873pub async fn prune(db: &DatabaseConnection) -> Result<u64> {
874    let sessions = session::Entity::delete_many()
875        .filter(session::Column::ExpiresAt.lte(now()))
876        .exec(db)
877        .await?
878        .rows_affected;
879    let resets = reset::Entity::delete_many()
880        .filter(reset::Column::ExpiresAt.lte(now()))
881        .exec(db)
882        .await?
883        .rows_affected;
884    Ok(sessions + resets)
885}
886pub(crate) fn now() -> i64 {
887    SystemTime::now()
888        .duration_since(UNIX_EPOCH)
889        .expect("clock after Unix epoch")
890        .as_secs() as i64
891}