✨ (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:
parent
9a78b79939
commit
5172da65d6
39 changed files with 4711 additions and 310 deletions
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
149
extensions/pagetop-user/src/actions.rs
Normal file
149
extensions/pagetop-user/src/actions.rs
Normal 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
|
||||
}
|
||||
}
|
||||
|
|
@ -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()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 ¬es {
|
||||
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();
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
39
extensions/pagetop-user/src/entity/user_identity.rs
Normal file
39
extensions/pagetop-user/src/entity/user_identity.rs
Normal 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 {}
|
||||
|
|
@ -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,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)) = ¬e 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()),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
//
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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\""));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
701
extensions/pagetop-user/src/provider.rs
Normal file
701
extensions/pagetop-user/src/provider.rs
Normal 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"]
|
||||
);
|
||||
}
|
||||
}
|
||||
1003
extensions/pagetop-user/src/provider/handle.rs
Normal file
1003
extensions/pagetop-user/src/provider/handle.rs
Normal file
File diff suppressed because it is too large
Load diff
260
extensions/pagetop-user/src/provider/policy.rs
Normal file
260
extensions/pagetop-user/src/provider/policy.rs
Normal 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());
|
||||
}
|
||||
}
|
||||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
713
extensions/pagetop-user/tests/providers.rs
Normal file
713
extensions/pagetop-user/tests/providers.rs
Normal 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);
|
||||
}
|
||||
34
extensions/pagetop-user/tests/providers/common.toml
Normal file
34
extensions/pagetop-user/tests/providers/common.toml
Normal 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"
|
||||
Loading…
Add table
Add a link
Reference in a new issue