From 5540c0c6a0c5054e4ec8b9527d25e60e6094f431 Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sat, 31 Oct 2026 01:05:15 +0100 Subject: [PATCH] =?UTF-8?q?=F0=9F=94=92=EF=B8=8F=20(user):=20Limita=20soli?= =?UTF-8?q?citudes=20de=20recuperaci=C3=B3n?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Añade `max_password_resets` (3; 0 = sin límite) y `password_reset_window_secs` (3600) en [user]. Alcanzado el límite no se envía el correo y la respuesta es la misma, para no revelar si la cuenta existe. --- config/reference.toml | 4 ++ extensions/pagetop-user/src/config.rs | 14 ++++++ extensions/pagetop-user/src/handlers/auth.rs | 17 ++++++- extensions/pagetop-user/src/token.rs | 51 ++++++++++++++++++-- 4 files changed, 81 insertions(+), 5 deletions(-) diff --git a/config/reference.toml b/config/reference.toml index c533cc03..cac84285 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -274,6 +274,10 @@ failed_login_window_secs = 900 # Segundos desde el último fallo en los locked_for_secs = 600 # Duración del bloqueo de la cuenta en segundos (10 minutos). # Después se dispone otra vez de todos los intentos. +max_password_resets = 3 # Solicitudes de recuperación de contraseña por cuenta en la + # ventana; las siguientes no envían correo. 0 -> sin límite. +password_reset_window_secs = 3600 # Segundos en los que se cuentan las solicitudes (1 hora). + login_strict = false # Dificulta que el navegador recuerde o autorrellene las # credenciales en el formulario de acceso. diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs index e6233f3c..cb0d01a3 100644 --- a/extensions/pagetop-user/src/config.rs +++ b/extensions/pagetop-user/src/config.rs @@ -67,6 +67,20 @@ pub struct UserSettings { #[default = 600] pub locked_for_secs: i64, + /// Solicitudes de recuperación de contraseña que puede recibir una misma cuenta en + /// [`password_reset_window_secs`](Self::password_reset_window_secs). + /// + /// Cada solicitud envía un correo con un enlace nuevo que anula los anteriores. Alcanzado el + /// límite, las siguientes no envían nada hasta que la más antigua de la ventana queda fuera de + /// ella, y la respuesta es la misma para no revelar si la cuenta existe. Así nadie puede + /// inundar el buzón de otra persona ni dañar la reputación del servidor de correo. Con `0` no + /// hay límite. + #[default = 3] + pub max_password_resets: u32, + /// Segundos en los que se cuentan las solicitudes de recuperación de contraseña de una cuenta. + #[default = 3_600] + pub password_reset_window_secs: i64, + /// Sesiones, en la subsección `[user.session]`. pub session: SessionSettings, diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs index 1e3b42bd..920a43b0 100644 --- a/extensions/pagetop-user/src/handlers/auth.rs +++ b/extensions/pagetop-user/src/handlers/auth.rs @@ -13,7 +13,7 @@ use crate::handlers::admin::map_auth_error; use crate::mail::send_token_mail; use crate::password; use crate::session; -use crate::token::{TokenKind, consume_token, create_token, is_valid_token}; +use crate::token::{TokenKind, consume_token, count_tokens_since, create_token, is_valid_token}; use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_PATH}; // **< Tipos de formularios >*********************************************************************** @@ -241,6 +241,21 @@ pub async fn password_reset_post( return; } }; + let max = SETTINGS.max_password_resets; + if max > 0 { + let since = Utc::now() - Duration::seconds(SETTINGS.password_reset_window_secs); + match count_tokens_since(user_model.id, TokenKind::PasswordReset, since).await { + Ok(count) if count >= u64::from(max) => { + trace::warn!("Password reset limit reached for user {}", user_model.id); + return; + } + Ok(_) => {} + Err(err) => { + trace::error!("Cannot count password reset requests: {err}"); + return; + } + } + } match create_token(user_model.id, TokenKind::PasswordReset).await { Ok(token) => { send_token_mail(&mail_request, TokenKind::PasswordReset, &user_model, &token); diff --git a/extensions/pagetop-user/src/token.rs b/extensions/pagetop-user/src/token.rs index 47ff18dc..bb4902b5 100644 --- a/extensions/pagetop-user/src/token.rs +++ b/extensions/pagetop-user/src/token.rs @@ -3,8 +3,11 @@ use pagetop::prelude::*; use pagetop_seaorm::db::query::Expr; -use pagetop_seaorm::db::{ActiveValue, ColumnTrait, EntityTrait, QueryFilter, Set, dbconn}; +use pagetop_seaorm::db::{ + ActiveValue, ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, Set, dbconn, +}; +use crate::config::SETTINGS; use crate::entity::user_token; use crate::error::AuthError; @@ -62,23 +65,44 @@ impl TokenKind { TokenKind::EmailVerification => 86400 * 3, // 3 días } } + + // Segundos que se conserva un token desde su creación: hasta que caduca y, los de recuperación, + // mientras cuentan para el límite de solicitudes. + fn keep_secs(self) -> i64 { + match self { + TokenKind::PasswordReset => self.ttl_secs().max(SETTINGS.password_reset_window_secs), + TokenKind::EmailVerification => self.ttl_secs(), + } + } } // **< create_token >******************************************************************************* /// Crea un token en BD y devuelve el valor en claro para enviarlo al usuario. /// -/// Si el usuario ya tiene un token del mismo tipo vigente, lo reemplaza. +/// Anula los tokens del mismo tipo que el usuario tenga sin consumir, de modo que sólo vale el +/// último enlace enviado. pub async fn create_token(user_id: i32, kind: TokenKind) -> Result { - // Invalidar tokens anteriores del mismo tipo para este usuario. + let now = Utc::now(); + + // Los anteriores se anulan en lugar de borrarse para que sigan contando en + // `count_tokens_since()`; sólo se borran los que ya no pueden usarse ni cuentan. + user_token::Entity::update_many() + .col_expr(user_token::Column::ConsumedAt, Expr::value(now)) + .col_expr(user_token::Column::UpdatedAt, Expr::value(now)) + .filter(user_token::Column::UserId.eq(user_id)) + .filter(user_token::Column::Kind.eq(kind.as_str())) + .filter(user_token::Column::ConsumedAt.is_null()) + .exec(dbconn()) + .await?; user_token::Entity::delete_many() .filter(user_token::Column::UserId.eq(user_id)) .filter(user_token::Column::Kind.eq(kind.as_str())) + .filter(user_token::Column::CreatedAt.lt(now - Duration::seconds(kind.keep_secs()))) .exec(dbconn()) .await?; let token = generate_token(); - let now = Utc::now(); let expires_at = now + Duration::seconds(kind.ttl_secs()); let new_token = user_token::ActiveModel { @@ -95,6 +119,25 @@ pub async fn create_token(user_id: i32, kind: TokenKind) -> Result, +) -> Result { + Ok(user_token::Entity::find() + .filter(user_token::Column::UserId.eq(user_id)) + .filter(user_token::Column::Kind.eq(kind.as_str())) + .filter(user_token::Column::CreatedAt.gte(since)) + .count(dbconn()) + .await?) +} + // **< is_valid_token / consume_token >************************************************************* /// Comprueba, sin consumirlo, que el token en claro sea válido para el usuario: existe, es del tipo