diff --git a/config/reference.toml b/config/reference.toml index d1974e2b..49b081db 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -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. diff --git a/extensions/pagetop-user/README.md b/extensions/pagetop-user/README.md index ccba8092..212e4fec 100644 --- a/extensions/pagetop-user/README.md +++ b/extensions/pagetop-user/README.md @@ -11,18 +11,20 @@ -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 diff --git a/extensions/pagetop-user/src/account.rs b/extensions/pagetop-user/src/account.rs index 44dc192f..c29d46e9 100644 --- a/extensions/pagetop-user/src/account.rs +++ b/extensions/pagetop-user/src/account.rs @@ -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, } } } diff --git a/extensions/pagetop-user/src/actions.rs b/extensions/pagetop-user/src/actions.rs new file mode 100644 index 00000000..a45564dd --- /dev/null +++ b/extensions/pagetop-user/src/actions.rs @@ -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; + +/// 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 { + let mut actions: Vec = 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; + +/// 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 { + let mut extras = Vec::new(); + dispatch_actions(|action: &Self| extras.extend((action.f)(user_id))); + extras + } +} diff --git a/extensions/pagetop-user/src/auth.rs b/extensions/pagetop-user/src/auth.rs index 130c05f0..dbcc058d 100644 --- a/extensions/pagetop-user/src/auth.rs +++ b/extensions/pagetop-user/src/auth.rs @@ -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 { + client_ip: Option, +) -> Result { + 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 { 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 { +// +// 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 { 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 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 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() ); } } diff --git a/extensions/pagetop-user/src/component.rs b/extensions/pagetop-user/src/component.rs index bc7b2929..ed9d908a 100644 --- a/extensions/pagetop-user/src/component.rs +++ b/extensions/pagetop-user/src/component.rs @@ -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 `
`, @@ -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), + } +} diff --git a/extensions/pagetop-user/src/component/admin.rs b/extensions/pagetop-user/src/component/admin.rs index 6905ec79..5f54e401 100644 --- a/extensions/pagetop-user/src/component/admin.rs +++ b/extensions/pagetop-user/src/component/admin.rs @@ -43,12 +43,28 @@ pub(crate) type PermissionGroups = Vec<(Lc, Vec)>; // 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() diff --git a/extensions/pagetop-user/src/component/admin/user_form.rs b/extensions/pagetop-user/src/component/admin/user_form.rs index abd2a3c2..2973806a 100644 --- a/extensions/pagetop-user/src/component/admin/user_form.rs +++ b/extensions/pagetop-user/src/component/admin/user_form.rs @@ -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, + /// 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 { - 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_rows(Some(5)) - .with_maxlength(Some(ABOUT_MAX_CHARS)), - ); + 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()); + } + _ => { + 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) -> Self { + self.policy = policy; + self + } + + pub(crate) fn with_provider(mut self, provider: Option<(String, String)>) -> Self { + self.provider = provider; + self + } } diff --git a/extensions/pagetop-user/src/component/admin/user_table.rs b/extensions/pagetop-user/src/component/admin/user_table.rs index 9f78e8cc..3b3dc16f 100644 --- a/extensions/pagetop-user/src/component/admin/user_table.rs +++ b/extensions/pagetop-user/src/component/admin/user_table.rs @@ -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) - .with_style(button::Style::Solid(Intent::Primary)), - ) + 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", } } diff --git a/extensions/pagetop-user/src/component/login_form.rs b/extensions/pagetop-user/src/component/login_form.rs index bb8a8390..83f4c67e 100644 --- a/extensions/pagetop-user/src/component/login_form.rs +++ b/extensions/pagetop-user/src/component/login_form.rs @@ -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, + /// Enlace de ayuda junto al error (p. ej. dónde cambiar una contraseña caducada). + help: Option, /// 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 { 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, 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 { } } } - p class="user-reset-link" { - a href=(cx.route(PASSWORD_RESET_PATH)) { - (Lc::t("link-forgot-password", &LOCALES_USER).using(cx)) + @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) -> 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>) -> Self { self.error = error.into(); self } + /// Enlace de ayuda junto al error. + pub fn with_help(mut self, help: impl Into>) -> 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) -> Self { self.username = username.into(); diff --git a/extensions/pagetop-user/src/component/password_reset_confirm_form.rs b/extensions/pagetop-user/src/component/password_reset_confirm_form.rs index b8e07640..be394237 100644 --- a/extensions/pagetop-user/src/component/password_reset_confirm_form.rs +++ b/extensions/pagetop-user/src/component/password_reset_confirm_form.rs @@ -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, @@ -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>) -> Self { self.error = error.into(); self diff --git a/extensions/pagetop-user/src/component/password_reset_form.rs b/extensions/pagetop-user/src/component/password_reset_form.rs index dd9e15a1..5bc6764b 100644 --- a/extensions/pagetop-user/src/component/password_reset_form.rs +++ b/extensions/pagetop-user/src/component/password_reset_form.rs @@ -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, @@ -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>) -> Self { self.error = error.into(); self diff --git a/extensions/pagetop-user/src/component/register_form.rs b/extensions/pagetop-user/src/component/register_form.rs index ff2e75ef..c60daacb 100644 --- a/extensions/pagetop-user/src/component/register_form.rs +++ b/extensions/pagetop-user/src/component/register_form.rs @@ -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, @@ -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>) -> Self { self.error = error.into(); self diff --git a/extensions/pagetop-user/src/component/user_name.rs b/extensions/pagetop-user/src/component/user_name.rs index 2527f496..4fc286f2 100644 --- a/extensions/pagetop-user/src/component/user_name.rs +++ b/extensions/pagetop-user/src/component/user_name.rs @@ -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, diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs index e3646ad9..0287921e 100644 --- a/extensions/pagetop-user/src/config.rs +++ b/extensions/pagetop-user/src/config.rs @@ -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, + /// 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, + pub admin_password: Option, } /// Subsección **`[user.admin]`** de la configuración. diff --git a/extensions/pagetop-user/src/entity.rs b/extensions/pagetop-user/src/entity.rs index c2f95bc7..db578d4d 100644 --- a/extensions/pagetop-user/src/entity.rs +++ b/extensions/pagetop-user/src/entity.rs @@ -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; diff --git a/extensions/pagetop-user/src/entity/user_identity.rs b/extensions/pagetop-user/src/entity/user_identity.rs new file mode 100644 index 00000000..f3463a7d --- /dev/null +++ b/extensions/pagetop-user/src/entity/user_identity.rs @@ -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, + pub external_key: Option, + pub pending: bool, + pub expected_key: Option, + pub data: Option, + pub created_at: DateTimeUtc, + pub linked_at: Option, + pub last_login_at: Option, +} + +#[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 for Entity { + fn to() -> RelationDef { + Relation::User.def() + } +} + +impl ActiveModelBehavior for ActiveModel {} diff --git a/extensions/pagetop-user/src/error.rs b/extensions/pagetop-user/src/error.rs index 432a4d3e..b1720b79 100644 --- a/extensions/pagetop-user/src/error.rs +++ b/extensions/pagetop-user/src/error.rs @@ -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, }, + /// 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, } diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs index 909c750e..3d1a8fa6 100644 --- a/extensions/pagetop-user/src/handlers/account.rs +++ b/extensions/pagetop-user/src/handlers/account.rs @@ -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 { + 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 { 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 { - 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,12 +480,19 @@ 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, - Err(err) => Err(err), - }; + 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), + }; match result { Ok(user) => { @@ -435,6 +523,12 @@ pub(crate) async fn email_get(request: HttpRequest) -> Result Result( + 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()), + } +} diff --git a/extensions/pagetop-user/src/handlers/admin.rs b/extensions/pagetop-user/src/handlers/admin.rs index 9e4abb33..07deff17 100644 --- a/extensions/pagetop-user/src/handlers/admin.rs +++ b/extensions/pagetop-user/src/handlers/admin.rs @@ -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), } } diff --git a/extensions/pagetop-user/src/handlers/admin/users.rs b/extensions/pagetop-user/src/handlers/admin/users.rs index dadb055b..4c63b1c1 100644 --- a/extensions/pagetop-user/src/handlers/admin/users.rs +++ b/extensions/pagetop-user/src/handlers/admin/users.rs @@ -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************************************************************************* +#[derive(Deserialize)] +pub(crate) struct NewUserQuery { + #[serde(default)] + provider: Option, +} + +// 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 { +/// +/// 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, +) -> Result { 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::().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::().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 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 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::(&raw.0) else { return Err(ErrorPage::BadRequest(request)); }; - let allow_admin_field = request.extension::().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::().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) -> 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) -> 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::() - .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, - status, - is_admin, - can_toggle_admin, - can_change_status, + EditActions { + status, + 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 { + 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 { 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, - Err(err) => Err(err), + 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, + web::Form(form): web::Form, +) -> Result { + 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), + } +} diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs index 15be31ed..58f93bb5 100644 --- a/extensions/pagetop-user/src/handlers/auth.rs +++ b/extensions/pagetop-user/src/handlers/auth.rs @@ -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) } - result } else { - Err(AuthError::TooManyRequests) + 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) => { - send_token_mail(&mail_request, TokenKind::PasswordReset, &user_model, &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. // diff --git a/extensions/pagetop-user/src/identity.rs b/extensions/pagetop-user/src/identity.rs index 96d29ef0..f2f757c4 100644 --- a/extensions/pagetop-user/src/identity.rs +++ b/extensions/pagetop-user/src/identity.rs @@ -91,6 +91,16 @@ pub(crate) fn username_key(raw: &str) -> String { raw.trim().nfkc().collect::().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::().as_bytes()); diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs index 0c9d354f..c92ba748 100644 --- a/extensions/pagetop-user/src/lib.rs +++ b/extensions/pagetop-user/src/lib.rs @@ -12,18 +12,20 @@ -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) diff --git a/extensions/pagetop-user/src/locale/en-US/common.ftl b/extensions/pagetop-user/src/locale/en-US/common.ftl index 490d8c22..ce57ad5f 100644 --- a/extensions/pagetop-user/src/locale/en-US/common.ftl +++ b/extensions/pagetop-user/src/locale/en-US/common.ftl @@ -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-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. diff --git a/extensions/pagetop-user/src/locale/es-ES/common.ftl b/extensions/pagetop-user/src/locale/es-ES/common.ftl index 75ff42a6..d16bf93d 100644 --- a/extensions/pagetop-user/src/locale/es-ES/common.ftl +++ b/extensions/pagetop-user/src/locale/es-ES/common.ftl @@ -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-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. diff --git a/extensions/pagetop-user/src/mail.rs b/extensions/pagetop-user/src/mail.rs index 041037f6..56553f42 100644 --- a/extensions/pagetop-user/src/mail.rs +++ b/extensions/pagetop-user/src/mail.rs @@ -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, - link: String, + // Enlace principal; sin él, no se pinta el botón. + link: Option, // Horas que vale el enlace, si caduca. expires_hours: Option, + // Nombre del proveedor que gestiona la cuenta, para la introducción (`$provider`). + provider: Option, } 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 style="margin: 24px 0;" { - a href=(self.link) style=(BUTTON_STYLE) { (Lc::t(action, &LOCALES_USER).using(cx)) } + p { (intro.using(cx)) } + @if let Some(link) = &self.link { + p style="margin: 24px 0;" { + 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, +) { + 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, + username: Option, + 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\"")); } diff --git a/extensions/pagetop-user/src/middleware.rs b/extensions/pagetop-user/src/middleware.rs index 09d6fc03..21ca3ad1 100644 --- a/extensions/pagetop-user/src/middleware.rs +++ b/extensions/pagetop-user/src/middleware.rs @@ -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); /// - 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 diff --git a/extensions/pagetop-user/src/migration.rs b/extensions/pagetop-user/src/migration.rs index 53e8ec85..916dd134 100644 --- a/extensions/pagetop-user/src/migration.rs +++ b/extensions/pagetop-user/src/migration.rs @@ -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; diff --git a/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs b/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs index 70a20a43..8e459b07 100644 --- a/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs +++ b/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs @@ -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)) diff --git a/extensions/pagetop-user/src/migration/m20261111_000007_create_user_identities.rs b/extensions/pagetop-user/src/migration/m20261111_000007_create_user_identities.rs new file mode 100644 index 00000000..337376ab --- /dev/null +++ b/extensions/pagetop-user/src/migration/m20261111_000007_create_user_identities.rs @@ -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, +} diff --git a/extensions/pagetop-user/src/password.rs b/extensions/pagetop-user/src/password.rs index d31c1465..07570cbf 100644 --- a/extensions/pagetop-user/src/password.rs +++ b/extensions/pagetop-user/src/password.rs @@ -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 { 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 { - 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)); + } +} diff --git a/extensions/pagetop-user/src/provider.rs b/extensions/pagetop-user/src/provider.rs new file mode 100644 index 00000000..4461e70b --- /dev/null +++ b/extensions/pagetop-user/src/provider.rs @@ -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>, +} + +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, +} + +impl<'a> LoginAttempt<'a> { + pub(crate) fn new( + identifier: &'a str, + password: &'a util::SecretStr, + local: Option<&'a UserRef>, + client_ip: Option, + ) -> 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 { + 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, + }, + /// 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, + }, +} + +/// 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 { + 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 { + 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 = 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 { +/// vec![&pagetop_user::User] +/// } +/// +/// fn actions(&self) -> Vec { +/// 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> = 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, 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 { + 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 { + 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, 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, 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 { + 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, 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 { + 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"] + ); + } +} diff --git a/extensions/pagetop-user/src/provider/handle.rs b/extensions/pagetop-user/src/provider/handle.rs new file mode 100644 index 00000000..2e8e2a22 --- /dev/null +++ b/extensions/pagetop-user/src/provider/handle.rs @@ -0,0 +1,1003 @@ +use pagetop::prelude::*; +use pagetop_seaorm::db::query::{Expr, Query}; +use pagetop_seaorm::db::*; + +use crate::account::UserStatus; +use crate::actions::AfterUserStatusChanged; +use crate::config::SETTINGS; +use crate::entity::{role, session, user, user_identity, user_role, user_token}; +use crate::error::AuthError; +use crate::identity::{self, Email, Username}; +use crate::password::UNUSABLE_HASH; +use crate::provider::UserRef; +use crate::provider::policy::UserField; +use crate::service::user_admin::{ + ensure_email_available, ensure_username_available, taken_on_conflict, +}; + +// **< Funciones públicas de consulta >************************************************************* + +/// Comprueba que `username` es un nombre de usuario válido. +/// +/// Aplica la política de identidad configurada ([`IdentityPolicy`](crate::config::IdentityPolicy)) +/// y lo devuelve normalizado, tal como se guardaría. No comprueba si está en uso. +pub fn validate_username(username: &str) -> Result { + identity::username(username, SETTINGS.identity_policy, None).map(|u| u.value().to_owned()) +} + +/// Comprueba que `email` es una dirección válida y la devuelve tal como se guardaría. +/// +/// No comprueba si está en uso. +pub fn validate_email(email: &str) -> Result { + identity::email(email).map(|e| e.value().to_owned()) +} + +/// Cuenta que se busca con lo que se teclea para iniciar sesión. +/// +/// Por email si lleva `@` y por nombre de usuario si no, sin distinguir mayúsculas. +pub async fn find_user_by_login(identifier: &str) -> Result, AuthError> { + let filter = if identifier.contains('@') { + user::Column::EmailKey.eq(identity::email_key(identifier)) + } else { + user::Column::UsernameKey.eq(identity::username_key(identifier)) + }; + Ok(user::Entity::find() + .filter(filter) + .one(dbconn()) + .await? + .map(|user| UserRef::from(&user))) +} + +/// Identificador del rol con ese nombre interno (*machine name*), si existe. +pub async fn find_role_by_machine_name(machine_name: &str) -> Result, AuthError> { + Ok(role::Entity::find() + .filter(role::Column::MachineName.eq(machine_name)) + .one(dbconn()) + .await? + .map(|role| role.id)) +} + +// **< Datos de las operaciones >******************************************************************* + +/// Identidad de un proveedor guardada en una cuenta. +/// +/// La devuelve [`ProviderHandle::identity_of()`]. +#[derive(Clone, Debug, Getters)] +pub struct ExternalIdentity { + /// Cuenta a la que pertenece. + #[getters(copy)] + user_id: i32, + /// Identificador de la persona tal como lo da el proveedor (nulo si está pendiente). + external_id: Option, + /// Forma normalizada del identificador, la que se busca (nula si está pendiente). + external_key: Option, + /// Si es una marca de un administrador que permite vincular la cuenta, aún sin vincular. + #[getters(copy)] + pending: bool, + /// Con `pending`, el nombre de usuario o el email (en minúsculas) con el que se espera a la + /// persona. + expected_key: Option, + /// Datos propios del proveedor. + data: Option, + /// Cuándo se vinculó. + #[getters(copy)] + linked_at: Option>, + /// Último inicio de sesión de la cuenta mientras estaba vinculada. + #[getters(copy)] + last_login_at: Option>, +} + +impl From for ExternalIdentity { + fn from(row: user_identity::Model) -> Self { + ExternalIdentity { + user_id: row.user_id, + external_id: row.external_id, + external_key: row.external_key, + pending: row.pending, + expected_key: row.expected_key, + data: row.data, + linked_at: row.linked_at, + last_login_at: row.last_login_at, + } + } +} + +/// Datos de una cuenta nueva creada por un proveedor. +/// +/// Usado en [`ProviderHandle::create_user()`]. +#[derive(Clone, Debug)] +pub struct ExternalUserData { + username: String, + email: String, + email_verified: bool, + display_name: Option, + status: UserStatus, + data: Option, +} + +impl ExternalUserData { + /// Cuenta activa con ese nombre de usuario y email, sin verificar. + pub fn new(username: impl Into, email: impl Into) -> Self { + ExternalUserData { + username: username.into(), + email: email.into(), + email_verified: false, + display_name: None, + status: UserStatus::Active, + data: None, + } + } + + /// Da el email por verificado: el proveedor responde de él (p. ej. lo gestiona el + /// departamento de sistemas). + pub fn with_email_verified(mut self, verified: bool) -> Self { + self.email_verified = verified; + self + } + + /// Nombre visible. + pub fn with_display_name(mut self, display_name: impl Into>) -> Self { + self.display_name = display_name.into(); + self + } + + /// Estado inicial: [`UserStatus::Active`] (por defecto) o [`UserStatus::AwaitingApproval`]. + pub fn with_status(mut self, status: UserStatus) -> Self { + self.status = status; + self + } + + /// Datos propios del proveedor para la identidad. + pub fn with_data(mut self, data: impl Into>) -> Self { + self.data = data.into(); + self + } +} + +/// Cambios en los datos de una cuenta. Usado en [`ProviderHandle::update_user()`]. +/// +/// Sólo se tocan los campos indicados. En los opcionales, `None` borra el valor guardado. +#[derive(AutoDefault, Clone, Debug)] +pub struct ExternalUserUpdate { + email: Option<(String, bool)>, + display_name: Option>, + about: Option>, + language: Option>, + timezone: Option>, + theme: Option>, +} + +impl ExternalUserUpdate { + /// Sin cambios. + pub fn new() -> Self { + Self::default() + } + + /// Nuevo email, y si se da por verificado. + pub fn with_email(mut self, email: impl Into, verified: bool) -> Self { + self.email = Some((email.into(), verified)); + self + } + + /// Nuevo nombre visible. + pub fn with_display_name(mut self, value: Option) -> Self { + self.display_name = Some(value); + self + } + + /// Nuevo texto «Sobre mí». + pub fn with_about(mut self, value: Option) -> Self { + self.about = Some(value); + self + } + + /// Nuevo idioma (identificador BCP 47 de los que ofrece la aplicación). + pub fn with_language(mut self, value: Option) -> Self { + self.language = Some(value); + self + } + + /// Nueva zona horaria (identificador IANA de los que ofrece la aplicación). + pub fn with_timezone(mut self, value: Option) -> Self { + self.timezone = Some(value); + self + } + + /// Nuevo tema (nombre corto de un tema habilitado). + pub fn with_theme(mut self, value: Option) -> Self { + self.theme = Some(value); + self + } +} + +/// Resultado de [`ProviderHandle::update_user()`]. +#[derive(Debug, Default, Getters)] +pub struct UpdateReport { + /// Si ha cambiado algún dato. + #[getters(copy)] + changed: bool, + /// Campos que no se han aplicado, con el motivo (un valor no válido o un email en uso). El + /// resto se aplica igualmente. + rejected: Vec<(UserField, AuthError)>, +} + +// **< ProviderHandle >***************************************************************************** + +/// API privilegiada de `pagetop-user` para un proveedor de autenticación. +/// +/// Crea cuentas, las vincula con su identidad externa, cambia sus datos, su estado y sus roles, y +/// cierra sus sesiones. Sólo la tienen los proveedores activos: `pagetop-user` la entrega a cada +/// uno, una vez, con [`AuthProvider::attach()`](super::AuthProvider::attach). +/// +/// # Seguridad +/// +/// **Qué protege.** Estas operaciones no son funciones públicas del *crate*, sino métodos de un +/// objeto que sólo `pagetop-user` puede construir, ligado al identificador de un proveedor. Así las +/// reglas que impiden apropiarse de una cuenta viven en un único sitio y ningún proveedor las +/// puede saltar, aunque tenga un error: +/// +/// - Cada método que actúa sobre una cuenta comprueba primero que está vinculada a **este** +/// proveedor; si no, falla con [`AuthError::NotOwnedByProvider`]. Un proveedor no puede tocar +/// cuentas locales ni las de otro proveedor. +/// - Una cuenta existente sólo se vincula si un administrador lo ha permitido antes para esa +/// persona (una identidad pendiente de este proveedor), nunca si es de administrador, y al +/// vincularla deja de valer su contraseña local, se cierran sus sesiones y se anulan sus enlaces +/// de un solo uso ([`link_identity()`](Self::link_identity)). +/// - No hay forma de conceder el acceso total (`is_admin`), ni de leer o fijar contraseñas, ni de +/// abrir sesiones; los roles de sistema no se pueden asignar, y una cuenta de administrador no se +/// puede bloquear. +/// - Un proveedor declarado que no figura en +/// [`sources`](crate::config::LoginSettings::sources) no la recibe. +/// +/// No tiene constructor público ni implementa `Clone`, `Default` ni `Deserialize`: +/// +/// ```rust,compile_fail +/// use pagetop_user::provider::ProviderHandle; +/// +/// let handle = ProviderHandle { provider: "mine" }; +/// ``` +/// +/// **Qué no protege.** No es una barrera frente a código malicioso compilado en la misma +/// aplicación, que podría acceder a la base de datos directamente. Protege de errores, no de un +/// atacante con acceso al código. +/// +/// Cada operación queda registrada en las trazas con el identificador del proveedor. +pub struct ProviderHandle { + provider: &'static str, +} + +impl ProviderHandle { + // Sólo `pagetop-user` la construye, en `provider::initialize()`. NO hacerla pública ni añadir + // `Clone`, `Default` o `Deserialize` al tipo: cualquier copia fuera de su proveedor permitiría + // saltarse las comprobaciones de ámbito. + pub(crate) fn issue(provider: &'static str) -> Self { + ProviderHandle { provider } + } + + /// Identificador del proveedor al que pertenece. + pub fn provider(&self) -> &'static str { + self.provider + } + + // **< Consultas >****************************************************************************** + + /// Cuenta vinculada a este proveedor con esa clave externa (ver + /// [`ExternalIdentity::external_key()`]). + pub async fn find_user(&self, external_key: &str) -> Result, AuthError> { + let found = user_identity::Entity::find() + .filter(user_identity::Column::Provider.eq(self.provider)) + .filter(user_identity::Column::ExternalKey.eq(external_key)) + .filter(user_identity::Column::Pending.eq(false)) + .find_also_related(user::Entity) + .one(dbconn()) + .await?; + Ok(found + .and_then(|(_, user)| user) + .map(|user| UserRef::from(&user))) + } + + /// Cuentas con una identidad pendiente de este proveedor que esperan a la persona con ese + /// nombre de usuario o email (se compara sin distinguir mayúsculas). Normalmente una o + /// ninguna; más de una es un conflicto que debe resolver el proveedor. + pub async fn find_pending(&self, expected: &str) -> Result, AuthError> { + let rows = user_identity::Entity::find() + .filter(user_identity::Column::Provider.eq(self.provider)) + .filter(user_identity::Column::Pending.eq(true)) + .filter(user_identity::Column::ExpectedKey.eq(expected_key(expected))) + .find_also_related(user::Entity) + .all(dbconn()) + .await?; + Ok(rows + .into_iter() + .filter_map(|(_, user)| user) + .map(|user| UserRef::from(&user)) + .collect()) + } + + /// Cuenta vinculada a este proveedor. + pub async fn user(&self, user_id: i32) -> Result { + self.owned(user_id).await?; + Ok(UserRef::from(&find_user(user_id).await?)) + } + + /// Identidad de este proveedor en la cuenta, vinculada o pendiente. + pub async fn identity_of(&self, user_id: i32) -> Result, AuthError> { + Ok(user_identity::Entity::find() + .filter(user_identity::Column::Provider.eq(self.provider)) + .filter(user_identity::Column::UserId.eq(user_id)) + .one(dbconn()) + .await? + .map(ExternalIdentity::from)) + } + + /// Cuentas vinculadas a este proveedor con alguna sesión abierta. + pub async fn users_with_live_sessions(&self) -> Result, AuthError> { + Ok(session::Entity::find() + .select_only() + .column(session::Column::UserId) + .distinct() + .filter(session::Column::ExpiresAt.gt(Utc::now())) + .filter( + session::Column::UserId.in_subquery( + Query::select() + .column(user_identity::Column::UserId) + .from(user_identity::Entity) + .and_where(user_identity::Column::Provider.eq(self.provider)) + .and_where(user_identity::Column::Pending.eq(false)) + .to_owned(), + ), + ) + .into_tuple::() + .all(dbconn()) + .await?) + } + + // **< Cuentas >******************************************************************************** + + /// Crea una cuenta vinculada a este proveedor y devuelve su identificador. + /// + /// La cuenta no tiene contraseña local (no se puede entrar con ninguna). El nombre de usuario + /// debe cumplir la política de identidad, y ni él (ni uno que se confunda con él) ni el email + /// pueden estar en uso. El estado sólo puede ser [`UserStatus::Active`] o + /// [`UserStatus::AwaitingApproval`]. La cuenta y su identidad se crean en una sola transacción. + /// + /// Falla con [`AuthError::IdentityTaken`] si otra cuenta ya está vinculada a esa identidad + /// (p. ej. dos inicios de sesión simultáneos de la misma persona): basta con buscarla de nuevo. + pub async fn create_user( + &self, + external_id: &str, + external_key: &str, + data: ExternalUserData, + ) -> Result { + if !matches!( + data.status, + UserStatus::Active | UserStatus::AwaitingApproval + ) { + return Err(AuthError::InvalidStatus); + } + let username = identity::username(&data.username, SETTINGS.identity_policy, None)?; + let email = identity::email(&data.email)?; + ensure_username_available(&username, None).await?; + ensure_email_available(&email, None).await?; + if self.find_user(external_key).await?.is_some() { + return Err(AuthError::IdentityTaken); + } + + let now = Utc::now(); + let mut new_user = user::ActiveModel { + id: ActiveValue::NotSet, + email_verified_at: Set(data.email_verified.then_some(now)), + password_hash: Set(UNUSABLE_HASH.to_owned()), + status: Set(data.status.as_i16()), + display_name: Set(data.display_name), + failed_login_count: Set(0), + is_admin: Set(false), + created_at: Set(now), + updated_at: Set(now), + ..Default::default() + }; + username.set_on(&mut new_user); + email.set_on(&mut new_user); + let identity = user_identity::ActiveModel { + id: ActiveValue::NotSet, + user_id: ActiveValue::NotSet, + provider: Set(self.provider.to_owned()), + external_id: Set(Some(external_id.to_owned())), + external_key: Set(Some(external_key.to_owned())), + pending: Set(false), + expected_key: Set(None), + data: Set(data.data), + created_at: Set(now), + linked_at: Set(Some(now)), + last_login_at: Set(None), + }; + + let result = dbconn() + .transaction::<_, _, AuthError>(|txn| { + Box::pin(async move { + let user_id = user::Entity::insert(new_user) + .exec(txn) + .await? + .last_insert_id; + let mut identity = identity; + identity.user_id = Set(user_id); + user_identity::Entity::insert(identity).exec(txn).await?; + Ok(user_id) + }) + }) + .await + .map_err(flatten_txn_err); + let user_id = match result { + Ok(user_id) => user_id, + Err(err) => { + if self.find_user(external_key).await?.is_some() { + return Err(AuthError::IdentityTaken); + } + return Err(taken_on_conflict(err, Some(&username), &email, None).await); + } + }; + trace::info!( + "Provider \"{}\" created user {user_id} ({})", + self.provider, + if data.status == UserStatus::Active { + "active" + } else { + "awaiting approval" + } + ); + Ok(user_id) + } + + /// Vincula una cuenta existente con una identidad de este proveedor. + /// + /// Sólo si un administrador lo ha permitido (la cuenta tiene una identidad **pendiente** de + /// este proveedor) para esta persona, y nunca en una cuenta de administrador. `person` son los + /// nombres de usuario o emails con los que el proveedor conoce a la persona (los mismos con los + /// que la buscó en [`find_pending()`](Self::find_pending)); alguno debe ser el que espera la + /// identidad pendiente, sin distinguir mayúsculas. Al vincularla, en una sola + /// transacción, su contraseña local deja de valer, se cierran todas sus sesiones, se anulan sus + /// enlaces de recuperación, verificación y cambio de email sin usar, y se descarta el cambio de + /// email pendiente: quien la usara hasta ahora no debe conservar el acceso. + /// + /// Falla con [`AuthError::NotPendingIdentity`] si la cuenta no tiene esa identidad pendiente + /// o espera a otra persona, con [`AuthError::ProtectedAccount`] si es de administrador y con + /// [`AuthError::IdentityTaken`] si otra cuenta ya está vinculada a esa identidad. + pub async fn link_identity( + &self, + user_id: i32, + person: &[&str], + external_id: &str, + external_key: &str, + ) -> Result<(), AuthError> { + let Some(pending) = user_identity::Entity::find() + .filter(user_identity::Column::Provider.eq(self.provider)) + .filter(user_identity::Column::UserId.eq(user_id)) + .filter(user_identity::Column::Pending.eq(true)) + .one(dbconn()) + .await? + else { + return Err(AuthError::NotPendingIdentity); + }; + // La marca del administrador es para una persona concreta: un proveedor con un error no + // debe poder dar la cuenta a otra. + let expected = pending.expected_key.as_deref(); + if !person + .iter() + .any(|value| expected == Some(expected_key(value).as_str())) + { + return Err(AuthError::NotPendingIdentity); + } + let account = find_user(user_id).await?; + if account.is_admin { + return Err(AuthError::ProtectedAccount); + } + if self.find_user(external_key).await?.is_some() { + return Err(AuthError::IdentityTaken); + } + + let (external_id, external_key) = (external_id.to_owned(), external_key.to_owned()); + dbconn() + .transaction::<_, _, AuthError>(|txn| { + Box::pin(async move { + let now = Utc::now(); + user_identity::ActiveModel { + id: Set(pending.id), + external_id: Set(Some(external_id)), + external_key: Set(Some(external_key)), + pending: Set(false), + expected_key: Set(None), + linked_at: Set(Some(now)), + ..Default::default() + } + .update(txn) + .await?; + user::Entity::update_many() + .col_expr(user::Column::PasswordHash, Expr::value(UNUSABLE_HASH)) + .col_expr( + user::Column::PendingEmail, + Expr::value(Option::::None), + ) + .col_expr(user::Column::UpdatedAt, Expr::value(now)) + .filter(user::Column::Id.eq(user_id)) + .exec(txn) + .await?; + session::Entity::delete_many() + .filter(session::Column::UserId.eq(user_id)) + .exec(txn) + .await?; + user_token::Entity::update_many() + .col_expr(user_token::Column::ConsumedAt, Expr::value(now)) + .col_expr(user_token::Column::UpdatedAt, Expr::value(now)) + .filter(user_token::Column::UserId.eq(user_id)) + .filter(user_token::Column::ConsumedAt.is_null()) + .exec(txn) + .await?; + Ok(()) + }) + }) + .await + .map_err(flatten_txn_err)?; + trace::info!("Provider \"{}\" linked user {user_id}", self.provider); + Ok(()) + } + + /// Cambia el identificador externo de una cuenta vinculada a este proveedor, y sus datos + /// propios si se indican (p. ej. cuando la persona cambia de nombre en el proveedor). + pub async fn update_identity( + &self, + user_id: i32, + external_id: &str, + external_key: &str, + data: Option, + ) -> Result<(), AuthError> { + let identity = self.owned(user_id).await?; + let mut model = user_identity::ActiveModel { + id: Set(identity.id), + external_id: Set(Some(external_id.to_owned())), + external_key: Set(Some(external_key.to_owned())), + ..Default::default() + }; + if data.is_some() { + model.data = Set(data); + } + if let Err(err) = model.update(dbconn()).await { + if matches!(err.sql_err(), Some(SqlErr::UniqueConstraintViolation(_))) { + return Err(AuthError::IdentityTaken); + } + return Err(err.into()); + } + trace::info!( + "Provider \"{}\" updated the identity of user {user_id}", + self.provider + ); + Ok(()) + } + + /// Desvincula una cuenta de este proveedor y cierra sus sesiones, en una sola transacción. La + /// cuenta sigue sin contraseña local: para que pueda volver a entrar, un administrador debe + /// restablecérsela. + pub async fn unlink_identity(&self, user_id: i32) -> Result<(), AuthError> { + let identity = self.owned(user_id).await?; + dbconn() + .transaction::<_, _, AuthError>(|txn| { + Box::pin(async move { + user_identity::Entity::delete_by_id(identity.id) + .exec(txn) + .await?; + session::Entity::delete_many() + .filter(session::Column::UserId.eq(user_id)) + .exec(txn) + .await?; + Ok(()) + }) + }) + .await + .map_err(flatten_txn_err)?; + trace::info!( + "Provider \"{}\" unlinked user {user_id} and closed its sessions", + self.provider + ); + Ok(()) + } + + /// Actualiza los datos indicados de una cuenta vinculada a este proveedor, con las mismas + /// validaciones que el formulario del perfil. Un valor no válido (o un email que usa otra + /// cuenta) no se aplica y se anota en el [`UpdateReport`]; el resto se aplica igualmente. + /// + /// Un email nuevo descarta el cambio de email que el usuario tuviera pendiente y anula los + /// enlaces de recuperación y verificación enviados a la dirección anterior. + pub async fn update_user( + &self, + user_id: i32, + update: ExternalUserUpdate, + ) -> Result { + self.owned(user_id).await?; + let current = find_user(user_id).await?; + let mut report = UpdateReport::default(); + let mut model = user::ActiveModel { + id: Set(user_id), + ..Default::default() + }; + + let mut new_email = None; + if let Some((email, verified)) = update.email { + match identity::email(&email) { + Ok(email) + if *email.key() == current.email_key && email.value() == current.email => {} + Ok(email) => match ensure_email_available(&email, Some(user_id)).await { + Ok(()) => { + email.set_on(&mut model); + if *email.key() != current.email_key { + model.email_verified_at = Set(verified.then(Utc::now)); + } + new_email = Some(email); + } + Err(err) => report.rejected.push((UserField::Email, err)), + }, + Err(err) => report.rejected.push((UserField::Email, err)), + } + } + + let mut set = |field: UserField, + value: Option>, + current: &Option, + column: &mut ActiveValue>| { + let Some(value) = value else { return }; + let value = value.and_then(|v| util::non_blank(&v).map(str::to_owned)); + if &value == current { + return; + } + match normalized_field(field, value) { + Ok(value) => *column = Set(value), + Err(err) => report.rejected.push((field, err)), + } + }; + set( + UserField::DisplayName, + update.display_name, + ¤t.display_name, + &mut model.display_name, + ); + set( + UserField::About, + update.about, + ¤t.about, + &mut model.about, + ); + set( + UserField::Language, + update.language, + ¤t.language, + &mut model.language, + ); + set( + UserField::Timezone, + update.timezone, + ¤t.timezone, + &mut model.timezone, + ); + set( + UserField::Theme, + update.theme, + ¤t.theme, + &mut model.theme, + ); + + if !model.is_changed() { + return Ok(report); + } + model.updated_at = Set(Utc::now()); + if let Err(err) = model.update(dbconn()).await { + let err = match &new_email { + Some(email) => taken_on_conflict(err.into(), None, email, Some(user_id)).await, + None => err.into(), + }; + return Err(err); + } + report.changed = true; + trace::info!("Provider \"{}\" updated user {user_id}", self.provider); + if let Some(email) = new_email + && *email.key() != current.email_key + { + crate::auth::cancel_email_change(user_id).await?; + crate::auth::revoke_address_tokens(user_id).await?; + trace::info!( + "Provider \"{}\" changed the email of user {user_id}", + self.provider + ); + } + for (field, err) in &report.rejected { + trace::warn!( + "Provider \"{}\" could not set {} of user {user_id}: {err}", + self.provider, + field.as_str() + ); + } + Ok(report) + } + + /// Cambia el nombre de usuario de una cuenta vinculada a este proveedor. El nuevo nombre debe + /// cumplir la política de identidad y no estar en uso (ni uno que se confunda con él). + pub async fn rename_user(&self, user_id: i32, new_username: &str) -> Result<(), AuthError> { + self.owned(user_id).await?; + let current = find_user(user_id).await?; + let username: Username = identity::username( + new_username, + SETTINGS.identity_policy, + Some(¤t.username_key), + )?; + ensure_username_available(&username, Some(user_id)).await?; + let mut model = user::ActiveModel { + id: Set(user_id), + updated_at: Set(Utc::now()), + ..Default::default() + }; + username.set_on(&mut model); + if let Err(err) = model.update(dbconn()).await { + let email: Email = identity::email(¤t.email)?; + return Err( + taken_on_conflict(err.into(), Some(&username), &email, Some(user_id)).await, + ); + } + trace::info!( + "Provider \"{}\" renamed user {user_id} to \"{}\"", + self.provider, + username.value() + ); + Ok(()) + } + + /// Cambia el estado de una cuenta vinculada a este proveedor. Si deja de estar activa, se + /// cierran sus sesiones. Nunca bloquea una cuenta de administrador + /// ([`AuthError::ProtectedAccount`]). + pub async fn set_status(&self, user_id: i32, status: UserStatus) -> Result<(), AuthError> { + self.owned(user_id).await?; + let current = find_user(user_id).await?; + if current.is_admin && status != UserStatus::Active { + return Err(AuthError::ProtectedAccount); + } + let before = UserStatus::from_i16(current.status); + if before == status { + return Ok(()); + } + user::ActiveModel { + id: Set(user_id), + status: Set(status.as_i16()), + updated_at: Set(Utc::now()), + ..Default::default() + } + .update(dbconn()) + .await?; + if status != UserStatus::Active { + self.destroy_sessions(user_id).await?; + } + trace::info!( + "Provider \"{}\" changed the status of user {user_id}: {before:?} -> {status:?}", + self.provider + ); + AfterUserStatusChanged::dispatch(user_id, before, status); + Ok(()) + } + + /// Cierra todas las sesiones de una cuenta vinculada a este proveedor. + pub async fn destroy_sessions(&self, user_id: i32) -> Result<(), AuthError> { + self.owned(user_id).await?; + crate::session::destroy_user_sessions(user_id).await?; + trace::info!( + "Provider \"{}\" closed the sessions of user {user_id}", + self.provider + ); + Ok(()) + } + + // **< Roles >********************************************************************************** + + /// Roles asignados a una cuenta vinculada a este proveedor (nunca los de sistema). + pub async fn role_ids(&self, user_id: i32) -> Result, AuthError> { + self.owned(user_id).await?; + role_ids(user_id).await + } + + /// Asigna a una cuenta vinculada a este proveedor los roles indicados que aún no tenga, y + /// devuelve los que ha añadido. Ignora los roles de sistema y los que no existen. + pub async fn grant_roles(&self, user_id: i32, role_ids: &[i32]) -> Result, AuthError> { + self.owned(user_id).await?; + let current = self::role_ids(user_id).await?; + let mut wanted: Vec = role_ids + .iter() + .copied() + .filter(|id| !crate::is_system_role(*id) && !current.contains(id)) + .collect(); + wanted.sort_unstable(); + wanted.dedup(); + if wanted.is_empty() { + return Ok(wanted); + } + let existing: Vec = role::Entity::find() + .select_only() + .column(role::Column::Id) + .filter(role::Column::Id.is_in(wanted)) + .into_tuple() + .all(dbconn()) + .await?; + if existing.is_empty() { + return Ok(existing); + } + user_role::Entity::insert_many(existing.iter().map(|&role_id| user_role::ActiveModel { + user_id: Set(user_id), + role_id: Set(role_id), + })) + .exec_without_returning(dbconn()) + .await?; + trace::info!( + "Provider \"{}\" granted roles {existing:?} to user {user_id}", + self.provider + ); + Ok(existing) + } + + /// Retira de una cuenta vinculada a este proveedor los roles indicados que tenga, y devuelve + /// los que ha quitado. Ignora los roles de sistema. + pub async fn revoke_roles( + &self, + user_id: i32, + role_ids: &[i32], + ) -> Result, AuthError> { + self.owned(user_id).await?; + let current = self::role_ids(user_id).await?; + let removed: Vec = current + .into_iter() + .filter(|id| role_ids.contains(id)) + .collect(); + if removed.is_empty() { + return Ok(removed); + } + user_role::Entity::delete_many() + .filter(user_role::Column::UserId.eq(user_id)) + .filter(user_role::Column::RoleId.is_in(removed.clone())) + .exec(dbconn()) + .await?; + trace::info!( + "Provider \"{}\" revoked roles {removed:?} from user {user_id}", + self.provider + ); + Ok(removed) + } + + // Identidad vinculada (no pendiente) de este proveedor en la cuenta; si no la hay, la cuenta no + // es suya: `NotOwnedByProvider`. + async fn owned(&self, user_id: i32) -> Result { + user_identity::Entity::find() + .filter(user_identity::Column::Provider.eq(self.provider)) + .filter(user_identity::Column::UserId.eq(user_id)) + .filter(user_identity::Column::Pending.eq(false)) + .one(dbconn()) + .await? + .ok_or(AuthError::NotOwnedByProvider) + } +} + +// **< Identidades pendientes >********************************************************************* + +// Clave con la que se espera a una persona en una identidad pendiente: el email o el nombre de +// usuario, normalizados como para buscar la cuenta al iniciar sesión. +pub(crate) fn expected_key(value: &str) -> String { + identity::login_key(value) +} + +// Marca la cuenta para que el proveedor pueda vincularla cuando entre la persona esperada. Sólo lo +// hace un administrador (alta de una cuenta de proveedor, o "Permitir vincular" en su ficha). +pub(crate) async fn allow_linking( + user_id: i32, + provider: &str, + expected: &str, +) -> Result<(), AuthError> { + let account = find_user(user_id).await?; + if account.is_admin { + return Err(AuthError::ProtectedAccount); + } + let existing = user_identity::Entity::find() + .filter(user_identity::Column::Provider.eq(provider)) + .filter(user_identity::Column::UserId.eq(user_id)) + .one(dbconn()) + .await?; + match existing { + Some(row) if !row.pending => return Err(AuthError::IdentityTaken), + Some(row) => { + user_identity::ActiveModel { + id: Set(row.id), + expected_key: Set(Some(expected_key(expected))), + ..Default::default() + } + .update(dbconn()) + .await?; + } + None => { + user_identity::Entity::insert(pending_identity(user_id, provider, expected)) + .exec(dbconn()) + .await?; + } + } + trace::info!("User {user_id} may be linked by provider \"{provider}\""); + Ok(()) +} + +// Fila de la marca de `allow_linking()`, para insertarla también dentro de otra transacción (el +// alta de una cuenta de proveedor, ver `user_admin::create_user()`). +pub(crate) fn pending_identity( + user_id: i32, + provider: &str, + expected: &str, +) -> user_identity::ActiveModel { + user_identity::ActiveModel { + id: ActiveValue::NotSet, + user_id: Set(user_id), + provider: Set(provider.to_owned()), + external_id: Set(None), + external_key: Set(None), + pending: Set(true), + expected_key: Set(Some(expected_key(expected))), + data: Set(None), + created_at: Set(Utc::now()), + linked_at: Set(None), + last_login_at: Set(None), + } +} + +// Retira la marca de `allow_linking()`, si la cuenta aún no se ha vinculado. +pub(crate) async fn cancel_linking(user_id: i32, provider: &str) -> Result<(), AuthError> { + user_identity::Entity::delete_many() + .filter(user_identity::Column::Provider.eq(provider)) + .filter(user_identity::Column::UserId.eq(user_id)) + .filter(user_identity::Column::Pending.eq(true)) + .exec(dbconn()) + .await?; + Ok(()) +} + +// Todas las identidades (vinculadas o pendientes) de una cuenta, para la administración. +pub(crate) async fn identities_of(user_id: i32) -> Result, AuthError> { + Ok(user_identity::Entity::find() + .filter(user_identity::Column::UserId.eq(user_id)) + .all(dbconn()) + .await?) +} + +// **< Auxiliares >********************************************************************************* + +async fn find_user(user_id: i32) -> Result { + user::Entity::find_by_id(user_id) + .one(dbconn()) + .await? + .ok_or(AuthError::UserNotFound) +} + +async fn role_ids(user_id: i32) -> Result, AuthError> { + Ok(user_role::Entity::find() + .select_only() + .column(user_role::Column::RoleId) + .filter(user_role::Column::UserId.eq(user_id)) + .into_tuple::() + .all(dbconn()) + .await? + .into_iter() + .filter(|id| !crate::is_system_role(*id)) + .collect()) +} + +// Valida un dato del perfil con las reglas del formulario y lo devuelve tal como se guarda. +fn normalized_field(field: UserField, value: Option) -> Result, AuthError> { + use crate::service::user_admin as admin; + let to_owned = |value: Option<&str>| value.map(str::to_owned); + match field { + UserField::DisplayName => admin::validate_display_name(value.as_deref()).map(|()| value), + UserField::About => { + let about = value.map(|about| about.replace("\r\n", "\n")); + admin::validate_about(about.as_deref()).map(|()| about) + } + UserField::Language => admin::validate_language(value.as_deref()).map(to_owned), + UserField::Timezone => admin::validate_timezone(value.as_deref()).map(to_owned), + UserField::Theme => admin::validate_theme(value.as_deref()).map(to_owned), + UserField::Email => Ok(value), + } +} diff --git a/extensions/pagetop-user/src/provider/policy.rs b/extensions/pagetop-user/src/provider/policy.rs new file mode 100644 index 00000000..b7f76cb2 --- /dev/null +++ b/extensions/pagetop-user/src/provider/policy.rs @@ -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, text: Lc) -> Option { + 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, + }, +} + +/// 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, + /// Roles que asigna y retira el proveedor: no se pueden poner ni quitar a mano. + managed_roles: Vec, + /// Recuperación de la contraseña por correo. + password_reset: ResetPolicy, + /// Enlace de ayuda para el usuario. + help: Option, +} + +#[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) -> Self { + self.managed_fields = fields; + self + } + + /// Roles que gestiona el proveedor. + pub fn with_managed_roles(mut self, role_ids: Vec) -> 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) -> 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()); + } +} diff --git a/extensions/pagetop-user/src/service/user_admin.rs b/extensions/pagetop-user/src/service/user_admin.rs index aa8dbac9..41bebb11 100644 --- a/extensions/pagetop-user/src/service/user_admin.rs +++ b/extensions/pagetop-user/src/service/user_admin.rs @@ -185,8 +185,12 @@ pub(crate) async fn user_roles(user_id: i32) -> Result, 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 { + 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 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 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 .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 = 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, AuthError> { +pub(crate) fn validate_language(language: Option<&str>) -> Result, 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, 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, AuthError> { +pub(crate) fn validate_theme(theme: Option<&str>) -> Result, 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, 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, AuthError> { +pub(crate) fn validate_timezone(timezone: Option<&str>) -> Result, AuthError> { let timezone = timezone.and_then(util::non_blank); if let Some(tz) = timezone && !Timezone::supported_by_region() diff --git a/extensions/pagetop-user/src/throttle.rs b/extensions/pagetop-user/src/throttle.rs index 7d153de6..7d9d3f22 100644 --- a/extensions/pagetop-user/src/throttle.rs +++ b/extensions/pagetop-user/src/throttle.rs @@ -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>, +// 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 { + by_key: HashMap>, purged_at: Instant, } // Cada límite lleva su propia cuenta. -type Log = LazyLock>; +type Log = LazyLock>>; -const fn new_log() -> Log { +const fn new_log() -> Log { 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 = new_log(); +static FAILED_LOGINS: Log = new_log(); +static FAILED_IDENTIFIERS: Log = 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,43 +62,122 @@ 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, + 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(log: &'static Log) -> std::sync::MutexGuard<'static, Requests> { + log.lock().unwrap_or_else(PoisonError::into_inner) +} + fn window(secs: i64) -> StdDuration { StdDuration::from_secs(u64::try_from(secs).unwrap_or(0)) } // Anota la solicitud si se admite. -fn allow_at( - requests: &mut Requests, - ip: IpAddr, +fn allow_at( + requests: &mut Requests, + 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(requests: &mut Requests, 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 { 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 = 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)); + } } diff --git a/extensions/pagetop-user/tests/providers.rs b/extensions/pagetop-user/tests/providers.rs new file mode 100644 index 00000000..4c7a6429 --- /dev/null +++ b/extensions/pagetop-user/tests/providers.rs @@ -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 = 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> = 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 { + 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 { + 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 { + (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 { + 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 { + vec![&pagetop_user::User] + } + + fn actions(&self) -> Vec { + 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 { + 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 { + 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 { + let row = dbconn() + .query_one(Statement::from_string(DbBackend::Sqlite, sql.to_owned())) + .await + .unwrap()?; + Some(row.try_get::("", 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); +} diff --git a/extensions/pagetop-user/tests/providers/common.toml b/extensions/pagetop-user/tests/providers/common.toml new file mode 100644 index 00000000..9c174628 --- /dev/null +++ b/extensions/pagetop-user/tests/providers/common.toml @@ -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 " +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"