🔒️ (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

@ -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). 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. # 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 max_password_resets = 3 # Máximo de solicitudes de recuperación de contraseña de una
# ventana; las siguientes no envían correo. 0 -> sin límite. # misma cuenta en un periodo de 'password_reset_window_secs'
password_reset_window_secs = 3600 # Segundos en los que se cuentan las solicitudes (1 hora). # 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 max_email_changes = 3 # Máximo de cambios de email que puede pedir una misma cuenta
# desde una misma IP (IPv6 por su red /64) en la ventana. # en un periodo de 'email_change_window_secs' segundos; los
# Tras un proxy inverso requiere 'server.client_ip_header'. # siguientes dan error y no envían correo. 0 -> sin límite.
# Cada instancia cuenta las suyas. 0 -> sin límite. email_change_window_secs = 3600 # Duración del periodo en segundos (1 hora).
ip_request_window_secs = 3600 # Segundos en los que se cuentan las solicitudes (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 login_strict = false # Dificulta que el navegador recuerde o autorrellene las
# credenciales en el formulario de acceso. # credenciales en el formulario de acceso.

View file

@ -186,7 +186,7 @@
same "printed page" as the copyright notice for easier same "printed page" as the copyright notice for easier
identification within third-party archives. identification within third-party archives.
Copyright 2022 Manuel Cillero Copyright 2026 Manuel Cillero
Licensed under the Apache License, Version 2.0 (the "License"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.

View file

@ -1,6 +1,6 @@
MIT License 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 Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal

View file

@ -0,0 +1,180 @@
<div align="center">
<h1>PageTop User</h1>
<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
**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<ExtensionRef> {
vec![&pagetop_user::User]
}
fn configure_router(&self, router: Router) -> Router {
router.route("/dashboard", web::get(dashboard))
}
}
async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> {
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.

View file

@ -19,6 +19,7 @@ base_url = "https://example.com/"
require_email_verification = true require_email_verification = true
max_failed_logins = 3 max_failed_logins = 3
max_ip_requests = 3 max_ip_requests = 3
max_email_changes = 2
# Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas. # Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas.
[user.password] [user.password]

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, /// Falla con [`AuthError::InvalidCredentials`] si la contraseña no es correcta,
/// [`AuthError::AccountLocked`] si la cuenta está bloqueada por intentos fallidos, /// [`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::TooManyRequests`] si la cuenta ya ha pedido [`max_email_changes`] cambios en
/// [`AuthError::EmailTaken`] si la usa otra cuenta. /// [`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( pub(crate) async fn request_email_change(
user_id: i32, user_id: i32,
current_password: &str, current_password: &str,
@ -244,6 +248,16 @@ pub(crate) async fn request_email_change(
} }
ensure_email_available(&email, Some(user_id)).await?; 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(); let new_email = email.value().to_owned();
user::ActiveModel { user::ActiveModel {
id: Set(user_id), id: Set(user_id),
@ -253,7 +267,6 @@ pub(crate) async fn request_email_change(
} }
.update(dbconn()) .update(dbconn())
.await?; .await?;
let token = token::create_bound_token(user_id, TokenKind::EmailChange, email.key()).await?;
Ok((user_model, new_email, token)) Ok((user_model, new_email, token))
} }

View file

@ -73,21 +73,37 @@ pub struct UserSettings {
/// [`password_reset_window_secs`](Self::password_reset_window_secs). /// [`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 /// 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 /// límite, las siguientes no envían nada hasta que la más antigua de las contadas deja de
/// ella, y la respuesta es la misma para no revelar si la cuenta existe. Así nadie puede /// 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 /// inundar el buzón de otra persona ni dañar la reputación del servidor de correo. Con `0` no
/// hay límite. /// hay límite.
#[default = 3] #[default = 3]
pub max_password_resets: u32, 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] #[default = 3_600]
pub password_reset_window_secs: i64, 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// lleva su propia cuenta, en memoria: con varias instancias, el límite es por instancia. Con
/// `0` no hay límite. /// `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 /// [`pagetop::web::HttpRequest::client_ip()`]: pagetop::web::HttpRequest::client_ip
#[default = 20] #[default = 20]
pub max_ip_requests: u32, 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] #[default = 3_600]
pub ip_request_window_secs: i64, 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")] #[error("new email is the same as the current one")]
SameEmail, SameEmail,
#[error("too many requests from the same address")] #[error("too many requests")]
TooManyRequests, TooManyRequests,
#[error("passwords do not match")] #[error("passwords do not match")]

View file

@ -15,7 +15,7 @@ use crate::mail::send_token_mail;
use crate::password; use crate::password;
use crate::session; use crate::session;
use crate::throttle; 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}; use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_PATH};
// **< Tipos de formularios >*********************************************************************** // **< Tipos de formularios >***********************************************************************
@ -251,25 +251,13 @@ pub async fn password_reset_post(
return; 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 { match create_token(user_model.id, TokenKind::PasswordReset).await {
Ok(token) => { Ok(token) => {
send_token_mail(&mail_request, TokenKind::PasswordReset, &user_model, &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}"), 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> <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> </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 ## Guía rápida
Declara la dependencia en tu `Cargo.toml`: **Añade la dependencia** a tu `Cargo.toml`:
```toml ```toml
[dependencies] [dependencies]
pagetop-user = "..." pagetop-user = "..."
``` ```
Añade `&pagetop_user::User` a las dependencias de tu extensión. El usuario actual se inyecta Los usuarios y las sesiones se guardan con [`pagetop_seaorm`]: la aplicación elige el motor de base
automáticamente en el contexto de cada [`Page`] al crearla con [`Page::new()`], sin necesidad de de datos con su *feature* (`postgres`, `mysql` o `sqlite`) y configura la conexión en la sección
llamadas adicionales. Usa las helpers del core para acceder a él: `[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 ```rust,no_run
use pagetop::prelude::*; 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 ## Nombres de usuario y email
Cada cuenta tiene un nombre de usuario y un email, obligatorios y únicos; se puede iniciar sesión 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 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. 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 Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
recuperaciones de contraseña se limitan por cuenta (`max_password_resets`), y ellas, los registros de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
y los cambios de dirección, también por dirección IP (`max_ip_requests`). Detrás de un *proxy* `max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás
inverso, el límite por IP requiere configurar `server.client_ip_header`. de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
*/ */
use pagetop::prelude::*; 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-invalid-email = The email address is not valid.
error-email-taken = This email address is already registered. error-email-taken = This email address is already registered.
error-same-email = The new address is the same as the current one. 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-token-invalid = This link is invalid or has expired.
error-current-password = The current password is incorrect. error-current-password = The current password is incorrect.
error-internal = An unexpected error occurred. Please try again. 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-invalid-email = La dirección de correo no es válida.
error-email-taken = Esta dirección de email ya está registrada. 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-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-token-invalid = Este enlace no es válido o ha caducado.
error-current-password = La contraseña actual no es correcta. error-current-password = La contraseña actual no es correcta.
error-internal = Se ha producido un error inesperado. Inténtalo de nuevo. 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, // Límite de tokens de este tipo que puede pedir una cuenta: cuántos (0 = sin límite) y en
// mientras cuentan para el límite de solicitudes. // cuántos segundos.
fn keep_secs(self) -> i64 { fn limit(self) -> (u32, i64) {
match self { match self {
TokenKind::PasswordReset => self.ttl_secs().max(SETTINGS.password_reset_window_secs), TokenKind::PasswordReset => (
TokenKind::EmailVerification | TokenKind::EmailChange => self.ttl_secs(), 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 >******************************************************************************* // **< create_token >*******************************************************************************
/// Crea un token en BD y devuelve el valor en claro para enviarlo al usuario. /// 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 /// Anula los tokens anteriores del mismo tipo que el usuario tenga sin consumir, de modo que sólo
/// último enlace enviado. /// 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> { pub async fn create_token(user_id: i32, kind: TokenKind) -> Result<String, AuthError> {
create_bound_token(user_id, kind, "").await create_bound_token(user_id, kind, "").await
} }
@ -109,31 +131,58 @@ pub async fn create_bound_token(
binding: &str, binding: &str,
) -> Result<String, AuthError> { ) -> Result<String, AuthError> {
let now = Utc::now(); 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 // Se cuenta después de guardarlo y contándolo a él: si varias peticiones simultáneas guardan el
// `count_tokens_since()`; sólo se borran los que ya no pueden usarse ni cuentan. // suyo antes de contar, la última en contar los ve todos, así que nunca se admiten más de las
revoke_tokens(user_id, kind).await?; // 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() user_token::Entity::delete_many()
.filter(user_token::Column::UserId.eq(user_id)) .filter(user_token::Column::UserId.eq(user_id))
.filter(user_token::Column::Kind.eq(kind.as_str())) .filter(user_token::Column::Kind.eq(kind.as_str()))
.filter(user_token::Column::CreatedAt.lt(now - Duration::seconds(kind.keep_secs()))) .filter(user_token::Column::CreatedAt.lt(now - Duration::seconds(kind.keep_secs())))
.exec(dbconn()) .exec(dbconn())
.await?; .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) Ok(token)
} }
@ -152,25 +201,6 @@ pub async fn revoke_tokens(user_id: i32, kind: TokenKind) -> Result<(), AuthErro
Ok(()) 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 >************************************************************* // **< is_valid_token / consume_token >*************************************************************
/// Comprueba, sin consumirlo, que el token en claro sea válido para el usuario: existe, es del tipo /// Comprueba, sin consumirlo, que el token en claro sea válido para el usuario: existe, es del tipo

View file

@ -1,6 +1,7 @@
// End-to-end account flows against a real database. `config/common.toml` gives these tests an // 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 // 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 // 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 // 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_changes_revoke_links_sent_to_the_old_address(&client).await;
email_change_links_are_bound_to_their_address(&client).await; email_change_links_are_bound_to_their_address(&client).await;
wrong_current_passwords_lock_the_account(&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; 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); 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) { async fn requests_are_limited_by_address(client: &Client) {
let from = |ip: [u8; 4]| { let from = |ip: [u8; 4]| {
web::test::TestRequest::post() web::test::TestRequest::post()