diff --git a/config/reference.toml b/config/reference.toml
index c8d32cda..5055aa0a 100644
--- a/config/reference.toml
+++ b/config/reference.toml
@@ -304,15 +304,22 @@ 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).
+max_password_resets = 3 # Máximo de solicitudes de recuperación de contraseña de una
+ # misma cuenta en un periodo de 'password_reset_window_secs'
+ # segundos; las siguientes no envían correo. 0 -> sin límite.
+password_reset_window_secs = 3600 # Duración del periodo en segundos (1 hora).
-max_ip_requests = 20 # Registros, recuperaciones de contraseña y cambios de email
- # desde una misma IP (IPv6 por su red /64) en la ventana.
- # Tras un proxy inverso requiere 'server.client_ip_header'.
- # Cada instancia cuenta las suyas. 0 -> sin límite.
-ip_request_window_secs = 3600 # Segundos en los que se cuentan las solicitudes (1 hora).
+max_email_changes = 3 # Máximo de cambios de email que puede pedir una misma cuenta
+ # en un periodo de 'email_change_window_secs' segundos; los
+ # siguientes dan error y no envían correo. 0 -> sin límite.
+email_change_window_secs = 3600 # Duración del periodo en segundos (1 hora).
+
+max_ip_requests = 20 # Máximo de registros, recuperaciones de contraseña y cambios
+ # de email desde una misma IP (IPv6 por su red /64) en un
+ # periodo de 'ip_request_window_secs' segundos. Tras un proxy
+ # inverso requiere 'server.client_ip_header'. Cada instancia
+ # cuenta las suyas. 0 -> sin límite.
+ip_request_window_secs = 3600 # Duración del periodo en segundos (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/LICENSE-APACHE b/extensions/pagetop-user/LICENSE-APACHE
index 263ddac1..56cfd2db 100644
--- a/extensions/pagetop-user/LICENSE-APACHE
+++ b/extensions/pagetop-user/LICENSE-APACHE
@@ -186,7 +186,7 @@
same "printed page" as the copyright notice for easier
identification within third-party archives.
- Copyright 2022 Manuel Cillero
+ Copyright 2026 Manuel Cillero
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
diff --git a/extensions/pagetop-user/LICENSE-MIT b/extensions/pagetop-user/LICENSE-MIT
index cd8af3d6..4227455e 100644
--- a/extensions/pagetop-user/LICENSE-MIT
+++ b/extensions/pagetop-user/LICENSE-MIT
@@ -1,6 +1,6 @@
MIT License
-Copyright (c) 2022 Manuel Cillero
+Copyright (c) 2026 Manuel Cillero
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/extensions/pagetop-user/README.md b/extensions/pagetop-user/README.md
new file mode 100644
index 00000000..301aa552
--- /dev/null
+++ b/extensions/pagetop-user/README.md
@@ -0,0 +1,180 @@
+
+
+
PageTop User
+
+
Gestión de usuarios, autenticación, roles y permisos para PageTop.
+
+[](https://docs.rs/pagetop-user)
+[](https://crates.io/crates/pagetop-user)
+[](https://crates.io/crates/pagetop-user)
+[](https://git.cillero.es/manuelcillero/pagetop/src/branch/main/extensions/pagetop-user#licencia)
+
+
+
+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
+
+**Añade la dependencia** a tu `Cargo.toml`:
+
+```toml
+[dependencies]
+pagetop-user = "..."
+```
+
+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::*;
+use pagetop_user::prelude::*;
+
+#[derive(Clone, Copy, Debug)]
+enum MyPermission {
+ SeeDashboard,
+}
+
+impl Permission for MyPermission {
+ fn key(&self) -> CowStr {
+ match self {
+ Self::SeeDashboard => "myapp:see_dashboard".into(),
+ }
+ }
+}
+
+struct MyApp;
+
+#[async_trait]
+impl Extension for MyApp {
+ fn dependencies(&self) -> Vec {
+ vec![&pagetop_user::User]
+ }
+
+ fn configure_router(&self, router: Router) -> Router {
+ router.route("/dashboard", web::get(dashboard))
+ }
+}
+
+async fn dashboard(request: HttpRequest) -> Result {
+ if !has_permission(&request, &MyPermission::SeeDashboard) {
+ return Err(ErrorPage::NotFound(Some(request)));
+ }
+ Page::new(request)
+ .with_child(Html::with(|_| html! { h1 { "Panel" } }))
+ .render().await
+}
+```
+
+## 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
+con cualquiera de los dos. Qué nombres de usuario se aceptan lo decide `identity_policy` en la
+sección `[user]`:
+
+```toml
+[user]
+identity_policy = "unicode" # "strict" (por defecto), "unicode" o "permissive".
+```
+
+Con cualquier política, un nombre de usuario nunca contiene `@`, no se distinguen mayúsculas (`Ana`
+y `ana` son el mismo usuario) y no se admiten nombres que se confunden a simple vista con otro
+existente (`rnaria` si existe `maria`, o `аdmin` con una `а` cirílica). Las reglas completas de
+cada política, y las del email, están en `IdentityPolicy` (módulo `config`).
+
+## Correos
+
+La recuperación de contraseña, la confirmación de una nueva dirección y, con
+`require_email_verification`, la verificación de las cuentas nuevas envían un correo con un enlace
+de un solo uso mediante `pagetop-mail`. Además, se avisa a la dirección de la cuenta cuando
+cambia su contraseña (la cambie el usuario o un administrador) y cuando se pide cambiar su
+dirección. Configura el envío en la sección `[mail]`, incluidos el remitente (`mail.from`), que
+estos correos no indican, y la URL pública de los enlaces (`mail.base_url`): sin configurar, los
+correos se escriben en las trazas en lugar de enviarse.
+
+La recuperación de contraseña sólo se envía a cuentas activas. Mientras una dirección no está
+verificada podría ser de otra persona, así que sus correos no incluyen nada que elija quien creó
+la cuenta, ni el nombre de usuario ni el nombre visible. Una dirección queda verificada al
+confirmarla desde el enlace del correo de verificación (abrirlo no basta: hay que pulsar un botón,
+porque los servidores de correo abren los enlaces para analizarlos) o cuando la fija un
+administrador.
+
+Para cambiar su dirección, el usuario indica la nueva y su contraseña actual. La nueva no se aplica
+hasta que se confirma desde el enlace que se le envía, y entonces queda verificada; mientras tanto,
+la cuenta conserva la anterior, que recibe un aviso. Restablecer la contraseña descarta el cambio
+pendiente: es lo que el aviso pide hacer a quien no lo ha pedido. También lo descarta un
+administrador que fije otra dirección. Cada enlace sirve sólo para la dirección a la que se envió,
+y los enlaces sin usar de recuperación y de verificación dejan de valer cuando cambia la dirección
+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 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`.
+
+## Créditos
+
+Este *crate* guarda las contraseñas con el algoritmo Argon2 mediante
+[argon2](https://github.com/RustCrypto/password-hashes), de RustCrypto, y detecta los nombres de
+usuario que se confunden con otro con
+[unicode-security](https://github.com/unicode-rs/unicode-security). Ambos se distribuyen bajo
+licencia MIT o Apache 2.0, a elegir.
+
+## Advertencia
+
+**PageTop** es un proyecto personal para aprender [Rust](https://www.rust-lang.org/es) y conocer su
+ecosistema. Su API está sujeta a cambios frecuentes. No se recomienda su uso en producción, al menos
+hasta que se libere la versión **1.0.0**.
+
+## Licencia
+
+El código está disponible bajo una doble licencia:
+
+ * **Licencia MIT**
+ ([LICENSE-MIT](LICENSE-MIT) o también https://opensource.org/licenses/MIT)
+
+ * **Licencia Apache, Versión 2.0**
+ ([LICENSE-APACHE](LICENSE-APACHE) o también https://www.apache.org/licenses/LICENSE-2.0)
+
+Puedes elegir la licencia que prefieras. Este enfoque de doble licencia es el estándar de facto en
+el ecosistema Rust.
diff --git a/extensions/pagetop-user/config/common.toml b/extensions/pagetop-user/config/common.toml
index 7430bf97..1411191c 100644
--- a/extensions/pagetop-user/config/common.toml
+++ b/extensions/pagetop-user/config/common.toml
@@ -19,6 +19,7 @@ base_url = "https://example.com/"
require_email_verification = true
max_failed_logins = 3
max_ip_requests = 3
+max_email_changes = 2
# Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas.
[user.password]
diff --git a/extensions/pagetop-user/src/auth.rs b/extensions/pagetop-user/src/auth.rs
index bc173380..dfb305a5 100644
--- a/extensions/pagetop-user/src/auth.rs
+++ b/extensions/pagetop-user/src/auth.rs
@@ -230,8 +230,12 @@ async fn checked_user(user_id: i32, plain_password: &str) -> Result {
+ 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))
}
diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs
index 4267baf1..b2fd212a 100644
--- a/extensions/pagetop-user/src/config.rs
+++ b/extensions/pagetop-user/src/config.rs
@@ -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,
diff --git a/extensions/pagetop-user/src/error.rs b/extensions/pagetop-user/src/error.rs
index c1509388..432a4d3e 100644
--- a/extensions/pagetop-user/src/error.rs
+++ b/extensions/pagetop-user/src/error.rs
@@ -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")]
diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs
index 14e3247e..a9831c4c 100644
--- a/extensions/pagetop-user/src/handlers/auth.rs
+++ b/extensions/pagetop-user/src/handlers/auth.rs
@@ -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}"),
}
});
diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs
index 02e5c650..6d3b0364 100644
--- a/extensions/pagetop-user/src/lib.rs
+++ b/extensions/pagetop-user/src/lib.rs
@@ -5,20 +5,52 @@
Gestión de usuarios, autenticación, roles y permisos para PageTop.
+[](https://docs.rs/pagetop-user)
+[](https://crates.io/crates/pagetop-user)
+[](https://crates.io/crates/pagetop-user)
+[](https://git.cillero.es/manuelcillero/pagetop/src/branch/main/extensions/pagetop-user#licencia)
+
+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 {
}
```
+## 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::*;
diff --git a/extensions/pagetop-user/src/locale/en-US/common.ftl b/extensions/pagetop-user/src/locale/en-US/common.ftl
index 207e1867..f2fe0bd7 100644
--- a/extensions/pagetop-user/src/locale/en-US/common.ftl
+++ b/extensions/pagetop-user/src/locale/en-US/common.ftl
@@ -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.
diff --git a/extensions/pagetop-user/src/locale/es-ES/common.ftl b/extensions/pagetop-user/src/locale/es-ES/common.ftl
index 0d30832c..fb414378 100644
--- a/extensions/pagetop-user/src/locale/es-ES/common.ftl
+++ b/extensions/pagetop-user/src/locale/es-ES/common.ftl
@@ -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.
diff --git a/extensions/pagetop-user/src/token.rs b/extensions/pagetop-user/src/token.rs
index 66eec852..7a0e61b6 100644
--- a/extensions/pagetop-user/src/token.rs
+++ b/extensions/pagetop-user/src/token.rs
@@ -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 {
create_bound_token(user_id, kind, "").await
}
@@ -109,31 +131,58 @@ pub async fn create_bound_token(
binding: &str,
) -> Result {
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,
-) -> 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
diff --git a/extensions/pagetop-user/tests/flows.rs b/extensions/pagetop-user/tests/flows.rs
index a24ab84e..d5751058 100644
--- a/extensions/pagetop-user/tests/flows.rs
+++ b/extensions/pagetop-user/tests/flows.rs
@@ -1,6 +1,7 @@
// End-to-end account flows against a real database. `config/common.toml` gives these tests an
// in-memory SQLite database with a single connection, the memory mail transport, email
-// verification on sign-up, `max_failed_logins = 3` and `max_ip_requests = 3`.
+// verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 3` and
+// `max_email_changes = 2` (`max_password_resets` keeps its default, 3).
//
// Every scenario shares the same database, so they run one after another in a single test (and a
// single runtime, which also keeps the database connection alive). Each one uses its own accounts
@@ -191,6 +192,8 @@ async fn account_flows() {
email_changes_revoke_links_sent_to_the_old_address(&client).await;
email_change_links_are_bound_to_their_address(&client).await;
wrong_current_passwords_lock_the_account(&client).await;
+ email_changes_are_limited_by_account(&client).await;
+ password_resets_are_limited_by_account(&client).await;
requests_are_limited_by_address(&client).await;
}
@@ -651,6 +654,61 @@ async fn wrong_current_passwords_lock_the_account(client: &Client) {
assert_eq!(client.login("kim", "kim-password").await, None);
}
+async fn email_changes_are_limited_by_account(client: &Client) {
+ verified_account(client, "mar", "mar@example.com", "mar-password").await;
+ let session = client.login("mar", "mar-password").await.unwrap();
+ let request = |email| form(&[("email", email), ("current_password", "mar-password")]);
+ let mut confirm = String::new();
+ for email in ["mar.one@example.com", "mar.two@example.com"] {
+ let reply = client
+ .post("/user/email", &request(email), Some(&session))
+ .await;
+ assert_eq!(reply.status, Status::OK);
+ confirm = link(&mail_to(email).await, "/user/email/");
+ mail_to("mar@example.com").await;
+ }
+ // `max_email_changes = 2`: the third request sends nothing, to either address.
+ let reply = client
+ .post(
+ "/user/email",
+ &request("mar.three@example.com"),
+ Some(&session),
+ )
+ .await;
+ assert!(reply.body.contains("Too many requests"));
+ no_mail_to("mar.three@example.com").await;
+ no_mail_to("mar@example.com").await;
+
+ // The refused request leaves the pending change and its link as they were.
+ let reply = client.post(path(&confirm), "", None).await;
+ assert_eq!(reply.status, Status::SEE_OTHER);
+ assert!(
+ client
+ .login("mar.two@example.com", "mar-password")
+ .await
+ .is_some()
+ );
+}
+
+async fn password_resets_are_limited_by_account(client: &Client) {
+ verified_account(client, "nora", "nora@example.com", "nora-password").await;
+ let mut reset = String::new();
+ for _ in 0..3 {
+ client
+ .post("/user/password/reset", "email=nora%40example.com", None)
+ .await;
+ reset = link(&mail_to("nora@example.com").await, "/user/password/reset/");
+ }
+ // `max_password_resets` is 3 by default: the fourth request sends nothing, with the same
+ // answer, and the last link still works.
+ let reply = client
+ .post("/user/password/reset", "email=nora%40example.com", None)
+ .await;
+ assert_eq!(reply.status, Status::OK);
+ no_mail_to("nora@example.com").await;
+ assert_eq!(client.get(&reset, None).await.status, Status::OK);
+}
+
async fn requests_are_limited_by_address(client: &Client) {
let from = |ip: [u8; 4]| {
web::test::TestRequest::post()