use crate::{
dto::{invalid, validate_password},
models::{reset, session, user},
secret::{digest, random, valid_token},
throttle::Throttle,
*,
};
use axum::{
extract::{ConnectInfo, Request, State},
http::{header, HeaderMap, HeaderValue, Method, StatusCode},
middleware::{self, Next},
response::{IntoResponse, Response},
Extension, Router,
};
use capy_core::{AppContext, AppError, Result};
use capy_http::{Json, Routes};
use cookie::{Cookie, SameSite as CookieSameSite};
use sea_orm::{
sea_query::Expr, ActiveModelTrait, ColumnTrait, ConnectionTrait, DatabaseConnection,
EntityTrait, QueryFilter, Set, TransactionTrait,
};
use std::{
net::SocketAddr,
sync::Arc,
time::{SystemTime, UNIX_EPOCH},
};
use subtle::ConstantTimeEq;
#[derive(Clone)]
pub struct AuthService(Arc<Inner>);
struct Inner {
context: AppContext,
events: capy_core::Events,
delivery: Arc<dyn ResetDelivery>,
verification_delivery: Option<Arc<dyn VerificationDelivery>>,
throttle: Throttle,
passwords: password::PasswordService,
client_ip: capy_core::ClientIpResolver,
}
impl std::fmt::Debug for AuthService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("AuthService([REDACTED])")
}
}
pub fn routes() -> Routes {
Routes::new()
.get("/csrf", csrf)
.operation("authCsrf")
.response::<CsrfResponse>()
.error(403)
.error(429)
.error(503)
.post("/register", register)
.operation("authRegister")
.body::<RegisterRequest>()
.created::<UserResponse>()
.error(403)
.error(409)
.error(429)
.error(503)
.post("/login", login)
.operation("authLogin")
.error(409)
.body::<LoginRequest>()
.response::<UserResponse>()
.error(401)
.error(403)
.error(429)
.error(503)
.post("/logout", logout)
.operation("authLogout")
.error(409)
.error(422)
.error(503)
.no_content()
.authenticated()
.error(403)
.get("/me", me)
.operation("authMe")
.response::<UserResponse>()
.authenticated()
.post("/forgot-password", forgot)
.operation("authForgotPassword")
.body::<ForgotPasswordRequest>()
.response::<ResetRequestedResponse>()
.error(403)
.error(429)
.error(503)
.post("/reset-password", reset_password)
.operation("authResetPassword")
.error(409)
.body::<ResetPasswordRequest>()
.no_content()
.error(400)
.error(403)
.error(429)
.error(503)
}
impl AuthService {
pub fn new(context: AppContext, delivery: Arc<dyn ResetDelivery>) -> Result<Self> {
let production = context.config.app.environment == "production";
context.config.auth.validate(production)?;
if production && delivery.development_only() {
return Err(AppError::Configuration("Install an application-owned password reset delivery adapter before enabling auth in production.".into()));
}
Ok(Self(Arc::new(Inner {
client_ip: capy_core::ClientIpResolver::new(&context.config.http.client_ip)?,
passwords: password::PasswordService::new(context.config.auth.password.clone())?,
events: capy_core::Events::new(),
context,
delivery,
verification_delivery: None,
throttle: Throttle::default(),
})))
}
pub fn with_events(mut self, events: capy_core::Events) -> Self {
let inner = &self.0;
self.0 = Arc::new(Inner {
context: inner.context.clone(),
delivery: inner.delivery.clone(),
verification_delivery: inner.verification_delivery.clone(),
throttle: inner.throttle.clone(),
passwords: inner.passwords.clone(),
client_ip: inner.client_ip.clone(),
events,
});
self
}
pub fn with_email_verification(
mut self,
delivery: Arc<dyn VerificationDelivery>,
) -> Result<Self> {
if self.production() && delivery.development_only() {
return Err(AppError::Configuration(
"Install a production email verification delivery adapter.".into(),
));
}
let inner = &self.0;
self.0 = Arc::new(Inner {
context: inner.context.clone(),
events: inner.events.clone(),
delivery: inner.delivery.clone(),
verification_delivery: Some(delivery),
throttle: inner.throttle.clone(),
passwords: inner.passwords.clone(),
client_ip: inner.client_ip.clone(),
});
Ok(self)
}
pub fn close(&self) {
self.0.passwords.close();
}
pub fn passwords(&self) -> &password::PasswordService {
&self.0.passwords
}
pub async fn verify_email_in(
&self,
transaction: &sea_orm::DatabaseTransaction,
user_id: i64,
) -> Result<bool> {
let tx = transaction.begin().await?;
let changed = user::Entity::update_many()
.col_expr(user::Column::EmailVerifiedAt, Expr::value(now()))
.col_expr(user::Column::UpdatedAt, Expr::value(now()))
.filter(user::Column::Id.eq(user_id))
.filter(user::Column::EmailVerifiedAt.is_null())
.exec(&tx)
.await?;
if changed.rows_affected == 0 {
if user::Entity::find_by_id(user_id).one(&tx).await?.is_none() {
return Err(AppError::NotFound);
}
tx.commit().await?;
return Ok(false);
}
self.0
.events
.dispatch_in(&tx, &self.0.context, EmailVerified { user_id })
.await?;
tx.commit().await?;
Ok(true)
}
fn db(&self) -> &DatabaseConnection {
&self.0.context.db
}
fn settings(&self) -> &AuthSettings {
&self.0.context.config.auth
}
fn production(&self) -> bool {
self.0.context.config.app.environment == "production"
}
pub fn protect(&self, router: Router) -> Router {
router
.layer(Extension(self.clone()))
.layer(middleware::from_fn_with_state(self.clone(), guard))
}
pub(crate) fn cookie_token(&self, headers: &HeaderMap) -> Result<Option<Secret>> {
let name = self.settings().cookie_name(self.production());
let mut token = None;
for value in headers.get_all(header::COOKIE) {
let value = value.to_str().map_err(|_| AppError::Unauthorized)?;
for part in value.split(';') {
if part.trim().split('=').next().map(str::trim) != Some(name) {
continue;
}
let parsed =
Cookie::parse(part.trim().to_owned()).map_err(|_| AppError::Unauthorized)?;
if token.is_some() || !valid_token(parsed.value()) {
return Err(AppError::Unauthorized);
}
token = Some(Secret::new(parsed.value()));
}
}
Ok(token)
}
pub(crate) async fn session(&self, headers: &HeaderMap) -> Result<Option<session::Model>> {
let Some(token) = self.cookie_token(headers)? else {
return Ok(None);
};
let found = session::Entity::find_by_id(digest(token.expose()))
.one(self.db())
.await?
.ok_or(AppError::Unauthorized)?;
if found.expires_at <= now() {
tracing::info!(event = "auth.session.expired");
return Err(AppError::Unauthorized);
}
Ok(Some(found))
}
pub(crate) async fn identity(&self, headers: &HeaderMap) -> Result<Option<UserResponse>> {
let Some(session) = self.session(headers).await? else {
return Ok(None);
};
let Some(id) = session.user_id else {
return Ok(None);
};
let user = user::Entity::find_by_id(id)
.one(self.db())
.await?
.ok_or(AppError::Unauthorized)?;
if session.last_seen_at < now() - 300 {
session::Entity::update_many()
.col_expr(session::Column::LastSeenAt, Expr::value(now()))
.filter(session::Column::TokenHash.eq(session.token_hash))
.exec(self.db())
.await?;
}
Ok(Some(public_user(&user)))
}
fn cookie(&self, token: Option<&Secret>, lifetime: u64) -> Result<HeaderValue> {
let cookie = Cookie::build((
self.settings().cookie_name(self.production()).to_owned(),
token.map(|v| v.expose()).unwrap_or("").to_owned(),
))
.http_only(true)
.secure(self.settings().secure(self.production()))
.path("/")
.same_site(match self.settings().same_site {
SameSite::Lax => CookieSameSite::Lax,
SameSite::Strict => CookieSameSite::Strict,
})
.max_age(cookie::time::Duration::seconds(if token.is_some() {
lifetime as i64
} else {
0
}))
.build();
let mut value = HeaderValue::from_str(&cookie.to_string())
.map_err(|_| AppError::Configuration("Invalid auth cookie configuration".into()))?;
value.set_sensitive(true);
Ok(value)
}
fn throttle(
&self,
headers: &HeaderMap,
peer: Option<SocketAddr>,
action: &str,
account: Option<&str>,
) -> Result<()> {
let key = self.0.client_ip.resolve(peer, headers)?;
let settings = &self.settings().throttle;
if !settings.enabled {
return Ok(());
}
self.0
.throttle
.check(format!("auth:{action}:ip:{key}"), &settings.ip)?;
if let Some(account) = account {
self.0.throttle.check(
format!("auth:{action}:account:{}", digest(account)),
&settings.account,
)?;
}
Ok(())
}
}
async fn guard(State(service): State<AuthService>, mut request: Request, next: Next) -> Response {
let result = async {
if !matches!(
*request.method(),
Method::GET | Method::HEAD | Method::OPTIONS
) {
reject_cross_site(request.headers())?;
let session = service
.session(request.headers())
.await?
.ok_or(AppError::Forbidden)?;
let supplied = request
.headers()
.get("x-csrf-token")
.and_then(|v| v.to_str().ok())
.ok_or(AppError::Forbidden)?;
if !valid_token(supplied)
|| !bool::from(supplied.as_bytes().ct_eq(session.csrf_token.0.as_bytes()))
{
return Err(AppError::Forbidden);
}
request.extensions_mut().insert(session);
}
Ok(())
}
.await;
let mut response = match result {
Ok(()) => next.run(request).await,
Err(error) => error.into_response(),
};
if !response.headers().contains_key(header::CACHE_CONTROL) {
response
.headers_mut()
.insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
response
.headers_mut()
.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
}
response
}
fn reject_cross_site(headers: &HeaderMap) -> Result<()> {
if let Some(value) = headers.get("sec-fetch-site") {
if !matches!(value.to_str().unwrap_or(""), "same-origin" | "none") {
return Err(AppError::Forbidden);
}
}
Ok(())
}
async fn csrf(
Extension(service): Extension<AuthService>,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
) -> Result<Response> {
reject_cross_site(&headers)?;
if headers.get("x-capy-csrf").and_then(|v| v.to_str().ok()) != Some("1") {
return Err(AppError::Forbidden);
}
let existing = service.session(&headers).await;
if let Ok(Some(session)) = existing {
return Ok(Json(CsrfResponse {
csrf_token: session.csrf_token.0,
})
.into_response());
}
if let Err(error) = existing {
if !matches!(error, AppError::Unauthorized) {
return Err(error);
}
}
service.throttle(&headers, peer.map(|p| p.0 .0), "csrf", None)?;
let (token, session) = insert_session(service.db(), None, 1800).await?;
let mut response = Json(CsrfResponse {
csrf_token: session.csrf_token.0,
})
.into_response();
response
.headers_mut()
.insert(header::SET_COOKIE, service.cookie(Some(&token), 1800)?);
Ok(response)
}
async fn register(
Extension(service): Extension<AuthService>,
Extension(previous): Extension<session::Model>,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
Json(input): Json<RegisterRequest>,
) -> Result<Response> {
let email = normalize_email(&input.email)?;
let name = input.name.trim().to_owned();
if !(2..=100).contains(&name.chars().count()) {
return Err(invalid("name", "Use 2 to 100 characters."));
}
validate_password(&input.password, true)?;
service.throttle(&headers, peer.map(|p| p.0 .0), "register", Some(&email))?;
let password_hash = service.0.passwords.hash(input.password).await?;
let txn = service.db().begin().await?;
let created = user::ActiveModel {
name: Set(name),
email: Set(email),
password_hash: Set(crate::models::DbSecret(password_hash.expose().to_owned())),
email_verified_at: Set(None),
created_at: Set(now()),
updated_at: Set(now()),
..Default::default()
}
.insert(&txn)
.await;
let user = match created {
Ok(user) => user,
Err(error)
if matches!(
error.sql_err(),
Some(sea_orm::SqlErr::UniqueConstraintViolation(_))
) =>
{
return Err(AppError::Conflict(
"An account with this email already exists.".into(),
))
}
Err(error) => return Err(error.into()),
};
let token = rotate(
&txn,
&previous,
user.id,
service.settings().session_lifetime_seconds,
)
.await?;
service
.0
.events
.dispatch_in(
&txn,
&service.0.context,
UserRegistered {
user: public_user(&user),
},
)
.await?;
txn.commit().await?;
tracing::info!(event = "auth.register.success");
authenticated_response(&service, &user, &token, StatusCode::CREATED)
}
async fn login(
Extension(service): Extension<AuthService>,
Extension(previous): Extension<session::Model>,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
Json(input): Json<LoginRequest>,
) -> Result<Response> {
let email = normalize_email(&input.email)?;
validate_password(&input.password, false)?;
service.throttle(&headers, peer.map(|p| p.0 .0), "login", Some(&email))?;
let user = user::Entity::find()
.filter(user::Column::Email.eq(email))
.one(service.db())
.await?;
let verified = service
.0
.passwords
.verify(
input.password,
user.as_ref().map(|u| Secret::new(&u.password_hash.0)),
)
.await?;
if !verified {
tracing::info!(event = "auth.login.failed");
return Err(AppError::Unauthorized);
}
let user = user.ok_or(AppError::Unauthorized)?;
let txn = service.db().begin().await?;
let locked = user::Entity::update_many()
.col_expr(user::Column::UpdatedAt, Expr::value(now()))
.filter(user::Column::Id.eq(user.id))
.filter(user::Column::PasswordHash.eq(&user.password_hash.0))
.exec(&txn)
.await?;
if locked.rows_affected != 1 {
return Err(AppError::Unauthorized);
}
let token = rotate(
&txn,
&previous,
user.id,
service.settings().session_lifetime_seconds,
)
.await?;
service
.0
.events
.dispatch_in(
&txn,
&service.0.context,
LoginSucceeded { user_id: user.id },
)
.await?;
txn.commit().await?;
tracing::info!(event = "auth.login.success");
authenticated_response(&service, &user, &token, StatusCode::OK)
}
async fn me(AuthUser(user): AuthUser) -> Json<UserResponse> {
Json(user)
}
pub fn verification_routes() -> Routes {
Routes::new()
.get("/verification", verification_status)
.operation("authVerificationStatus")
.response::<VerificationStatus>()
.authenticated()
.post("/verification", request_verification)
.operation("authRequestVerification")
.no_content()
.authenticated()
.error(403)
.error(429)
.error(503)
.post("/verify-email", verify_email)
.operation("authVerifyEmail")
.body::<VerifyEmailRequest>()
.no_content()
.authenticated()
.error(400)
.error(403)
.error(409)
.error(429)
.error(503)
}
async fn verification_status(
Extension(service): Extension<AuthService>,
AuthUser(identity): AuthUser,
) -> Result<Json<VerificationStatus>> {
let user = user::Entity::find_by_id(identity.id)
.one(service.db())
.await?
.ok_or(AppError::Unauthorized)?;
Ok(Json(VerificationStatus {
verified: user.email_verified_at.is_some(),
}))
}
async fn request_verification(
Extension(service): Extension<AuthService>,
AuthUser(identity): AuthUser,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
) -> Result<capy_http::NoContent> {
use crate::models::verification;
service.throttle(
&headers,
peer.map(|peer| peer.0 .0),
"verification-request",
Some(&identity.email),
)?;
let delivery = service
.0
.verification_delivery
.as_ref()
.ok_or(AppError::AuthCapacity)?;
let tx = service.db().begin().await?;
lock_user(&tx, identity.id).await?;
let user = user::Entity::find_by_id(identity.id)
.one(&tx)
.await?
.ok_or(AppError::Unauthorized)?;
if user.email_verified_at.is_some() {
tx.commit().await?;
return Ok(capy_http::NoContent);
}
let token = random()?;
let expires_at = now() + 1800;
verification::Entity::delete_by_id(user.id)
.exec(&tx)
.await?;
verification::ActiveModel {
user_id: Set(user.id),
token_hash: Set(crate::models::DbSecret(digest(token.expose()))),
email: Set(crate::models::DbSecret(user.email.clone())),
expires_at: Set(expires_at),
}
.insert(&tx)
.await?;
tx.commit().await?;
delivery
.deliver(VerificationMessage {
email: user.email,
token,
expires_at,
})
.await?;
Ok(capy_http::NoContent)
}
async fn verify_email(
Extension(service): Extension<AuthService>,
AuthUser(identity): AuthUser,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
Json(input): Json<VerifyEmailRequest>,
) -> Result<capy_http::NoContent> {
use crate::models::verification;
service.throttle(
&headers,
peer.map(|peer| peer.0 .0),
"verification-consume",
Some(&identity.email),
)?;
if !valid_token(input.token.expose()) {
return Err(verification_invalid());
}
let tx = service.db().begin().await?;
lock_user(&tx, identity.id).await?;
let user = user::Entity::find_by_id(identity.id)
.one(&tx)
.await?
.ok_or(AppError::Unauthorized)?;
let consumed = verification::Entity::delete_many()
.filter(verification::Column::UserId.eq(user.id))
.filter(verification::Column::Email.eq(user.email))
.filter(verification::Column::TokenHash.eq(digest(input.token.expose())))
.filter(verification::Column::ExpiresAt.gt(now()))
.exec(&tx)
.await?;
if consumed.rows_affected != 1 {
return Err(verification_invalid());
}
service.verify_email_in(&tx, identity.id).await?;
tx.commit().await?;
Ok(capy_http::NoContent)
}
fn verification_invalid() -> AppError {
AppError::BadRequest("Invalid or expired email verification token.".into())
}
async fn logout(
Extension(service): Extension<AuthService>,
Extension(session): Extension<session::Model>,
AuthUser(user): AuthUser,
) -> Result<Response> {
let txn = service.db().begin().await?;
let removed = session::Entity::delete_by_id(session.token_hash)
.exec(&txn)
.await?;
if removed.rows_affected == 1 {
service
.0
.events
.dispatch_in(&txn, &service.0.context, LoggedOut { user_id: user.id })
.await?;
}
txn.commit().await?;
let mut response = StatusCode::NO_CONTENT.into_response();
response
.headers_mut()
.insert(header::SET_COOKIE, service.cookie(None, 0)?);
tracing::info!(event = "auth.logout");
Ok(response)
}
async fn forgot(
Extension(service): Extension<AuthService>,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
Json(input): Json<ForgotPasswordRequest>,
) -> Result<Json<ResetRequestedResponse>> {
let email = normalize_email(&input.email)?;
service.throttle(
&headers,
peer.map(|p| p.0 .0),
"reset-request",
Some(&email),
)?;
let token = random()?;
let user = user::Entity::find()
.filter(user::Column::Email.eq(&email))
.one(service.db())
.await?;
if let Some(user) = user {
let txn = service.db().begin().await?;
lock_user(&txn, user.id).await?;
reset::Entity::delete_many()
.filter(reset::Column::UserId.eq(user.id))
.exec(&txn)
.await?;
let expires_at = now() + service.settings().password_reset_lifetime_seconds as i64;
reset::ActiveModel {
token_hash: Set(digest(token.expose())),
user_id: Set(user.id),
created_at: Set(now()),
expires_at: Set(expires_at),
}
.insert(&txn)
.await?;
txn.commit().await?;
let delivered = tokio::time::timeout(
std::time::Duration::from_secs(5),
service.0.delivery.deliver(ResetMessage {
email,
token,
expires_at,
}),
)
.await;
if !matches!(delivered, Ok(Ok(()))) {
tracing::warn!(event = "auth.password_reset.delivery_failed");
}
}
tracing::info!(event = "auth.password_reset.requested");
Ok(Json(ResetRequestedResponse {
message: "If that account exists, password reset instructions will be delivered.",
}))
}
async fn reset_password(
Extension(service): Extension<AuthService>,
peer: Option<Extension<ConnectInfo<SocketAddr>>>,
headers: HeaderMap,
Json(input): Json<ResetPasswordRequest>,
) -> Result<Response> {
service.throttle(
&headers,
peer.map(|p| p.0 .0),
"reset-complete",
Some(input.token.expose()),
)?;
validate_password(&input.password, true)?;
if !valid_token(input.token.expose()) {
return Err(reset_invalid());
}
let digest = digest(input.token.expose());
let reset = reset::Entity::find_by_id(&digest)
.one(service.db())
.await?
.filter(|r| r.expires_at > now())
.ok_or_else(reset_invalid)?;
let password = service.0.passwords.hash(input.password).await?;
let txn = service.db().begin().await?;
lock_user(&txn, reset.user_id).await?;
let consumed = reset::Entity::delete_many()
.filter(reset::Column::TokenHash.eq(digest))
.filter(reset::Column::ExpiresAt.gt(now()))
.exec(&txn)
.await?;
if consumed.rows_affected != 1 {
return Err(reset_invalid());
}
user::Entity::update_many()
.col_expr(user::Column::PasswordHash, Expr::value(password.expose()))
.col_expr(user::Column::UpdatedAt, Expr::value(now()))
.filter(user::Column::Id.eq(reset.user_id))
.exec(&txn)
.await?;
reset::Entity::delete_many()
.filter(reset::Column::UserId.eq(reset.user_id))
.exec(&txn)
.await?;
session::Entity::delete_many()
.filter(session::Column::UserId.eq(reset.user_id))
.exec(&txn)
.await?;
service
.0
.events
.dispatch_in(
&txn,
&service.0.context,
PasswordResetCompleted {
user_id: reset.user_id,
},
)
.await?;
txn.commit().await?;
tracing::info!(event = "auth.password_reset.completed");
let mut response = StatusCode::NO_CONTENT.into_response();
response
.headers_mut()
.insert(header::SET_COOKIE, service.cookie(None, 0)?);
Ok(response)
}
fn reset_invalid() -> AppError {
AppError::BadRequest("Invalid or expired password reset token.".into())
}
async fn lock_user(db: &impl ConnectionTrait, id: i64) -> Result<()> {
let result = user::Entity::update_many()
.col_expr(user::Column::UpdatedAt, Expr::value(now()))
.filter(user::Column::Id.eq(id))
.exec(db)
.await?;
if result.rows_affected != 1 {
return Err(AppError::Unauthorized);
}
Ok(())
}
fn authenticated_response(
service: &AuthService,
user: &user::Model,
token: &Secret,
status: StatusCode,
) -> Result<Response> {
let mut response = (status, Json(public_user(user))).into_response();
response.headers_mut().insert(
header::SET_COOKIE,
service.cookie(Some(token), service.settings().session_lifetime_seconds)?,
);
Ok(response)
}
fn public_user(user: &user::Model) -> UserResponse {
UserResponse {
id: user.id,
name: user.name.clone(),
email: user.email.clone(),
}
}
async fn rotate(
db: &impl ConnectionTrait,
previous: &session::Model,
user: i64,
lifetime: u64,
) -> Result<Secret> {
let removed = session::Entity::delete_many()
.filter(session::Column::TokenHash.eq(&previous.token_hash))
.filter(session::Column::ExpiresAt.gt(now()))
.exec(db)
.await?;
if removed.rows_affected != 1 {
return Err(AppError::Unauthorized);
}
Ok(insert_session(db, Some(user), lifetime).await?.0)
}
async fn insert_session(
db: &impl ConnectionTrait,
user: Option<i64>,
lifetime: u64,
) -> Result<(Secret, session::Model)> {
let token = random()?;
let csrf = random()?;
let model = session::ActiveModel {
token_hash: Set(digest(token.expose())),
user_id: Set(user),
csrf_token: Set(crate::models::DbSecret(csrf.expose().to_owned())),
created_at: Set(now()),
last_seen_at: Set(now()),
expires_at: Set(now() + lifetime as i64),
}
.insert(db)
.await?;
Ok((token, model))
}
pub async fn prune(db: &DatabaseConnection) -> Result<u64> {
let sessions = session::Entity::delete_many()
.filter(session::Column::ExpiresAt.lte(now()))
.exec(db)
.await?
.rows_affected;
let resets = reset::Entity::delete_many()
.filter(reset::Column::ExpiresAt.lte(now()))
.exec(db)
.await?
.rows_affected;
Ok(sessions + resets)
}
pub(crate) fn now() -> i64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("clock after Unix epoch")
.as_secs() as i64
}