From d215e00daabc7a9f72d3894a5445601629ad849d Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Tue, 13 Oct 2026 07:33:35 +0200 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20(user):=20Aplica=20los=20permisos?= =?UTF-8?q?=20del=20rol=20anonymous?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cachea los permisos de anonymous en memoria (invalidación local y caducidad de 60s) e impide asignar roles de sistema a cuentas. --- extensions/pagetop-user/src/auth.rs | 5 ++ .../pagetop-user/src/handlers/admin/users.rs | 7 +- extensions/pagetop-user/src/lib.rs | 15 +++- extensions/pagetop-user/src/middleware.rs | 37 ++++++--- .../pagetop-user/src/service/role_admin.rs | 8 +- .../pagetop-user/src/service/user_admin.rs | 7 +- extensions/pagetop-user/src/session.rs | 77 ++++++++++++++++++- 7 files changed, 135 insertions(+), 21 deletions(-) diff --git a/extensions/pagetop-user/src/auth.rs b/extensions/pagetop-user/src/auth.rs index a2832d70..871693f1 100644 --- a/extensions/pagetop-user/src/auth.rs +++ b/extensions/pagetop-user/src/auth.rs @@ -156,7 +156,12 @@ pub async fn register( // **< assign_role >******************************************************************************** /// Asigna un rol a un usuario (sin error si ya está asignado). +/// +/// Los roles de sistema ("anonymous" y "authenticated") no se asignan nunca: se ignoran. pub async fn assign_role(user_id: i32, role_id: i32) -> Result<(), AuthError> { + if crate::is_system_role(role_id) { + return Ok(()); + } let already = user_role::Entity::find() .filter(user_role::Column::UserId.eq(user_id)) .filter(user_role::Column::RoleId.eq(role_id)) diff --git a/extensions/pagetop-user/src/handlers/admin/users.rs b/extensions/pagetop-user/src/handlers/admin/users.rs index d1fff9de..eb7a3805 100644 --- a/extensions/pagetop-user/src/handlers/admin/users.rs +++ b/extensions/pagetop-user/src/handlers/admin/users.rs @@ -6,8 +6,6 @@ use pagetop::prelude::*; use pagetop_htmx::prelude::*; use crate::ADMIN_USERS_PATH; -use crate::ANONYMOUS_ROLE_ID; -use crate::AUTHENTICATED_ROLE_ID; use crate::LOCALES_USER; use crate::account::{Account, UserStatus}; use crate::component::admin::{ @@ -111,8 +109,7 @@ fn search_bar(current_query: Option) -> Html { // **< available_roles >**************************************************************************** -// Roles asignables desde la UI de usuarios: excluye "anonymous" (nunca se asigna explícitamente) -// y "authenticated" (implícito, nunca se asigna). +// Roles asignables desde la UI de usuarios: todos salvo los de sistema, que nunca se asignan. async fn available_roles(selected: &[i32]) -> Result, AuthError> { let items = role_admin::list_roles(&role_admin::RoleListParams { sort: role_admin::RoleSortField::Weight, @@ -121,7 +118,7 @@ async fn available_roles(selected: &[i32]) -> Result, A .await?; Ok(items .into_iter() - .filter(|r| r.id != ANONYMOUS_ROLE_ID && r.id != AUTHENTICATED_ROLE_ID) + .filter(|r| !crate::is_system_role(r.id)) .map(|r| { let checked = selected.contains(&r.id); (r.id, r.label, checked) diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs index 4a487bbf..e810bd4f 100644 --- a/extensions/pagetop-user/src/lib.rs +++ b/extensions/pagetop-user/src/lib.rs @@ -196,11 +196,19 @@ fn declare_admin_pages(bag: &mut PageBag) { // **< Roles de sistema (fijos) >******************************************************************* // Sembrados con id fijo en `migration/m20260629_000002_create_roles.rs` y bloqueados (`locked`); -// no se borran ni cambian de id. +// no se borran ni cambian de id. Ninguno se asigna en `user_role` (ver `is_system_role()`). + +// Implícito para las peticiones sin sesión; sus permisos no se aplican a ninguna cuenta. const ANONYMOUS_ROLE_ID: i32 = 1; -// Implícito: nunca se asigna en `user_role`; sus permisos se aplican a toda cuenta autenticada. +// Implícito para toda cuenta autenticada; sus permisos se aplican a todas ellas. const AUTHENTICATED_ROLE_ID: i32 = 2; +// Un rol de sistema no se asigna a ningún usuario: si "anonymous" llegara a `user_role`, esa cuenta +// recibiría los permisos pensados sólo para peticiones sin sesión. +fn is_system_role(role_id: i32) -> bool { + role_id == ANONYMOUS_ROLE_ID || role_id == AUTHENTICATED_ROLE_ID +} + // **< Extension >********************************************************************************** /// Implementa la extensión `pagetop-user`. @@ -249,6 +257,9 @@ impl Extension for User { m20260629_000006_create_user_tokens, )?; permission::build_registry(); + // 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(); auth::seed_initial_data().await; #[cfg(feature = "demo-data")] demo::seed_demo_data().await; diff --git a/extensions/pagetop-user/src/middleware.rs b/extensions/pagetop-user/src/middleware.rs index da5bc36b..eddda73b 100644 --- a/extensions/pagetop-user/src/middleware.rs +++ b/extensions/pagetop-user/src/middleware.rs @@ -4,18 +4,27 @@ //! peticiones a rutas de la aplicación antes de que lleguen al handler, excepto en las de archivos //! estáticos (ver [`pagetop::core::extension::Extension::configure_static_files`]). Inserta //! [`pagetop::auth::CurrentUser`] y, si el usuario está autenticado, el [`crate::account::Account`] -//! con sus datos ricos en las extensiones de la petición HTTP. +//! con sus datos ricos en las extensiones de la petición HTTP; si no, los permisos del rol +//! "anonymous". + +use std::sync::Arc; use pagetop::prelude::*; -use crate::account::Account; +use crate::account::{Account, PermissionSet}; use crate::session; +// Permisos del rol "anonymous", insertados en las peticiones sin sesión. Un tipo propio para que no +// se confundan con los de un `Account`; `Arc` para compartirlos sin copiarlos en cada petición. +#[derive(Clone)] +struct AnonymousPermissions(Arc); + /// Resuelve la sesión del usuario e inyecta los tipos de identidad en las extensiones de la /// petición HTTP. /// /// - Siempre inserta [`pagetop::auth::CurrentUser`] (anónimo o autenticado). -/// - Si hay sesión activa, inserta también el [`Account`] con roles y permisos. +/// - Si hay sesión activa, inserta también el [`Account`] con roles y permisos; si no, los permisos +/// del rol "anonymous". /// - 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, @@ -25,8 +34,15 @@ pub(crate) async fn session_middleware( session::resolve_session(req.headers()).await; req.extensions_mut().insert(current_user); - if let Some(account) = maybe_account { - req.extensions_mut().insert(account); + match maybe_account { + Some(account) => { + req.extensions_mut().insert(account); + } + None => { + let permissions = session::anonymous_permissions().await; + req.extensions_mut() + .insert(AnonymousPermissions(permissions)); + } } let mut response = next.run(req).await; @@ -55,16 +71,19 @@ pub(crate) async fn session_middleware( /// /// Lee el [`Account`] inyectado por el middleware de sesión desde las extensiones de la petición /// HTTP y concede el permiso si el account lo tiene (un administrador lo tiene concedido siempre, -/// ver [`Account::has_permission`]). +/// ver [`Account::has_permission`]). Sin sesión, lo concede si lo tiene el rol "anonymous". pub(crate) fn check_rbac_permission( request: &pagetop::web::HttpRequest, perm: PermissionRef, granted: &mut bool, ) { - let Some(account) = request.extension::() else { - return; + let has_permission = match request.extension::() { + Some(account) => account.has_permission(perm), + None => request + .extension::() + .is_some_and(|anonymous| anonymous.0.contains(perm.key().as_ref())), }; - if account.has_permission(perm) { + if has_permission { *granted = true; } } diff --git a/extensions/pagetop-user/src/service/role_admin.rs b/extensions/pagetop-user/src/service/role_admin.rs index 784da570..8c3cdecf 100644 --- a/extensions/pagetop-user/src/service/role_admin.rs +++ b/extensions/pagetop-user/src/service/role_admin.rs @@ -11,6 +11,7 @@ use pagetop_seaorm::db::{ use crate::entity::{role, role_permission, user_role}; use crate::error::AuthError; use crate::permission; +use crate::session; // **< listado >************************************************************************************ @@ -292,5 +293,10 @@ pub(crate) async fn set_role_permissions( }) }) .await - .map_err(flatten_txn_err) + .map_err(flatten_txn_err)?; + + if role_id == crate::ANONYMOUS_ROLE_ID { + session::invalidate_anonymous_permissions(); + } + Ok(()) } diff --git a/extensions/pagetop-user/src/service/user_admin.rs b/extensions/pagetop-user/src/service/user_admin.rs index 81de34c2..e16e6cfe 100644 --- a/extensions/pagetop-user/src/service/user_admin.rs +++ b/extensions/pagetop-user/src/service/user_admin.rs @@ -296,15 +296,16 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul /// Reemplaza por completo el conjunto de roles asignados a un usuario. /// -/// "authenticated" ([`crate::AUTHENTICATED_ROLE_ID`]) nunca se almacena: es implícito para toda -/// cuenta autenticada, por lo que se descarta si llega en `role_ids`. +/// 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> { find_user(user_id).await?; let mut role_ids: Vec = role_ids .iter() .copied() - .filter(|id| *id != crate::AUTHENTICATED_ROLE_ID) + .filter(|id| !crate::is_system_role(*id)) .collect(); role_ids.sort_unstable(); role_ids.dedup(); diff --git a/extensions/pagetop-user/src/session.rs b/extensions/pagetop-user/src/session.rs index 796509fa..f2ffa3d9 100644 --- a/extensions/pagetop-user/src/session.rs +++ b/extensions/pagetop-user/src/session.rs @@ -1,13 +1,18 @@ //! Gestión de sesiones de usuario (creación, carga, prórroga y destrucción). +//! +//! Y también de los permisos de las peticiones sin sesión. + +use std::sync::{Arc, PoisonError, RwLock}; +use std::time::Instant; use pagetop::prelude::*; use pagetop_seaorm::db::query::Expr; use pagetop_seaorm::db::{ColumnTrait, DbErr, EntityTrait, QueryFilter, QuerySelect, Set, dbconn}; -use crate::AUTHENTICATED_ROLE_ID; use crate::account::{Account, PermissionSet, UserStatus}; use crate::config::SETTINGS; use crate::entity::{role, role_permission, session, user, user_role}; +use crate::{ANONYMOUS_ROLE_ID, AUTHENTICATED_ROLE_ID}; // **< Generación de session ID >******************************************************************* @@ -182,6 +187,76 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option, (current_user, Some(account), renewed_cookie) } +// **< anonymous_permissions >********************************************************************** + +// Los permisos de "anonymous" son los mismos para todas las peticiones sin sesión y cambian muy +// poco: se guardan en memoria para no consultarlos en cada una. Al cambiarlos se invalidan en esta +// instancia; en las demás (o si se editan directamente en la base de datos) caducan tras +// `ANONYMOUS_TTL`. La generación evita guardar una carga que empezó antes de una invalidación. +const ANONYMOUS_TTL: std::time::Duration = std::time::Duration::from_secs(60); + +struct AnonymousCache { + generation: u64, + loaded: Option<(Instant, Arc)>, +} + +static ANONYMOUS_CACHE: RwLock = RwLock::new(AnonymousCache { + generation: 0, + loaded: None, +}); + +/// Devuelve los permisos del rol "anonymous", que se aplican a las peticiones sin sesión. +/// +/// Un usuario autenticado no los hereda: recibe los de "authenticated" y los de sus roles. Si la +/// consulta falla, devuelve un conjunto vacío (no concede nada), lo registra como aviso y lo vuelve +/// a intentar en la siguiente petición. +pub(crate) async fn anonymous_permissions() -> Arc { + let generation = { + let cache = ANONYMOUS_CACHE + .read() + .unwrap_or_else(PoisonError::into_inner); + if let Some((loaded_at, permissions)) = &cache.loaded + && loaded_at.elapsed() < ANONYMOUS_TTL + { + return Arc::clone(permissions); + } + cache.generation + }; + + let keys = role_permission::Entity::find() + .select_only() + .column(role_permission::Column::PermissionKey) + .filter(role_permission::Column::RoleId.eq(ANONYMOUS_ROLE_ID)) + .into_tuple::() + .all(dbconn()) + .await; + let permissions = match keys { + Ok(keys) => Arc::new(PermissionSet::new(keys)), + Err(err) => { + trace::warn!("session: failed to load anonymous permissions: {err}"); + return Arc::default(); + } + }; + + let mut cache = ANONYMOUS_CACHE + .write() + .unwrap_or_else(PoisonError::into_inner); + if cache.generation == generation { + cache.loaded = Some((Instant::now(), Arc::clone(&permissions))); + } + permissions +} + +/// Descarta los permisos de "anonymous" guardados en memoria, para que la siguiente petición sin +/// sesión los vuelva a leer. Se llama al cambiar los permisos de ese rol. +pub(crate) fn invalidate_anonymous_permissions() { + let mut cache = ANONYMOUS_CACHE + .write() + .unwrap_or_else(PoisonError::into_inner); + cache.generation = cache.generation.wrapping_add(1); + cache.loaded = None; +} + // Tiempo sin uso tras el que caduca una sesión, según se iniciara o no con "recordarme". fn idle_period(remember: bool) -> Duration { Duration::seconds(if remember {