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.

+ +[![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) + +
+ +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.

+[![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) + +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()