🔒️ (user): Limita los cambios de email por cuenta

- `max_email_changes` en `email_change_window_secs`: una cuenta no puede
  usar el cambio de email para enviar confirmaciones a muchas
  direcciones ajenas, aunque reparta las peticiones entre muchas IP.
- El límite por cuenta se aplica al crear el token (`TokenKind::limit()`
  para los dos límites): guarda primero y cuenta después, así las
  peticiones simultáneas no lo superan; rechazado, el enlace anterior
  sigue valiendo. Sustituye a `count_tokens_since()`.
- El cambio de email crea el token antes de guardar la dirección
  pendiente, para que un rechazo no anule el cambio en curso.
- Mensaje de `TooManyRequests` genérico, válido para los límites por
  cuenta y por IP.
This commit is contained in:
Manuel Cillero 2026-11-01 07:33:26 +01:00
parent 3fba1ca875
commit a110dd0482
14 changed files with 432 additions and 91 deletions

View file

@ -230,8 +230,12 @@ async fn checked_user(user_id: i32, plain_password: &str) -> Result<user::Model,
///
/// Falla con [`AuthError::InvalidCredentials`] si la contraseña no es correcta,
/// [`AuthError::AccountLocked`] si la cuenta está bloqueada por intentos fallidos,
/// [`AuthError::SameEmail`] si la dirección es la actual (sin distinguir mayúsculas) y
/// [`AuthError::EmailTaken`] si la usa otra cuenta.
/// [`AuthError::TooManyRequests`] si la cuenta ya ha pedido [`max_email_changes`] cambios en
/// [`email_change_window_secs`], [`AuthError::SameEmail`] si la dirección es la actual (sin
/// distinguir mayúsculas) y [`AuthError::EmailTaken`] si la usa otra cuenta.
///
/// [`max_email_changes`]: crate::config::UserSettings::max_email_changes
/// [`email_change_window_secs`]: crate::config::UserSettings::email_change_window_secs
pub(crate) async fn request_email_change(
user_id: i32,
current_password: &str,
@ -244,6 +248,16 @@ pub(crate) async fn request_email_change(
}
ensure_email_available(&email, Some(user_id)).await?;
// Después de la contraseña (quien no la tenga no sabe nada del límite) y antes de guardar la
// dirección: rechazado, el cambio pendiente y su enlace siguen como estaban.
let token = match token::create_bound_token(user_id, TokenKind::EmailChange, email.key()).await
{
Err(AuthError::TooManyRequests) => {
trace::warn!("Email change limit reached for user {user_id}");
return Err(AuthError::TooManyRequests);
}
result => result?,
};
let new_email = email.value().to_owned();
user::ActiveModel {
id: Set(user_id),
@ -253,7 +267,6 @@ pub(crate) async fn request_email_change(
}
.update(dbconn())
.await?;
let token = token::create_bound_token(user_id, TokenKind::EmailChange, email.key()).await?;
Ok((user_model, new_email, token))
}

View file

@ -73,21 +73,37 @@ pub struct UserSettings {
/// [`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
/// límite, las siguientes no envían nada hasta que la más antigua de las contadas deja de
/// contar, 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.
/// Periodo en segundos, hacia atrás desde cada solicitud, en el que se cuentan las de
/// recuperación de contraseña de una cuenta: cada una deja de contar al cumplirse este tiempo.
#[default = 3_600]
pub password_reset_window_secs: i64,
/// Cambios de email que puede pedir una misma cuenta en
/// [`email_change_window_secs`](Self::email_change_window_secs).
///
/// Cada petición envía dos correos: el enlace de confirmación a la nueva dirección, que puede
/// ser de otra persona, y un aviso a la actual. Alcanzado el límite, el formulario muestra un
/// error y no se envía nada hasta que la más antigua de las contadas deja de contar. Así nadie
/// puede usar una cuenta para enviar confirmaciones a muchas direcciones ajenas, aunque reparta
/// las peticiones entre muchas direcciones IP. Con `0` no hay límite.
#[default = 3]
pub max_email_changes: u32,
/// Periodo en segundos, hacia atrás desde cada petición, en el que se cuentan los cambios de
/// email pedidos por una cuenta: cada uno deja de contar al cumplirse este tiempo.
#[default = 3_600]
pub email_change_window_secs: i64,
/// Solicitudes que envían un correo o crean una cuenta (registros, recuperaciones de
/// contraseña y cambios de email) que se admiten desde una misma dirección IP en
/// [`ip_request_window_secs`](Self::ip_request_window_secs).
/// [`ip_request_window_secs`].
///
/// Complementa a [`max_password_resets`](Self::max_password_resets), que limita las de cada
/// Complementa a [`max_password_resets`] y [`max_email_changes`], que limitan las de cada
/// cuenta: sin este límite, cualquiera podría usar la aplicación para enviar correos a muchas
/// direcciones ajenas, registrándolas o pidiendo su recuperación. Alcanzado el límite, el
/// registro y el cambio de email muestran un error, y la recuperación no envía nada, con la
@ -100,10 +116,14 @@ pub struct UserSettings {
/// lleva su propia cuenta, en memoria: con varias instancias, el límite es por instancia. Con
/// `0` no hay límite.
///
/// [`ip_request_window_secs`]: Self::ip_request_window_secs
/// [`max_email_changes`]: Self::max_email_changes
/// [`max_password_resets`]: Self::max_password_resets
/// [`pagetop::web::HttpRequest::client_ip()`]: pagetop::web::HttpRequest::client_ip
#[default = 20]
pub max_ip_requests: u32,
/// Segundos en los que se cuentan las solicitudes de una misma dirección IP.
/// Periodo en segundos, hacia atrás desde cada solicitud, en el que se cuentan las de una misma
/// dirección IP: cada una deja de contar al cumplirse este tiempo.
#[default = 3_600]
pub ip_request_window_secs: i64,

View file

@ -47,7 +47,7 @@ pub enum AuthError {
#[error("new email is the same as the current one")]
SameEmail,
#[error("too many requests from the same address")]
#[error("too many requests")]
TooManyRequests,
#[error("passwords do not match")]

View file

@ -15,7 +15,7 @@ use crate::mail::send_token_mail;
use crate::password;
use crate::session;
use crate::throttle;
use crate::token::{TokenKind, consume_token, count_tokens_since, create_token, is_valid_token};
use crate::token::{TokenKind, consume_token, create_token, is_valid_token};
use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_PATH};
// **< Tipos de formularios >***********************************************************************
@ -251,25 +251,13 @@ 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);
}
Err(AuthError::TooManyRequests) => {
trace::warn!("Password reset limit reached for user {}", user_model.id);
}
Err(err) => trace::error!("Cannot create password reset token: {err}"),
}
});

View file

@ -5,20 +5,52 @@
<p>Gestión de usuarios, autenticación, roles y permisos para <strong>PageTop</strong>.</p>
[![Doc API](https://img.shields.io/docsrs/pagetop-user?label=Doc%20API&style=for-the-badge&logo=Docs.rs)](https://docs.rs/pagetop-user)
[![Crates.io](https://img.shields.io/crates/v/pagetop-user.svg?style=for-the-badge&logo=ipfs)](https://crates.io/crates/pagetop-user)
[![Descargas](https://img.shields.io/crates/d/pagetop-user.svg?label=Descargas&style=for-the-badge&logo=transmission)](https://crates.io/crates/pagetop-user)
[![Licencia](https://img.shields.io/badge/license-MIT%2FApache-blue.svg?label=Licencia&style=for-the-badge)](https://git.cillero.es/manuelcillero/pagetop/src/branch/main/extensions/pagetop-user#licencia)
</div>
Añade cuentas de usuario a una aplicación PageTop: registro, inicio de sesión con sesiones en la
base de datos, perfil propio, recuperación de contraseña y verificación del email por correo, y
control de acceso con roles y permisos. Incluye las páginas de administración de usuarios, roles y
permisos sobre `pagetop-admin`, hechas sólo con componentes del núcleo para que funcionen con
cualquier tema.
## Sobre PageTop
[PageTop](https://docs.rs/pagetop) es un entorno de desarrollo que reivindica la esencia de la web
clásica para crear soluciones web SSR (*renderizadas en el servidor*) modulares, extensibles y
configurables, basadas en HTML, CSS y JavaScript.
## Guía rápida
Declara la dependencia en tu `Cargo.toml`:
**Añade la dependencia** a tu `Cargo.toml`:
```toml
[dependencies]
pagetop-user = "..."
```
Añade `&pagetop_user::User` a las dependencias de tu extensión. El usuario actual se inyecta
automáticamente en el contexto de cada [`Page`] al crearla con [`Page::new()`], sin necesidad de
llamadas adicionales. Usa las helpers del core para acceder a él:
Los usuarios y las sesiones se guardan con [`pagetop_seaorm`]: la aplicación elige el motor de base
de datos con su *feature* (`postgres`, `mysql` o `sqlite`) y configura la conexión en la sección
`[database]`.
**Declara la extensión** como dependencia de tu aplicación o de la extensión que la requiera
(`&pagetop_user::User`, como en el ejemplo de más abajo). Al arrancar crea sus tablas y, si no hay
ninguna cuenta, el primer administrador, con los datos de `[user.seed]`:
```toml
[user.seed]
admin_username = "admin"
admin_email = "admin@example.com"
# Sin 'admin_password', se genera una aleatoria y se muestra una sola vez al crearlo.
```
**Comprueba los permisos** en tus *handlers*. El usuario actual se inyecta automáticamente en el
contexto de cada [`Page`] al crearla con [`Page::new()`], y las funciones del núcleo, como
[`has_permission()`], lo consultan:
```rust,no_run
use pagetop::prelude::*;
@ -60,6 +92,18 @@ async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> {
}
```
## Páginas
| Ruta | Uso |
|---------------------------|--------------------------------------------------------------|
| `/user/login` | Inicio de sesión, con el nombre de usuario o el email. |
| `/user/register` | Registro, si lo permite `allow_registration`. |
| `/user` | Perfil propio: editarlo, cambiar la contraseña o el email. |
| `/user/password/reset` | Recuperación de la contraseña por correo. |
| `/admin/user/users` | Administración de usuarios: alta, edición, roles, bloqueo... |
| `/admin/user/roles` | Administración de roles y de sus permisos. |
| `/admin/user/permissions` | Catálogo de los permisos que declaran las extensiones. |
## Nombres de usuario y email
Cada cuenta tiene un nombre de usuario y un email, obligatorios y únicos; se puede iniciar sesión
@ -104,10 +148,10 @@ de la cuenta; los de recuperación, también cuando cambia su contraseña.
Cambiar la contraseña o el email exige la contraseña actual, y sus fallos cuentan para el bloqueo
por intentos fallidos (`max_failed_logins`), como los del inicio de sesión.
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las
recuperaciones de contraseña se limitan por cuenta (`max_password_resets`), y ellas, los registros
y los cambios de dirección, también por dirección IP (`max_ip_requests`). Detrás de un *proxy*
inverso, el límite por IP requiere configurar `server.client_ip_header`.
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás
de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
*/
use pagetop::prelude::*;

View file

@ -134,7 +134,7 @@ error-invalid-username = The username is not valid: check the rules shown b
error-invalid-email = The email address is not valid.
error-email-taken = This email address is already registered.
error-same-email = The new address is the same as the current one.
error-too-many-requests = Too many requests from your connection. Please try again later.
error-too-many-requests = Too many requests. Please try again later.
error-token-invalid = This link is invalid or has expired.
error-current-password = The current password is incorrect.
error-internal = An unexpected error occurred. Please try again.

View file

@ -134,7 +134,7 @@ error-invalid-username = El nombre de usuario no es válido: revisa las reg
error-invalid-email = La dirección de correo no es válida.
error-email-taken = Esta dirección de email ya está registrada.
error-same-email = La nueva dirección es la misma que la actual.
error-too-many-requests = Demasiadas solicitudes desde tu conexión. Inténtalo de nuevo más tarde.
error-too-many-requests = Demasiadas solicitudes. Inténtalo de nuevo más tarde.
error-token-invalid = Este enlace no es válido o ha caducado.
error-current-password = La contraseña actual no es correcta.
error-internal = Se ha producido un error inesperado. Inténtalo de nuevo.

View file

@ -80,22 +80,44 @@ impl TokenKind {
}
}
// 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 {
// Límite de tokens de este tipo que puede pedir una cuenta: cuántos (0 = sin límite) y en
// cuántos segundos.
fn limit(self) -> (u32, i64) {
match self {
TokenKind::PasswordReset => self.ttl_secs().max(SETTINGS.password_reset_window_secs),
TokenKind::EmailVerification | TokenKind::EmailChange => self.ttl_secs(),
TokenKind::PasswordReset => (
SETTINGS.max_password_resets,
SETTINGS.password_reset_window_secs,
),
TokenKind::EmailChange => (
SETTINGS.max_email_changes,
SETTINGS.email_change_window_secs,
),
TokenKind::EmailVerification => (0, 0),
}
}
// Segundos que se conserva un token desde su creación: hasta que caduca y mientras cuenta para
// el límite de su tipo.
fn keep_secs(self) -> i64 {
self.ttl_secs().max(self.limit().1)
}
}
// **< create_token >*******************************************************************************
/// Crea un token en BD y devuelve el valor en claro para enviarlo al usuario.
///
/// Anula los tokens del mismo tipo que el usuario tenga sin consumir, de modo que sólo vale el
/// último enlace enviado.
/// Anula los tokens anteriores del mismo tipo que el usuario tenga sin consumir, de modo que sólo
/// vale el último enlace enviado. Falla con [`AuthError::TooManyRequests`] si el usuario ya ha
/// pedido todos los que admite el límite de su tipo:
/// [`max_password_resets`](crate::config::UserSettings::max_password_resets) en
/// [`password_reset_window_secs`](crate::config::UserSettings::password_reset_window_secs) los de
/// recuperación de contraseña, y
/// [`max_email_changes`](crate::config::UserSettings::max_email_changes) en
/// [`email_change_window_secs`](crate::config::UserSettings::email_change_window_secs) los de
/// cambio de email. Cuentan todos los creados en ese tiempo, consumidos o anulados también, pero no
/// los rechazados; los de verificación de email no tienen límite. Rechazado, los anteriores siguen
/// valiendo.
pub async fn create_token(user_id: i32, kind: TokenKind) -> Result<String, AuthError> {
create_bound_token(user_id, kind, "").await
}
@ -109,31 +131,58 @@ pub async fn create_bound_token(
binding: &str,
) -> Result<String, AuthError> {
let now = Utc::now();
let token = generate_token();
let new_token = user_token::ActiveModel {
id: ActiveValue::NotSet,
user_id: Set(user_id),
kind: Set(kind.as_str().to_owned()),
token_hash: Set(bound_hash(&token, binding)),
expires_at: Set(now + Duration::seconds(kind.ttl_secs())),
consumed_at: Set(None),
created_at: Set(now),
updated_at: Set(now),
};
let id = user_token::Entity::insert(new_token)
.exec(dbconn())
.await?
.last_insert_id;
// 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.
revoke_tokens(user_id, kind).await?;
// Se cuenta después de guardarlo y contándolo a él: si varias peticiones simultáneas guardan el
// suyo antes de contar, la última en contar los ve todos, así que nunca se admiten más de las
// que permite el límite (como mucho, se rechaza alguna de más). El rechazado se borra para que
// no cuente.
let (max, window_secs) = kind.limit();
if max > 0 {
let count = 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(now - Duration::seconds(window_secs)))
.count(dbconn())
.await?;
if count > u64::from(max) {
user_token::Entity::delete_by_id(id).exec(dbconn()).await?;
return Err(AuthError::TooManyRequests);
}
}
// Sólo los anteriores a éste: si dos peticiones simultáneas se anularan entre sí, no valdría
// ningún enlace. Se anulan en lugar de borrarse para que sigan contando para el límite; 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())
.filter(user_token::Column::Id.lt(id))
.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 expires_at = now + Duration::seconds(kind.ttl_secs());
let new_token = user_token::ActiveModel {
id: ActiveValue::NotSet,
user_id: Set(user_id),
kind: Set(kind.as_str().to_owned()),
token_hash: Set(bound_hash(&token, binding)),
expires_at: Set(expires_at),
consumed_at: Set(None),
created_at: Set(now),
updated_at: Set(now),
};
user_token::Entity::insert(new_token).exec(dbconn()).await?;
Ok(token)
}
@ -152,25 +201,6 @@ pub async fn revoke_tokens(user_id: i32, kind: TokenKind) -> Result<(), AuthErro
Ok(())
}
/// Cuenta los tokens del tipo indicado creados para el usuario desde `since`, consumidos o no.
///
/// Los tokens se conservan al menos durante su tiempo de vida o, en los de recuperación de
/// contraseña, durante
/// [`password_reset_window_secs`](crate::config::UserSettings::password_reset_window_secs) si es
/// mayor. Con un `since` más antiguo el recuento puede quedarse corto.
pub async fn count_tokens_since(
user_id: i32,
kind: TokenKind,
since: DateTime<Utc>,
) -> Result<u64, AuthError> {
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