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#[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
47pub 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 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 pub fn with_events(mut self, events: capy_core::Events) -> Self {
123 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 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 pub fn close(&self) {
161 self.0.passwords.close();
162 }
163 pub fn passwords(&self) -> &password::PasswordService {
165 &self.0.passwords
166 }
167 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 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 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 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 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 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 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 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
527pub 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 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 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 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}
871pub 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}