From 9c77a664f87ef3d2182370c084da52a69cef2b77 Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Fri, 13 Nov 2026 07:12:47 +0100 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20(user):=20Contrase=C3=B1a=20local?= =?UTF-8?q?=20en=20cuentas=20liberadas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Una cuenta que su proveedor libera (`releases()`) confirma los cambios de email y contraseña con su contraseña local, no con el proveedor. - Nuevo `ProviderHandle::disable_password()` para que el proveedor vuelva a gestionarla: anula la contraseña local, las sesiones y los enlaces, en la misma transacción qe `link_identity()` (`take_over()`). --- extensions/pagetop-user/src/auth.rs | 28 ++++--- extensions/pagetop-user/src/provider.rs | 16 +++- .../pagetop-user/src/provider/handle.rs | 75 +++++++++++++------ extensions/pagetop-user/tests/providers.rs | 39 +++++++++- 4 files changed, 121 insertions(+), 37 deletions(-) diff --git a/extensions/pagetop-user/src/auth.rs b/extensions/pagetop-user/src/auth.rs index dbcc058d..43d85355 100644 --- a/extensions/pagetop-user/src/auth.rs +++ b/extensions/pagetop-user/src/auth.rs @@ -376,8 +376,14 @@ pub(crate) async fn change_own_password( // 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. // -// La de una cuenta que gestiona un proveedor la comprueba el proveedor -// (`AuthProvider::reauthenticate()`), con los mismos contadores de fallos. +// Si la cuenta la gestiona un proveedor, la comprueba él (`AuthProvider::reauthenticate()`; en un +// directorio LDAP, un *bind* con el DN de la persona), con los mismos contadores de fallos. Si el +// proveedor la libera (`AuthProvider::releases()`), se trata como local y vale su contraseña local, +// igual que al iniciar sesión. Por ejemplo, un administrador excluye una cuenta del directorio y +// le da una contraseña local: su titular entra con ella y, al cambiar su email, confirma con esa +// misma contraseña, no con la del directorio, que ya no gestiona su cuenta. Una cuenta liberada sin +// contraseña local no puede confirmar nada (cada intento cuenta como un fallo) hasta que un +// administrador le dé una. async fn checked_user(user_id: i32, password: &util::SecretStr) -> Result { let user_model = user::Entity::find_by_id(user_id) .one(dbconn()) @@ -389,16 +395,16 @@ async fn checked_user(user_id: i32, password: &util::SecretStr) -> 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, + Some(p) if !p.releases(&user_ref).await => { + match p.reauthenticate(&user_ref, password).await { + ReauthOutcome::Valid => true, + ReauthOutcome::Invalid => false, + ReauthOutcome::Unavailable => return Err(AuthError::ExternalUnavailable), + } + } + _ => password::verify_password_async(password.expose(), &user_model.password_hash).await, }; if !valid { register_failed_login(&user_model, now).await?; diff --git a/extensions/pagetop-user/src/provider.rs b/extensions/pagetop-user/src/provider.rs index 4461e70b..6aae29ff 100644 --- a/extensions/pagetop-user/src/provider.rs +++ b/extensions/pagetop-user/src/provider.rs @@ -236,9 +236,19 @@ pub trait AuthProvider: Send + Sync + 'static { /// 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. + /// Si el proveedor renuncia a gestionar una cuenta vinculada a él. Por defecto, no. + /// + /// Una cuenta liberada se trata como local: + /// + /// - **Al iniciar sesión**, con [`LocalFallback::Released`], puede entrar con su contraseña + /// local aunque `"local"` no esté en `sources`. + /// - **Al confirmar una operación sensible** (cambiar el email o la contraseña), se comprueba + /// su contraseña local en lugar de llamar a [`reauthenticate()`](Self::reauthenticate). + /// + /// Sirve, por ejemplo, para que un administrador saque una cuenta de la gestión de un + /// directorio y le dé una contraseña local con la que su titular entre y confirme sus cambios. + /// Mientras no tenga contraseña local, una cuenta liberada no puede entrar ni confirmar nada + /// por esta vía. async fn releases(&self, _user: &UserRef) -> bool { false } diff --git a/extensions/pagetop-user/src/provider/handle.rs b/extensions/pagetop-user/src/provider/handle.rs index 2e8e2a22..03bd9b98 100644 --- a/extensions/pagetop-user/src/provider/handle.rs +++ b/extensions/pagetop-user/src/provider/handle.rs @@ -511,28 +511,7 @@ impl ProviderHandle { } .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(()) + take_over(txn, user_id, now).await }) }) .await @@ -541,6 +520,27 @@ impl ProviderHandle { Ok(()) } + /// Anula la contraseña local de una cuenta vinculada a este proveedor, como al vincularla: + /// cierra sus sesiones, descarta su cambio de email pendiente y anula todos sus enlaces sin + /// usar (recuperación, verificación y cambio de email). Para cuando el proveedor vuelve a + /// gestionar una cuenta que había liberado + /// ([`AuthProvider::releases()`](super::AuthProvider::releases)) y que mientras tanto recibió + /// una contraseña local. + pub async fn disable_password(&self, user_id: i32) -> Result<(), AuthError> { + self.owned(user_id).await?; + dbconn() + .transaction::<_, _, AuthError>(|txn| { + Box::pin(async move { take_over(txn, user_id, Utc::now()).await }) + }) + .await + .map_err(flatten_txn_err)?; + trace::info!( + "Provider \"{}\" disabled the local password of 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( @@ -877,6 +877,37 @@ impl ProviderHandle { } } +// Deja la cuenta sólo en manos del proveedor: sin contraseña local, sin sesiones y sin cambio de +// email ni enlaces pendientes, que valían para la cuenta local. +async fn take_over( + txn: &DatabaseTransaction, + user_id: i32, + now: DateTime, +) -> Result<(), AuthError> { + 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(()) +} + // **< Identidades pendientes >********************************************************************* // Clave con la que se espera a una persona en una identidad pendiente: el email o el nombre de diff --git a/extensions/pagetop-user/tests/providers.rs b/extensions/pagetop-user/tests/providers.rs index 4c7a6429..aa92ac8a 100644 --- a/extensions/pagetop-user/tests/providers.rs +++ b/extensions/pagetop-user/tests/providers.rs @@ -25,6 +25,7 @@ const PEOPLE: &[(&str, &str, &str)] = &[ ("eva", "eva@example.com", "eva-dir"), ("rejected", "rejected@example.com", "rejected-dir"), ("admin", "admin@example.com", "admin-dir"), + ("released", "released@example.com", "released-dir"), ]; static HANDLE: OnceLock = OnceLock::new(); @@ -126,7 +127,11 @@ impl AuthProvider for Fake { } } - async fn account_policy(&self, _user: &UserRef) -> Option { + async fn account_policy(&self, user: &UserRef) -> Option { + // A released account is treated as local. + if self.releases(user).await { + return None; + } let staff = STAFF.load(Ordering::SeqCst); Some( AccountPolicy::new(Lc::n("Fake directory")) @@ -344,6 +349,7 @@ async fn provider_flows() { managed_roles_survive_the_administration_form(&client, &admin).await; actions_reach_other_extensions(&client, &admin).await; unlinking_closes_the_sessions(&client).await; + released_accounts_are_local_until_taken_back(&client).await; } async fn directory_people_get_a_linked_account(client: &Client) { @@ -543,6 +549,10 @@ async fn the_handle_only_acts_on_its_own_accounts() { handle().destroy_sessions(admin).await, Err(AuthError::NotOwnedByProvider) )); + assert!(matches!( + handle().disable_password(admin).await, + Err(AuthError::NotOwnedByProvider) + )); assert!(matches!( handle() .link_identity(admin, &["admin"], "admin", "fake:admin") @@ -711,3 +721,30 @@ async fn unlinking_closes_the_sessions(client: &Client) { .unwrap(); assert_ne!(client.get("/user", Some(&session)).await.status, Status::OK); } + +async fn released_accounts_are_local_until_taken_back(client: &Client) { + assert!(client.login("released", "released-dir").await.is_some()); + let released = user_id("released").await; + // An administrator gives it a local password (the administrator's own hash, to skip Argon2). + dbconn() + .execute_unprepared(&format!( + "UPDATE users SET password_hash = \ + (SELECT password_hash FROM users WHERE username_key = 'admin') WHERE id = {released}" + )) + .await + .unwrap(); + let session = client.login("released", "admin-password").await.unwrap(); + // Sensitive changes are confirmed with the local password, not with the provider's. + let change = form(&[ + ("email", "released.new@example.com"), + ("current_password", "admin-password"), + ]); + client.post("/user/email", &change, Some(&session)).await; + mail_to("released.new@example.com").await; + + // Taken back by the provider: no local password and no sessions. + handle().disable_password(released).await.unwrap(); + assert_eq!(client.login("released", "admin-password").await, None); + assert_ne!(client.get("/user", Some(&session)).await.status, Status::OK); + assert!(client.login("released", "released-dir").await.is_some()); +}