✨ (user): Añade proveedores de autenticación

Otras extensiones pueden comprobar las credenciales del inicio de sesión
con un servicio externo (un directorio LDAP...): módulo público provider
(AuthProvider, ProviderHandle, AccountPolicy, DeclareAuthProviders),
tabla `user_identities`, sección `[user.login]` (sources, local_fallback
y strict, que sustituye a login_strict), estado AwaitingApproval y
acciones AfterSessionResolved, AfterUserStatusChanged y
AdminUserFormExtras.

Las reglas que protegen las cuentas son siempre de pagetop-user: sólo se
vincula una cuenta que un administrador ha permitido para esa persona,
nunca la de un administrador, y una caída del proveedor no bloquea a
nadie.

Añade el límite de fallos por identificador tecleado, guarda las
contraseñas en util::SecretStr, crea en una sola transacción las cuentas
de proveedor y documenta todos los elementos públicos del crate.
This commit is contained in:
Manuel Cillero 2026-11-12 23:13:58 +01:00
parent 9a78b79939
commit 5172da65d6
39 changed files with 4711 additions and 310 deletions

View file

@ -310,7 +310,10 @@ identity_policy = "strict" # Nombres de usuario que se aceptan:
max_failed_logins = 5 # Intentos fallidos seguidos que bloquean la cuenta, también
# los de la contraseña actual al cambiar la contraseña o el
# email. 0 -> nunca.
# email. Limita también los fallos de cada identificador
# tecleado, exista o no la cuenta. Con un proveedor externo
# (LDAP...), debe ser menor que su propio umbral de bloqueo.
# 0 -> nunca.
failed_login_window_secs = 900 # Segundos desde el último fallo en los que el siguiente se
# suma al recuento (15 minutos); si no, empieza de nuevo.
locked_for_secs = 600 # Duración del bloqueo de la cuenta en segundos (10 minutos).
@ -335,10 +338,23 @@ ip_request_window_secs = 3600 # Duración del periodo en segundos (1 ho
max_ip_failed_logins = 30 # Máximo de inicios de sesión fallidos desde una misma IP en
# un periodo de 'ip_failed_login_window_secs' segundos; los
# siguientes se rechazan sin comprobar la contraseña. Frena
# probar contraseñas en muchas cuentas. 0 -> sin límite.
# probar contraseñas en muchas cuentas. Sin IP conocida y
# con un proveedor externo activo, es el máximo para todas
# esas peticiones juntas. 0 -> sin límite.
ip_failed_login_window_secs = 900 # Duración del periodo en segundos (15 minutos).
login_strict = false # Dificulta que el navegador recuerde o autorrellene las
[user.login] # Inicio de sesión.
sources = ["local"] # Fuentes que comprueban las credenciales, en orden: "local"
# (la contraseña guardada en PageTop) y los proveedores de
# autenticación declarados (p. ej. "ldap"). Uno desconocido
# o repetido, o la lista vacía, impiden arrancar.
local_fallback = "released" # Si "local" no está en 'sources', qué cuentas pueden aún
# entrar con su contraseña local:
# "none" -> ninguna.
# "released" -> las que un proveedor libera.
# "admins" -> además, cualquier administrador (acceso
# de emergencia si el proveedor cae).
strict = false # Dificulta que el navegador recuerde o autorrellene las
# credenciales en el formulario de acceso.
[user.session] # Sesiones de usuario.

View file

@ -11,18 +11,20 @@
</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 en el panel de administración del núcleo, 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.
## Descripción general
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 en el panel de administración del núcleo, hechas sólo con componentes del núcleo para que
funcionen con cualquier tema.
## Guía rápida
**Añade la dependencia** a tu `Cargo.toml`:
@ -122,6 +124,42 @@ y `ana` son el mismo usuario) y no se admiten nombres que se confunden a simple
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`).
## Proveedores de autenticación
Otras extensiones pueden comprobar las credenciales del inicio de sesión con un servicio externo,
como un directorio LDAP o Active Directory. Cada una declara su proveedor con la acción
`DeclareAuthProviders`, y la configuración decide con qué fuentes, y en qué orden, se comprueban
las credenciales. Por ejemplo, las dos, primero el directorio y después la contraseña local:
```toml
[user.login]
sources = ["ldap", "local"]
```
O sólo el directorio, salvo los administradores, que conservan su contraseña local como acceso de
emergencia por si el directorio no responde (`local_fallback` sólo se aplica cuando `"local"` no
está en `sources`):
```toml
[user.login]
sources = ["ldap"]
local_fallback = "admins"
```
Los límites de intentos, el bloqueo de cuentas, el estado de cada cuenta y las sesiones son los de
`pagetop-user` para todas las fuentes. Una cuenta vinculada a un proveedor sólo se autentica con él,
y lo que su titular puede cambiar (contraseña, email, datos del perfil, roles) lo decide el
proveedor. La contraseña tecleada nunca se guarda ni se escribe en las trazas: el proveedor sólo la
recibe para comprobarla (`pagetop::util::SecretStr`).
Las operaciones que crean cuentas, las vinculan con su identidad externa o cambian sus roles no son
funciones públicas: son métodos de un `ProviderHandle` que sólo
`pagetop-user` construye y que entrega a cada proveedor activo. Así sus reglas viven en un único
sitio: un proveedor sólo actúa sobre sus propias cuentas, una cuenta existente sólo se vincula si un
administrador lo ha permitido en su ficha (y nunca la de un administrador), y nadie puede conceder
el acceso total. Protege de errores en un proveedor, no de código malicioso compilado en la misma
aplicación. Los detalles están en el módulo `provider`.
## Correos
La recuperación de contraseña, la confirmación de una nueva dirección y, con

View file

@ -9,27 +9,40 @@ use crate::entity::user;
// **< UserStatus >*********************************************************************************
/// Estado de la cuenta de usuario.
///
/// Sólo una cuenta [`Active`](Self::Active) puede iniciar sesión.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum UserStatus {
/// Puede iniciar sesión.
Active,
/// Bloqueada por un administrador (o por el proveedor que la gestiona).
Blocked,
/// Pendiente de que su titular confirme el email (ver
/// [`require_email_verification`](crate::config::UserSettings::require_email_verification)).
Pending,
/// Creada por un proveedor de autenticación y pendiente de que un administrador la apruebe.
AwaitingApproval,
}
impl UserStatus {
/// Estado a partir del valor guardado en la base de datos. Un valor desconocido se trata como
/// bloqueada.
pub fn from_i16(v: i16) -> Self {
match v {
1 => UserStatus::Active,
2 => UserStatus::Pending,
3 => UserStatus::AwaitingApproval,
_ => UserStatus::Blocked,
}
}
/// Valor que se guarda en la base de datos.
pub fn as_i16(self) -> i16 {
match self {
UserStatus::Blocked => 0,
UserStatus::Active => 1,
UserStatus::Pending => 2,
UserStatus::AwaitingApproval => 3,
}
}
}

View file

@ -0,0 +1,149 @@
//! Acciones para que otras extensiones intervengan en el ciclo de vida de las cuentas.
//!
//! Todas son síncronas, como el resto de acciones de PageTop: la que necesite hacer E/S debe
//! lanzar su propia tarea o, si pinta algo, aportar un componente que la haga al renderizarse.
//!
//! La acción para declarar proveedores de autenticación,
//! [`DeclareAuthProviders`](crate::provider::DeclareAuthProviders), está en el módulo
//! [`provider`](crate::provider).
use pagetop::prelude::*;
use crate::account::{Account, UserStatus};
// **< AfterSessionResolved >***********************************************************************
/// Tipo de función de la acción [`AfterSessionResolved`].
pub type FnAfterSessionResolved = fn(request: &HttpRequest, account: &Account) -> Option<Response>;
/// Acción que se ejecuta en cada petición con una sesión iniciada.
///
/// Se ejecuta justo tras resolver la cuenta y antes de llegar al *handler*. Si devuelve una
/// respuesta, se responde con ella y la petición no llega al *handler* (p. ej. para llevar al
/// usuario a completar su perfil).
///
/// Responde la primera, por orden de peso, que devuelva una respuesta. Se ejecuta en todas las
/// peticiones de quien ha iniciado sesión, salvo las de archivos estáticos, así que debe decidir
/// muy deprisa y sin E/S; también debe dejar pasar la propia página a la que redirige, o el usuario
/// no podría llegar a ella.
///
/// Va dentro del *middleware* de sesión de `pagetop-user`, no en una capa propia: las capas de las
/// extensiones se ejecutan en orden y una propia podría hacerlo antes de que se resuelva la sesión.
pub struct AfterSessionResolved {
f: FnAfterSessionResolved,
weight: Weight,
}
impl ActionDispatcher for AfterSessionResolved {
fn weight(&self) -> Weight {
self.weight
}
}
impl AfterSessionResolved {
/// Registra una nueva acción.
pub fn new(f: FnAfterSessionResolved) -> Self {
AfterSessionResolved { f, weight: 0 }
}
/// Opcional. Las acciones de menor peso se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
// Despacha las acciones hasta que una responde. Primero las recoge, en su orden, y sólo si hay
// alguna separa la petición para crear la `HttpRequest`: así no cuesta nada a las aplicaciones
// que no la usan (separarla y volver a montarla añadía unos 180 ns a cada petición con sesión).
pub(crate) fn dispatch(req: &mut web::Request, account: &Account) -> Option<Response> {
let mut actions: Vec<FnAfterSessionResolved> = Vec::new();
dispatch_actions(|action: &Self| actions.push(action.f));
if actions.is_empty() {
return None;
}
let (parts, body) = std::mem::take(req).into_parts();
let request = HttpRequest::from_parts(&parts);
let response = actions.iter().find_map(|f| f(&request, account));
*req = web::Request::from_parts(parts, body);
response
}
}
// **< AfterUserStatusChanged >*********************************************************************
/// Tipo de función de la acción [`AfterUserStatusChanged`].
pub type FnAfterUserStatusChanged = fn(user_id: i32, before: UserStatus, after: UserStatus);
/// Acción que se ejecuta tras cambiar el estado de una cuenta.
///
/// Sirve para avisar a quien corresponda cuando un administrador la bloquea, la activa o la
/// aprueba, o cuando la cambia el proveedor que la gestiona.
///
/// No se ejecuta al verificar el email de una cuenta nueva.
pub struct AfterUserStatusChanged {
f: FnAfterUserStatusChanged,
weight: Weight,
}
impl ActionDispatcher for AfterUserStatusChanged {
fn weight(&self) -> Weight {
self.weight
}
}
impl AfterUserStatusChanged {
/// Registra una nueva acción.
pub fn new(f: FnAfterUserStatusChanged) -> Self {
AfterUserStatusChanged { f, weight: 0 }
}
/// Opcional. Las acciones de menor peso se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
pub(crate) fn dispatch(user_id: i32, before: UserStatus, after: UserStatus) {
dispatch_actions(|action: &Self| (action.f)(user_id, before, after));
}
}
// **< AdminUserFormExtras >************************************************************************
/// Tipo de función de la acción [`AdminUserFormExtras`].
pub type FnAdminUserFormExtras = fn(user_id: i32) -> Option<Child>;
/// Acción para añadir contenido a la ficha y a la edición de un usuario en la administración.
///
/// Por ejemplo, los datos que guarda un proveedor de autenticación sobre la cuenta. El componente
/// que devuelva se pinta tras los datos de la cuenta. Como la acción es síncrona, el que necesite
/// consultar la base de datos debe hacerlo en su `prepare()`.
pub struct AdminUserFormExtras {
f: FnAdminUserFormExtras,
weight: Weight,
}
impl ActionDispatcher for AdminUserFormExtras {
fn weight(&self) -> Weight {
self.weight
}
}
impl AdminUserFormExtras {
/// Registra una nueva acción.
pub fn new(f: FnAdminUserFormExtras) -> Self {
AdminUserFormExtras { f, weight: 0 }
}
/// Opcional. Las acciones de menor peso se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
pub(crate) fn collect(user_id: i32) -> Vec<Child> {
let mut extras = Vec::new();
dispatch_actions(|action: &Self| extras.extend((action.f)(user_id)));
extras
}
}

View file

@ -6,70 +6,214 @@ use pagetop_seaorm::db::*;
use crate::account::UserStatus;
use crate::config::SETTINGS;
use crate::entity::{role_permission, user};
use crate::entity::{role_permission, user, user_identity};
use crate::error::AuthError;
use crate::identity::{self, Email, Username};
use crate::password;
use crate::permission::UserPermission;
use crate::provider::{
self, AuthProvider, LoginAttempt, LoginVia, ProviderOutcome, ReauthOutcome, Source, UserRef,
};
use crate::service::user_admin::{
ensure_email_available, ensure_username_available, taken_on_conflict,
};
use crate::session;
use crate::token::{self, TokenKind};
use pagetop_seaorm::db::query::Expr;
use std::net::IpAddr;
// **< login >**************************************************************************************
/// Valida las credenciales y crea una sesión. Devuelve el session ID.
// Topes de lo que se teclea para iniciar sesión. Más allá no hay ninguna cuenta posible (un email
// tiene como mucho 254 caracteres), y una contraseña enorme sólo serviría para hacer trabajar a
// Argon2 o al proveedor externo.
const MAX_IDENTIFIER_CHARS: usize = 255;
const MAX_PASSWORD_BYTES: usize = 1024;
// Plazo para `AuthProvider::after_login()`: su trabajo no debe retrasar el inicio de sesión.
const AFTER_LOGIN_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
/// Si lo tecleado puede ser una credencial: un identificador de hasta 255 caracteres sin
/// caracteres de control y una contraseña de hasta 1024 bytes sin NUL. Si no, se rechaza sin
/// consultar ninguna fuente.
pub(crate) fn acceptable_credentials(identifier: &str, password: &util::SecretStr) -> bool {
identifier.chars().count() <= MAX_IDENTIFIER_CHARS
&& !identifier.chars().any(char::is_control)
&& password.len() <= MAX_PASSWORD_BYTES
&& !password.expose().contains('\0')
}
/// Sesión creada por [`login()`].
pub(crate) struct NewSession {
/// Identificador de la sesión, para la *cookie*.
pub(crate) sid: String,
/// Si se ha aplicado "Recuérdame": se pidió y la fuente que autenticó lo admite.
pub(crate) remember: bool,
}
/// Comprueba las credenciales con las fuentes de
/// [`[user.login] sources`](crate::config::LoginSettings::sources) y, si alguna las acepta, crea
/// una sesión.
///
/// Acepta nombre de usuario o email como primer parámetro. Aplica la política de bloqueo
/// por intentos fallidos y rehashea la contraseña si los parámetros de coste han cambiado.
/// Acepta nombre de usuario o email como identificador. Las fuentes se prueban en orden: la
/// contraseña local (`"local"`) y los proveedores de autenticación activos; una cuenta vinculada a
/// un proveedor sólo se prueba con él. El primer acierto decide la cuenta, y entonces se comprueban
/// **su** bloqueo por intentos fallidos y **su** estado. Si ninguna acierta, el intento fallido se
/// anota una sola vez, en la cuenta de lo tecleado o, si no la hay, en la que indicó un proveedor;
/// si un proveedor no ha respondido, sólo cuando otra fuente ha rechazado la contraseña.
///
/// Sólo con la contraseña correcta se informa de que la cuenta está bloqueada
/// ([`AuthError::AccountBlocked`]) o pendiente de verificar ([`AuthError::AccountPending`]): sin
/// ella, cualquiera sabría así qué cuentas existen y en qué estado están. Por lo mismo, sin cuenta
/// se tarda lo mismo que con una contraseña errónea.
pub async fn login(
username_or_email: &str,
plain_password: &str,
/// ([`AuthError::AccountBlocked`]), pendiente de verificar ([`AuthError::AccountPending`]) o de
/// aprobar ([`AuthError::AccountAwaitingApproval`]), o de que un proveedor deniega el acceso
/// ([`AuthError::ExternalRejected`]): sin ella, cualquiera sabría así qué cuentas existen y en qué
/// estado están. Por lo mismo, sin cuenta se tarda lo mismo que con una contraseña errónea, y si un
/// proveedor no está disponible se responde [`AuthError::ExternalUnavailable`] exista o no la
/// cuenta.
pub(crate) async fn login(
identifier: &str,
password: &util::SecretStr,
remember: bool,
) -> Result<String, AuthError> {
client_ip: Option<IpAddr>,
) -> Result<NewSession, AuthError> {
if !acceptable_credentials(identifier, password) {
return Err(AuthError::InvalidCredentials);
}
let now = Utc::now();
// Buscar usuario por email o por username, sin distinguir mayúsculas. Un nombre de usuario
// nunca contiene `@`, así que la entrada sólo puede ser uno de los dos.
let filter = if username_or_email.contains('@') {
user::Column::EmailKey.eq(identity::email_key(username_or_email))
// Un nombre de usuario nunca contiene `@`, así que la entrada sólo puede ser uno de los dos.
let filter = if identifier.contains('@') {
user::Column::EmailKey.eq(identity::email_key(identifier))
} else {
user::Column::UsernameKey.eq(identity::username_key(username_or_email))
user::Column::UsernameKey.eq(identity::username_key(identifier))
};
let Some(user_model) = user::Entity::find().filter(filter).one(dbconn()).await? else {
password::verify_password_without_account(plain_password).await;
return Err(AuthError::InvalidCredentials);
};
// Comprobar bloqueo temporal por intentos fallidos.
if let Some(locked_until) = user_model.locked_until
&& locked_until > now
let local_model = user::Entity::find().filter(filter).one(dbconn()).await?;
if let Some(model) = &local_model
&& model.locked_until.is_some_and(|until| until > now)
{
return Err(AuthError::AccountLocked);
}
let local = local_model.as_ref().map(UserRef::from);
let has_providers = provider::active_providers().next().is_some();
let linked = match &local {
Some(user) if has_providers => provider::linked_providers(user.id()).await?,
_ => Vec::new(),
};
// Verificar contraseña.
if !password::verify_password_async(plain_password, &user_model.password_hash).await {
register_failed_login(&user_model, now).await?;
return Err(AuthError::InvalidCredentials);
let fallback = SETTINGS.login.local_fallback;
let mut released = false;
if let Some(user) = local
.as_ref()
.filter(|_| provider::needs_release_check(fallback, local.as_ref()))
{
for p in provider::active_providers() {
if p.releases(user).await {
released = true;
break;
}
}
}
let chain = provider::login_chain(
provider::active_sources(),
fallback,
local.as_ref(),
released,
);
let attempt = LoginAttempt::new(identifier, password, local.as_ref(), client_ip);
let mut checked = false;
// Si alguna fuente ha comprobado la contraseña y la ha rechazado de verdad. Una cuenta sin
// contraseña local (la de un proveedor) no rechaza nada con `"local"`: así, si el proveedor no
// responde, sus intentos no cuentan para el bloqueo de la cuenta.
let mut rejected = false;
let mut unavailable = false;
let mut failed_user = None;
let mut success = None;
for source in chain {
match source {
Source::Local => {
let Some(model) = &local_model else {
continue;
};
// Sin contraseña local no se calcula Argon2: no cuenta como comprobada, para que
// tarde lo mismo que una cuenta inexistente.
let usable = model.password_hash != password::UNUSABLE_HASH;
checked |= usable;
if password::verify_password_async(password.expose(), &model.password_hash).await {
success = Some((model.id, None));
break;
}
rejected |= usable;
}
Source::Provider(p) => {
if !linked.is_empty() && !linked.iter().any(|id| id == p.id()) {
continue;
}
checked = true;
match p.authenticate(&attempt).await {
ProviderOutcome::NotFound => {}
ProviderOutcome::InvalidCredentials { user_id } => {
rejected = true;
failed_user = failed_user.or(user_id);
}
ProviderOutcome::Unavailable => unavailable = true,
ProviderOutcome::Rejected(reason) => {
return Err(AuthError::ExternalRejected(reason));
}
ProviderOutcome::Authenticated { user_id } => {
success = Some((user_id, Some(p)));
break;
}
}
}
}
}
// Comprobar estado de la cuenta.
let Some((user_id, via)) = success else {
let failed = match (local_model, failed_user) {
(Some(model), _) => Some(model),
(None, Some(id)) => user::Entity::find_by_id(id).one(dbconn()).await?,
(None, None) => None,
};
// Con un proveedor que no responde, sólo cuenta si otra fuente la ha rechazado.
if let Some(model) = failed
&& (rejected || !unavailable)
{
register_failed_login(&model, now).await?;
}
if !checked {
password::verify_password_without_account(password.expose()).await;
}
return Err(if unavailable {
AuthError::ExternalUnavailable
} else {
AuthError::InvalidCredentials
});
};
// La cuenta que ha resultado, que con un proveedor puede no ser la de lo tecleado, o haber
// cambiado al resolverla: se comprueban su bloqueo y su estado, no los de otra.
let user_model = match (via, local_model) {
(None, Some(model)) => model,
_ => user::Entity::find_by_id(user_id)
.one(dbconn())
.await?
.ok_or(AuthError::UserNotFound)?,
};
if user_model.locked_until.is_some_and(|until| until > now) {
return Err(AuthError::AccountLocked);
}
match UserStatus::from_i16(user_model.status) {
UserStatus::Blocked => return Err(AuthError::AccountBlocked),
UserStatus::Pending => return Err(AuthError::AccountPending),
UserStatus::AwaitingApproval => return Err(AuthError::AccountAwaitingApproval),
UserStatus::Active => {}
}
// Actualizar last_login_at y resetear contador de fallos.
let user_id = user_model.id;
let needs_rehash = password::needs_rehash(&user_model.password_hash);
// Último acceso y contador de fallos a cero. La contraseña local sólo se vuelve a cifrar si se
// ha usado: es la única ocasión en que se conoce.
let needs_rehash = via.is_none() && password::needs_rehash(&user_model.password_hash);
let mut active = user_model.into_active_model();
active.last_login_at = Set(Some(now));
active.last_access_at = Set(Some(now));
@ -77,15 +221,49 @@ pub async fn login(
active.failed_login_at = Set(None);
active.locked_until = Set(None);
if needs_rehash {
let new_hash = password::hash_password_async(plain_password).await?;
active.password_hash = Set(new_hash);
active.password_hash = Set(password::hash_password_async(password.expose()).await?);
}
active.update(dbconn()).await?;
// Crear sesión y devolver el SID.
session::create_session(user_id, remember)
let remember = remember && via.is_none_or(|p| p.allows_remember());
let sid = session::create_session(user_id, remember)
.await
.map_err(AuthError::Database)
.map_err(AuthError::Database)?;
if has_providers {
let (providers, login_via): (Vec<&'static dyn AuthProvider>, _) = match via {
Some(p) => (vec![p], LoginVia::Provider),
None => (
provider::active_providers()
.filter(|p| linked.iter().any(|id| id == p.id()))
.collect(),
LoginVia::Local,
),
};
for p in providers {
if tokio::time::timeout(AFTER_LOGIN_TIMEOUT, p.after_login(user_id, login_via))
.await
.is_err()
{
trace::warn!(
"Provider \"{}\" took too long after the login of user {user_id}",
p.id()
);
}
}
// La sesión ya está creada: un fallo aquí no debe impedir el inicio de sesión.
if let Err(err) = user_identity::Entity::update_many()
.col_expr(user_identity::Column::LastLoginAt, Expr::value(now))
.filter(user_identity::Column::UserId.eq(user_id))
.filter(user_identity::Column::Pending.eq(false))
.exec(dbconn())
.await
{
trace::error!("Cannot record the login of user {user_id} in its identities: {err}");
}
}
Ok(NewSession { sid, remember })
}
// **< logout >*************************************************************************************
@ -164,13 +342,13 @@ pub async fn register(
/// `checked_user()`).
pub(crate) async fn change_own_password(
user_id: i32,
current_password: &str,
new_password: &str,
current_password: &util::SecretStr,
new_password: &util::SecretStr,
current_sid: Option<&str>,
) -> Result<user::Model, AuthError> {
let user_model = checked_user(user_id, current_password).await?;
password::validate_strength(new_password)?;
let hash = password::hash_password_async(new_password).await?;
password::validate_strength(new_password.expose())?;
let hash = password::hash_password_async(new_password.expose()).await?;
user::ActiveModel {
id: Set(user_id),
@ -190,14 +368,17 @@ pub(crate) async fn change_own_password(
Ok(user_model)
}
// Cuenta del usuario, si `plain_password` es su contraseña actual; si no,
// Cuenta del usuario, si `password` es su contraseña actual; si no,
// `AuthError::InvalidCredentials`.
//
// Los fallos cuentan para el bloqueo por intentos fallidos, como en `login()`, y con la cuenta
// bloqueada se rechaza también la contraseña correcta (`AuthError::AccountLocked`): si no, quien
// tuviera una sesión robada podría adivinar la contraseña desde estos formularios sin límite, y
// pedirla no protegería el cambio de la contraseña ni el del email.
async fn checked_user(user_id: i32, plain_password: &str) -> Result<user::Model, AuthError> {
//
// La de una cuenta que gestiona un proveedor la comprueba el proveedor
// (`AuthProvider::reauthenticate()`), con los mismos contadores de fallos.
async fn checked_user(user_id: i32, password: &util::SecretStr) -> Result<user::Model, AuthError> {
let user_model = user::Entity::find_by_id(user_id)
.one(dbconn())
.await?
@ -208,7 +389,18 @@ async fn checked_user(user_id: i32, plain_password: &str) -> Result<user::Model,
{
return Err(AuthError::AccountLocked);
}
if !password::verify_password_async(plain_password, &user_model.password_hash).await {
let valid = match provider::managing_provider(user_id).await? {
Some(p) => match p
.reauthenticate(&UserRef::from(&user_model), password)
.await
{
ReauthOutcome::Valid => true,
ReauthOutcome::Invalid => false,
ReauthOutcome::Unavailable => return Err(AuthError::ExternalUnavailable),
},
None => password::verify_password_async(password.expose(), &user_model.password_hash).await,
};
if !valid {
register_failed_login(&user_model, now).await?;
return Err(AuthError::InvalidCredentials);
}
@ -237,7 +429,7 @@ async fn checked_user(user_id: i32, plain_password: &str) -> Result<user::Model,
/// [`email_change_window_secs`]: crate::config::UserSettings::email_change_window_secs
pub(crate) async fn request_email_change(
user_id: i32,
current_password: &str,
current_password: &util::SecretStr,
new_email: &str,
) -> Result<(user::Model, String, String), AuthError> {
let user_model = checked_user(user_id, current_password).await?;
@ -450,11 +642,14 @@ async fn do_seed(username: Username, email: Email) {
use rand_core::{OsRng, RngCore};
let mut bytes = [0u8; 15];
OsRng.fill_bytes(&mut bytes);
(Base64UrlUnpadded::encode_string(&bytes), true)
(
util::SecretStr::new(Base64UrlUnpadded::encode_string(&bytes)),
true,
)
}
};
let hash = match password::hash_password(&admin_password) {
let hash = match password::hash_password(admin_password.expose()) {
Ok(h) => h,
Err(e) => {
eprintln!(
@ -494,7 +689,8 @@ async fn do_seed(username: Username, email: Email) {
if generated {
println!(
"\npagetop-user: admin account created.\n username: {}\n password: {}\n",
admin_username, admin_password
admin_username,
admin_password.expose()
);
}
}

View file

@ -28,6 +28,7 @@ use crate::account::UserStatus;
use crate::component::admin::status_key;
use crate::config::{user_language_applies, user_timezone_applies};
use crate::entity::user;
use crate::provider;
use crate::{LOCALES_USER, PROFILE_PATH};
// Texto libre de varias líneas como contenido seguro: cada salto de línea se convierte en `<br>`,
@ -171,6 +172,15 @@ pub(crate) async fn user_details(user: &user::Model, cx: &mut Context) -> Block
)),
);
// El origen de la cuenta sólo dice algo si hay proveedores de autenticación activos.
if provider::active_providers().next().is_some() {
table = table.with_row(
table::Row::new()
.with_cell(Lc::t("field-origin", &LOCALES_USER))
.with_cell(account_origin(user.id, cx).await),
);
}
if user.is_admin {
let badge = Badge::severe(Lc::t("badge-admin", &LOCALES_USER))
.render(cx)
@ -186,3 +196,28 @@ pub(crate) async fn user_details(user: &user::Model, cx: &mut Context) -> Block
.with_title(Lc::t("title-user-details", &LOCALES_USER))
.with_child(table)
}
// Origen de la cuenta: local, vinculada a un proveedor o local a la espera de vincularse con uno.
async fn account_origin(user_id: i32, cx: &Context) -> Lc {
let identities = match provider::identities_of(user_id).await {
Ok(identities) => identities,
Err(err) => {
trace::error!("Cannot load the identities of user {user_id}: {err}");
return Lc::n("-");
}
};
let label = |id: &str| {
provider::active_provider(id).map_or_else(|| Lc::n(id.to_owned()), |p| p.label())
};
if let Some(linked) = identities.iter().find(|identity| !identity.pending) {
return label(&linked.provider);
}
match identities.first() {
// Los argumentos de `Lc` son texto fijo: la etiqueta del proveedor se traduce ya.
Some(pending) => Lc::t("value-origin-pending", &LOCALES_USER).with_arg(
"provider",
label(&pending.provider).lookup(cx).unwrap_or_default(),
),
None => Lc::t("value-origin-local", &LOCALES_USER),
}
}

View file

@ -43,12 +43,28 @@ pub(crate) type PermissionGroups = Vec<(Lc, Vec<PermissionItem>)>;
// rol "authenticated" no se lista como casilla ni se envía: todo usuario autenticado lo tiene
// concedido por definición (ver `session::load_user_from_session`), sin necesidad de una fila en
// `user_role`.
pub(crate) fn roles_fieldset(roles: &[(i32, String, bool)]) -> form::Fieldset {
//
// Los roles de `managed` los asigna el proveedor `provider` que gestiona la cuenta: se muestran
// deshabilitados, con una nota, y quien recibe el formulario los conserva como estén.
pub(crate) fn roles_fieldset(
roles: &[(i32, String, bool)],
managed: &[i32],
provider: &str,
) -> form::Fieldset {
let mut field = form::check::Field::new().with_name("role_ids");
for (role_id, label, checked) in roles {
let is_managed = managed.contains(role_id);
let label = if is_managed {
Lc::t("value-role-managed", &LOCALES_USER)
.with_arg("role", label.clone())
.with_arg("provider", provider.to_owned())
} else {
Lc::n(label.clone())
};
field = field.with_item(
form::check::Item::new(role_id.to_string(), Lc::n(label.clone()))
.with_checked(*checked),
form::check::Item::new(role_id.to_string(), label)
.with_checked(*checked)
.with_disabled(is_managed),
);
}
form::Fieldset::new()

View file

@ -9,6 +9,7 @@ use crate::{ADMIN_USERS_PATH, PROFILE_EDIT_PATH};
use crate::component::{PasswordConfirm, error_banner, form_actions, profile_form_actions};
use crate::identity::{EMAIL_MAX_CHARS, USERNAME_MIN_CHARS, username_help, username_max_chars};
use crate::provider::{AccountPolicy, UserField};
use crate::service::user_admin::{ABOUT_MAX_CHARS, DISPLAY_NAME_MAX_CHARS};
use super::{USER_ADMIN_FORM_ID, roles_fieldset};
@ -42,6 +43,11 @@ pub(crate) struct UserForm {
/// En modo `Profile`, si el nombre de usuario es editable; si no, se muestra de sólo lectura.
allow_username_field: bool,
is_admin: bool,
/// Política del proveedor que gestiona la cuenta, si lo hay: los datos que gestiona se muestran
/// de sólo lectura (y quien recibe el formulario los ignora).
policy: Option<AccountPolicy>,
/// En modo `New`, el proveedor con el que entrará la cuenta (`(id, nombre)`): sin contraseña.
provider: Option<(String, String)>,
}
#[async_trait]
@ -56,11 +62,29 @@ impl Component for UserForm {
UserFormMode::Edit => user_path(self.user_id().copied().unwrap_or_default(), "edit"),
UserFormMode::Profile => PROFILE_EDIT_PATH.into(),
};
let username_readonly =
*self.mode() == UserFormMode::Profile && !*self.allow_username_field();
let policy = self.policy();
let managed = |field: UserField| policy.is_some_and(|p| p.manages(field));
let managed_help = match policy {
Some(p) => Lc::t("help-managed-by", &LOCALES_USER).with_arg(
"provider",
p.provider_label().lookup(cx).unwrap_or_default(),
),
None => Lc::none(),
};
let help = |readonly: bool| {
if readonly {
managed_help.clone()
} else {
Lc::none()
}
};
let username_managed = policy.is_some_and(|p| !p.username().is_editable());
let username_readonly = username_managed
|| (*self.mode() == UserFormMode::Profile && !*self.allow_username_field());
// El propio usuario cambia su email en otra pantalla, que pide su contraseña y confirma la
// nueva dirección antes de aplicarla.
let email_readonly = *self.mode() == UserFormMode::Profile;
let email_managed = policy.is_some_and(|p| !p.email().is_editable());
let email_readonly = email_managed || *self.mode() == UserFormMode::Profile;
let action = cx.route(action);
let mut form = Form::new()
@ -73,7 +97,9 @@ impl Component for UserForm {
.with_name("username")
.with_value(self.username())
.with_label(Lc::t("field-username-admin", &LOCALES_USER))
.with_help_text(if username_readonly {
.with_help_text(if username_managed {
managed_help.clone()
} else if username_readonly {
Lc::none()
} else {
username_help(SETTINGS.identity_policy)
@ -88,7 +114,9 @@ impl Component for UserForm {
.with_name("email")
.with_value(self.email())
.with_label(Lc::t("field-email", &LOCALES_USER))
.with_help_text(if email_readonly {
.with_help_text(if email_managed {
managed_help.clone()
} else if email_readonly {
Lc::t("help-email-readonly", &LOCALES_USER)
} else {
Lc::none()
@ -102,6 +130,8 @@ impl Component for UserForm {
.with_name("display_name")
.with_value(self.display_name())
.with_label(Lc::t("field-display-name", &LOCALES_USER))
.with_help_text(help(managed(UserField::DisplayName)))
.with_readonly(managed(UserField::DisplayName))
.with_maxlength(DISPLAY_NAME_MAX_CHARS),
);
@ -112,6 +142,7 @@ impl Component for UserForm {
form::SelectLanguage::new()
.with_name("language")
.with_label(Lc::t("field-language", &LOCALES_USER))
.with_disabled(managed(UserField::Language))
.with_selected(self.language()),
);
}
@ -121,6 +152,7 @@ impl Component for UserForm {
.with_name("timezone")
.with_label(Lc::t("field-timezone", &LOCALES_USER))
.with_utc_offset(true)
.with_disabled(managed(UserField::Timezone))
.with_selected(self.timezone()),
);
}
@ -128,24 +160,47 @@ impl Component for UserForm {
form::SelectTheme::new()
.with_name("theme")
.with_label(Lc::t("field-theme", &LOCALES_USER))
.with_disabled(managed(UserField::Theme))
.with_selected(self.theme()),
);
if *self.mode() == UserFormMode::New {
match (self.mode(), self.provider()) {
// Una cuenta que entrará con un proveedor no tiene contraseña local.
(UserFormMode::New, Some((id, name))) => {
form = form
.with_child(form::Hidden::field("provider", id.as_str()))
.with_child(Html::with({
let note = Lc::t("help-external-user", &LOCALES_USER)
.with_arg("provider", name.clone());
move |cx| html! { p { (note.using(cx)) } }
}));
}
(UserFormMode::New, None) => {
form = form.with_child(PasswordConfirm::new());
} else {
}
_ => {
form = form.with_child(
form::Textarea::new()
.with_name("about")
.with_value(self.about())
.with_label(Lc::t("field-about", &LOCALES_USER))
.with_help_text(help(managed(UserField::About)))
.with_readonly(managed(UserField::About))
.with_rows(Some(5))
.with_maxlength(Some(ABOUT_MAX_CHARS)),
);
}
}
if *self.mode() != UserFormMode::Profile && !self.roles().is_empty() {
form = form.with_child(roles_fieldset(self.roles()));
let (managed_roles, provider) = match policy {
Some(p) => (
p.managed_roles(),
p.provider_label().lookup(cx).unwrap_or_default(),
),
None => (&[][..], String::new()),
};
form = form.with_child(roles_fieldset(self.roles(), managed_roles, &provider));
}
if *self.mode() == UserFormMode::New && *self.allow_admin_field() {
@ -248,4 +303,14 @@ impl UserForm {
self.is_admin = is_admin;
self
}
pub(crate) fn with_policy(mut self, policy: Option<AccountPolicy>) -> Self {
self.policy = policy;
self
}
pub(crate) fn with_provider(mut self, provider: Option<(String, String)>) -> Self {
self.provider = provider;
self
}
}

View file

@ -7,6 +7,7 @@ use pagetop_htmx::hx_table::sort_link;
use crate::ADMIN_USERS_PATH;
use crate::LOCALES_USER;
use crate::account::{Account, UserStatus};
use crate::provider;
use crate::service::user_admin::{UserListItem, UserSortField};
use crate::user_path;
@ -68,12 +69,23 @@ impl Component for UserTable {
let new_href = cx.route(util::join!(ADMIN_USERS_PATH.as_str(), "/new"));
let mut list = ListView::new()
.with_id("user-table-wrapper")
.with_action(
Button::anchor(Lc::t("btn-create-user", &LOCALES_USER), new_href)
let mut list = ListView::new().with_id("user-table-wrapper").with_action(
Button::anchor(Lc::t("btn-create-user", &LOCALES_USER), new_href.clone())
.with_style(button::Style::Solid(Intent::Primary)),
);
// Alta de una cuenta que entrará con un proveedor de autenticación (ver `new_get()`).
for provider in provider::active_providers() {
let name = provider.label().lookup(cx).unwrap_or_default();
let href = new_href.clone().with_param("provider", provider.id());
list = list.with_action(
Button::anchor(
Lc::t("btn-create-external-user", &LOCALES_USER).with_arg("provider", name),
href,
)
.with_style(button::Style::Solid(Intent::Neutral)),
);
}
let mut list = list
.with_table(table)
.with_pager(hx_pager::boost(pager, "#user-table-wrapper"));
Ok(list.render(cx).await)
@ -221,5 +233,6 @@ pub(crate) fn status_key(status: UserStatus) -> &'static str {
UserStatus::Active => "status-active",
UserStatus::Blocked => "status-blocked",
UserStatus::Pending => "status-pending",
UserStatus::AwaitingApproval => "status-awaiting-approval",
}
}

View file

@ -4,11 +4,23 @@ use pagetop::prelude::*;
use crate::component::error_banner;
use crate::config::SETTINGS;
use crate::provider::{self, HelpLink, ResetLink};
use crate::{LOCALES_USER, LOGIN_PATH, PASSWORD_RESET_PATH, REGISTER_PATH};
/// Formulario de inicio de sesión.
///
/// Además de los campos de usuario y contraseña, muestra lo que piden los proveedores de
/// autenticación activos (ver
/// [`AuthProvider::login_hints()`](crate::provider::AuthProvider::login_hints)): su nota bajo el
/// formulario y, si `"local"` no está en `[user.login] sources`, su enlace para recuperar la
/// contraseña en lugar del de `pagetop-user`. La casilla «Recuérdame» sólo aparece si alguna fuente
/// la admite.
#[derive(AutoDefault, Clone, Debug, Getters)]
pub struct LoginForm {
/// Mensaje de error sobre el formulario.
error: Option<Lc>,
/// Enlace de ayuda junto al error (p. ej. dónde cambiar una contraseña caducada).
help: Option<HelpLink>,
/// Usuario o email con el que se rellena el campo.
username: String,
/// Página a la que volver tras iniciar sesión.
@ -23,7 +35,8 @@ impl Component for LoginForm {
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let action = self.waypoint().append_to(cx.route(LOGIN_PATH));
let strict = SETTINGS.login_strict;
let strict = SETTINGS.login.strict;
let (notes, reset) = provider::login_hints();
// En modo estricto se dificulta que el navegador recuerde o autorrellene las
// credenciales: nombres de campo neutros y campos `Field::strict_text()`/
@ -54,19 +67,23 @@ impl Component for LoginForm {
.with_action(action)
.with_method(form::Method::Post)
.with_child(error_banner(self.error().cloned()))
.with_child(help_link(self.help().cloned()))
.with_child(username)
.with_child(password)
.with_child(
.with_child(password);
if provider::any_allows_remember() {
form = form.with_child(
form::Checkbox::check()
.with_name("remember")
.with_label(Lc::t("field-remember-me", &LOCALES_USER))
.with_help_text(Lc::t("help-remember-me", &LOCALES_USER)),
)
);
}
form = form
.with_child(
Button::submit(Lc::t("btn-login", &LOCALES_USER))
.with_style(button::Style::Solid(Intent::Primary)),
)
.with_child(links(SETTINGS.allow_registration));
.with_child(links(SETTINGS.allow_registration, notes, reset));
if strict {
form = form
@ -85,9 +102,12 @@ impl Component for LoginForm {
}
}
fn links(allow_registration: bool) -> Html {
fn links(allow_registration: bool, notes: Vec<Lc>, reset: ResetLink) -> Html {
Html::with(move |cx| {
html! {
@for note in &notes {
p class="user-login-note" { (note.using(cx)) }
}
@if allow_registration {
p class="user-register-link" {
a href=(cx.route(REGISTER_PATH)) {
@ -95,22 +115,61 @@ fn links(allow_registration: bool) -> Html {
}
}
}
@match &reset {
ResetLink::Local => {
p class="user-reset-link" {
a href=(cx.route(PASSWORD_RESET_PATH)) {
(Lc::t("link-forgot-password", &LOCALES_USER).using(cx))
}
}
}
ResetLink::External(help) => {
p class="user-reset-link" {
a href=(help.url()) {
@match help.text().lookup(cx) {
Some(text) => (text),
None => (Lc::t("link-forgot-password", &LOCALES_USER).using(cx)),
}
}
}
}
ResetLink::Hidden => {}
}
}
})
}
// Enlace de ayuda que acompaña a un error, si lo hay.
fn help_link(help: Option<HelpLink>) -> Html {
Html::with(move |cx| match &help {
Some(help) => html! {
p class="user-login-help" {
a href=(help.url()) {
@match help.text().lookup(cx) {
Some(text) => (text),
None => (help.url()),
}
}
}
},
None => html! {},
})
}
#[builder_impl]
impl LoginForm {
/// Mensaje de error sobre el formulario, p. ej. el del envío que ha fallado.
pub fn with_error(mut self, error: impl Into<Option<Lc>>) -> Self {
self.error = error.into();
self
}
/// Enlace de ayuda junto al error.
pub fn with_help(mut self, help: impl Into<Option<HelpLink>>) -> Self {
self.help = help.into();
self
}
/// Rellena el usuario o email, p. ej. con el enviado si el inicio de sesión falla.
pub fn with_username(mut self, username: impl Into<String>) -> Self {
self.username = username.into();

View file

@ -5,6 +5,10 @@ use pagetop::prelude::*;
use crate::LOCALES_USER;
use crate::component::{PasswordConfirm, error_banner};
/// Formulario para elegir la nueva contraseña desde el enlace de recuperación.
///
/// Pide la contraseña y su confirmación, y se envía a la propia página del enlace, cuya dirección
/// lleva la cuenta y el *token*: sólo funciona dentro de ella.
#[derive(AutoDefault, Clone, Debug)]
pub struct PasswordResetConfirmForm {
error: Option<Lc>,
@ -38,6 +42,7 @@ impl Component for PasswordResetConfirmForm {
#[builder_impl]
impl PasswordResetConfirmForm {
/// Mensaje de error sobre el formulario, p. ej. el del envío que ha fallado.
pub fn with_error(mut self, error: impl Into<Option<Lc>>) -> Self {
self.error = error.into();
self

View file

@ -5,6 +5,11 @@ use pagetop::prelude::*;
use crate::component::error_banner;
use crate::{LOCALES_USER, LOGIN_PATH, PASSWORD_RESET_PATH};
/// Formulario para pedir la recuperación de la contraseña.
///
/// Pide el email de la cuenta y lo envía a `/user/password/reset`, que, si es de una cuenta activa,
/// manda por correo el enlace para elegir una nueva (o un aviso, si la contraseña la gestiona un
/// proveedor de autenticación). La respuesta es la misma exista o no la cuenta.
#[derive(AutoDefault, Clone, Debug)]
pub struct PasswordResetForm {
error: Option<Lc>,
@ -54,6 +59,7 @@ fn back_to_login() -> Html {
#[builder_impl]
impl PasswordResetForm {
/// Mensaje de error sobre el formulario, p. ej. el del envío que ha fallado.
pub fn with_error(mut self, error: impl Into<Option<Lc>>) -> Self {
self.error = error.into();
self

View file

@ -8,6 +8,11 @@ use crate::component::{PasswordConfirm, error_banner};
use crate::config::SETTINGS;
use crate::identity::{EMAIL_MAX_CHARS, USERNAME_MIN_CHARS, username_help, username_max_chars};
/// Formulario de registro de una cuenta nueva.
///
/// Pide el nombre de usuario (con las reglas de la política de identidad configurada), el email y
/// la contraseña con su confirmación, y se envía a `/user/register`, que sólo admite registros con
/// [`allow_registration`](crate::config::UserSettings::allow_registration).
#[derive(AutoDefault, Clone, Debug)]
pub struct RegisterForm {
error: Option<Lc>,
@ -60,6 +65,7 @@ impl Component for RegisterForm {
#[builder_impl]
impl RegisterForm {
/// Mensaje de error sobre el formulario, p. ej. el del envío que ha fallado.
pub fn with_error(mut self, error: impl Into<Option<Lc>>) -> Self {
self.error = error.into();
self

View file

@ -6,12 +6,12 @@ use crate::Account;
use crate::permission::UserPermission;
use crate::profile_path;
/// Componente para mostrar el **nombre de un usuario**, enlazado a su perfil público cuando quien
/// mira puede verlo.
/// Componente para mostrar el **nombre de un usuario**.
///
/// Se renderiza como enlace a `/user/{id}` si quien hace la petición tiene `user:view_profiles` o
/// es el propio usuario; si no, como texto. Las propiedades del componente (identificador, clases,
/// atributos) se aplican en ambos casos.
/// Enlaza con su perfil público, siempre que quien mira pueda verlo. Se renderiza como enlace a
/// `/user/{id}` si quien hace la petición tiene `user:view_profiles` o es el propio usuario; si no,
/// como texto. Las propiedades del componente (identificador, clases, atributos) se aplican en
/// ambos casos.
///
/// Recibe el identificador y el nombre que el llamador ya tiene de su propia consulta, así que no
/// consulta la base de datos al renderizarse. El nombre suele ser el nombre visible del usuario o,

View file

@ -23,7 +23,8 @@
//! ```
//!
//! Todas las opciones, con su valor por defecto, se documentan en [`UserSettings`] y sus
//! subsecciones ([`SessionSettings`], [`PasswordSettings`], [`SeedSettings`] y [`AdminSettings`]).
//! subsecciones ([`SessionSettings`], [`PasswordSettings`], [`SeedSettings`], [`AdminSettings`] y
//! [`LoginSettings`]).
//! Las reglas de los nombres de usuario y del email se explican en [`IdentityPolicy`].
//!
//! Consulta [`pagetop::config`] para ver cómo PageTop lee los archivos de configuración y aplica
@ -163,14 +164,71 @@ pub struct UserSettings {
/// Listados de administración, en la subsección `[user.admin]`.
pub admin: AdminSettings,
/// Activa las medidas para dificultar que el navegador recuerde o autorrellene las
/// credenciales en la pantalla de login (gestor de contraseñas, autocompletado agresivo...).
#[default = false]
pub login_strict: bool,
/// Inicio de sesión, en la subsección `[user.login]`.
pub login: LoginSettings,
}
/// Política de identidad: qué nombres de usuario se aceptan al crear una cuenta o al cambiar su
/// nombre. Usado en [`UserSettings::identity_policy`].
/// Subsección **`[user.login]`** de la configuración.
///
/// Decide con qué se comprueban las credenciales del formulario de inicio de sesión: con la
/// contraseña guardada en PageTop (`"local"`) o con los proveedores de autenticación que declaren
/// otras extensiones (un directorio LDAP, por ejemplo; ver
/// [`AuthProvider`](crate::provider::AuthProvider)).
///
/// | Quiero... | `sources` | `local_fallback` |
/// |---|---|---|
/// | Sólo cuentas locales (por defecto) | `["local"]` | - |
/// | Las dos, primero las locales | `["local", "ldap"]` | - |
/// | Las dos, primero el proveedor | `["ldap", "local"]` | - |
/// | Sólo el proveedor, con administradores locales de emergencia | `["ldap"]` | `"admins"` |
/// | Sólo el proveedor, salvo las cuentas que libere | `["ldap"]` | `"released"` |
/// | Sólo el proveedor, sin excepciones | `["ldap"]` | `"none"` |
#[settings]
pub struct LoginSettings {
/// Fuentes de credenciales, en el orden en que se comprueban: `"local"` es la contraseña
/// guardada en PageTop, y el resto, identificadores de proveedores declarados
/// ([`AuthProvider::id()`](crate::provider::AuthProvider::id)).
///
/// Un identificador desconocido o repetido, o una lista vacía, impiden arrancar. Un proveedor
/// declarado que no esté en la lista no autentica a nadie (se avisa al arrancar).
///
/// Una cuenta vinculada a un proveedor sólo se autentica con él (y con `"local"`, si está en la
/// lista o lo permite [`local_fallback`](Self::local_fallback)). Poner primero el proveedor
/// evita calcular la contraseña local (Argon2, unas decenas de milisegundos) a quien entra con
/// él.
#[default(vec!["local".to_owned()])]
pub sources: Vec<String>,
/// Qué cuentas pueden aún entrar con su contraseña local cuando `"local"` no está en
/// [`sources`](Self::sources). Ver [`LocalFallback`].
pub local_fallback: LocalFallback,
/// Activa las medidas para dificultar que el navegador recuerde o autorrellene las
/// credenciales en la pantalla de inicio de sesión (gestor de contraseñas, autocompletado
/// agresivo...).
#[default = false]
pub strict: bool,
}
/// Define qué cuentas pueden entrar con su contraseña local.
///
/// Sólo se aplica cuando `"local"` no está en [`LoginSettings::sources`].
#[derive(AutoDefault, Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum LocalFallback {
/// Ninguna: sólo entran las cuentas que autentique un proveedor.
None,
/// Las que algún proveedor de `sources` libera (p. ej. las que excluye de su gestión, o los
/// administradores si así lo decide). Es el valor por defecto.
#[default]
Released,
/// Además de las liberadas, cualquier cuenta de administrador: un acceso de emergencia si el
/// proveedor deja de responder.
Admins,
}
/// Define la política de identidad.
///
/// Establece qué nombres de usuario se aceptan al crear una cuenta o al cambiar su nombre. Usado en
/// [`UserSettings::identity_policy`].
///
/// Cada nivel admite todo lo del anterior y algo más:
///
@ -344,7 +402,7 @@ pub struct SeedSettings {
pub admin_email: String,
/// Contraseña del primer administrador. Sin valor, se genera una aleatoria y se muestra una
/// sola vez por la salida estándar al crearlo.
pub admin_password: Option<String>,
pub admin_password: Option<util::SecretStr>,
}
/// Subsección **`[user.admin]`** de la configuración.

View file

@ -4,5 +4,6 @@ pub mod role;
pub mod role_permission;
pub mod session;
pub mod user;
pub mod user_identity;
pub mod user_role;
pub mod user_token;

View file

@ -0,0 +1,39 @@
use pagetop_seaorm::db::*;
/// Vínculo entre una cuenta y la identidad de una persona en un proveedor de autenticación externo,
/// o marca de que la cuenta puede vincularse con él (`pending`).
#[derive(Clone, Debug, DeriveEntityModel, PartialEq)]
#[sea_orm(table_name = "user_identities")]
pub struct Model {
#[sea_orm(primary_key)]
pub id: i32,
pub user_id: i32,
pub provider: String,
pub external_id: Option<String>,
pub external_key: Option<String>,
pub pending: bool,
pub expected_key: Option<String>,
pub data: Option<String>,
pub created_at: DateTimeUtc,
pub linked_at: Option<DateTimeUtc>,
pub last_login_at: Option<DateTimeUtc>,
}
#[derive(Clone, Copy, Debug, DeriveRelation, EnumIter)]
pub enum Relation {
#[sea_orm(
belongs_to = "super::user::Entity",
from = "Column::UserId",
to = "super::user::Column::Id",
on_delete = "Cascade"
)]
User,
}
impl Related<super::user::Entity> for Entity {
fn to() -> RelationDef {
Relation::User.def()
}
}
impl ActiveModelBehavior for ActiveModel {}

View file

@ -2,107 +2,206 @@
use thiserror::Error;
use crate::provider::RejectReason;
/// Definición de errores.
///
/// Incluye errores de las credenciales y el estado de las cuentas, de los datos que no superan su
/// validación, de la administración de usuarios y roles, de los proveedores de autenticación y de
/// la configuración.
///
/// El mensaje de cada error (`Display`) está en inglés, para las trazas; los formularios muestran
/// al usuario un texto traducido.
#[derive(Debug, Error)]
pub enum AuthError {
/// El usuario o la contraseña no son correctos (o no hay cuenta con ese usuario).
#[error("invalid credentials")]
InvalidCredentials,
/// La cuenta está bloqueada por un administrador o por el proveedor que la gestiona.
#[error("account is blocked")]
AccountBlocked,
/// La cuenta está pendiente de que su titular confirme el email.
#[error("account is pending email verification")]
AccountPending,
/// La cuenta está bloqueada temporalmente por demasiados intentos fallidos.
#[error("account is temporarily locked due to too many failed login attempts")]
AccountLocked,
/// No se ha podido calcular o comprobar el *hash* de una contraseña.
#[error("password hashing failed: {0}")]
PasswordHash(String),
/// Error de la base de datos.
#[error("database error: {0}")]
Database(#[from] pagetop_seaorm::db::DbErr),
/// El enlace (*token*) de un solo uso no es válido o ha caducado.
#[error("token is invalid or has expired")]
InvalidToken,
/// El nombre de usuario ya lo usa otra cuenta, o uno que se confunde con él.
#[error("username is already taken")]
UsernameTaken,
/// El nombre de usuario no cumple la política de identidad configurada.
#[error("username does not meet the identity policy (user.identity_policy)")]
InvalidUsername,
/// La dirección de email no es válida.
#[error("invalid email address")]
InvalidEmail,
/// Un ajuste de la configuración no es válido; `source` dice por qué.
#[error("invalid setting \"{key}\"")]
InvalidSetting {
/// Clave del ajuste, p. ej. `user.seed.admin_email`.
key: &'static str,
/// Motivo.
#[source]
source: Box<AuthError>,
},
/// La dirección de email ya la usa otra cuenta.
#[error("email is already registered")]
EmailTaken,
/// La nueva dirección de email es la misma que la actual.
#[error("new email is the same as the current one")]
SameEmail,
/// Se ha alcanzado un límite de solicitudes o de intentos fallidos.
#[error("too many requests")]
TooManyRequests,
/// La contraseña y su confirmación no coinciden.
#[error("passwords do not match")]
PasswordMismatch,
/// La contraseña no llega a la longitud mínima indicada.
#[error("password must be at least {0} characters")]
PasswordTooShort(usize),
/// La zona horaria no es una de las que ofrece la aplicación.
#[error("invalid IANA timezone identifier")]
InvalidTimezone,
/// El idioma no es uno de los que ofrece la aplicación.
#[error("unsupported language identifier")]
InvalidLanguage,
/// El tema no existe o no está habilitado.
#[error("unknown or disabled theme")]
InvalidTheme,
/// El texto «Sobre mí» supera la longitud máxima indicada.
#[error("about text must be at most {0} characters")]
AboutTooLong(usize),
/// El nombre visible supera la longitud máxima indicada.
#[error("display name must be at most {0} characters")]
DisplayNameTooLong(usize),
/// La cuenta no existe.
#[error("user not found")]
UserNotFound,
/// El rol no existe.
#[error("role not found")]
RoleNotFound,
/// El nombre interno del rol ya lo usa otro rol.
#[error("role machine name is already taken")]
RoleMachineNameTaken,
/// El nombre interno del rol no es válido.
#[error(
"role machine name must contain only lowercase letters, digits and underscores, up to 64"
)]
InvalidMachineName,
/// La etiqueta del rol está vacía o supera la longitud máxima indicada.
#[error("role label must not be blank and must be at most {0} characters")]
InvalidRoleLabel(usize),
/// El rol está protegido (`locked`, como los de sistema) y no se puede modificar ni eliminar.
#[error("role is locked and cannot be modified or deleted")]
RoleLocked,
/// El rol tiene usuarios asignados y no se puede eliminar.
#[error("role has users assigned and cannot be deleted")]
RoleInUse,
/// Es la única cuenta de administrador, y no se puede bloquear.
#[error("cannot remove the last administrator")]
LastAdministrator,
/// Nadie puede bloquear su propia cuenta.
#[error("cannot block your own account")]
CannotBlockSelf,
/// Nadie puede concederse ni retirarse a sí mismo el acceso total.
#[error("cannot modify your own administrator flag")]
CannotModifyOwnAdminFlag,
/// La clave de permiso no está en el catálogo.
#[error("unknown permission key: {0}")]
UnknownPermission(String),
/// La cuenta espera a que un administrador la apruebe.
#[error("account is awaiting approval by an administrator")]
AccountAwaitingApproval,
/// Un proveedor de autenticación no ha podido comprobar las credenciales.
#[error("the authentication provider is not available")]
ExternalUnavailable,
/// Un proveedor de autenticación deniega el acceso, con su motivo.
#[error("access rejected by the authentication provider: {0:?}")]
ExternalRejected(RejectReason),
/// La cuenta no está vinculada al proveedor que intenta modificarla.
#[error("the account is not linked to this authentication provider")]
NotOwnedByProvider,
/// La cuenta no espera a ser vinculada con esa persona por ese proveedor.
#[error(
"the account is not waiting to be linked with this person by this authentication provider"
)]
NotPendingIdentity,
/// Otra cuenta ya está vinculada a esa identidad del proveedor.
#[error("another account is already linked to this external identity")]
IdentityTaken,
/// La operación haría que un proveedor gestionara una cuenta de administrador.
#[error("administrator accounts cannot be managed by an authentication provider")]
ProtectedAccount,
/// Un proveedor sólo puede crear cuentas activas o pendientes de aprobación.
#[error(
"an authentication provider can only create active accounts or accounts awaiting approval"
)]
InvalidStatus,
/// `[user.login] sources` está vacía.
#[error("[user.login] sources must not be empty")]
NoLoginSources,
/// `[user.login] sources` repite una fuente.
#[error("[user.login] sources has \"{0}\" more than once")]
DuplicateLoginSource(String),
/// `[user.login] sources` incluye una fuente que no es `"local"` ni un proveedor declarado.
#[error(
"[user.login] sources has \"{0}\", which is neither \"local\" nor a declared \
authentication provider"
)]
UnknownLoginSource(String),
/// La contraseña de la cuenta la gestiona un proveedor y no se puede cambiar aquí.
#[error("the password is managed by an external authentication provider")]
PasswordManagedExternally,
}

View file

@ -17,6 +17,7 @@ use crate::handlers::{confirm_page, message_page, no_referrer};
use crate::mail::{Notice, send_email_change_mail, send_notice};
use crate::password;
use crate::permission::UserPermission;
use crate::provider::{self, AccountPolicy, FieldPolicy, UserField};
use crate::service::user_admin;
use crate::session;
use crate::throttle;
@ -102,16 +103,29 @@ pub(crate) async fn profile_get(request: HttpRequest) -> Response {
Ok(roles) => roles,
Err(_) => return ErrorPage::InternalError(request).into_response(),
};
// Con la cuenta gestionada por un proveedor, la contraseña y el email que no son editables no
// se ofrecen: se indica quién los gestiona y, si lo hay, el enlace de ayuda.
let policy = provider::account_policy(&user).await;
let editable =
|f: fn(&AccountPolicy) -> FieldPolicy| policy.as_ref().is_none_or(|p| f(p).is_editable());
let can_edit = has_permission(&request, &UserPermission::EditOwnProfile);
let can_change_password = has_permission(&request, &UserPermission::ChangeOwnPassword);
let can_change_email = can_edit && editable(AccountPolicy::email);
let can_change_password = has_permission(&request, &UserPermission::ChangeOwnPassword)
&& editable(AccountPolicy::password);
let mut page = Page::new(request);
let details_block = user_details(&user, page.context_mut()).await;
let roles_block = profile_roles(&roles, page.context_mut()).await;
let actions = profile_actions(can_edit, can_change_password, page.context());
let actions = profile_actions(
can_edit,
can_change_email,
can_change_password,
page.context(),
);
page.with_title(Lc::t("title-profile", &LOCALES_USER))
.with_child(details_block)
.with_child(managed_note(policy.as_ref()))
.with_child(actions)
.with_child(roles_block)
.render()
@ -119,10 +133,64 @@ pub(crate) async fn profile_get(request: HttpRequest) -> Response {
.into_response()
}
// Nota «Tu cuenta se gestiona en ...», con el enlace de ayuda del proveedor si lo hay. Sin
// proveedor, no pinta nada.
fn managed_note(policy: Option<&AccountPolicy>) -> Html {
let note = policy.map(|p| (p.provider_label().clone(), p.help().cloned()));
Html::with(move |cx| {
let Some((label, help)) = &note else {
return html! {};
};
let text = Lc::t("help-account-managed", &LOCALES_USER)
.with_arg("provider", label.lookup(cx).unwrap_or_default());
html! {
p class="user-managed-note" {
(text.using(cx))
@if let Some(help) = help {
" "
a href=(help.url()) {
@match help.text().lookup(cx) {
Some(text) => (text),
None => (help.url()),
}
}
}
}
}
})
}
// Página informativa en lugar de un formulario que la política de la cuenta no permite.
async fn managed_page(request: HttpRequest, title: Lc, policy: &AccountPolicy) -> Response {
let note = managed_note(Some(policy));
Page::new(request)
.with_title(title.clone())
.with_child(Block::new().with_title(title).with_child(note))
.render()
.await
.into_response()
}
// Política de la cuenta si gestiona el campo de forma que el usuario no puede cambiarlo.
async fn locked_by_policy(
user_id: i32,
field: fn(&AccountPolicy) -> FieldPolicy,
) -> Option<AccountPolicy> {
let user = user_admin::find_user(user_id).await.ok()?;
provider::account_policy(&user)
.await
.filter(|policy| !field(policy).is_editable())
}
// Botones para editar el perfil, cambiar el email y cambiar la contraseña, cada uno sólo si se
// tiene el permiso (el email, con el de editar el perfil). Sin ninguno, el contenedor queda vacío y
// no se renderiza.
fn profile_actions(can_edit: bool, can_change_password: bool, cx: &Context) -> Flex {
// tiene el permiso (el email, con el de editar el perfil) y la cuenta lo permite. Sin ninguno, el
// contenedor queda vacío y no se renderiza.
fn profile_actions(
can_edit: bool,
can_change_email: bool,
can_change_password: bool,
cx: &Context,
) -> Flex {
let mut actions = Flex::new()
.with_wrap(flex::Behavior::Wrap)
.with_gap(align::Gap::Both(UnitValue::RelRem(0.5)));
@ -134,6 +202,8 @@ fn profile_actions(can_edit: bool, can_change_password: bool, cx: &Context) -> F
)
.with_style(button::Style::Solid(Intent::Primary)),
);
}
if can_change_email {
actions = actions.with_child(
Button::anchor(
Lc::t("btn-change-email", &LOCALES_USER),
@ -281,7 +351,9 @@ pub(crate) async fn profile_edit_get(request: HttpRequest) -> Result<Response, E
return Err(ErrorPage::NotFound(request));
};
let policy = provider::account_policy(&user).await;
let form = UserForm::new()
.with_policy(policy)
.with_username(user.username)
.with_email(user.email)
.with_display_name(user.display_name.unwrap_or_default())
@ -322,23 +394,28 @@ pub(crate) async fn profile_edit_post(
return Err(ErrorPage::NotFound(request));
};
// Sin permiso se conserva el nombre actual, aunque la petición se haya manipulado a mano.
let username = if has_permission(&request, &UserPermission::ChangeOwnUsername) {
// Sin permiso se conserva el nombre actual, aunque la petición se haya manipulado a mano; y lo
// que gestiona un proveedor, también.
let policy = provider::account_policy(&user).await;
let username = if has_permission(&request, &UserPermission::ChangeOwnUsername)
&& policy.as_ref().is_none_or(|p| p.username().is_editable())
{
form.username
} else {
user.username
user.username.clone()
};
let field = |field, submitted| managed_or(policy.as_ref(), field, submitted, &user);
let result = user_admin::update_user(
id,
user_admin::UserUpdateData {
username: &username,
email: &user.email,
display_name: util::non_blank(&form.display_name),
about: util::non_blank(&form.about),
language: util::non_blank(&form.language),
timezone: util::non_blank(&form.timezone),
theme: util::non_blank(&form.theme),
display_name: field(UserField::DisplayName, &form.display_name),
about: field(UserField::About, &form.about),
language: field(UserField::Language, &form.language),
timezone: field(UserField::Timezone, &form.timezone),
theme: field(UserField::Theme, &form.theme),
},
)
.await;
@ -350,6 +427,7 @@ pub(crate) async fn profile_edit_post(
}
Err(err) => {
let form = UserForm::new()
.with_policy(policy)
.with_username(username)
.with_email(user.email)
.with_display_name(form.display_name)
@ -376,18 +454,21 @@ async fn render_profile_edit(request: HttpRequest, form: UserForm) -> Response {
/// GET /user/password - Formulario de cambio de la contraseña propia.
pub(crate) async fn password_get(request: HttpRequest) -> Result<Response, ErrorPage> {
if current_user_id(&request).is_none() {
let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, PROFILE_PASSWORD_PATH));
}
};
let title = Lc::t("title-profile-password", &LOCALES_USER);
if let Some(policy) = locked_by_policy(id, AccountPolicy::password).await {
return Ok(managed_page(request, title, &policy).await);
}
Ok(render_profile_page(request, title, ChangePasswordForm::new()).await)
}
#[derive(Deserialize)]
pub(crate) struct ChangePasswordFormData {
current_password: String,
password: String,
confirm_password: String,
current_password: util::SecretStr,
password: util::SecretStr,
confirm_password: util::SecretStr,
}
/// POST /user/password - Cambia la contraseña propia tras comprobar la actual, cierra el resto de
@ -399,10 +480,17 @@ pub(crate) async fn password_post(
let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, PROFILE_PASSWORD_PATH));
};
if let Some(policy) = locked_by_policy(id, AccountPolicy::password).await {
let title = Lc::t("title-profile-password", &LOCALES_USER);
return Ok(managed_page(request, title, &policy).await);
}
let sid = session::extract_sid(Some(request.headers()));
let result = match password::passwords_match(&form.password, &form.confirm_password) {
Ok(()) => auth::change_own_password(id, &form.current_password, &form.password, sid).await,
let result =
match password::passwords_match(form.password.expose(), form.confirm_password.expose()) {
Ok(()) => {
auth::change_own_password(id, &form.current_password, &form.password, sid).await
}
Err(err) => Err(err),
};
@ -435,6 +523,12 @@ pub(crate) async fn email_get(request: HttpRequest) -> Result<Response, ErrorPag
return Err(ErrorPage::NotFound(request));
};
let title = Lc::t("title-profile-email", &LOCALES_USER);
if let Some(policy) = provider::account_policy(&user)
.await
.filter(|policy| !policy.email().is_editable())
{
return Ok(managed_page(request, title, &policy).await);
}
let form = ChangeEmailForm::new().with_pending_email(user.pending_email);
Ok(render_profile_page(request, title, form).await)
}
@ -442,7 +536,7 @@ pub(crate) async fn email_get(request: HttpRequest) -> Result<Response, ErrorPag
#[derive(Deserialize)]
pub(crate) struct ChangeEmailFormData {
email: String,
current_password: String,
current_password: util::SecretStr,
}
/// POST /user/email - Pide cambiar el email propio tras comprobar la contraseña actual: envía a la
@ -455,6 +549,10 @@ pub(crate) async fn email_post(
let Some(id) = current_user_id(&request) else {
return Ok(login_redirect(request, EMAIL_PATH));
};
if let Some(policy) = locked_by_policy(id, AccountPolicy::email).await {
let title = Lc::t("title-profile-email", &LOCALES_USER);
return Ok(managed_page(request, title, &policy).await);
}
let result = if throttle::allow(&request) {
auth::request_email_change(id, &form.current_password, &form.email).await
@ -560,3 +658,24 @@ async fn render_profile_page(
.await
.into_response()
}
// Valor de un dato del perfil para guardar: el enviado o, si lo gestiona el proveedor de la cuenta,
// el guardado.
pub(crate) fn managed_or<'a>(
policy: Option<&AccountPolicy>,
field: UserField,
submitted: &'a str,
user: &'a user::Model,
) -> Option<&'a str> {
if !policy.is_some_and(|p| p.manages(field)) {
return util::non_blank(submitted);
}
match field {
UserField::DisplayName => user.display_name.as_deref(),
UserField::About => user.about.as_deref(),
UserField::Language => user.language.as_deref(),
UserField::Timezone => user.timezone.as_deref(),
UserField::Theme => user.theme.as_deref(),
UserField::Email => Some(user.email.as_str()),
}
}

View file

@ -55,6 +55,14 @@ pub(crate) fn map_auth_error(err: &AuthError) -> Lc {
Lc::t("error-cannot-modify-own-admin-flag", &LOCALES_USER)
}
AuthError::UnknownPermission(_) => Lc::t("error-unknown-permission", &LOCALES_USER),
AuthError::AccountAwaitingApproval => {
Lc::t("error-account-awaiting-approval", &LOCALES_USER)
}
AuthError::ExternalUnavailable => Lc::t("error-external-unavailable", &LOCALES_USER),
AuthError::PasswordManagedExternally => Lc::t("error-password-managed", &LOCALES_USER),
AuthError::IdentityTaken => Lc::t("error-identity-taken", &LOCALES_USER),
AuthError::ProtectedAccount => Lc::t("error-protected-account", &LOCALES_USER),
AuthError::NotPendingIdentity => Lc::t("error-not-pending-identity", &LOCALES_USER),
_ => Lc::t("error-internal", &LOCALES_USER),
}
}

View file

@ -8,6 +8,7 @@ use pagetop_htmx::prelude::*;
use crate::ADMIN_USERS_PATH;
use crate::LOCALES_USER;
use crate::account::{Account, UserStatus};
use crate::actions::AdminUserFormExtras;
use crate::component::admin::{
AdminPasswordForm, USER_ADMIN_FORM_ID, UserForm, UserFormMode, UserTable,
};
@ -15,10 +16,12 @@ use crate::component::{cancel_link, user_details};
use crate::config::SETTINGS;
use crate::entity::{role, user};
use crate::error::AuthError;
use crate::handlers::account::managed_or;
use crate::handlers::admin::{back_link, map_auth_error};
use crate::mail::{Notice, send_notice};
use crate::password;
use crate::permission::UserPermission;
use crate::provider::{self, UserField};
use crate::role_path;
use crate::service::role_admin;
use crate::service::user_admin::{self, UserListParams, UserSortField};
@ -139,16 +142,39 @@ async fn require_manageable(request: &HttpRequest, id: i32) -> Result<user::Mode
// **< new_get / new_post >*************************************************************************
#[derive(Deserialize)]
pub(crate) struct NewUserQuery {
#[serde(default)]
provider: Option<String>,
}
// Proveedor activo con el que entrará la cuenta que se da de alta, como `(id, nombre)`.
fn external_provider(id: Option<&str>, cx: &Context) -> Option<(String, String)> {
let provider = provider::active_provider(id?)?;
let name = provider.label().lookup(cx).unwrap_or_default();
Some((provider.id().to_owned(), name))
}
/// GET /admin/user/users/new - Formulario de alta de usuario.
pub(crate) async fn new_get(request: HttpRequest) -> Result<Response, ErrorPage> {
///
/// Con `?provider={id}`, el alta es de una cuenta que entrará con ese proveedor de autenticación:
/// sin contraseña local y marcada para que el proveedor la vincule cuando la persona inicie sesión
/// con el mismo nombre de usuario (ver `provider::allow_linking()`).
pub(crate) async fn new_get(
request: HttpRequest,
web::Query(query): web::Query<NewUserQuery>,
) -> Result<Response, ErrorPage> {
let roles = match available_roles(&[]).await {
Ok(roles) => roles,
Err(_) => return Err(ErrorPage::InternalError(request)),
};
// El campo "administrador" sólo se ofrece si quien da de alta ya es administrador: no es un
// permiso del catálogo (igual que conceder/revocar en la edición, ver `set_user_admin`).
let allow_admin_field = request.extension::<Account>().is_some_and(|a| a.is_admin());
// permiso del catálogo (igual que conceder/revocar en la edición, ver `set_user_admin`). Una
// cuenta de proveedor nunca puede serlo.
let viewer_is_admin = request.extension::<Account>().is_some_and(|a| a.is_admin());
let page = Page::admin(request);
let provider = external_provider(query.provider.as_deref(), page.context());
let allow_admin_field = provider.is_none() && viewer_is_admin;
let title = Lc::t("title-admin-user-new", &LOCALES_USER);
Ok(page
.with_title(title)
@ -156,7 +182,8 @@ pub(crate) async fn new_get(request: HttpRequest) -> Result<Response, ErrorPage>
UserForm::new()
.with_mode(UserFormMode::New)
.with_roles(roles)
.with_allow_admin_field(allow_admin_field),
.with_allow_admin_field(allow_admin_field)
.with_provider(provider),
)
.render()
.await
@ -167,8 +194,12 @@ pub(crate) async fn new_get(request: HttpRequest) -> Result<Response, ErrorPage>
pub(crate) struct NewUserFormData {
username: String,
email: String,
password: String,
confirm_password: String,
#[serde(default)]
password: util::SecretStr,
#[serde(default)]
confirm_password: util::SecretStr,
#[serde(default)]
provider: String,
#[serde(default)]
display_name: String,
#[serde(default)]
@ -194,17 +225,29 @@ pub(crate) async fn new_post(
let Ok(form) = serde_qs::from_bytes::<NewUserFormData>(&raw.0) else {
return Err(ErrorPage::BadRequest(request));
};
let allow_admin_field = request.extension::<Account>().is_some_and(|a| a.is_admin());
let cx = Context::admin(request.clone());
let provider = match util::non_blank(&form.provider) {
Some(id) => match external_provider(Some(id), &cx) {
Some(provider) => Some(provider),
None => return Err(ErrorPage::BadRequest(request)),
},
None => None,
};
let allow_admin_field =
provider.is_none() && request.extension::<Account>().is_some_and(|a| a.is_admin());
// Nunca fiarse sólo de que el campo esté presente en el formulario: sólo se concede si quien
// envía la petición ya es administrador, aunque alguien manipulase la petición a mano.
let is_admin = form.is_admin && allow_admin_field;
let role_ids = parse_role_ids(&form.role_ids);
let password = provider
.is_none()
.then(|| (form.password.expose(), form.confirm_password.expose()));
let result = user_admin::create_user(user_admin::NewUserData {
username: &form.username,
email: &form.email,
password: &form.password,
confirm_password: &form.confirm_password,
password,
link_provider: provider.as_ref().map(|(id, _)| id.as_str()),
display_name: util::non_blank(&form.display_name),
language: util::non_blank(&form.language),
timezone: util::non_blank(&form.timezone),
@ -216,7 +259,6 @@ pub(crate) async fn new_post(
match result {
Ok(_) => {
let cx = Context::admin(request);
let target = cx.route(ADMIN_USERS_PATH.as_str());
Ok(Redirect::see_other(target).into_response())
}
@ -225,6 +267,7 @@ pub(crate) async fn new_post(
let page = Page::admin(request);
let form_component = UserForm::new()
.with_mode(UserFormMode::New)
.with_provider(provider)
.with_username(form.username)
.with_email(form.email)
.with_display_name(form.display_name)
@ -262,9 +305,11 @@ async fn render_user_edit(request: HttpRequest, id: i32, error: Option<Lc>) -> R
Ok(roles) => roles,
Err(_) => return ErrorPage::InternalError(request).into_response(),
};
let policy = provider::account_policy(&user).await;
let status = UserStatus::from_i16(user.status);
let is_admin = user.is_admin;
let form = UserForm::new()
.with_policy(policy)
.with_username(user.username)
.with_email(user.email)
.with_display_name(user.display_name.unwrap_or_default())
@ -279,7 +324,8 @@ async fn render_user_edit(request: HttpRequest, id: i32, error: Option<Lc>) -> R
// Pantalla de edición del usuario `id` con `form` ya relleno, sea con los datos guardados o con los
// enviados que no se pudieron guardar. Siempre lleva la botonera de `edit_actions()`, porque en
// modo `Edit` el botón "Guardar" está en ella y no dentro del formulario.
// modo `Edit` el botón "Guardar" está en ella y no dentro del formulario, y lo que añadan otras
// extensiones con `AdminUserFormExtras`.
async fn render_edit_page(
request: HttpRequest,
id: i32,
@ -287,33 +333,81 @@ async fn render_edit_page(
is_admin: bool,
form: UserForm,
) -> Response {
let can_reset_password = form
.policy()
.is_none_or(|policy| policy.password().is_editable());
let linking = linking_options(id, is_admin).await;
// El botón de conceder/revocar sólo se muestra si quien lo ve ya es administrador y no está
// viendo su propio perfil: no es un permiso del catálogo, y nadie puede automodificarse el flag
// (ver `set_user_admin`).
// (ver `set_user_admin`). Tampoco para conceder el acceso total a una cuenta que gestiona un
// proveedor, que `set_user_admin` rechaza.
let can_toggle_admin = request
.extension::<Account>()
.is_some_and(|a| a.is_admin() && a.id() != id);
.is_some_and(|a| a.is_admin() && a.id() != id)
&& (is_admin || form.policy().is_none());
// Bloquear y activar exige además `user:block_accounts` (ver `status_post`).
let can_change_status = has_permission(&request, &UserPermission::BlockAccounts);
let mut page = Page::admin(request);
let title = Lc::t("title-admin-user-edit", &LOCALES_USER);
let actions = edit_actions(
id,
EditActions {
status,
is_admin,
target_is_admin: is_admin,
can_toggle_admin,
can_change_status,
can_reset_password,
linking,
},
page.context_mut(),
);
page.with_title(title)
.with_child(form.with_mode(UserFormMode::Edit).with_user_id(Some(id)))
.with_child(actions)
.with_child(ChildOp::AddMany(AdminUserFormExtras::collect(id)))
.render()
.await
.into_response()
}
// Proveedores con los que un administrador puede permitir (o dejar de permitir) que se vincule una
// cuenta: los activos, si la cuenta no es de administrador y no está vinculada ya a ninguno. Cada
// uno con su nombre y si ya está permitido.
async fn linking_options(user_id: i32, is_admin: bool) -> Vec<(&'static str, Lc, bool)> {
if is_admin || provider::active_providers().next().is_none() {
return Vec::new();
}
let identities = match provider::identities_of(user_id).await {
Ok(identities) => identities,
Err(err) => {
trace::error!("Cannot load the identities of user {user_id}: {err}");
return Vec::new();
}
};
if identities.iter().any(|identity| !identity.pending) {
return Vec::new();
}
provider::active_providers()
.map(|p| {
let pending = identities
.iter()
.any(|identity| identity.provider == p.id());
(p.id(), p.label(), pending)
})
.collect()
}
// Estado de la cuenta que decide qué botones lleva la edición.
struct EditActions {
status: UserStatus,
target_is_admin: bool,
can_toggle_admin: bool,
can_change_status: bool,
can_reset_password: bool,
linking: Vec<(&'static str, Lc, bool)>,
}
// Botonera de la edición: "Guardar", "Cancelar", el enlace a la pantalla de restablecer contraseña
// y los botones de bloqueo/activación (sólo si `can_change_status`) y de concesión/revocación de
// acceso total (sólo si `can_toggle_admin`).
@ -323,21 +417,15 @@ async fn render_edit_page(
// concesión/revocación de admin van cada uno en su propio `Form`, con un campo `Hidden` para el
// nuevo valor, para conservar el envío nativo sin JavaScript, mejorado con `hx-post`/`hx-confirm`.
// Todos son hijos directos del mismo `Flex`, que los alinea en fila con espaciado uniforme.
fn edit_actions(
user_id: i32,
status: UserStatus,
target_is_admin: bool,
can_toggle_admin: bool,
can_change_status: bool,
cx: &mut Context,
) -> Flex {
fn edit_actions(user_id: i32, state: EditActions, cx: &mut Context) -> Flex {
// Una cuenta pendiente de verificar su email también se puede activar directamente, p. ej. si
// el correo de verificación no llegó.
let (next_status, label_key) = match status {
// el correo de verificación no llegó; una pendiente de aprobación se aprueba.
let (next_status, label_key) = match state.status {
UserStatus::Active => ("blocked", "btn-block"),
UserStatus::Blocked | UserStatus::Pending => ("active", "btn-activate"),
UserStatus::AwaitingApproval => ("active", "btn-approve"),
};
let (next_is_admin, admin_label_key, admin_confirm_key) = if target_is_admin {
let (next_is_admin, admin_label_key, admin_confirm_key) = if state.target_is_admin {
("false", "btn-revoke-admin", "confirm-revoke-admin")
} else {
("true", "btn-grant-admin", "confirm-grant-admin")
@ -369,16 +457,39 @@ fn edit_actions(
.with_style(button::Style::Solid(Intent::Primary))
.with_prop(PropsOp::set("form", USER_ADMIN_FORM_ID)),
)
.with_child(cancel_link(cx.route(ADMIN_USERS_PATH.as_str())))
.with_child(
.with_child(cancel_link(cx.route(ADMIN_USERS_PATH.as_str())));
if state.can_reset_password {
container = container.with_child(
Button::anchor(Lc::t("btn-reset-password", &LOCALES_USER), password_href)
.with_style(button::Style::Solid(Intent::Neutral)),
);
if can_change_status {
}
if state.can_change_status {
container = container.with_child(status_form);
}
if can_toggle_admin {
let identity_action = cx.route(user_path(user_id, "identity"));
for (provider, label, pending) in state.linking {
let name = label.lookup(cx).unwrap_or_default();
let (op, key) = if pending {
("cancel", "btn-cancel-linking")
} else {
("allow", "btn-allow-linking")
};
container = container.with_child(
Form::new()
.with_action(identity_action.clone())
.with_method(form::Method::Post)
.with_child(form::Hidden::field("provider", provider))
.with_child(form::Hidden::field("op", op))
.with_child(
Button::submit(Lc::t(key, &LOCALES_USER).with_arg("provider", name))
.with_style(button::Style::Solid(Intent::Neutral)),
),
);
}
if state.can_toggle_admin {
let admin_button = Button::submit(Lc::t(admin_label_key, &LOCALES_USER))
.with_style(button::Style::Solid(Intent::Severe));
let mut admin_form = Form::new()
@ -436,22 +547,39 @@ pub(crate) async fn edit_post(
return Err(ErrorPage::BadRequest(request));
};
let role_ids = parse_role_ids(&form.role_ids);
let policy = provider::account_policy(&user).await;
// Lo que gestiona un proveedor se conserva como está, llegue lo que llegue del formulario.
let keep = |editable: bool, submitted: &'_ str, current: &'_ str| -> String {
if editable { submitted } else { current }.to_owned()
};
let username = keep(
policy.as_ref().is_none_or(|p| p.username().is_editable()),
&form.username,
&user.username,
);
let email = keep(
policy.as_ref().is_none_or(|p| p.email().is_editable()),
&form.email,
&user.email,
);
let field = |field, submitted| managed_or(policy.as_ref(), field, submitted, &user);
let mut result = user_admin::update_user(
id,
user_admin::UserUpdateData {
username: &form.username,
email: &form.email,
display_name: util::non_blank(&form.display_name),
about: util::non_blank(&form.about),
language: util::non_blank(&form.language),
timezone: util::non_blank(&form.timezone),
theme: util::non_blank(&form.theme),
username: &username,
email: &email,
display_name: field(UserField::DisplayName, &form.display_name),
about: field(UserField::About, &form.about),
language: field(UserField::Language, &form.language),
timezone: field(UserField::Timezone, &form.timezone),
theme: field(UserField::Theme, &form.theme),
},
)
.await;
if result.is_ok() {
result = user_admin::set_user_roles(id, &role_ids).await;
let managed = policy.as_ref().map_or(&[][..], |p| p.managed_roles());
result = user_admin::set_user_roles(id, &role_ids, managed).await;
}
match result {
@ -464,8 +592,9 @@ pub(crate) async fn edit_post(
let roles = available_roles(&role_ids).await.unwrap_or_default();
let status = UserStatus::from_i16(user.status);
let form = UserForm::new()
.with_username(form.username)
.with_email(form.email)
.with_policy(policy)
.with_username(username)
.with_email(email)
.with_display_name(form.display_name)
.with_about(form.about)
.with_language(form.language)
@ -505,6 +634,7 @@ pub(crate) async fn view_get(
.with_title(title)
.with_child(details_block)
.with_child(roles_block)
.with_child(ChildOp::AddMany(AdminUserFormExtras::collect(id)))
.with_child(back_link(back_href))
.render()
.await
@ -671,19 +801,33 @@ pub(crate) async fn password_get(
let user = require_manageable(&request, id).await?;
let page = Page::admin(request);
let title = Lc::t("title-admin-user-password", &LOCALES_USER);
Ok(page
.with_title(title)
.with_child(user_summary(&user))
.with_child(AdminPasswordForm::new().with_user_id(id))
.render()
.await
.into_response())
let page = page.with_title(title).with_child(user_summary(&user));
let mut page = match external_password(&user).await {
Some(note) => page.with_child(note),
None => page.with_child(AdminPasswordForm::new().with_user_id(id)),
};
Ok(page.render().await.into_response())
}
// Nota en lugar del formulario de restablecimiento, si la contraseña de la cuenta la gestiona un
// proveedor de autenticación.
async fn external_password(user: &user::Model) -> Option<Html> {
let policy = provider::account_policy(user).await?;
if policy.password().is_editable() {
return None;
}
let label = policy.provider_label().clone();
Some(Html::with(move |cx| {
let note = Lc::t("help-password-managed", &LOCALES_USER)
.with_arg("provider", label.lookup(cx).unwrap_or_default());
html! { p { (note.using(cx)) } }
}))
}
#[derive(Deserialize)]
pub(crate) struct AdminPasswordFormData {
password: String,
confirm_password: String,
password: util::SecretStr,
confirm_password: util::SecretStr,
}
/// POST /admin/user/users/{id}/password - Aplica la nueva contraseña, invalida las sesiones
@ -695,9 +839,13 @@ pub(crate) async fn password_post(
) -> Result<Response, ErrorPage> {
let user = require_manageable(&request, id).await?;
let result = match password::passwords_match(&form.password, &form.confirm_password) {
Ok(()) => user_admin::admin_reset_password(id, &form.password).await,
let result = if external_password(&user).await.is_some() {
Err(AuthError::PasswordManagedExternally)
} else {
match password::passwords_match(form.password.expose(), form.confirm_password.expose()) {
Ok(()) => user_admin::admin_reset_password(id, form.password.expose()).await,
Err(err) => Err(err),
}
};
match result {
@ -724,3 +872,41 @@ pub(crate) async fn password_post(
}
}
}
// **< identity_post >******************************************************************************
#[derive(Deserialize)]
pub(crate) struct IdentityFormData {
provider: String,
op: String,
}
/// POST /admin/user/users/{id}/identity - Permite (`op=allow`) o deja de permitir (`op=cancel`)
/// que un proveedor de autenticación vincule la cuenta cuando la persona con su nombre de usuario
/// inicie sesión con él.
///
/// Es la única forma de que una cuenta existente acabe vinculada a un proveedor: si bastara con
/// que coincidieran los nombres, quien consiguiera en el proveedor el nombre de una cuenta local
/// se quedaría con ella. Nunca para una cuenta de administrador.
pub(crate) async fn identity_post(
request: HttpRequest,
web::Path(id): web::Path<i32>,
web::Form(form): web::Form<IdentityFormData>,
) -> Result<Response, ErrorPage> {
let user = require_manageable(&request, id).await?;
let Some(provider) = provider::active_provider(&form.provider) else {
return Err(ErrorPage::BadRequest(request));
};
let result = match form.op.as_str() {
"allow" => provider::allow_linking(id, provider.id(), &user.username).await,
"cancel" => provider::cancel_linking(id, provider.id()).await,
_ => return Err(ErrorPage::BadRequest(request)),
};
match result {
Ok(()) => {
let cx = Context::admin(request);
Ok(Redirect::see_other(cx.route(user_path(id, "edit"))).into_response())
}
Err(err) => Ok(render_user_edit(request, id, Some(map_auth_error(&err))).await),
}
}

View file

@ -11,11 +11,12 @@ use crate::config::SETTINGS;
use crate::error::AuthError;
use crate::handlers::admin::map_auth_error;
use crate::handlers::{confirm_page, message_page, no_referrer};
use crate::mail::send_token_mail;
use crate::mail::{send_external_password_notice, send_token_mail};
use crate::password;
use crate::provider::{self, RejectReason, ResetPolicy};
use crate::session;
use crate::throttle;
use crate::token::{TokenKind, consume_token, create_token, is_valid_token};
use crate::token::{TokenKind, consume_token, create_token, is_valid_token, revoke_tokens};
use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_PATH};
// **< Tipos de formularios >***********************************************************************
@ -28,7 +29,7 @@ pub struct LoginFormData {
username: String,
// Acepta también `token`, el nombre de campo usado en el modo de login estricto.
#[serde(alias = "token")]
password: String,
password: util::SecretStr,
#[serde(default)]
remember: bool,
}
@ -37,8 +38,8 @@ pub struct LoginFormData {
pub struct RegisterFormData {
username: String,
email: String,
password: String,
confirm_password: String,
password: util::SecretStr,
confirm_password: util::SecretStr,
}
#[derive(Deserialize)]
@ -48,8 +49,8 @@ pub struct PasswordResetFormData {
#[derive(Deserialize)]
pub struct PasswordResetConfirmFormData {
password: String,
confirm_password: String,
password: util::SecretStr,
confirm_password: util::SecretStr,
}
// **< login_get >**********************************************************************************
@ -87,27 +88,63 @@ pub async fn login_post(
) -> Response {
let cx = Context::new(request.clone());
let next = waypoint.or(cx.route("/"));
// Una dirección que ya ha fallado demasiadas veces no llega a comprobar la contraseña (Argon2).
let result = if throttle::allow_login(&request) {
let result = auth::login(&form.username, &form.password, form.remember).await;
if !matches!(result, Err(AuthError::InvalidCredentials)) {
throttle::forget_login(&request);
let result = if auth::acceptable_credentials(&form.username, &form.password) {
// Una dirección o un identificador que ya han fallado demasiadas veces no llegan a
// comprobar la contraseña (ni Argon2 ni un proveedor externo).
let keys = throttle::LoginKeys::new(&request, &form.username);
if throttle::allow_login(&keys) {
let result = auth::login(
&form.username,
&form.password,
form.remember,
request.client_ip(),
)
.await;
// Sólo se retira el intento si la contraseña era correcta: un acceso, o un rechazo
// que sólo se revela con ella. Si un proveedor no ha respondido, no cuenta para el
// identificador (no es culpa de quien entra), pero sí para la dirección IP.
match &result {
Ok(_)
| Err(
AuthError::ExternalRejected(_)
| AuthError::AccountBlocked
| AuthError::AccountPending
| AuthError::AccountAwaitingApproval,
) => throttle::forget_login(&keys),
Err(AuthError::ExternalUnavailable) => throttle::forget_identifier(&keys),
Err(_) => {}
}
result
} else {
Err(AuthError::TooManyRequests)
}
} else {
Err(AuthError::InvalidCredentials)
};
match result {
Ok(sid) => {
let cookie = session::build_cookie(&sid, form.remember);
Ok(session) => {
let cookie = session::build_cookie(&session.sid, session.remember);
redirect_with_cookie(next, &cookie)
}
Err(err) => {
let mut help = None;
let error_key = match &err {
AuthError::AccountBlocked => "error-account-blocked",
AuthError::AccountPending => "error-account-pending",
AuthError::AccountAwaitingApproval => "error-account-awaiting-approval",
AuthError::AccountLocked => "error-account-locked",
AuthError::TooManyRequests => "error-too-many-requests",
AuthError::ExternalUnavailable => "error-external-unavailable",
AuthError::ExternalRejected(reason) => match reason {
RejectReason::Disallowed => "error-login-disallowed",
RejectReason::NotRegistered => "error-login-not-registered",
RejectReason::AwaitingApproval => "error-account-awaiting-approval",
RejectReason::Conflict => "error-login-conflict",
RejectReason::PasswordExpired { help: link } => {
help = link.clone();
"error-password-expired"
}
},
_ => "error-invalid-credentials",
};
Page::new(request)
@ -116,6 +153,7 @@ pub async fn login_post(
LoginForm::new()
.with_username(form.username)
.with_error(Lc::t(error_key, &LOCALES_USER))
.with_help(help)
.with_waypoint(waypoint),
)
.render()
@ -182,8 +220,8 @@ pub async fn register_post(
auth::register(
&form.username,
&form.email,
&form.password,
&form.confirm_password,
form.password.expose(),
form.confirm_password.expose(),
)
.await
} else {
@ -265,10 +303,31 @@ pub async fn password_reset_post(
return;
}
};
// Una cuenta cuya contraseña se gestiona fuera recibe un aviso en lugar del enlace. El
// token se crea igualmente y se anula enseguida, para que el aviso cuente para el mismo
// límite de solicitudes por cuenta.
let forbidden = match provider::account_policy(&user_model).await {
Some(policy) => match policy.password_reset() {
ResetPolicy::Forbidden { help } => {
Some((policy.provider_label().clone(), help.clone()))
}
ResetPolicy::Allowed => None,
},
None => None,
};
match create_token(user_model.id, TokenKind::PasswordReset).await {
Ok(token) => {
Ok(token) => match forbidden {
None => {
send_token_mail(&mail_request, TokenKind::PasswordReset, &user_model, &token);
}
Some((label, help)) => {
if let Err(err) = revoke_tokens(user_model.id, TokenKind::PasswordReset).await {
trace::error!("Cannot revoke a password reset token: {err}");
return;
}
send_external_password_notice(&mail_request, &user_model, label, help);
}
},
Err(AuthError::TooManyRequests) => {
trace::warn!("Password reset limit reached for user {}", user_model.id);
}
@ -288,6 +347,7 @@ pub async fn password_reset_confirm_get(
if !is_valid_token(uid, &token, TokenKind::PasswordReset)
.await
.unwrap_or(false)
|| reset_forbidden(uid).await
{
return Err(ErrorPage::NotFound(request));
}
@ -317,9 +377,13 @@ pub async fn password_reset_confirm_post(
let result = async {
use crate::entity::user;
use pagetop_seaorm::db::{ActiveModelTrait, Set, dbconn};
password::passwords_match(&form.password, &form.confirm_password)?;
password::validate_strength(&form.password)?;
let hash = password::hash_password_async(&form.password).await?;
// Un enlace anterior a que un proveedor gestionara la cuenta ya no vale.
if reset_forbidden(uid).await {
return Err(AuthError::InvalidToken);
}
password::passwords_match(form.password.expose(), form.confirm_password.expose())?;
password::validate_strength(form.password.expose())?;
let hash = password::hash_password_async(form.password.expose()).await?;
consume_token(uid, &token, TokenKind::PasswordReset).await?;
user::ActiveModel {
id: Set(uid),
@ -336,6 +400,9 @@ pub async fn password_reset_confirm_post(
.await
.map_err(AuthError::Database)?;
auth::cancel_email_change(uid).await?;
if let Ok(user) = crate::service::user_admin::find_user(uid).await {
throttle::forget_account(&user.username, &user.email);
}
Ok::<(), AuthError>(())
}
.await;
@ -436,6 +503,22 @@ pub async fn verify_email_post(
// **< HELPERS >************************************************************************************
// Si la cuenta no puede recuperar su contraseña por correo porque la gestiona un proveedor. Ante un
// error de la base de datos, se considera que no puede.
async fn reset_forbidden(user_id: i32) -> bool {
use crate::service::user_admin::find_user;
match find_user(user_id).await {
Ok(user) => matches!(
provider::account_policy(&user)
.await
.map(|policy| policy.password_reset().clone()),
Some(ResetPolicy::Forbidden { .. })
),
Err(AuthError::UserNotFound) => false,
Err(_) => true,
}
}
// Envía el correo para verificar la dirección de la cuenta recién creada. Un fallo no impide el
// registro: la cuenta queda pendiente y un administrador puede activarla.
//

View file

@ -91,6 +91,16 @@ pub(crate) fn username_key(raw: &str) -> String {
raw.trim().nfkc().collect::<String>().to_lowercase()
}
// Clave con la que se busca una cuenta a partir de lo que se teclea para iniciar sesión: la del
// email si lleva `@` (un nombre de usuario nunca lo lleva) y la del nombre de usuario si no.
pub(crate) fn login_key(raw: &str) -> String {
if raw.contains('@') {
email_key(raw)
} else {
username_key(raw)
}
}
// *Hash* SHA-256, en hexadecimal, del esqueleto de confusión (UTS #39) de la clave del nombre.
fn skeleton_hash(key: &str) -> String {
let digest = Sha256::digest(skeleton(key).collect::<String>().as_bytes());

View file

@ -12,18 +12,20 @@
</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 en el panel de administración del núcleo, 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.
## Descripción general
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 en el panel de administración del núcleo, hechas sólo con componentes del núcleo para que
funcionen con cualquier tema.
## Guía rápida
**Añade la dependencia** a tu `Cargo.toml`:
@ -123,6 +125,43 @@ y `ana` son el mismo usuario) y no se admiten nombres que se confunden a simple
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`](config::IdentityPolicy).
## Proveedores de autenticación
Otras extensiones pueden comprobar las credenciales del inicio de sesión con un servicio externo,
como un directorio LDAP o Active Directory. Cada una declara su proveedor con la acción
[`DeclareAuthProviders`](provider::DeclareAuthProviders), y la configuración decide con qué
fuentes, y en qué orden, se comprueban las credenciales. Por ejemplo, las dos, primero el
directorio y después la contraseña local:
```toml
[user.login]
sources = ["ldap", "local"]
```
O sólo el directorio, salvo los administradores, que conservan su contraseña local como acceso de
emergencia por si el directorio no responde (`local_fallback` sólo se aplica cuando `"local"` no
está en `sources`):
```toml
[user.login]
sources = ["ldap"]
local_fallback = "admins"
```
Los límites de intentos, el bloqueo de cuentas, el estado de cada cuenta y las sesiones son los de
`pagetop-user` para todas las fuentes. Una cuenta vinculada a un proveedor sólo se autentica con él,
y lo que su titular puede cambiar (contraseña, email, datos del perfil, roles) lo decide el
proveedor. La contraseña tecleada nunca se guarda ni se escribe en las trazas: el proveedor sólo la
recibe para comprobarla ([`pagetop::util::SecretStr`]).
Las operaciones que crean cuentas, las vinculan con su identidad externa o cambian sus roles no son
funciones públicas: son métodos de un [`ProviderHandle`](provider::ProviderHandle) que sólo
`pagetop-user` construye y que entrega a cada proveedor activo. Así sus reglas viven en un único
sitio: un proveedor sólo actúa sobre sus propias cuentas, una cuenta existente sólo se vincula si un
administrador lo ha permitido en su ficha (y nunca la de un administrador), y nadie puede conceder
el acceso total. Protege de errores en un proveedor, no de código malicioso compilado en la misma
aplicación. Los detalles están en el módulo [`provider`].
## Correos
La recuperación de contraseña, la confirmación de una nueva dirección y, con
@ -187,10 +226,12 @@ use pagetop_seaorm::install_migrations;
use std::sync::LazyLock;
pub mod account;
pub mod actions;
pub mod config;
pub mod error;
pub mod password;
pub mod permission;
pub mod provider;
pub(crate) mod auth;
#[cfg(feature = "demo-data")]
@ -402,7 +443,9 @@ impl Extension for User {
m20260629_000004_create_role_permissions,
m20260629_000005_create_sessions,
m20260629_000006_create_user_tokens,
m20261111_000007_create_user_identities,
)?;
provider::initialize()?;
// Los permisos de "anonymous" en memoria sobreviven a una nueva preparación en el mismo
// proceso (las pruebas lo hacen), que puede usar otra base de datos.
session::invalidate_anonymous_permissions();
@ -494,6 +537,10 @@ impl Extension for User {
&format!("{ADMIN_USERS}/{{id}}/admin"),
web::post(handlers::admin::users::admin_post),
)
.admin_route(
&format!("{ADMIN_USERS}/{{id}}/identity"),
web::post(handlers::admin::users::identity_post),
)
.admin_route(
&format!("{ADMIN_USERS}/{{id}}/password"),
web::get(handlers::admin::users::password_get)

View file

@ -115,12 +115,17 @@ mail-email-change-requested-intro = Someone asked to change the email address
mail-notice-action = Reset my password
mail-notice-ignore = If you already knew, you do not need to do anything.
mail-reset-external-subject = Your { $app } password
mail-reset-external-intro = We have received a request to reset the password of your account, but its password is not managed by this application: it is managed by { $provider }. Please change it there.
mail-reset-external-action = How to change my password
mail-preview-reset = Password reset
mail-preview-verify = Email verification on sign-up
mail-preview-email-change = Confirmation of a new address
mail-preview-email-change-requested = Notice of a requested address change
mail-preview-password-changed = Notice of a password change
mail-preview-password-changed-admin = Notice of a password change by an administrator
mail-preview-reset-external = Notice of a password managed elsewhere
# **< Error messages >**
@ -144,12 +149,20 @@ 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.
error-account-awaiting-approval = Your account is waiting for an administrator to approve it.
error-external-unavailable = Your password cannot be checked right now. Please try again later.
error-login-disallowed = Your account has no access to this application.
error-login-not-registered = You have no account in this application. Ask to be registered.
error-login-conflict = You cannot sign in with this account. Please contact the administrator.
error-password-expired = Your password has expired. Change it before signing in.
error-password-managed = The password of this account is not managed by this application.
# **< Account statuses >**
status-active = Active
status-blocked = Blocked
status-pending = Pending email verification
status-awaiting-approval = Awaiting approval
# **< System roles >**
@ -201,6 +214,10 @@ field-language = Language
field-timezone = Timezone
field-theme = Theme
value-theme-site-default = Site theme: { $theme }
field-origin = Origin
value-origin-local = Local account
value-origin-pending = Local account, may be linked with { $provider }
value-role-managed = { $role } (managed by { $provider })
field-machine-name = Machine name
field-label = Label
field-description = Description
@ -226,6 +243,11 @@ help-password-min-length = At least { $n } characters.
help-email-readonly = To change it, use "Change email" in your profile.
help-managed-by = Managed by { $provider }.
help-account-managed = Your account is managed by { $provider }: change your password and the data that comes from there in { $provider }.
help-password-managed = The password of this account is managed by { $provider } and cannot be changed here.
help-external-user = The account will have no password in this application: it will be linked with { $provider } the first time the person signs in with this username.
help-remember-me = Keeps you signed in using a cookie. Do not check on a shared device.
help-machine-name-immutable =
@ -247,6 +269,10 @@ btn-manage-permissions = Manage permissions
btn-reset-password = Reset password
btn-block = Block
btn-activate = Activate
btn-create-external-user = New { $provider } account
btn-approve = Approve
btn-allow-linking = Allow linking with { $provider }
btn-cancel-linking = Do not link with { $provider }
btn-grant-admin = Grant administrator
btn-revoke-admin = Revoke administrator
link-back = Back
@ -277,3 +303,6 @@ error-cannot-block-self = You cannot block your own account.
error-cannot-modify-own-admin-flag = You cannot grant or revoke your own unrestricted access.
error-user-not-found = User not found.
error-unknown-permission = Unknown permission key.
error-identity-taken = Another account is already linked to that identity.
error-protected-account = An administrator account cannot be linked to an authentication provider.
error-not-pending-identity = The account is not waiting to be linked.

View file

@ -115,12 +115,17 @@ mail-email-change-requested-intro = Se ha pedido cambiar la dirección de corr
mail-notice-action = Restablecer mi contraseña
mail-notice-ignore = Si ya lo sabías, no tienes que hacer nada.
mail-reset-external-subject = Tu contraseña de { $app }
mail-reset-external-intro = Hemos recibido una solicitud para restablecer la contraseña de tu cuenta, pero su contraseña no se gestiona en esta aplicación, sino en { $provider }. Cámbiala allí.
mail-reset-external-action = Cómo cambiar mi contraseña
mail-preview-reset = Recuperación de contraseña
mail-preview-verify = Verificación del correo al registrarse
mail-preview-email-change = Confirmación de una nueva dirección
mail-preview-email-change-requested = Aviso de cambio de dirección pedido
mail-preview-password-changed = Aviso de cambio de contraseña
mail-preview-password-changed-admin = Aviso de cambio de contraseña por un administrador
mail-preview-reset-external = Aviso de contraseña gestionada fuera
# **< Mensajes de error >**
@ -144,12 +149,20 @@ error-too-many-requests = Demasiadas solicitudes. Inténtalo de nuevo más t
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.
error-account-awaiting-approval = Tu cuenta está pendiente de que un administrador la apruebe.
error-external-unavailable = No se puede comprobar tu contraseña en este momento. Inténtalo de nuevo más tarde.
error-login-disallowed = Tu cuenta no tiene acceso a esta aplicación.
error-login-not-registered = No tienes una cuenta en esta aplicación. Pide que te den de alta.
error-login-conflict = No se puede iniciar sesión con esta cuenta. Contacta con el administrador.
error-password-expired = Tu contraseña ha caducado. Cámbiala antes de iniciar sesión.
error-password-managed = La contraseña de esta cuenta no se gestiona en esta aplicación.
# **< Estados de cuenta >**
status-active = Activo
status-blocked = Bloqueado
status-pending = Pendiente de verificación de email
status-awaiting-approval = Pendiente de aprobación
# **< Roles de sistema >**
@ -201,6 +214,10 @@ field-language = Idioma
field-timezone = Zona horaria
field-theme = Tema
value-theme-site-default = Tema del sitio: { $theme }
field-origin = Origen
value-origin-local = Cuenta local
value-origin-pending = Cuenta local, puede vincularse con { $provider }
value-role-managed = { $role } (gestionado por { $provider })
field-machine-name = Nombre técnico
field-label = Etiqueta
field-description = Descripción
@ -227,6 +244,11 @@ help-password-min-length = Al menos { $n } caracteres.
help-email-readonly = Para cambiarla, usa «Cambiar email» en tu perfil.
help-managed-by = Gestionado por { $provider }.
help-account-managed = Tu cuenta se gestiona en { $provider }: la contraseña y los datos que vienen de allí se cambian allí.
help-password-managed = La contraseña de esta cuenta se gestiona en { $provider } y no se puede cambiar desde aquí.
help-external-user = La cuenta no tendrá contraseña en esta aplicación: se vinculará con { $provider } la primera vez que la persona inicie sesión con este nombre de usuario.
help-remember-me = Mantiene la sesión abierta usando una cookie. No marcar en un equipo compartido.
help-machine-name-immutable =
@ -248,6 +270,10 @@ btn-manage-permissions = Gestionar permisos
btn-reset-password = Restablecer contraseña
btn-block = Bloquear
btn-activate = Activar
btn-create-external-user = Nueva cuenta de { $provider }
btn-approve = Aprobar
btn-allow-linking = Permitir vincular con { $provider }
btn-cancel-linking = No vincular con { $provider }
btn-grant-admin = Conceder administrador
btn-revoke-admin = Revocar administrador
link-back = Volver
@ -278,3 +304,6 @@ error-cannot-block-self = No puedes bloquear tu propia cuenta.
error-cannot-modify-own-admin-flag = No puedes conceder ni revocar tu propio acceso total.
error-user-not-found = Usuario no encontrado.
error-unknown-permission = Clave de permiso desconocida.
error-identity-taken = Otra cuenta ya está vinculada a esa identidad.
error-protected-account = Una cuenta de administrador no puede estar vinculada a un proveedor de autenticación.
error-not-pending-identity = La cuenta no está a la espera de vincularse.

View file

@ -7,6 +7,7 @@ use pagetop_mail::prelude::*;
use crate::config;
use crate::entity::user;
use crate::provider::HelpLink;
use crate::token::TokenKind;
use crate::{EMAIL_PATH, LOCALES_USER, PASSWORD_RESET_PATH, VERIFY_PATH};
@ -27,6 +28,9 @@ pub(crate) enum Notice {
PasswordChangedByAdmin,
/// Se ha pedido cambiar la dirección de la cuenta por otra, pendiente de confirmar.
EmailChangeRequested,
/// Se ha pedido recuperar la contraseña de una cuenta cuya contraseña se gestiona fuera de la
/// aplicación (ver `ResetPolicy::Forbidden`).
PasswordManagedExternally,
}
// **< UserMail >***********************************************************************************
@ -38,9 +42,12 @@ struct UserMail {
keys: [&'static str; 4],
// Nombre de usuario para el saludo, sólo si la dirección está verificada (ver `recipient()`).
username: Option<String>,
link: String,
// Enlace principal; sin él, no se pinta el botón.
link: Option<String>,
// Horas que vale el enlace, si caduca.
expires_hours: Option<u32>,
// Nombre del proveedor que gestiona la cuenta, para la introducción (`$provider`).
provider: Option<String>,
}
impl UserMail {
@ -69,8 +76,9 @@ impl UserMail {
UserMail {
keys,
username,
link,
link: Some(link),
expires_hours: Some(u32::try_from(kind.ttl_secs() / 3600).unwrap_or(u32::MAX)),
provider: None,
}
}
@ -89,14 +97,35 @@ impl UserMail {
"mail-email-change-requested-subject",
"mail-email-change-requested-intro",
],
Notice::PasswordManagedExternally => {
return UserMail {
keys: [
"mail-reset-external-subject",
"mail-reset-external-intro",
"mail-reset-external-action",
"mail-reset-ignore",
],
username,
link: None,
expires_hours: None,
provider: None,
}
.with_link(link);
}
};
UserMail {
keys: [subject, intro, "mail-notice-action", "mail-notice-ignore"],
username,
link,
link: Some(link),
expires_hours: None,
provider: None,
}
}
fn with_link(mut self, link: String) -> Self {
self.link = util::non_blank(&link).map(str::to_owned);
self
}
}
impl MailTemplate for UserMail {
@ -120,11 +149,17 @@ impl MailTemplate for UserMail {
let expires = self
.expires_hours
.map(|hours| Lc::t("mail-link-expires", &LOCALES_USER).with_number("hours", hours));
let mut intro = Lc::t(intro, &LOCALES_USER);
if let Some(provider) = &self.provider {
intro = intro.with_arg("provider", provider.clone());
}
Some(html! {
p { (greeting.using(cx)) }
p { (Lc::t(intro, &LOCALES_USER).using(cx)) }
p { (intro.using(cx)) }
@if let Some(link) = &self.link {
p style="margin: 24px 0;" {
a href=(self.link) style=(BUTTON_STYLE) { (Lc::t(action, &LOCALES_USER).using(cx)) }
a href=(link) style=(BUTTON_STYLE) { (Lc::t(action, &LOCALES_USER).using(cx)) }
}
}
@if let Some(expires) = expires {
p { (expires.using(cx)) }
@ -175,6 +210,33 @@ pub(crate) fn send_notice(request: &HttpRequest, notice: Notice, user: &user::Mo
notice_email(&cx, notice, username, to).send_later();
}
// Avisa a la cuenta de que su contraseña se gestiona fuera de la aplicación, con el enlace de ayuda
// del proveedor si lo hay, en lugar del enlace de recuperación.
pub(crate) fn send_external_password_notice(
request: &HttpRequest,
user: &user::Model,
provider_label: Lc,
help: Option<HelpLink>,
) {
let cx = user_context(request, user);
let (username, to) = recipient(user);
external_notice_email(&cx, provider_label, help, username, to).send_later();
}
// Compone el aviso de `send_external_password_notice()`.
fn external_notice_email(
cx: &Context,
provider_label: Lc,
help: Option<HelpLink>,
username: Option<String>,
to: Mailbox,
) -> Email {
let link = help.map(|help| help.url().to_owned()).unwrap_or_default();
let mut template = UserMail::notice(Notice::PasswordManagedExternally, username, link);
template.provider = Some(provider_label.lookup(cx).unwrap_or_default());
Email::from_template(&template, cx).with_to(to)
}
// Contexto de la petición con el idioma propio del usuario, si lo tiene y se aplica.
fn user_context(request: &HttpRequest, user: &user::Model) -> Context {
let mut cx = Context::new(request.clone());
@ -261,6 +323,15 @@ pub(crate) fn declare_previews(previews: &mut MailPreviews) {
Lc::t("mail-preview-password-changed", &LOCALES_USER),
|cx| sample_notice(cx, Notice::PasswordChanged),
);
previews.add(
"user.password_managed_externally",
Lc::t("mail-preview-reset-external", &LOCALES_USER),
|cx| {
let (username, to) = sample_verified();
let help = HelpLink::new("https://help.example.com/password", Lc::none());
external_notice_email(cx, Lc::n("Corporate directory"), help, username, to)
},
);
previews.add(
"user.password_changed_by_admin",
Lc::t("mail-preview-password-changed-admin", &LOCALES_USER),
@ -338,6 +409,7 @@ mod tests {
"https://example.com/user/password/reset".to_owned(),
);
assert!(mail.expires_hours.is_none());
assert!(mail.link.is_some());
let html = mail.html(&Context::default()).unwrap().into_string();
assert!(html.contains("href=\"https://example.com/user/password/reset\""));
}

View file

@ -12,6 +12,7 @@ use std::sync::Arc;
use pagetop::prelude::*;
use crate::account::{Account, PermissionSet};
use crate::actions::AfterSessionResolved;
use crate::config::SETTINGS;
use crate::session;
@ -26,6 +27,8 @@ struct AnonymousPermissions(Arc<PermissionSet>);
/// - Siempre inserta [`pagetop::auth::CurrentUser`] (anónimo o autenticado).
/// - Si hay sesión activa, inserta también el [`Account`] con sus permisos; si no, los permisos del
/// rol "anonymous".
/// - Con sesión, despacha [`AfterSessionResolved`]: si una acción responde, la petición no llega al
/// *handler*.
/// - Si se ha prorrogado una sesión iniciada con "recordarme", renueva su cookie en la respuesta.
pub(crate) async fn session_middleware(
mut req: web::Request,
@ -35,18 +38,25 @@ pub(crate) async fn session_middleware(
session::resolve_session(req.headers()).await;
req.extensions_mut().insert(current_user);
match maybe_account {
let early = match maybe_account {
Some(account) => {
// Antes de insertar la cuenta, para no clonarla: la acción la recibe aparte.
let early = AfterSessionResolved::dispatch(&mut req, &account);
req.extensions_mut().insert(account);
early
}
None => {
let permissions = session::anonymous_permissions().await;
req.extensions_mut()
.insert(AnonymousPermissions(permissions));
None
}
}
};
let mut response = next.run(req).await;
let mut response = match early {
Some(response) => response,
None => next.run(req).await,
};
// No se pisa la cookie de sesión que ya fije el handler (p. ej. la de expiración al cerrar
// sesión). Las demás (mensajes, estado de un listado) conviven con la renovación: si la

View file

@ -6,3 +6,4 @@ pub mod m20260629_000003_create_user_roles;
pub mod m20260629_000004_create_role_permissions;
pub mod m20260629_000005_create_sessions;
pub mod m20260629_000006_create_user_tokens;
pub mod m20261111_000007_create_user_identities;

View file

@ -22,7 +22,7 @@ impl MigrationTrait for Migration {
// Nueva dirección pedida en el perfil, hasta que se confirma desde ella.
.col(string_len_null(Users::PendingEmail, 254))
.col(string(Users::PasswordHash))
// 0=Blocked, 1=Active, 2=Pending
// 0=Blocked, 1=Active, 2=Pending, 3=AwaitingApproval
.col(small_integer(Users::Status).default(1))
.col(string_len_null(Users::Language, 16))
.col(string_len_null(Users::Timezone, 64))

View file

@ -0,0 +1,98 @@
use pagetop_seaorm::migration::*;
use super::m20260629_000001_create_users::Users;
pub struct Migration;
#[pagetop::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(UserIdentities::Table)
.if_not_exists()
.col(pk_auto(UserIdentities::Id))
.col(integer(UserIdentities::UserId))
// Identificador del proveedor (`AuthProvider::id()`).
.col(string_len(UserIdentities::Provider, 64))
// Identificador de la persona tal como lo da el proveedor, y su forma
// normalizada para buscar, con el ámbito que el proveedor necesite. Nulos en
// una identidad pendiente.
.col(string_len_null(UserIdentities::ExternalId, 320))
.col(string_len_null(UserIdentities::ExternalKey, 320))
// Marca que un administrador pone en una cuenta para que el proveedor pueda
// vincularla, con el nombre o email con el que se espera a la persona.
.col(boolean(UserIdentities::Pending).default(false))
.col(string_len_null(UserIdentities::ExpectedKey, 320))
.col(text_null(UserIdentities::Data))
.col(timestamp(UserIdentities::CreatedAt).default(Expr::current_timestamp()))
.col(timestamp_null(UserIdentities::LinkedAt))
.col(timestamp_null(UserIdentities::LastLoginAt))
.foreign_key(
ForeignKey::create()
.from(UserIdentities::Table, UserIdentities::UserId)
.to(Users::Table, Users::Id)
.on_delete(ForeignKeyAction::Cascade),
)
.to_owned(),
)
.await?;
// Una persona del proveedor sólo puede estar en una cuenta (varias pendientes, con la
// clave nula, sí), y una cuenta sólo tiene una identidad de cada proveedor.
manager
.create_index(
Index::create()
.name("idx_user_identities_external")
.table(UserIdentities::Table)
.col(UserIdentities::Provider)
.col(UserIdentities::ExternalKey)
.unique()
.to_owned(),
)
.await?;
manager
.create_index(
Index::create()
.name("idx_user_identities_user")
.table(UserIdentities::Table)
.col(UserIdentities::Provider)
.col(UserIdentities::UserId)
.unique()
.to_owned(),
)
.await?;
manager
.create_index(
Index::create()
.name("idx_user_identities_user_id")
.table(UserIdentities::Table)
.col(UserIdentities::UserId)
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(UserIdentities::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
pub enum UserIdentities {
Table,
Id,
UserId,
Provider,
ExternalId,
ExternalKey,
Pending,
ExpectedKey,
Data,
CreatedAt,
LinkedAt,
LastLoginAt,
}

View file

@ -1,5 +1,7 @@
//! Hashing de contraseñas con Argon2id.
use pagetop::prelude::*;
use argon2::{
Argon2, ParamsBuilder, PasswordHash, PasswordHasher, PasswordVerifier,
password_hash::SaltString,
@ -11,6 +13,12 @@ use std::sync::LazyLock;
use crate::config::SETTINGS;
use crate::error::AuthError;
// Lo que se guarda como contraseña de una cuenta sin contraseña local (las que gestiona un
// proveedor de autenticación). No es un *hash* PHC válido, así que `verify_password()` siempre
// devuelve `false`; y nunca se recalcula, porque `needs_rehash()` sólo se consulta tras verificar
// la contraseña.
pub(crate) const UNUSABLE_HASH: &str = "!external";
/// Genera el hash PHC de una contraseña usando Argon2id con los parámetros configurados.
pub fn hash_password(plain: &str) -> Result<String, AuthError> {
let params = ParamsBuilder::new()
@ -44,16 +52,18 @@ pub fn verify_password(plain: &str, phc: &str) -> bool {
// el *pool* de hilos bloqueantes de Tokio. Con los costes por defecto tarda decenas de milisegundos,
// que retendrían un hilo del *runtime* asíncrono y retrasarían las demás peticiones (p. ej. durante
// un intento de fuerza bruta contra el inicio de sesión).
//
// La copia de la contraseña que viaja al hilo va en un `SecretStr`, que la borra al terminar.
pub(crate) async fn hash_password_async(plain: &str) -> Result<String, AuthError> {
let plain = plain.to_owned();
tokio::task::spawn_blocking(move || hash_password(&plain))
let plain = util::SecretStr::new(plain);
tokio::task::spawn_blocking(move || hash_password(plain.expose()))
.await
.map_err(|err| AuthError::PasswordHash(err.to_string()))?
}
pub(crate) async fn verify_password_async(plain: &str, phc: &str) -> bool {
let (plain, phc) = (plain.to_owned(), phc.to_owned());
tokio::task::spawn_blocking(move || verify_password(&plain, &phc))
let (plain, phc) = (util::SecretStr::new(plain), phc.to_owned());
tokio::task::spawn_blocking(move || verify_password(plain.expose(), &phc))
.await
.unwrap_or(false)
}
@ -67,8 +77,9 @@ pub(crate) async fn verify_password_without_account(plain: &str) {
verify_password_async(plain, DUMMY_HASH.as_str()).await;
}
/// Indica si el hash necesita actualizarse: no es de Argon2id o se cifró con otros parámetros de
/// coste que los configurados.
/// Indica si el hash necesita actualizarse.
///
/// No es de Argon2id o se cifró con otros parámetros de coste que los configurados.
pub fn needs_rehash(phc: &str) -> bool {
let Ok(parsed) = PasswordHash::new(phc) else {
return true;
@ -99,3 +110,15 @@ pub fn passwords_match(password: &str, confirm_password: &str) -> Result<(), Aut
Err(AuthError::PasswordMismatch)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[pagetop::test]
async fn the_unusable_hash_never_verifies() {
assert!(PasswordHash::new(UNUSABLE_HASH).is_err());
assert!(!verify_password("", UNUSABLE_HASH));
assert!(!verify_password("!external", UNUSABLE_HASH));
}
}

View file

@ -0,0 +1,701 @@
//! Proveedores de autenticación externos.
//!
//! Permite a otras extensiones comprobar credenciales y gestionar cuentas de `pagetop-user` (un
//! directorio LDAP, un proveedor OAuth...).
//!
//! # Cómo funciona
//!
//! 1. La extensión implementa [`AuthProvider`] y lo declara con la acción
//! [`DeclareAuthProviders`].
//! 2. Quien configura la aplicación decide en
//! [`[user.login] sources`](crate::config::LoginSettings::sources) con qué fuentes, y en qué
//! orden, se comprueban las credenciales del formulario de inicio de sesión: la contraseña
//! guardada en PageTop (`"local"`) y los proveedores por su [`id()`](AuthProvider::id).
//! 3. Al arrancar, `pagetop-user` entrega a cada proveedor que figura en `sources` su
//! [`ProviderHandle`] ([`AuthProvider::attach()`]): la única vía para crear cuentas, vincularlas
//! con su identidad externa, cambiar sus datos y roles o cerrar sus sesiones.
//! 4. En cada inicio de sesión, `pagetop-user` aplica los límites de intentos, recorre las fuentes
//! en orden ([`AuthProvider::authenticate()`]) y, si una autentica, comprueba el estado de la
//! cuenta resultante y abre la sesión. Las comprobaciones del estado, del bloqueo por intentos
//! fallidos y de los límites son siempre las de `pagetop-user`, para todas las fuentes.
//!
//! Una cuenta vinculada a un proveedor sólo se autentica con ese proveedor (y con `"local"` si
//! `sources` o [`local_fallback`](crate::config::LoginSettings::local_fallback) lo permiten), y su
//! contraseña local deja de valer al vincularla. Lo que el usuario puede cambiar de su cuenta lo
//! decide el proveedor con [`AuthProvider::account_policy()`].
//!
//! # La contraseña
//!
//! El proveedor recibe la contraseña tecleada como [`pagetop::util::SecretStr`] y sólo debe usarla
//! para comprobarla: nunca guardarla, registrarla ni pasarla a tareas que sobrevivan a la petición.
//!
//! `SecretStr` la borra de la memoria al descartarse, pero el cuerpo del formulario pasa antes por
//! búferes del servidor web que PageTop no controla: se garantiza que la contraseña no se guarda ni
//! se registra, no que no quede ningún rastro en la memoria del proceso.
mod handle;
mod policy;
pub use handle::{ExternalIdentity, ExternalUserData, ExternalUserUpdate, ProviderHandle};
pub use handle::{UpdateReport, find_role_by_machine_name, find_user_by_login};
pub use handle::{validate_email, validate_username};
pub(crate) use handle::{allow_linking, cancel_linking, identities_of, pending_identity};
pub use policy::UserField;
pub use policy::{AccountPolicy, FieldPolicy, HelpLink, LoginHints, ResetLink, ResetPolicy};
use pagetop::prelude::*;
use pagetop_seaorm::db::{ColumnTrait, EntityTrait, QueryFilter, dbconn};
use crate::account::UserStatus;
use crate::config::{LocalFallback, SETTINGS};
use crate::entity::{user, user_identity};
use crate::error::AuthError;
use std::net::IpAddr;
use std::sync::OnceLock;
/// Identificador de la fuente de credenciales que es la contraseña guardada en PageTop.
pub const LOCAL_SOURCE: &str = "local";
// **< UserRef >************************************************************************************
/// Vista de sólo lectura de una cuenta, la que reciben los proveedores.
#[derive(Clone, Debug, Getters)]
pub struct UserRef {
/// Identificador de la cuenta.
#[getters(copy)]
id: i32,
/// Nombre de usuario.
username: String,
/// Email.
email: String,
/// Estado de la cuenta.
#[getters(copy)]
status: UserStatus,
/// Si es una cuenta de administrador (`is_admin`).
#[getters(copy)]
is_admin: bool,
/// Hasta cuándo está bloqueada por intentos fallidos, si lo está o lo estuvo.
#[getters(copy)]
locked_until: Option<DateTime<Utc>>,
}
impl From<&user::Model> for UserRef {
fn from(user: &user::Model) -> Self {
UserRef {
id: user.id,
username: user.username.clone(),
email: user.email.clone(),
status: UserStatus::from_i16(user.status),
is_admin: user.is_admin,
locked_until: user.locked_until,
}
}
}
// **< LoginAttempt >*******************************************************************************
/// Un intento de inicio de sesión, tal como lo recibe [`AuthProvider::authenticate()`].
///
/// Cuando llega al proveedor ya ha superado los límites de intentos de `pagetop-user` (por
/// dirección IP y por identificador) y los topes de longitud: un identificador de hasta 255
/// caracteres sin caracteres de control y una contraseña de hasta 1024 bytes sin NUL.
pub struct LoginAttempt<'a> {
identifier: &'a str,
password: &'a util::SecretStr,
local: Option<&'a UserRef>,
client_ip: Option<IpAddr>,
}
impl<'a> LoginAttempt<'a> {
pub(crate) fn new(
identifier: &'a str,
password: &'a util::SecretStr,
local: Option<&'a UserRef>,
client_ip: Option<IpAddr>,
) -> Self {
LoginAttempt {
identifier,
password,
local,
client_ip,
}
}
/// Lo tecleado como usuario: un nombre de usuario o un email, sin normalizar.
pub fn identifier(&self) -> &'a str {
self.identifier
}
/// La contraseña tecleada.
pub fn password(&self) -> &'a util::SecretStr {
self.password
}
/// La cuenta de PageTop que corresponde a lo tecleado (por email si lleva `@`, por nombre de
/// usuario si no), si existe.
pub fn local(&self) -> Option<&'a UserRef> {
self.local
}
/// Dirección IP del cliente, si se conoce.
pub fn client_ip(&self) -> Option<IpAddr> {
self.client_ip
}
}
// **< Resultados >*********************************************************************************
/// Resultado de [`AuthProvider::authenticate()`].
#[derive(Debug)]
pub enum ProviderOutcome {
/// El proveedor no conoce a la persona, o no le corresponde comprobarla.
NotFound,
/// La contraseña no es válida para una persona que el proveedor conoce. `user_id` es su cuenta
/// de PageTop, si la tiene: en ella se anota el intento fallido.
InvalidCredentials {
/// Cuenta de PageTop de la persona, si la tiene.
user_id: Option<i32>,
},
/// Credenciales válidas, y ésta es la cuenta de PageTop (creada, vinculada o ya vinculada).
Authenticated {
/// Cuenta de PageTop con la que se inicia la sesión.
user_id: i32,
},
/// Credenciales **válidas**, pero el proveedor deniega el acceso. Detiene la cadena: no se
/// prueba ninguna otra fuente.
///
/// Sólo se puede devolver tras comprobar que la contraseña es correcta: si no, el motivo
/// revelaría a cualquiera qué cuentas existen y en qué situación están.
Rejected(RejectReason),
/// El proveedor no está disponible (red, TLS, plazo agotado...).
Unavailable,
}
/// Motivo de un [`ProviderOutcome::Rejected`], que se muestra al usuario.
#[derive(Clone, Debug)]
pub enum RejectReason {
/// El proveedor no permite el acceso a esta persona.
Disallowed,
/// La persona no tiene cuenta en la aplicación y no se crean automáticamente.
NotRegistered,
/// La cuenta se ha creado y espera a que un administrador la apruebe.
AwaitingApproval,
/// No se puede asociar a ninguna cuenta sin ambigüedad. El mensaje es genérico; el motivo
/// concreto debe ir a las trazas.
Conflict,
/// La contraseña ha caducado y debe cambiarse fuera de la aplicación.
PasswordExpired {
/// Enlace a la página donde se cambia, si lo hay.
help: Option<HelpLink>,
},
}
/// Resultado de [`AuthProvider::reauthenticate()`].
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ReauthOutcome {
/// La contraseña es correcta.
Valid,
/// La contraseña no es correcta.
Invalid,
/// No se ha podido comprobar.
Unavailable,
}
/// Cómo ha entrado una cuenta vinculada a un proveedor.
///
/// Lo recibe [`AuthProvider::after_login()`].
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LoginVia {
/// Con su contraseña local (ver
/// [`local_fallback`](crate::config::LoginSettings::local_fallback)).
Local,
/// Con el propio proveedor.
Provider,
}
// **< AuthProvider >*******************************************************************************
/// Un proveedor de autenticación externo. Ver la [documentación del módulo](self).
#[async_trait]
pub trait AuthProvider: Send + Sync + 'static {
/// Identificador estable del proveedor (`"ldap"`), el que se escribe en
/// [`sources`](crate::config::LoginSettings::sources) y se guarda en cada identidad vinculada.
/// No debe cambiar nunca: las cuentas vinculadas quedarían sin proveedor.
fn id(&self) -> &'static str;
/// Nombre visible del proveedor («Directorio corporativo»).
fn label(&self) -> Lc;
/// Recibe la API privilegiada de `pagetop-user`. Se llama una sola vez, al arrancar, y sólo si
/// el proveedor figura en `sources`.
///
/// El proveedor debe guardar el [`ProviderHandle`] en un lugar privado (un `OnceLock` de su
/// módulo) y no compartirlo: es la única vía para crear y modificar las cuentas que gestiona.
/// Ver la sección *Seguridad* de [`ProviderHandle`].
fn attach(&self, handle: ProviderHandle);
/// Si el proveedor renuncia a gestionar la cuenta, que entonces puede entrar con su contraseña
/// local aunque `"local"` no esté en `sources` (ver
/// [`LocalFallback::Released`]). Por defecto, no.
async fn releases(&self, _user: &UserRef) -> bool {
false
}
/// Comprueba las credenciales de un intento de inicio de sesión.
///
/// Con la contraseña correcta, el proveedor resuelve la cuenta de PageTop con su
/// [`ProviderHandle`]: la ya vinculada a la persona
/// ([`find_user()`](ProviderHandle::find_user)), una que un administrador haya permitido
/// vincular ([`find_pending()`](ProviderHandle::find_pending) y
/// [`link_identity()`](ProviderHandle::link_identity)) o una nueva
/// ([`create_user()`](ProviderHandle::create_user)), y devuelve
/// [`Authenticated`](ProviderOutcome::Authenticated). Si la persona existe pero la contraseña
/// no vale, [`InvalidCredentials`](ProviderOutcome::InvalidCredentials); si no la conoce,
/// [`NotFound`](ProviderOutcome::NotFound); si no puede comprobarla,
/// [`Unavailable`](ProviderOutcome::Unavailable). [`Rejected`](ProviderOutcome::Rejected)
/// sólo tras comprobar que la contraseña es correcta.
async fn authenticate(&self, attempt: &LoginAttempt<'_>) -> ProviderOutcome;
/// Comprueba de nuevo la contraseña de una cuenta ya vinculada a este proveedor, cuando el
/// usuario confirma con ella una operación sensible (p. ej. cambiar su email).
async fn reauthenticate(&self, user: &UserRef, password: &util::SecretStr) -> ReauthOutcome;
/// Qué se puede cambiar de una cuenta vinculada a este proveedor, o `None` si no la gestiona.
async fn account_policy(&self, _user: &UserRef) -> Option<AccountPolicy> {
None
}
/// Si admite «Recuérdame» para sus cuentas. Si no, la sesión dura lo que el navegador
/// abierto, aunque el usuario marque la casilla.
fn allows_remember(&self) -> bool {
true
}
/// Lo que quiere mostrar en el formulario de inicio de sesión.
fn login_hints(&self) -> Option<LoginHints> {
None
}
/// Se llama tras un inicio de sesión correcto de una cuenta vinculada a este proveedor, antes
/// de responder. Sus errores no impiden el inicio de sesión, y `pagetop-user` deja de esperarlo
/// pasados unos segundos.
async fn after_login(&self, _user_id: i32, _via: LoginVia) {}
}
// **< DeclareAuthProviders >***********************************************************************
/// Tipo de función que declara proveedores en un [`AuthProviders`].
pub type FnDeclareAuthProviders = fn(providers: &mut AuthProviders);
/// Proveedores declarados por las extensiones. Ver [`DeclareAuthProviders`].
#[derive(AutoDefault)]
pub struct AuthProviders {
providers: Vec<&'static dyn AuthProvider>,
}
impl AuthProviders {
/// Añade un proveedor.
pub fn add(&mut self, provider: &'static dyn AuthProvider) {
self.providers.push(provider);
}
}
/// Acción para declarar proveedores de autenticación.
///
/// Se despacha una sola vez, al inicializar `pagetop-user`.
///
/// # Ejemplo
///
/// ```rust,no_run
/// use pagetop::prelude::*;
/// use pagetop_user::provider::*;
///
/// use std::sync::OnceLock;
///
/// static HANDLE: OnceLock<ProviderHandle> = OnceLock::new();
///
/// struct Sso;
///
/// #[async_trait]
/// impl AuthProvider for Sso {
/// fn id(&self) -> &'static str {
/// "sso"
/// }
///
/// fn label(&self) -> Lc {
/// Lc::n("Single sign-on")
/// }
///
/// fn attach(&self, handle: ProviderHandle) {
/// let _ = HANDLE.set(handle);
/// }
///
/// async fn authenticate(&self, _attempt: &LoginAttempt<'_>) -> ProviderOutcome {
/// ProviderOutcome::NotFound
/// }
///
/// async fn reauthenticate(
/// &self,
/// _user: &UserRef,
/// _password: &util::SecretStr,
/// ) -> ReauthOutcome {
/// ReauthOutcome::Invalid
/// }
/// }
///
/// fn declare_providers(providers: &mut AuthProviders) {
/// providers.add(&Sso);
/// }
///
/// struct MyApp;
///
/// #[async_trait]
/// impl Extension for MyApp {
/// fn dependencies(&self) -> Vec<ExtensionRef> {
/// vec![&pagetop_user::User]
/// }
///
/// fn actions(&self) -> Vec<ActionBox> {
/// actions![DeclareAuthProviders::new(declare_providers)]
/// }
/// }
/// ```
pub struct DeclareAuthProviders {
f: FnDeclareAuthProviders,
weight: Weight,
}
impl ActionDispatcher for DeclareAuthProviders {
fn weight(&self) -> Weight {
self.weight
}
}
impl DeclareAuthProviders {
/// Registra una función que declara proveedores.
pub fn new(f: FnDeclareAuthProviders) -> Self {
DeclareAuthProviders { f, weight: 0 }
}
/// Opcional. Las acciones de menor peso se aplican antes. Se pueden usar valores negativos.
pub fn with_weight(mut self, value: Weight) -> Self {
self.weight = value;
self
}
}
// **< Registro de fuentes >************************************************************************
// Una fuente de credenciales de `sources`.
#[derive(Clone, Copy)]
pub(crate) enum Source {
Local,
Provider(&'static dyn AuthProvider),
}
// Fuentes activas, en el orden de `sources`, resueltas una sola vez al arrancar. Arrancar de nuevo
// en el mismo proceso (las pruebas lo hacen) conserva las primeras, como las propias acciones.
static SOURCES: OnceLock<Vec<Source>> = OnceLock::new();
// Recoge los proveedores declarados, valida `sources` y entrega su `ProviderHandle` a los que
// figuran en ella. Se llama desde `User::initialize()`.
pub(crate) fn initialize() -> Result<(), AuthError> {
if SOURCES.get().is_some() {
return Ok(());
}
let mut declared = AuthProviders::default();
dispatch_actions(|action: &DeclareAuthProviders| (action.f)(&mut declared));
let sources = resolve_sources(&SETTINGS.login.sources, &declared.providers)?;
for provider in &declared.providers {
if !sources
.iter()
.any(|s| matches!(s, Source::Provider(p) if p.id() == provider.id()))
{
trace::warn!(
"Authentication provider \"{}\" is not in [user.login] sources: it will not \
authenticate anyone",
provider.id()
);
}
}
let has_providers = sources.iter().any(|s| matches!(s, Source::Provider(_)));
if has_providers && SETTINGS.allow_registration {
trace::warn!(
"Local registration is open (user.allow_registration) while an authentication \
provider is active: anyone can create a local account, and a name taken here can \
block the account of the person with that name in the provider"
);
}
if SOURCES.set(sources).is_ok() {
for source in active_sources() {
if let Source::Provider(provider) = source {
provider.attach(ProviderHandle::issue(provider.id()));
}
}
}
Ok(())
}
// Comprueba la lista `sources` contra los proveedores declarados y la devuelve resuelta.
fn resolve_sources(
ids: &[String],
declared: &[&'static dyn AuthProvider],
) -> Result<Vec<Source>, AuthError> {
if ids.is_empty() {
return Err(AuthError::NoLoginSources);
}
let mut sources = Vec::with_capacity(ids.len());
for (i, id) in ids.iter().enumerate() {
if ids[..i].contains(id) {
return Err(AuthError::DuplicateLoginSource(id.clone()));
}
if id == LOCAL_SOURCE {
sources.push(Source::Local);
} else {
let provider = declared
.iter()
.find(|p| p.id() == id)
.ok_or_else(|| AuthError::UnknownLoginSource(id.clone()))?;
sources.push(Source::Provider(*provider));
}
}
Ok(sources)
}
// Fuentes activas, o sólo `"local"` fuera de una aplicación (o antes de arrancar).
pub(crate) fn active_sources() -> &'static [Source] {
SOURCES.get().map_or(&[Source::Local], Vec::as_slice)
}
/// Proveedores activos (los de `sources`), en su orden.
pub fn active_providers() -> impl Iterator<Item = &'static dyn AuthProvider> {
active_sources().iter().filter_map(|source| match source {
Source::Provider(provider) => Some(*provider),
Source::Local => None,
})
}
/// Proveedor activo con ese identificador.
pub fn active_provider(id: &str) -> Option<&'static dyn AuthProvider> {
active_providers().find(|provider| provider.id() == id)
}
// Si `"local"` está en `sources`.
pub(crate) fn local_is_source() -> bool {
active_sources().iter().any(|s| matches!(s, Source::Local))
}
// Cadena de fuentes de un intento. Si `"local"` no está en `sources` y la cuenta existe, se añade
// al principio cuando `local_fallback` lo permite: para un administrador con `Admins`, o para una
// cuenta que algún proveedor libera (`released`) con `Released` o `Admins`.
pub(crate) fn login_chain(
sources: &[Source],
fallback: LocalFallback,
local: Option<&UserRef>,
released: bool,
) -> Vec<Source> {
let mut chain = Vec::with_capacity(sources.len() + 1);
let has_local = sources.iter().any(|s| matches!(s, Source::Local));
if !has_local && let Some(user) = local {
let admin = fallback == LocalFallback::Admins && user.is_admin();
let freed = fallback != LocalFallback::None && released;
if admin || freed {
chain.push(Source::Local);
}
}
chain.extend_from_slice(sources);
chain
}
// Si hace falta preguntar a los proveedores si liberan la cuenta para construir la cadena.
pub(crate) fn needs_release_check(fallback: LocalFallback, local: Option<&UserRef>) -> bool {
!local_is_source()
&& fallback != LocalFallback::None
&& local.is_some_and(|user| !(fallback == LocalFallback::Admins && user.is_admin()))
}
// Proveedores (por identificador) a los que está vinculada la cuenta; vacío si es local.
pub(crate) async fn linked_providers(user_id: i32) -> Result<Vec<String>, AuthError> {
let rows = user_identity::Entity::find()
.filter(user_identity::Column::UserId.eq(user_id))
.filter(user_identity::Column::Pending.eq(false))
.all(dbconn())
.await?;
Ok(rows.into_iter().map(|row| row.provider).collect())
}
// Proveedor activo que gestiona la cuenta, si está vinculada a alguno.
pub(crate) async fn managing_provider(
user_id: i32,
) -> Result<Option<&'static dyn AuthProvider>, AuthError> {
if active_providers().next().is_none() {
return Ok(None);
}
let linked = linked_providers(user_id).await?;
Ok(active_providers().find(|p| linked.iter().any(|id| id == p.id())))
}
// Política de la cuenta, si la gestiona un proveedor activo que devuelve una.
pub(crate) async fn account_policy(user: &user::Model) -> Option<AccountPolicy> {
match managing_provider(user.id).await {
Ok(Some(provider)) => provider.account_policy(&UserRef::from(user)).await,
Ok(None) => None,
Err(err) => {
trace::error!("Cannot load the identities of user {}: {err}", user.id);
None
}
}
}
// Pistas para el formulario de inicio de sesión: la nota de cada proveedor activo y el enlace de
// recuperación (el local si `"local"` es una fuente; si no, el primero que indique un proveedor).
pub(crate) fn login_hints() -> (Vec<Lc>, ResetLink) {
let mut notes = Vec::new();
let mut reset = None;
for provider in active_providers() {
if let Some(hints) = provider.login_hints() {
if !hints.note().is_none() {
notes.push(hints.note().clone());
}
reset.get_or_insert_with(|| hints.reset().clone());
}
}
let reset = if local_is_source() {
ResetLink::Local
} else {
reset.unwrap_or(ResetLink::Hidden)
};
(notes, reset)
}
// Si alguna fuente admite "Recuérdame".
pub(crate) fn any_allows_remember() -> bool {
active_sources().iter().any(|source| match source {
Source::Local => true,
Source::Provider(provider) => provider.allows_remember(),
})
}
#[cfg(test)]
mod tests {
use super::*;
struct Fake;
#[async_trait]
impl AuthProvider for Fake {
fn id(&self) -> &'static str {
"fake"
}
fn label(&self) -> Lc {
Lc::n("Fake")
}
fn attach(&self, _handle: ProviderHandle) {}
async fn authenticate(&self, _attempt: &LoginAttempt<'_>) -> ProviderOutcome {
ProviderOutcome::NotFound
}
async fn reauthenticate(
&self,
_user: &UserRef,
_password: &util::SecretStr,
) -> ReauthOutcome {
ReauthOutcome::Invalid
}
}
static FAKE: Fake = Fake;
fn ids(values: &[&str]) -> Vec<String> {
values.iter().map(|v| (*v).to_owned()).collect()
}
fn names(chain: &[Source]) -> Vec<&'static str> {
chain
.iter()
.map(|s| match s {
Source::Local => LOCAL_SOURCE,
Source::Provider(p) => p.id(),
})
.collect()
}
fn user(is_admin: bool) -> UserRef {
UserRef {
id: 1,
username: "ana".into(),
email: "ana@example.com".into(),
status: UserStatus::Active,
is_admin,
locked_until: None,
}
}
#[pagetop::test]
async fn sources_must_be_known_unique_and_not_empty() {
let declared: [&'static dyn AuthProvider; 1] = [&FAKE];
assert!(resolve_sources(&ids(&["local", "fake"]), &declared).is_ok());
assert!(matches!(
resolve_sources(&ids(&[]), &declared),
Err(AuthError::NoLoginSources)
));
assert!(matches!(
resolve_sources(&ids(&["fake", "fake"]), &declared),
Err(AuthError::DuplicateLoginSource(_))
));
assert!(matches!(
resolve_sources(&ids(&["local", "ldap"]), &declared),
Err(AuthError::UnknownLoginSource(_))
));
}
#[pagetop::test]
async fn local_is_only_added_when_the_fallback_allows_it() {
let declared: [&'static dyn AuthProvider; 1] = [&FAKE];
let only_fake = resolve_sources(&ids(&["fake"]), &declared).unwrap();
let both = resolve_sources(&ids(&["fake", "local"]), &declared).unwrap();
let admin = user(true);
let plain = user(false);
use LocalFallback::*;
// "local" already in the sources: the chain is the configured one.
assert_eq!(
names(&login_chain(&both, None, Some(&admin), true)),
["fake", "local"]
);
// No account: nothing to fall back to.
assert_eq!(
names(&login_chain(&only_fake, Admins, Option::None, true)),
["fake"]
);
// `none` never falls back.
assert_eq!(
names(&login_chain(&only_fake, None, Some(&admin), true)),
["fake"]
);
// `released` only for released accounts, administrators included.
assert_eq!(
names(&login_chain(&only_fake, Released, Some(&admin), false)),
["fake"]
);
assert_eq!(
names(&login_chain(&only_fake, Released, Some(&plain), true)),
["local", "fake"]
);
// `admins` adds any administrator, and released accounts too.
assert_eq!(
names(&login_chain(&only_fake, Admins, Some(&admin), false)),
["local", "fake"]
);
assert_eq!(
names(&login_chain(&only_fake, Admins, Some(&plain), false)),
["fake"]
);
assert_eq!(
names(&login_chain(&only_fake, Admins, Some(&plain), true)),
["local", "fake"]
);
}
}

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,260 @@
use pagetop::prelude::*;
// **< HelpLink >***********************************************************************************
/// Enlace de ayuda de un proveedor.
///
/// Por ejemplo, la página donde se cambia la contraseña del directorio.
///
/// Sólo admite direcciones `http://` o `https://`: el enlace se muestra en páginas de la aplicación
/// y una dirección `javascript:` sería un ataque. Ver [`HelpLink::new()`].
#[derive(Clone, Debug, Getters)]
pub struct HelpLink {
/// Dirección del enlace.
url: String,
/// Texto del enlace. Sin texto, se muestra la dirección (en el enlace de recuperación del
/// formulario de inicio de sesión, «¿Olvidaste tu contraseña?»).
text: Lc,
}
impl HelpLink {
/// Crea el enlace, o devuelve `None` si la dirección no empieza por `http://` o `https://`
/// (sin distinguir mayúsculas) o contiene espacios o caracteres de control.
pub fn new(url: impl Into<String>, text: Lc) -> Option<Self> {
let url = url.into();
let url = url.trim();
let lower = url.get(..8).unwrap_or(url).to_ascii_lowercase();
let scheme = if lower.starts_with("https://") {
8
} else if lower.starts_with("http://") {
7
} else {
return None;
};
let valid = url.len() > scheme && !url.chars().any(|c| c.is_whitespace() || c.is_control());
valid.then(|| HelpLink {
url: url.to_owned(),
text,
})
}
}
// **< Políticas >**********************************************************************************
/// Qué puede hacer el usuario con un dato de su cuenta. Usado en [`AccountPolicy`].
#[derive(AutoDefault, Clone, Copy, Debug, Eq, PartialEq)]
pub enum FieldPolicy {
/// Lo puede cambiar el propio usuario, como en cualquier cuenta local.
#[default]
Editable,
/// No se puede cambiar desde la aplicación: se indica que lo gestiona el proveedor.
ReadOnly,
}
impl FieldPolicy {
/// Si el usuario lo puede cambiar.
pub fn is_editable(self) -> bool {
self == FieldPolicy::Editable
}
}
/// Si la cuenta puede recuperar su contraseña por correo. Usado en [`AccountPolicy`].
#[derive(AutoDefault, Clone, Debug)]
pub enum ResetPolicy {
/// Puede, como cualquier cuenta local.
#[default]
Allowed,
/// No puede: la contraseña se gestiona fuera de la aplicación. En lugar del enlace, la cuenta
/// recibe por correo un aviso, con el enlace de ayuda si lo hay.
Forbidden {
/// Enlace de ayuda que se incluye en el aviso, si lo hay.
help: Option<HelpLink>,
},
}
/// Datos de la cuenta que puede gestionar un proveedor. Usado en [`AccountPolicy`].
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum UserField {
/// Email.
Email,
/// Nombre visible.
DisplayName,
/// Texto «Sobre mí».
About,
/// Idioma.
Language,
/// Zona horaria.
Timezone,
/// Tema.
Theme,
}
impl UserField {
/// Nombre del campo, para las trazas.
pub const fn as_str(self) -> &'static str {
match self {
UserField::Email => "email",
UserField::DisplayName => "display_name",
UserField::About => "about",
UserField::Language => "language",
UserField::Timezone => "timezone",
UserField::Theme => "theme",
}
}
}
/// Qué puede cambiar el usuario, o el administrador, en una cuenta gestionada.
///
/// La devuelve [`AuthProvider::account_policy()`](super::AuthProvider::account_policy).
/// `pagetop-user` la aplica en el perfil, en las páginas de cambio de contraseña y de email, en la
/// recuperación de la contraseña y en la administración de usuarios. Por defecto todo es editable,
/// como en una cuenta local; el proveedor restringe lo que gestiona él.
#[derive(Clone, Debug, Getters)]
pub struct AccountPolicy {
/// Nombre visible del proveedor, para indicar «gestionado por ...».
provider_label: Lc,
/// Contraseña. Si no es editable, no se puede cambiar desde la aplicación (tampoco un
/// administrador puede restablecerla).
#[getters(copy)]
password: FieldPolicy,
/// Email.
#[getters(copy)]
email: FieldPolicy,
/// Nombre de usuario.
#[getters(copy)]
username: FieldPolicy,
/// Datos del perfil que actualiza el proveedor: se muestran deshabilitados y se ignoran al
/// guardar. El email se rige por [`email`](Self::email).
managed_fields: Vec<UserField>,
/// Roles que asigna y retira el proveedor: no se pueden poner ni quitar a mano.
managed_roles: Vec<i32>,
/// Recuperación de la contraseña por correo.
password_reset: ResetPolicy,
/// Enlace de ayuda para el usuario.
help: Option<HelpLink>,
}
#[builder_impl]
impl AccountPolicy {
/// Política con todo editable, como una cuenta local, del proveedor indicado.
pub fn new(provider_label: Lc) -> Self {
AccountPolicy {
provider_label,
password: FieldPolicy::Editable,
email: FieldPolicy::Editable,
username: FieldPolicy::Editable,
managed_fields: Vec::new(),
managed_roles: Vec::new(),
password_reset: ResetPolicy::Allowed,
help: None,
}
}
/// Política de la contraseña.
pub fn with_password(mut self, policy: FieldPolicy) -> Self {
self.password = policy;
self
}
/// Política del email.
pub fn with_email(mut self, policy: FieldPolicy) -> Self {
self.email = policy;
self
}
/// Política del nombre de usuario.
pub fn with_username(mut self, policy: FieldPolicy) -> Self {
self.username = policy;
self
}
/// Datos del perfil que gestiona el proveedor.
pub fn with_managed_fields(mut self, fields: Vec<UserField>) -> Self {
self.managed_fields = fields;
self
}
/// Roles que gestiona el proveedor.
pub fn with_managed_roles(mut self, role_ids: Vec<i32>) -> Self {
self.managed_roles = role_ids;
self
}
/// Recuperación de la contraseña por correo.
pub fn with_password_reset(mut self, policy: ResetPolicy) -> Self {
self.password_reset = policy;
self
}
/// Enlace de ayuda para el usuario.
pub fn with_help(mut self, help: Option<HelpLink>) -> Self {
self.help = help;
self
}
/// Si el proveedor gestiona ese dato del perfil.
pub fn manages(&self, field: UserField) -> bool {
self.managed_fields.contains(&field)
}
}
// **< LoginHints >*********************************************************************************
/// Enlace «¿Olvidaste tu contraseña?» del formulario de inicio de sesión.
///
/// Usado en [`LoginHints`].
#[derive(AutoDefault, Clone, Debug)]
pub enum ResetLink {
/// La recuperación por correo de `pagetop-user`.
#[default]
Local,
/// Una página de ayuda externa.
External(HelpLink),
/// Sin enlace.
Hidden,
}
/// Lo que un proveedor quiere mostrar en el formulario de inicio de sesión.
///
/// Lo devuelve [`AuthProvider::login_hints()`](super::AuthProvider::login_hints).
#[derive(AutoDefault, Clone, Debug, Getters)]
pub struct LoginHints {
/// Texto breve bajo el formulario (p. ej. «Usa tu usuario y contraseña de la red»).
note: Lc,
/// Enlace para recuperar la contraseña. Sólo se tiene en cuenta si `"local"` no está en
/// [`sources`](crate::config::LoginSettings::sources): si lo está, se ofrece siempre la
/// recuperación de `pagetop-user`.
reset: ResetLink,
}
#[builder_impl]
impl LoginHints {
/// Texto breve bajo el formulario. `Lc::none()` lo quita.
pub fn with_note(mut self, note: Lc) -> Self {
self.note = note;
self
}
/// Enlace para recuperar la contraseña.
pub fn with_reset(mut self, reset: ResetLink) -> Self {
self.reset = reset;
self
}
}
#[cfg(test)]
mod tests {
use super::*;
#[pagetop::test]
async fn help_links_only_accept_http_urls() {
assert!(HelpLink::new("https://help.example/pwd", Lc::none()).is_some());
assert!(HelpLink::new("HTTP://help.example", Lc::none()).is_some());
assert!(HelpLink::new("javascript:alert(1)", Lc::none()).is_none());
assert!(HelpLink::new("https://", Lc::none()).is_none());
assert!(HelpLink::new("http://", Lc::none()).is_none());
assert!(HelpLink::new("http://a", Lc::none()).is_some());
assert!(HelpLink::new("https://a b", Lc::none()).is_none());
assert!(HelpLink::new("//help.example", Lc::none()).is_none());
}
}

View file

@ -185,8 +185,12 @@ pub(crate) async fn user_roles(user_id: i32) -> Result<Vec<role::Model>, AuthErr
pub(crate) struct NewUserData<'a> {
pub username: &'a str,
pub email: &'a str,
pub password: &'a str,
pub confirm_password: &'a str,
/// Contraseña y su confirmación. Sin ellas, la cuenta no tiene contraseña local: la de una
/// cuenta que entrará con un proveedor de autenticación.
pub password: Option<(&'a str, &'a str)>,
/// Proveedor de autenticación que podrá vincular la cuenta cuando la persona inicie sesión
/// con este nombre de usuario (ver `provider::allow_linking()`). Nunca con `is_admin`.
pub link_provider: Option<&'a str>,
pub display_name: Option<&'a str>,
pub language: Option<&'a str>,
pub timezone: Option<&'a str>,
@ -200,13 +204,19 @@ pub(crate) struct NewUserData<'a> {
/// activo y con el email verificado de inmediato (lo crea un administrador de confianza), y admite
/// asignar roles iniciales (los de sistema se descartan, ver [`set_user_roles`]).
///
/// El usuario y sus roles se crean en una sola transacción: si falla cualquier inserción (p. ej.
/// porque se ha eliminado uno de los roles mientras tanto), no se crea nada.
/// El usuario, sus roles y, con `link_provider`, la marca de vinculación se crean en una sola
/// transacción: si falla cualquier inserción (p. ej. porque se ha eliminado uno de los roles
/// mientras tanto), no se crea nada.
pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError> {
if data.link_provider.is_some() && data.is_admin {
return Err(AuthError::ProtectedAccount);
}
let username = identity::username(data.username, SETTINGS.identity_policy, None)?;
let email = identity::email(data.email)?;
password::validate_strength(data.password)?;
password::passwords_match(data.password, data.confirm_password)?;
if let Some((plain, confirm)) = data.password {
password::validate_strength(plain)?;
password::passwords_match(plain, confirm)?;
}
// El idioma y la zona horaria que no se aplican no se ofrecen en el formulario: se ignora lo
// que pudiera llegar y el usuario se crea sin ellos.
let language = if user_language_applies() {
@ -224,7 +234,10 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError>
ensure_username_available(&username, None).await?;
ensure_email_available(&email, None).await?;
let hash = password::hash_password_async(data.password).await?;
let hash = match data.password {
Some((plain, _)) => password::hash_password_async(plain).await?,
None => password::UNUSABLE_HASH.to_owned(),
};
let now = Utc::now();
let mut new_user = user::ActiveModel {
@ -249,6 +262,9 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError>
username.set_on(&mut new_user);
email.set_on(&mut new_user);
let role_ids = assignable_roles(data.initial_role_ids);
let link = data
.link_provider
.map(|provider| (provider.to_owned(), username.value().to_owned()));
let result = dbconn()
.transaction::<_, _, AuthError>(|txn| {
@ -258,6 +274,12 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError>
.await?
.last_insert_id;
insert_user_roles(txn, user_id, role_ids).await?;
if let Some((provider, expected)) = link {
let identity = crate::provider::pending_identity(user_id, &provider, &expected);
crate::entity::user_identity::Entity::insert(identity)
.exec(txn)
.await?;
}
Ok(user_id)
})
})
@ -278,8 +300,18 @@ pub(crate) const ABOUT_MAX_CHARS: u16 = 2000;
/// Longitud máxima, en caracteres, del nombre visible, la de su columna.
pub(crate) const DISPLAY_NAME_MAX_CHARS: u16 = 128;
// Comprueba que el texto "Sobre mí", con los saltos de línea ya normalizados, no supere su longitud
// máxima.
pub(crate) fn validate_about(about: Option<&str>) -> Result<(), AuthError> {
let max = usize::from(ABOUT_MAX_CHARS);
if about.is_some_and(|about| about.chars().count() > max) {
return Err(AuthError::AboutTooLong(max));
}
Ok(())
}
// Comprueba que el nombre visible no supere la longitud de su columna.
fn validate_display_name(display_name: Option<&str>) -> Result<(), AuthError> {
pub(crate) fn validate_display_name(display_name: Option<&str>) -> Result<(), AuthError> {
let max = usize::from(DISPLAY_NAME_MAX_CHARS);
if display_name.is_some_and(|name| name.chars().count() > max) {
return Err(AuthError::DisplayNameTooLong(max));
@ -339,13 +371,7 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
// contarlos como un único carácter: se normalizan antes de medir para no rechazar un texto que
// el formulario sí admitió.
let about = data.about.map(|about| about.replace("\r\n", "\n"));
let max_about = usize::from(ABOUT_MAX_CHARS);
if about
.as_deref()
.is_some_and(|about| about.chars().count() > max_about)
{
return Err(AuthError::AboutTooLong(max_about));
}
validate_about(about.as_deref())?;
ensure_username_available(&username, Some(user_id)).await?;
ensure_email_available(&email, Some(user_id)).await?;
@ -378,14 +404,32 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
// **< set_user_roles >*****************************************************************************
/// Reemplaza por completo el conjunto de roles asignados a un usuario.
/// Reemplaza por completo el conjunto de roles asignados a un usuario, salvo los de `managed`.
///
/// Los roles de sistema nunca se almacenan, por lo que se descartan si llegan en `role_ids`:
/// "authenticated" es implícito para toda cuenta autenticada y "anonymous" sólo se aplica a las
/// peticiones sin sesión.
pub(crate) async fn set_user_roles(user_id: i32, role_ids: &[i32]) -> Result<(), AuthError> {
/// peticiones sin sesión. Los de `managed` los asigna y retira el proveedor que gestiona la cuenta
/// (ver `AccountPolicy::managed_roles()`): se conservan tal como estén, llegue lo que llegue.
pub(crate) async fn set_user_roles(
user_id: i32,
role_ids: &[i32],
managed: &[i32],
) -> Result<(), AuthError> {
find_user(user_id).await?;
let role_ids = assignable_roles(role_ids);
let mut role_ids: Vec<i32> = role_ids
.iter()
.copied()
.filter(|id| !managed.contains(id))
.collect();
if !managed.is_empty() {
role_ids.extend(
user_role_ids(user_id)
.await?
.into_iter()
.filter(|id| managed.contains(id)),
);
}
let role_ids = assignable_roles(&role_ids);
dbconn()
.transaction::<_, _, AuthError>(|txn| {
@ -441,7 +485,7 @@ pub(crate) async fn set_user_status(
new_status: UserStatus,
acting_user_id: i32,
) -> Result<(), AuthError> {
find_user(user_id).await?;
let before = UserStatus::from_i16(find_user(user_id).await?.status);
if new_status == UserStatus::Blocked {
if user_id == acting_user_id {
@ -467,6 +511,9 @@ pub(crate) async fn set_user_status(
.await
.map_err(AuthError::Database)?;
}
if before != new_status {
crate::actions::AfterUserStatusChanged::dispatch(user_id, before, new_status);
}
Ok(())
}
@ -481,6 +528,10 @@ pub(crate) async fn set_user_status(
/// "último administrador": para llegar aquí quien actúa ya tiene que ser administrador, así que si
/// sólo queda uno, sólo él podría revocarse a sí mismo, y eso ya lo bloquea la comprobación
/// anterior.
///
/// Tampoco concede el acceso total a una cuenta vinculada a un proveedor de autenticación
/// ([`AuthError::ProtectedAccount`]): quien controlara la persona en el proveedor lo tendría. Hay
/// que desvincularla antes, igual que un proveedor nunca vincula una cuenta de administrador.
pub(crate) async fn set_user_admin(
user_id: i32,
is_admin: bool,
@ -491,6 +542,9 @@ pub(crate) async fn set_user_admin(
if user_id == acting_user_id {
return Err(AuthError::CannotModifyOwnAdminFlag);
}
if is_admin && !crate::provider::linked_providers(user_id).await?.is_empty() {
return Err(AuthError::ProtectedAccount);
}
let now = Utc::now();
user::ActiveModel {
@ -538,6 +592,7 @@ pub(crate) async fn admin_reset_password(
crate::auth::cancel_email_change(user_id).await?;
// Un enlace de recuperación pedido antes no debe deshacer el cambio.
crate::token::revoke_tokens(user_id, crate::token::TokenKind::PasswordReset).await?;
crate::throttle::forget_account(&user_model.username, &user_model.email);
Ok(user_model)
}
@ -546,7 +601,7 @@ pub(crate) async fn admin_reset_password(
// Devuelve el idioma sin espacios, tal como debe guardarse. Ha de ser uno de los identificadores
// que ofrece el selector (`Locale::supported_languages()`); uno ausente o en blanco es válido y
// devuelve `None`: equivale a usar el predeterminado de la aplicación.
fn validate_language(language: Option<&str>) -> Result<Option<&str>, AuthError> {
pub(crate) fn validate_language(language: Option<&str>) -> Result<Option<&str>, AuthError> {
let language = language.and_then(util::non_blank);
if let Some(code) = language
&& !Locale::supported_languages()
@ -561,7 +616,7 @@ fn validate_language(language: Option<&str>) -> Result<Option<&str>, AuthError>
// Devuelve el nombre corto del tema tal como debe guardarse, el que declara el propio tema aunque
// llegue con otras mayúsculas. Ha de ser uno de los temas habilitados; uno ausente o en blanco es
// válido y devuelve `None`: equivale a usar el predeterminado de la aplicación.
fn validate_theme(theme: Option<&str>) -> Result<Option<&'static str>, AuthError> {
pub(crate) fn validate_theme(theme: Option<&str>) -> Result<Option<&'static str>, AuthError> {
match theme.and_then(util::non_blank) {
Some(name) => theme_by_short_name(name)
.map(|theme| Some(theme.short_name()))
@ -573,7 +628,7 @@ fn validate_theme(theme: Option<&str>) -> Result<Option<&'static str>, AuthError
// Devuelve la zona sin espacios, tal como debe guardarse. Ha de ser una de las que ofrece el
// selector (`Timezone::supported_by_region()`); una ausente o en blanco es válida y devuelve
// `None`: equivale a usar la predeterminada de la aplicación.
fn validate_timezone(timezone: Option<&str>) -> Result<Option<&str>, AuthError> {
pub(crate) fn validate_timezone(timezone: Option<&str>) -> Result<Option<&str>, AuthError> {
let timezone = timezone.and_then(util::non_blank);
if let Some(tz) = timezone
&& !Timezone::supported_by_region()

View file

@ -1,35 +1,44 @@
//! Límites de solicitudes por dirección IP: las que envían un correo o crean una cuenta
//! (`user.max_ip_requests`) y los inicios de sesión fallidos (`user.max_ip_failed_logins`).
//! (`user.max_ip_requests`) y los inicios de sesión fallidos (`user.max_ip_failed_logins`), y de
//! los inicios de sesión fallidos por identificador tecleado (`user.max_failed_logins`).
use pagetop::prelude::*;
use crate::config::SETTINGS;
use std::collections::{HashMap, VecDeque};
use std::hash::Hash;
use std::net::{IpAddr, Ipv6Addr};
use std::sync::{LazyLock, Mutex};
use std::sync::{LazyLock, Mutex, PoisonError};
use std::time::{Duration as StdDuration, Instant};
// Momentos de las solicitudes de cada dirección dentro de la ventana, y última limpieza.
struct Requests {
by_ip: HashMap<IpAddr, VecDeque<Instant>>,
// Claves distintas que se siguen como mucho en cada límite. Sin tope, quien enviara intentos con
// identificadores siempre distintos haría crecer la tabla sin medida; alcanzado, una clave nueva no
// se anota (los límites por dirección IP siguen aplicándose).
const MAX_TRACKED_KEYS: usize = 100_000;
// Momentos de las solicitudes de cada clave dentro de la ventana, y última limpieza.
struct Requests<K> {
by_key: HashMap<K, VecDeque<Instant>>,
purged_at: Instant,
}
// Cada límite lleva su propia cuenta.
type Log = LazyLock<Mutex<Requests>>;
type Log<K> = LazyLock<Mutex<Requests<K>>>;
const fn new_log() -> Log {
const fn new_log<K>() -> Log<K> {
LazyLock::new(|| {
Mutex::new(Requests {
by_ip: HashMap::new(),
by_key: HashMap::new(),
purged_at: Instant::now(),
})
})
}
static REQUESTS: Log = new_log();
static FAILED_LOGINS: Log = new_log();
static REQUESTS: Log<IpAddr> = new_log();
static FAILED_LOGINS: Log<IpAddr> = new_log();
static FAILED_IDENTIFIERS: Log<String> = new_log();
static FAILED_ANYWHERE: Log<()> = new_log();
/// Anota una solicitud de la dirección del cliente y devuelve si se admite, según
/// [`max_ip_requests`](crate::config::UserSettings::max_ip_requests).
@ -41,7 +50,7 @@ pub(crate) fn allow(request: &HttpRequest) -> bool {
return true;
};
let allowed = allow_at(
&mut REQUESTS.lock().unwrap(),
&mut lock(&REQUESTS),
network(ip),
Instant::now(),
SETTINGS.max_ip_requests,
@ -53,33 +62,112 @@ pub(crate) fn allow(request: &HttpRequest) -> bool {
allowed
}
/// Anota un intento de inicio de sesión de la dirección del cliente y devuelve si se admite, según
/// [`max_ip_failed_logins`](crate::config::UserSettings::max_ip_failed_logins).
///
/// El intento se anota antes de comprobar la contraseña, para que varios intentos simultáneos no
/// puedan superar el límite; si no resulta fallido, se retira con [`forget_login()`].
pub(crate) fn allow_login(request: &HttpRequest) -> bool {
let Some(ip) = request.client_ip() else {
return true;
};
let allowed = allow_at(
&mut FAILED_LOGINS.lock().unwrap(),
network(ip),
Instant::now(),
SETTINGS.max_ip_failed_logins,
window(SETTINGS.ip_failed_login_window_secs),
);
if !allowed {
trace::warn!("Failed login limit reached for address {ip}");
}
allowed
// Límites que se aplican a un intento de inicio de sesión: por dirección IP (o, sin dirección
// conocida y con un proveedor de autenticación activo, el global) y por identificador tecleado.
pub(crate) struct LoginKeys {
ip: Option<IpAddr>,
anywhere: bool,
identifier: String,
}
/// Retira un intento anotado por [`allow_login()`] que no ha resultado fallido.
pub(crate) fn forget_login(request: &HttpRequest) {
if let Some(ip) = request.client_ip() {
forget_at(&mut FAILED_LOGINS.lock().unwrap(), network(ip));
impl LoginKeys {
pub(crate) fn new(request: &HttpRequest, identifier: &str) -> Self {
let ip = request.client_ip().map(network);
LoginKeys {
ip,
// Sin dirección conocida no hay límite por IP. Con sólo cuentas locales queda el
// bloqueo de cada cuenta; con un proveedor, cada intento llega además a un servicio
// externo (p. ej. el directorio, que bloquearía la cuenta), así que se limita en
// conjunto.
anywhere: ip.is_none() && crate::provider::active_providers().next().is_some(),
identifier: crate::identity::login_key(identifier),
}
}
}
/// Anota un intento de inicio de sesión y devuelve si se admite: según
/// [`max_ip_failed_logins`](crate::config::UserSettings::max_ip_failed_logins) para la dirección
/// del cliente y según [`max_failed_logins`](crate::config::UserSettings::max_failed_logins) para
/// el identificador tecleado, exista o no la cuenta.
///
/// El intento se anota antes de comprobar la contraseña, para que varios intentos simultáneos no
/// puedan superar el límite; si resulta correcto, se retira con [`forget_login()`]. Rechazado, no
/// se anota en ningún límite.
pub(crate) fn allow_login(keys: &LoginKeys) -> bool {
let now = Instant::now();
let ip_window = window(SETTINGS.ip_failed_login_window_secs);
let ip_allowed = match keys.ip {
Some(ip) => allow_at(
&mut lock(&FAILED_LOGINS),
ip,
now,
SETTINGS.max_ip_failed_logins,
ip_window,
),
None if keys.anywhere => allow_at(
&mut lock(&FAILED_ANYWHERE),
(),
now,
SETTINGS.max_ip_failed_logins,
ip_window,
),
None => true,
};
if !ip_allowed {
match keys.ip {
Some(ip) => trace::warn!("Failed login limit reached for address {ip}"),
None => trace::warn!("Failed login limit reached for requests of unknown address"),
}
return false;
}
let max = u32::try_from(SETTINGS.max_failed_logins).unwrap_or(0);
let identifier_allowed = allow_at(
&mut lock(&FAILED_IDENTIFIERS),
keys.identifier.clone(),
now,
max,
window(SETTINGS.failed_login_window_secs),
);
if !identifier_allowed {
trace::warn!("Failed login limit reached for an identifier");
forget_ip(keys);
}
identifier_allowed
}
/// Retira un intento anotado por [`allow_login()`] con la contraseña correcta. Como un acceso
/// correcto pone a cero el recuento de fallos de la cuenta, también borra el del identificador.
pub(crate) fn forget_login(keys: &LoginKeys) {
forget_ip(keys);
lock(&FAILED_IDENTIFIERS).by_key.remove(&keys.identifier);
}
/// Retira el intento anotado por [`allow_login()`] para el identificador, pero no el de la
/// dirección IP. Para un intento que no se ha podido comprobar (un proveedor que no responde).
pub(crate) fn forget_identifier(keys: &LoginKeys) {
forget_at(&mut lock(&FAILED_IDENTIFIERS), &keys.identifier);
}
/// Borra los fallos anotados para el nombre de usuario y el email de una cuenta. Se llama al
/// restablecer su contraseña, que también levanta el bloqueo de la cuenta.
pub(crate) fn forget_account(username: &str, email: &str) {
let mut failed = lock(&FAILED_IDENTIFIERS);
failed.by_key.remove(&crate::identity::login_key(username));
failed.by_key.remove(&crate::identity::login_key(email));
}
fn forget_ip(keys: &LoginKeys) {
match keys.ip {
Some(ip) => forget_at(&mut lock(&FAILED_LOGINS), &ip),
None if keys.anywhere => forget_at(&mut lock(&FAILED_ANYWHERE), &()),
None => {}
}
}
// Una tabla envenenada sigue siendo válida: cada operación la deja consistente antes de cualquier
// punto en que pudiera fallar.
fn lock<K>(log: &'static Log<K>) -> std::sync::MutexGuard<'static, Requests<K>> {
log.lock().unwrap_or_else(PoisonError::into_inner)
}
fn window(secs: i64) -> StdDuration {
@ -87,9 +175,9 @@ fn window(secs: i64) -> StdDuration {
}
// Anota la solicitud si se admite.
fn allow_at(
requests: &mut Requests,
ip: IpAddr,
fn allow_at<K: Eq + Hash>(
requests: &mut Requests<K>,
key: K,
now: Instant,
max: u32,
window: StdDuration,
@ -98,15 +186,19 @@ fn allow_at(
return true;
}
let expired = |at: &Instant| now.duration_since(*at) >= window;
// Sin limpiar, la tabla guardaría todas las direcciones vistas desde el arranque. Basta con
// hacerlo una vez por ventana: sólo quedan las direcciones con solicitudes recientes.
if now.duration_since(requests.purged_at) >= window {
// Sin limpiar, la tabla guardaría todas las claves vistas desde el arranque. Basta con hacerlo
// una vez por ventana (o al llenarse): sólo quedan las claves con solicitudes recientes.
let full = requests.by_key.len() >= MAX_TRACKED_KEYS;
if full || now.duration_since(requests.purged_at) >= window {
requests
.by_ip
.by_key
.retain(|_, times| times.back().is_some_and(|at| !expired(at)));
requests.purged_at = now;
}
let times = requests.by_ip.entry(ip).or_default();
if requests.by_key.len() >= MAX_TRACKED_KEYS && !requests.by_key.contains_key(&key) {
return true;
}
let times = requests.by_key.entry(key).or_default();
while times.front().is_some_and(expired) {
times.pop_front();
}
@ -117,9 +209,9 @@ fn allow_at(
true
}
// Retira la solicitud más reciente de la dirección. Todas cuentan igual, así que da lo mismo cuál.
fn forget_at(requests: &mut Requests, ip: IpAddr) {
if let Some(times) = requests.by_ip.get_mut(&ip) {
// Retira la solicitud más reciente de la clave. Todas cuentan igual, así que da lo mismo cuál.
fn forget_at<K: Eq + Hash>(requests: &mut Requests<K>, key: &K) {
if let Some(times) = requests.by_key.get_mut(key) {
times.pop_back();
}
}
@ -143,9 +235,9 @@ mod tests {
const WINDOW: StdDuration = StdDuration::from_secs(60);
fn requests(start: Instant) -> Requests {
fn requests(start: Instant) -> Requests<IpAddr> {
Requests {
by_ip: HashMap::new(),
by_key: HashMap::new(),
purged_at: start,
}
}
@ -174,11 +266,11 @@ mod tests {
let start = Instant::now();
let mut log = requests(start);
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
forget_at(&mut log, ip("192.0.2.1"));
forget_at(&mut log, &ip("192.0.2.1"));
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
assert!(!allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
// Unknown addresses are ignored.
forget_at(&mut log, ip("192.0.2.2"));
forget_at(&mut log, &ip("192.0.2.2"));
}
#[pagetop::test]
@ -188,7 +280,7 @@ mod tests {
for _ in 0..10 {
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 0, WINDOW));
}
assert!(log.by_ip.is_empty());
assert!(log.by_key.is_empty());
}
#[pagetop::test]
@ -197,8 +289,8 @@ mod tests {
let mut log = requests(start);
allow_at(&mut log, ip("192.0.2.1"), start, 5, WINDOW);
allow_at(&mut log, ip("192.0.2.2"), start + WINDOW, 5, WINDOW);
assert_eq!(log.by_ip.len(), 1);
assert!(log.by_ip.contains_key(&ip("192.0.2.2")));
assert_eq!(log.by_key.len(), 1);
assert!(log.by_key.contains_key(&ip("192.0.2.2")));
}
#[pagetop::test]
@ -206,4 +298,18 @@ mod tests {
assert_eq!(network(ip("2001:db8:1:2:aaaa::1")), ip("2001:db8:1:2::"));
assert_eq!(network(ip("192.0.2.1")), ip("192.0.2.1"));
}
#[pagetop::test]
async fn keys_of_any_type_are_limited_and_forgotten() {
let start = Instant::now();
let mut log: Requests<String> = Requests {
by_key: HashMap::new(),
purged_at: start,
};
assert!(allow_at(&mut log, "ana".to_owned(), start, 1, WINDOW));
assert!(!allow_at(&mut log, "ana".to_owned(), start, 1, WINDOW));
assert!(allow_at(&mut log, "bea".to_owned(), start, 1, WINDOW));
forget_at(&mut log, &"ana".to_owned());
assert!(allow_at(&mut log, "ana".to_owned(), start, 1, WINDOW));
}
}

View file

@ -0,0 +1,713 @@
// Login flows with an authentication provider, against a real database. `CONFIG_DIR` points to
// `tests/providers/`, whose `common.toml` sets `[user.login] sources = ["fake", "local"]`: a fake
// directory provider checked before the local passwords.
//
// Every scenario shares the same database, so they run one after another in a single test, as in
// `tests/flows.rs`.
use pagetop::prelude::*;
use pagetop_mail::outbox::{self, SentEmail};
use pagetop_seaorm::db::sea_orm::Statement;
use pagetop_seaorm::db::{ConnectionTrait, DbBackend, dbconn};
use pagetop_user::actions::{AdminUserFormExtras, AfterSessionResolved, AfterUserStatusChanged};
use pagetop_user::error::AuthError;
use pagetop_user::provider::*;
use pagetop_user::{Account, UserStatus};
use std::sync::atomic::{AtomicBool, AtomicI32, AtomicUsize, Ordering};
use std::sync::{Mutex, OnceLock};
// **< The fake provider >**************************************************************************
// People in the fake directory: username, email and password.
const PEOPLE: &[(&str, &str, &str)] = &[
("dora", "dora@example.com", "dora-dir"),
("eva", "eva@example.com", "eva-dir"),
("rejected", "rejected@example.com", "rejected-dir"),
("admin", "admin@example.com", "admin-dir"),
];
static HANDLE: OnceLock<ProviderHandle> = OnceLock::new();
// Calls to `authenticate()`, to check what never reaches the provider.
static CALLS: AtomicUsize = AtomicUsize::new(0);
// Simulates a provider that does not answer.
static DOWN: AtomicBool = AtomicBool::new(false);
// Role managed by the provider (0 = none yet).
static STAFF: AtomicI32 = AtomicI32::new(0);
// Status changes announced by `AfterUserStatusChanged`.
static STATUS_CHANGES: Mutex<Vec<(i32, UserStatus, UserStatus)>> = Mutex::new(Vec::new());
fn person(identifier: &str) -> Option<&'static (&'static str, &'static str, &'static str)> {
let identifier = identifier.to_lowercase();
PEOPLE
.iter()
.find(|(username, email, _)| *username == identifier || *email == identifier)
}
fn handle() -> &'static ProviderHandle {
HANDLE.get().expect("the fake provider is attached")
}
struct Fake;
#[async_trait]
impl AuthProvider for Fake {
fn id(&self) -> &'static str {
"fake"
}
fn label(&self) -> Lc {
Lc::n("Fake directory")
}
fn attach(&self, handle: ProviderHandle) {
assert!(HANDLE.set(handle).is_ok(), "attached only once");
}
async fn releases(&self, user: &UserRef) -> bool {
user.username() == "released"
}
async fn authenticate(&self, attempt: &LoginAttempt<'_>) -> ProviderOutcome {
CALLS.fetch_add(1, Ordering::SeqCst);
if DOWN.load(Ordering::SeqCst) {
return ProviderOutcome::Unavailable;
}
let Some((username, email, password)) = person(attempt.identifier()) else {
return ProviderOutcome::NotFound;
};
let key = format!("fake:{username}");
let Ok(linked) = handle().find_user(&key).await else {
return ProviderOutcome::Unavailable;
};
if attempt.password().expose() != *password {
return ProviderOutcome::InvalidCredentials {
user_id: linked.map(|user| user.id()),
};
}
if *username == "rejected" {
return ProviderOutcome::Rejected(RejectReason::Disallowed);
}
let user_id = match linked {
Some(user) => user.id(),
None => {
let pending = handle().find_pending(username).await.unwrap_or_default();
if let [user] = pending.as_slice() {
if handle()
.link_identity(user.id(), &[username], username, &key)
.await
.is_err()
{
return ProviderOutcome::Rejected(RejectReason::Conflict);
}
user.id()
} else if attempt.local().is_some() {
return ProviderOutcome::Rejected(RejectReason::Conflict);
} else {
let data = ExternalUserData::new(*username, *email).with_email_verified(true);
match handle().create_user(username, &key, data).await {
Ok(user_id) => user_id,
Err(_) => return ProviderOutcome::Rejected(RejectReason::Conflict),
}
}
}
};
let staff = STAFF.load(Ordering::SeqCst);
if staff > 0 {
handle().grant_roles(user_id, &[staff]).await.unwrap();
}
ProviderOutcome::Authenticated { user_id }
}
async fn reauthenticate(&self, user: &UserRef, password: &util::SecretStr) -> ReauthOutcome {
match person(user.username()) {
Some((_, _, expected)) if password.expose() == *expected => ReauthOutcome::Valid,
_ => ReauthOutcome::Invalid,
}
}
async fn account_policy(&self, _user: &UserRef) -> Option<AccountPolicy> {
let staff = STAFF.load(Ordering::SeqCst);
Some(
AccountPolicy::new(Lc::n("Fake directory"))
.with_password(FieldPolicy::ReadOnly)
.with_email(FieldPolicy::ReadOnly)
.with_managed_fields(vec![UserField::DisplayName])
.with_managed_roles(if staff > 0 { vec![staff] } else { vec![] })
.with_password_reset(ResetPolicy::Forbidden {
help: HelpLink::new("https://help.example.com/password", Lc::none()),
}),
)
}
fn allows_remember(&self) -> bool {
false
}
fn login_hints(&self) -> Option<LoginHints> {
Some(LoginHints::default().with_note(Lc::n("Use your network account.")))
}
}
static FAKE: Fake = Fake;
// **< The test application >***********************************************************************
fn declare_providers(providers: &mut AuthProviders) {
providers.add(&FAKE);
}
fn redirect_dora(request: &HttpRequest, account: &Account) -> Option<Response> {
(request.path() == "/user/redirect-me" && account.username() == "dora")
.then(|| Redirect::see_other("/user"))
}
fn record_status_change(user_id: i32, before: UserStatus, after: UserStatus) {
STATUS_CHANGES
.lock()
.unwrap()
.push((user_id, before, after));
}
fn fake_panel(user_id: i32) -> Option<Child> {
Some(Child::with(Html::with(move |_| {
html! { p class="fake-panel" { "Fake panel of " (user_id) } }
})))
}
struct TestApp;
#[async_trait]
impl Extension for TestApp {
fn dependencies(&self) -> Vec<ExtensionRef> {
vec![&pagetop_user::User]
}
fn actions(&self) -> Vec<ActionBox> {
actions![
DeclareAuthProviders::new(declare_providers),
AfterSessionResolved::new(redirect_dora),
AfterUserStatusChanged::new(record_status_change),
AdminUserFormExtras::new(fake_panel),
]
}
}
// **< Client >*************************************************************************************
type Status = web::http::StatusCode;
struct Reply {
status: Status,
headers: web::http::HeaderMap,
body: String,
}
impl Reply {
fn header(&self, name: &str) -> &str {
self.headers
.get(name)
.and_then(|value| value.to_str().ok())
.unwrap_or_default()
}
fn session_cookie(&self) -> Option<String> {
let pair = self.header("set-cookie").split(';').next()?;
(!pair.ends_with('=')).then(|| pair.to_owned())
}
}
struct Client {
app: Router,
}
impl Client {
async fn send(&self, request: web::test::TestRequest, session: Option<&str>) -> Reply {
let request = match session {
Some(cookie) => request.header("cookie", cookie),
None => request,
};
let response = web::test::send_request(&self.app, request.to_request()).await;
let status = response.status();
let headers = response.headers().clone();
let body = web::test::read_body_text(response).await;
Reply {
status,
headers,
body,
}
}
async fn get(&self, uri: &str, session: Option<&str>) -> Reply {
self.send(web::test::TestRequest::get().uri(uri), session)
.await
}
async fn post(&self, uri: &str, fields: &str, session: Option<&str>) -> Reply {
let request = web::test::TestRequest::post().uri(uri).form(fields);
self.send(request, session).await
}
async fn try_login(&self, username: &str, password: &str) -> Reply {
let fields = form(&[
("username", username),
("password", password),
("remember", "true"),
]);
self.post("/user/login", &fields, None).await
}
async fn login(&self, username: &str, password: &str) -> Option<String> {
let reply = self.try_login(username, password).await;
match reply.status {
Status::SEE_OTHER => Some(reply.session_cookie().expect("login sets the cookie")),
Status::OK => None,
status => panic!("unexpected login status {status}"),
}
}
}
fn form(fields: &[(&str, &str)]) -> String {
let mut body = String::new();
for (name, value) in fields {
if !body.is_empty() {
body.push('&');
}
body.push_str(name);
body.push('=');
for byte in value.bytes() {
if byte.is_ascii_alphanumeric() || b"-._~".contains(&byte) {
body.push(char::from(byte));
} else {
body.push_str(&format!("%{byte:02X}"));
}
}
}
body
}
async fn mail_to(address: &str) -> SentEmail {
for _ in 0..200 {
let mut sent = outbox::take_to(address);
if !sent.is_empty() {
assert_eq!(sent.len(), 1, "expected exactly one email for {address}");
return sent.remove(0);
}
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
}
panic!("no email sent to {address}");
}
async fn query_i64(sql: &str, column: &str) -> Option<i64> {
let row = dbconn()
.query_one(Statement::from_string(DbBackend::Sqlite, sql.to_owned()))
.await
.unwrap()?;
Some(row.try_get::<i64>("", column).unwrap())
}
async fn user_id(username: &str) -> i32 {
let sql = format!("SELECT id FROM users WHERE username_key = '{username}'");
i32::try_from(query_i64(&sql, "id").await.expect("user exists")).unwrap()
}
async fn failed_logins(username: &str) -> i64 {
let sql = format!("SELECT failed_login_count FROM users WHERE username_key = '{username}'");
query_i64(&sql, "failed_login_count").await.unwrap()
}
// **< Scenarios >**********************************************************************************
#[pagetop::test]
async fn provider_flows() {
// SAFETY: the only test of this binary sets it before reading any setting.
unsafe {
std::env::set_var(
"CONFIG_DIR",
concat!(env!("CARGO_MANIFEST_DIR"), "/tests/providers"),
);
}
let client = Client {
app: Application::prepare(&TestApp).await.test(),
};
let admin = client.login("admin", "admin-password").await.unwrap();
directory_people_get_a_linked_account(&client).await;
rejections_are_only_revealed_with_the_right_password(&client).await;
existing_local_accounts_are_never_taken_over(&client, &admin).await;
an_unavailable_provider_answers_the_same_with_or_without_account(&client).await;
failed_identifiers_stop_reaching_the_provider(&client).await;
oversized_or_invalid_input_never_reaches_the_provider(&client).await;
pages_follow_the_account_policy(&client).await;
password_resets_send_a_notice_instead_of_a_link(&client).await;
the_handle_only_acts_on_its_own_accounts().await;
managed_roles_survive_the_administration_form(&client, &admin).await;
actions_reach_other_extensions(&client, &admin).await;
unlinking_closes_the_sessions(&client).await;
}
async fn directory_people_get_a_linked_account(client: &Client) {
let reply = client.try_login("dora", "dora-dir").await;
assert_eq!(reply.status, Status::SEE_OTHER);
// "Remember me" was asked for, but the provider does not allow it: a browser session cookie.
assert!(!reply.header("set-cookie").contains("Max-Age"));
let session = reply.session_cookie().unwrap();
assert_eq!(client.get("/user", Some(&session)).await.status, Status::OK);
// A wrong password counts once on the account, not once per source.
assert_eq!(client.login("dora", "wrong").await, None);
assert_eq!(failed_logins("dora").await, 1);
// The right one resets the count.
assert!(client.login("dora@example.com", "dora-dir").await.is_some());
assert_eq!(failed_logins("dora").await, 0);
// The login form shows the provider's note.
let page = client.get("/user/login", None).await;
assert!(page.body.contains("Use your network account."));
// "local" allows "remember me", so the box is still offered.
assert!(page.body.contains("name=\"remember\""));
}
async fn rejections_are_only_revealed_with_the_right_password(client: &Client) {
let wrong = client.try_login("rejected", "wrong").await;
assert!(wrong.body.contains("Invalid username or password"));
let right = client.try_login("rejected", "rejected-dir").await;
assert!(
right
.body
.contains("Your account has no access to this application.")
);
}
async fn existing_local_accounts_are_never_taken_over(client: &Client, admin: &str) {
// The local administrator is also in the directory: the directory password does not get in.
let reply = client.try_login("admin", "admin-dir").await;
assert!(reply.body.contains("You cannot sign in with this account."));
assert!(client.login("admin", "admin-password").await.is_some());
// A local account with a name in the directory.
let fields = form(&[
("username", "eva"),
("email", "eva@example.com"),
("password", "eva-local"),
("confirm_password", "eva-local"),
]);
let reply = client
.post("/admin/user/users/new", &fields, Some(admin))
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
let eva = user_id("eva").await;
let local = client.login("eva", "eva-local").await.unwrap();
let reply = client.try_login("eva", "eva-dir").await;
assert!(reply.body.contains("You cannot sign in with this account."));
// Once an administrator allows it, the directory links it: the local password and every open
// session stop working.
let link = format!("/admin/user/users/{eva}/identity");
let reply = client
.post(&link, "provider=fake&op=allow", Some(admin))
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
assert!(client.login("eva", "eva-dir").await.is_some());
assert_eq!(client.login("eva", "eva-local").await, None);
assert_eq!(
client.get("/user", Some(&local)).await.status,
Status::SEE_OTHER
);
// Never for an administrator.
let admin_id = user_id("admin").await;
let link = format!("/admin/user/users/{admin_id}/identity");
let reply = client
.post(&link, "provider=fake&op=allow", Some(admin))
.await;
assert!(
reply
.body
.contains("An administrator account cannot be linked")
);
}
async fn an_unavailable_provider_answers_the_same_with_or_without_account(client: &Client) {
DOWN.store(true, Ordering::SeqCst);
let unavailable = "Your password cannot be checked right now.";
assert!(
client
.try_login("nobody", "x")
.await
.body
.contains(unavailable)
);
assert!(
client
.try_login("admin", "wrong")
.await
.body
.contains(unavailable)
);
// Local accounts still get in with "local" in the sources.
assert!(client.login("admin", "admin-password").await.is_some());
// Attempts that could not be checked lock nobody out: neither the account nor its identifier.
for _ in 0..4 {
assert!(
client
.try_login("dora", "dora-dir")
.await
.body
.contains(unavailable)
);
}
assert_eq!(failed_logins("dora").await, 0);
DOWN.store(false, Ordering::SeqCst);
assert!(client.login("dora", "dora-dir").await.is_some());
}
async fn failed_identifiers_stop_reaching_the_provider(client: &Client) {
let before = CALLS.load(Ordering::SeqCst);
for _ in 0..3 {
assert_eq!(client.login("mallory", "guess").await, None);
}
let reply = client.try_login("mallory", "guess").await;
assert!(reply.body.contains("Too many requests"));
assert_eq!(CALLS.load(Ordering::SeqCst), before + 3);
}
async fn oversized_or_invalid_input_never_reaches_the_provider(client: &Client) {
let before = CALLS.load(Ordering::SeqCst);
assert_eq!(client.login("dora\u{7}", "dora-dir").await, None);
assert_eq!(client.login(&"d".repeat(256), "dora-dir").await, None);
assert_eq!(client.login("dora", &"p".repeat(1025)).await, None);
assert_eq!(CALLS.load(Ordering::SeqCst), before);
}
async fn pages_follow_the_account_policy(client: &Client) {
let dora = client.login("dora", "dora-dir").await.unwrap();
let managed = "Your account is managed by Fake directory";
let profile = client.get("/user", Some(&dora)).await;
assert!(profile.body.contains(managed));
assert!(!profile.body.contains("href=\"/user/password\""));
assert!(!profile.body.contains("href=\"/user/email\""));
for path in ["/user/password", "/user/email"] {
let page = client.get(path, Some(&dora)).await;
assert!(page.body.contains(managed), "GET {path}");
assert!(!page.body.contains("current_password"), "GET {path}");
}
let fields = form(&[
("current_password", "dora-dir"),
("password", "local-password"),
("confirm_password", "local-password"),
]);
let page = client.post("/user/password", &fields, Some(&dora)).await;
assert!(page.body.contains(managed));
assert_eq!(client.login("dora", "local-password").await, None);
}
async fn password_resets_send_a_notice_instead_of_a_link(client: &Client) {
let reply = client
.post("/user/password/reset", "email=dora%40example.com", None)
.await;
assert_eq!(reply.status, Status::OK);
let notice = mail_to("dora@example.com").await;
let links = notice.links();
assert!(
links
.iter()
.any(|link| link == "https://help.example.com/password")
);
assert!(
!links
.iter()
.any(|link| link.contains("/user/password/reset/"))
);
}
async fn the_handle_only_acts_on_its_own_accounts() {
let admin = user_id("admin").await;
let update = ExternalUserUpdate::new().with_display_name(Some("Mallory".into()));
assert!(matches!(
handle().update_user(admin, update).await,
Err(AuthError::NotOwnedByProvider)
));
assert!(matches!(
handle().set_status(admin, UserStatus::Blocked).await,
Err(AuthError::NotOwnedByProvider)
));
assert!(matches!(
handle().grant_roles(admin, &[3]).await,
Err(AuthError::NotOwnedByProvider)
));
assert!(matches!(
handle().destroy_sessions(admin).await,
Err(AuthError::NotOwnedByProvider)
));
assert!(matches!(
handle()
.link_identity(admin, &["admin"], "admin", "fake:admin")
.await,
Err(AuthError::NotPendingIdentity)
));
// Even with a pending identity planted in the database, an administrator is never linked.
dbconn()
.execute_unprepared(&format!(
"INSERT INTO user_identities (user_id, provider, pending, expected_key, created_at) \
VALUES ({admin}, 'fake', true, 'admin', CURRENT_TIMESTAMP)"
))
.await
.unwrap();
assert!(matches!(
handle()
.link_identity(admin, &["admin"], "admin", "fake:admin")
.await,
Err(AuthError::ProtectedAccount)
));
dbconn()
.execute_unprepared("DELETE FROM user_identities WHERE expected_key = 'admin'")
.await
.unwrap();
}
async fn managed_roles_survive_the_administration_form(client: &Client, admin: &str) {
let fields = form(&[("machine_name", "staff"), ("label", "Staff")]);
let reply = client
.post("/admin/user/roles/new", &fields, Some(admin))
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
let staff = query_i64("SELECT id FROM roles WHERE machine_name = 'staff'", "id")
.await
.unwrap();
STAFF.store(i32::try_from(staff).unwrap(), Ordering::SeqCst);
assert!(client.login("dora", "dora-dir").await.is_some());
let dora = user_id("dora").await;
let has_staff = format!(
"SELECT COUNT(*) AS n FROM user_roles WHERE user_id = {dora} AND role_id = {staff}"
);
assert_eq!(query_i64(&has_staff, "n").await, Some(1));
// The form shows it as managed, and saving it without the role keeps it.
let edit = format!("/admin/user/users/{dora}/edit");
let page = client.get(&edit, Some(admin)).await;
assert!(page.body.contains("Staff (managed by Fake directory)"));
let fields = form(&[
("username", "dora"),
("email", "dora@example.com"),
("display_name", "Changed by hand"),
]);
let reply = client.post(&edit, &fields, Some(admin)).await;
assert_eq!(reply.status, Status::SEE_OTHER);
assert_eq!(query_i64(&has_staff, "n").await, Some(1));
// The display name is managed too: the submitted one is ignored.
let changed = format!(
"SELECT COUNT(*) AS n FROM users WHERE id = {dora} AND display_name = 'Changed by hand'"
);
assert_eq!(query_i64(&changed, "n").await, Some(0));
// And the password of an external account cannot be reset by an administrator.
let page = client
.get(&format!("/admin/user/users/{dora}/password"), Some(admin))
.await;
assert!(
page.body
.contains("is managed by Fake directory and cannot be changed here")
);
// Nor can it be given unrestricted access: whoever controls the person in the provider would
// have it. The button is not offered, and a forged request is refused.
assert!(
!client
.get(&edit, Some(admin))
.await
.body
.contains("Grant administrator")
);
let reply = client
.post(
&format!("/admin/user/users/{dora}/admin"),
"is_admin=true",
Some(admin),
)
.await;
assert!(
reply
.body
.contains("An administrator account cannot be linked")
);
let is_admin = format!("SELECT is_admin AS n FROM users WHERE id = {dora}");
assert_eq!(query_i64(&is_admin, "n").await, Some(0));
// An account created for the provider gets its pending identity in the same step.
let fields = form(&[
("username", "gina"),
("email", "gina@example.com"),
("provider", "fake"),
]);
let reply = client
.post("/admin/user/users/new", &fields, Some(admin))
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
let gina = user_id("gina").await;
let pending = format!(
"SELECT COUNT(*) AS n FROM user_identities \
WHERE user_id = {gina} AND provider = 'fake' AND pending AND expected_key = 'gina'"
);
assert_eq!(query_i64(&pending, "n").await, Some(1));
// And only the person it waits for can take it, whatever the provider asks for.
assert!(matches!(
handle()
.link_identity(
gina,
&["mallory", "mallory@example.com"],
"mallory",
"fake:mallory"
)
.await,
Err(AuthError::NotPendingIdentity)
));
assert_eq!(query_i64(&pending, "n").await, Some(1));
}
async fn actions_reach_other_extensions(client: &Client, admin: &str) {
let dora = user_id("dora").await;
let session = client.login("dora", "dora-dir").await.unwrap();
let reply = client.get("/user/redirect-me", Some(&session)).await;
assert_eq!(reply.status, Status::SEE_OTHER);
assert_eq!(reply.header("location"), "/user");
// Without a session the action does not run: the request reaches the router (`/user/{id}`).
assert_ne!(
client.get("/user/redirect-me", None).await.status,
Status::SEE_OTHER
);
let page = client
.get(&format!("/admin/user/users/{dora}/view"), Some(admin))
.await;
assert!(page.body.contains(&format!("Fake panel of {dora}")));
let reply = client
.post(
&format!("/admin/user/users/{dora}/status"),
"status=blocked",
Some(admin),
)
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
assert!(STATUS_CHANGES.lock().unwrap().contains(&(
dora,
UserStatus::Active,
UserStatus::Blocked
)));
let reply = client.try_login("dora", "dora-dir").await;
assert!(reply.body.contains("Your account is blocked"));
}
async fn unlinking_closes_the_sessions(client: &Client) {
let session = client.login("eva", "eva-dir").await.unwrap();
assert_eq!(client.get("/user", Some(&session)).await.status, Status::OK);
handle()
.unlink_identity(user_id("eva").await)
.await
.unwrap();
assert_ne!(client.get("/user", Some(&session)).await.status, Status::OK);
}

View file

@ -0,0 +1,34 @@
# Configuration for `tests/providers.rs`, which points `CONFIG_DIR` here: the same as the crate's
# `config/common.toml`, plus a fake authentication provider checked before the local passwords.
[app]
language = "en-US"
# New on every run, with a single connection so that every query shares it.
[database]
db_type = "sqlite"
db_name = "user-provider-tests?mode=memory"
max_pool_size = 1
[mail]
transport = "memory"
from = "PageTop Tests <tests@example.com>"
base_url = "https://example.com/"
[user]
allow_registration = false
max_failed_logins = 3
max_ip_failed_logins = 50
[user.login]
sources = ["fake", "local"]
# Minimal Argon2id costs: the tests hash many passwords.
[user.password]
argon2_m_cost = 64
argon2_t_cost = 1
[user.seed]
admin_username = "admin"
admin_email = "admin@example.com"
admin_password = "admin-password"