🔒️ (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:
parent
3fba1ca875
commit
a110dd0482
14 changed files with 432 additions and 91 deletions
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
180
extensions/pagetop-user/README.md
Normal file
180
extensions/pagetop-user/README.md
Normal 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>
|
||||
|
||||
[](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)
|
||||
|
||||
</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.
|
||||
|
|
@ -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]
|
||||
|
|
|
|||
|
|
@ -230,8 +230,12 @@ async fn checked_user(user_id: i32, plain_password: &str) -> Result<user::Model,
|
|||
///
|
||||
/// Falla con [`AuthError::InvalidCredentials`] si la contraseña no es correcta,
|
||||
/// [`AuthError::AccountLocked`] si la cuenta está bloqueada por intentos fallidos,
|
||||
/// [`AuthError::SameEmail`] si la dirección es la actual (sin distinguir mayúsculas) y
|
||||
/// [`AuthError::EmailTaken`] si la usa otra cuenta.
|
||||
/// [`AuthError::TooManyRequests`] si la cuenta ya ha pedido [`max_email_changes`] cambios en
|
||||
/// [`email_change_window_secs`], [`AuthError::SameEmail`] si la dirección es la actual (sin
|
||||
/// distinguir mayúsculas) y [`AuthError::EmailTaken`] si la usa otra cuenta.
|
||||
///
|
||||
/// [`max_email_changes`]: crate::config::UserSettings::max_email_changes
|
||||
/// [`email_change_window_secs`]: crate::config::UserSettings::email_change_window_secs
|
||||
pub(crate) async fn request_email_change(
|
||||
user_id: i32,
|
||||
current_password: &str,
|
||||
|
|
@ -244,6 +248,16 @@ pub(crate) async fn request_email_change(
|
|||
}
|
||||
ensure_email_available(&email, Some(user_id)).await?;
|
||||
|
||||
// Después de la contraseña (quien no la tenga no sabe nada del límite) y antes de guardar la
|
||||
// dirección: rechazado, el cambio pendiente y su enlace siguen como estaban.
|
||||
let token = match token::create_bound_token(user_id, TokenKind::EmailChange, email.key()).await
|
||||
{
|
||||
Err(AuthError::TooManyRequests) => {
|
||||
trace::warn!("Email change limit reached for user {user_id}");
|
||||
return Err(AuthError::TooManyRequests);
|
||||
}
|
||||
result => result?,
|
||||
};
|
||||
let new_email = email.value().to_owned();
|
||||
user::ActiveModel {
|
||||
id: Set(user_id),
|
||||
|
|
@ -253,7 +267,6 @@ pub(crate) async fn request_email_change(
|
|||
}
|
||||
.update(dbconn())
|
||||
.await?;
|
||||
let token = token::create_bound_token(user_id, TokenKind::EmailChange, email.key()).await?;
|
||||
Ok((user_model, new_email, token))
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
||||
|
|
|
|||
|
|
@ -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")]
|
||||
|
|
|
|||
|
|
@ -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}"),
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -5,20 +5,52 @@
|
|||
|
||||
<p>Gestión de usuarios, autenticación, roles y permisos para <strong>PageTop</strong>.</p>
|
||||
|
||||
[](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)
|
||||
|
||||
</div>
|
||||
|
||||
Añade cuentas de usuario a una aplicación PageTop: registro, inicio de sesión con sesiones en la
|
||||
base de datos, perfil propio, recuperación de contraseña y verificación del email por correo, y
|
||||
control de acceso con roles y permisos. Incluye las páginas de administración de usuarios, roles y
|
||||
permisos sobre `pagetop-admin`, hechas sólo con componentes del núcleo para que funcionen con
|
||||
cualquier tema.
|
||||
|
||||
## Sobre PageTop
|
||||
|
||||
[PageTop](https://docs.rs/pagetop) es un entorno de desarrollo que reivindica la esencia de la web
|
||||
clásica para crear soluciones web SSR (*renderizadas en el servidor*) modulares, extensibles y
|
||||
configurables, basadas en HTML, CSS y JavaScript.
|
||||
|
||||
## Guía rápida
|
||||
|
||||
Declara la dependencia en tu `Cargo.toml`:
|
||||
**Añade la dependencia** a tu `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
pagetop-user = "..."
|
||||
```
|
||||
|
||||
Añade `&pagetop_user::User` a las dependencias de tu extensión. El usuario actual se inyecta
|
||||
automáticamente en el contexto de cada [`Page`] al crearla con [`Page::new()`], sin necesidad de
|
||||
llamadas adicionales. Usa las helpers del core para acceder a él:
|
||||
Los usuarios y las sesiones se guardan con [`pagetop_seaorm`]: la aplicación elige el motor de base
|
||||
de datos con su *feature* (`postgres`, `mysql` o `sqlite`) y configura la conexión en la sección
|
||||
`[database]`.
|
||||
|
||||
**Declara la extensión** como dependencia de tu aplicación o de la extensión que la requiera
|
||||
(`&pagetop_user::User`, como en el ejemplo de más abajo). Al arrancar crea sus tablas y, si no hay
|
||||
ninguna cuenta, el primer administrador, con los datos de `[user.seed]`:
|
||||
|
||||
```toml
|
||||
[user.seed]
|
||||
admin_username = "admin"
|
||||
admin_email = "admin@example.com"
|
||||
# Sin 'admin_password', se genera una aleatoria y se muestra una sola vez al crearlo.
|
||||
```
|
||||
|
||||
**Comprueba los permisos** en tus *handlers*. El usuario actual se inyecta automáticamente en el
|
||||
contexto de cada [`Page`] al crearla con [`Page::new()`], y las funciones del núcleo, como
|
||||
[`has_permission()`], lo consultan:
|
||||
|
||||
```rust,no_run
|
||||
use pagetop::prelude::*;
|
||||
|
|
@ -60,6 +92,18 @@ async fn dashboard(request: HttpRequest) -> Result<Markup, ErrorPage> {
|
|||
}
|
||||
```
|
||||
|
||||
## Páginas
|
||||
|
||||
| Ruta | Uso |
|
||||
|---------------------------|--------------------------------------------------------------|
|
||||
| `/user/login` | Inicio de sesión, con el nombre de usuario o el email. |
|
||||
| `/user/register` | Registro, si lo permite `allow_registration`. |
|
||||
| `/user` | Perfil propio: editarlo, cambiar la contraseña o el email. |
|
||||
| `/user/password/reset` | Recuperación de la contraseña por correo. |
|
||||
| `/admin/user/users` | Administración de usuarios: alta, edición, roles, bloqueo... |
|
||||
| `/admin/user/roles` | Administración de roles y de sus permisos. |
|
||||
| `/admin/user/permissions` | Catálogo de los permisos que declaran las extensiones. |
|
||||
|
||||
## Nombres de usuario y email
|
||||
|
||||
Cada cuenta tiene un nombre de usuario y un email, obligatorios y únicos; se puede iniciar sesión
|
||||
|
|
@ -104,10 +148,10 @@ de la cuenta; los de recuperación, también cuando cambia su contraseña.
|
|||
Cambiar la contraseña o el email exige la contraseña actual, y sus fallos cuentan para el bloqueo
|
||||
por intentos fallidos (`max_failed_logins`), como los del inicio de sesión.
|
||||
|
||||
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las
|
||||
recuperaciones de contraseña se limitan por cuenta (`max_password_resets`), y ellas, los registros
|
||||
y los cambios de dirección, también por dirección IP (`max_ip_requests`). Detrás de un *proxy*
|
||||
inverso, el límite por IP requiere configurar `server.client_ip_header`.
|
||||
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
|
||||
de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
|
||||
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás
|
||||
de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
|
||||
*/
|
||||
|
||||
use pagetop::prelude::*;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -80,22 +80,44 @@ impl TokenKind {
|
|||
}
|
||||
}
|
||||
|
||||
// Segundos que se conserva un token desde su creación: hasta que caduca y, los de recuperación,
|
||||
// mientras cuentan para el límite de solicitudes.
|
||||
fn keep_secs(self) -> i64 {
|
||||
// Límite de tokens de este tipo que puede pedir una cuenta: cuántos (0 = sin límite) y en
|
||||
// cuántos segundos.
|
||||
fn limit(self) -> (u32, i64) {
|
||||
match self {
|
||||
TokenKind::PasswordReset => self.ttl_secs().max(SETTINGS.password_reset_window_secs),
|
||||
TokenKind::EmailVerification | TokenKind::EmailChange => self.ttl_secs(),
|
||||
TokenKind::PasswordReset => (
|
||||
SETTINGS.max_password_resets,
|
||||
SETTINGS.password_reset_window_secs,
|
||||
),
|
||||
TokenKind::EmailChange => (
|
||||
SETTINGS.max_email_changes,
|
||||
SETTINGS.email_change_window_secs,
|
||||
),
|
||||
TokenKind::EmailVerification => (0, 0),
|
||||
}
|
||||
}
|
||||
|
||||
// Segundos que se conserva un token desde su creación: hasta que caduca y mientras cuenta para
|
||||
// el límite de su tipo.
|
||||
fn keep_secs(self) -> i64 {
|
||||
self.ttl_secs().max(self.limit().1)
|
||||
}
|
||||
}
|
||||
|
||||
// **< create_token >*******************************************************************************
|
||||
|
||||
/// Crea un token en BD y devuelve el valor en claro para enviarlo al usuario.
|
||||
///
|
||||
/// Anula los tokens del mismo tipo que el usuario tenga sin consumir, de modo que sólo vale el
|
||||
/// último enlace enviado.
|
||||
/// Anula los tokens anteriores del mismo tipo que el usuario tenga sin consumir, de modo que sólo
|
||||
/// vale el último enlace enviado. Falla con [`AuthError::TooManyRequests`] si el usuario ya ha
|
||||
/// pedido todos los que admite el límite de su tipo:
|
||||
/// [`max_password_resets`](crate::config::UserSettings::max_password_resets) en
|
||||
/// [`password_reset_window_secs`](crate::config::UserSettings::password_reset_window_secs) los de
|
||||
/// recuperación de contraseña, y
|
||||
/// [`max_email_changes`](crate::config::UserSettings::max_email_changes) en
|
||||
/// [`email_change_window_secs`](crate::config::UserSettings::email_change_window_secs) los de
|
||||
/// cambio de email. Cuentan todos los creados en ese tiempo, consumidos o anulados también, pero no
|
||||
/// los rechazados; los de verificación de email no tienen límite. Rechazado, los anteriores siguen
|
||||
/// valiendo.
|
||||
pub async fn create_token(user_id: i32, kind: TokenKind) -> Result<String, AuthError> {
|
||||
create_bound_token(user_id, kind, "").await
|
||||
}
|
||||
|
|
@ -109,31 +131,58 @@ pub async fn create_bound_token(
|
|||
binding: &str,
|
||||
) -> Result<String, AuthError> {
|
||||
let now = Utc::now();
|
||||
let token = generate_token();
|
||||
let new_token = user_token::ActiveModel {
|
||||
id: ActiveValue::NotSet,
|
||||
user_id: Set(user_id),
|
||||
kind: Set(kind.as_str().to_owned()),
|
||||
token_hash: Set(bound_hash(&token, binding)),
|
||||
expires_at: Set(now + Duration::seconds(kind.ttl_secs())),
|
||||
consumed_at: Set(None),
|
||||
created_at: Set(now),
|
||||
updated_at: Set(now),
|
||||
};
|
||||
let id = user_token::Entity::insert(new_token)
|
||||
.exec(dbconn())
|
||||
.await?
|
||||
.last_insert_id;
|
||||
|
||||
// Los anteriores se anulan en lugar de borrarse para que sigan contando en
|
||||
// `count_tokens_since()`; sólo se borran los que ya no pueden usarse ni cuentan.
|
||||
revoke_tokens(user_id, kind).await?;
|
||||
// Se cuenta después de guardarlo y contándolo a él: si varias peticiones simultáneas guardan el
|
||||
// suyo antes de contar, la última en contar los ve todos, así que nunca se admiten más de las
|
||||
// que permite el límite (como mucho, se rechaza alguna de más). El rechazado se borra para que
|
||||
// no cuente.
|
||||
let (max, window_secs) = kind.limit();
|
||||
if max > 0 {
|
||||
let count = user_token::Entity::find()
|
||||
.filter(user_token::Column::UserId.eq(user_id))
|
||||
.filter(user_token::Column::Kind.eq(kind.as_str()))
|
||||
.filter(user_token::Column::CreatedAt.gte(now - Duration::seconds(window_secs)))
|
||||
.count(dbconn())
|
||||
.await?;
|
||||
if count > u64::from(max) {
|
||||
user_token::Entity::delete_by_id(id).exec(dbconn()).await?;
|
||||
return Err(AuthError::TooManyRequests);
|
||||
}
|
||||
}
|
||||
|
||||
// Sólo los anteriores a éste: si dos peticiones simultáneas se anularan entre sí, no valdría
|
||||
// ningún enlace. Se anulan en lugar de borrarse para que sigan contando para el límite; sólo se
|
||||
// borran los que ya no pueden usarse ni cuentan.
|
||||
user_token::Entity::update_many()
|
||||
.col_expr(user_token::Column::ConsumedAt, Expr::value(now))
|
||||
.col_expr(user_token::Column::UpdatedAt, Expr::value(now))
|
||||
.filter(user_token::Column::UserId.eq(user_id))
|
||||
.filter(user_token::Column::Kind.eq(kind.as_str()))
|
||||
.filter(user_token::Column::ConsumedAt.is_null())
|
||||
.filter(user_token::Column::Id.lt(id))
|
||||
.exec(dbconn())
|
||||
.await?;
|
||||
user_token::Entity::delete_many()
|
||||
.filter(user_token::Column::UserId.eq(user_id))
|
||||
.filter(user_token::Column::Kind.eq(kind.as_str()))
|
||||
.filter(user_token::Column::CreatedAt.lt(now - Duration::seconds(kind.keep_secs())))
|
||||
.exec(dbconn())
|
||||
.await?;
|
||||
|
||||
let token = generate_token();
|
||||
let expires_at = now + Duration::seconds(kind.ttl_secs());
|
||||
|
||||
let new_token = user_token::ActiveModel {
|
||||
id: ActiveValue::NotSet,
|
||||
user_id: Set(user_id),
|
||||
kind: Set(kind.as_str().to_owned()),
|
||||
token_hash: Set(bound_hash(&token, binding)),
|
||||
expires_at: Set(expires_at),
|
||||
consumed_at: Set(None),
|
||||
created_at: Set(now),
|
||||
updated_at: Set(now),
|
||||
};
|
||||
user_token::Entity::insert(new_token).exec(dbconn()).await?;
|
||||
Ok(token)
|
||||
}
|
||||
|
||||
|
|
@ -152,25 +201,6 @@ pub async fn revoke_tokens(user_id: i32, kind: TokenKind) -> Result<(), AuthErro
|
|||
Ok(())
|
||||
}
|
||||
|
||||
/// Cuenta los tokens del tipo indicado creados para el usuario desde `since`, consumidos o no.
|
||||
///
|
||||
/// Los tokens se conservan al menos durante su tiempo de vida o, en los de recuperación de
|
||||
/// contraseña, durante
|
||||
/// [`password_reset_window_secs`](crate::config::UserSettings::password_reset_window_secs) si es
|
||||
/// mayor. Con un `since` más antiguo el recuento puede quedarse corto.
|
||||
pub async fn count_tokens_since(
|
||||
user_id: i32,
|
||||
kind: TokenKind,
|
||||
since: DateTime<Utc>,
|
||||
) -> Result<u64, AuthError> {
|
||||
Ok(user_token::Entity::find()
|
||||
.filter(user_token::Column::UserId.eq(user_id))
|
||||
.filter(user_token::Column::Kind.eq(kind.as_str()))
|
||||
.filter(user_token::Column::CreatedAt.gte(since))
|
||||
.count(dbconn())
|
||||
.await?)
|
||||
}
|
||||
|
||||
// **< is_valid_token / consume_token >*************************************************************
|
||||
|
||||
/// Comprueba, sin consumirlo, que el token en claro sea válido para el usuario: existe, es del tipo
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue