✨ (user): Aplica los permisos del rol anonymous

Cachea los permisos de anonymous en memoria (invalidación local
y caducidad de 60s) e impide asignar roles de sistema a cuentas.
This commit is contained in:
Manuel Cillero 2026-10-13 07:33:35 +02:00
parent fd6030ee7d
commit d215e00daa
7 changed files with 135 additions and 21 deletions

View file

@ -156,7 +156,12 @@ pub async fn register(
// **< assign_role >******************************************************************************** // **< assign_role >********************************************************************************
/// Asigna un rol a un usuario (sin error si ya está asignado). /// 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> { 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() let already = user_role::Entity::find()
.filter(user_role::Column::UserId.eq(user_id)) .filter(user_role::Column::UserId.eq(user_id))
.filter(user_role::Column::RoleId.eq(role_id)) .filter(user_role::Column::RoleId.eq(role_id))

View file

@ -6,8 +6,6 @@ use pagetop::prelude::*;
use pagetop_htmx::prelude::*; use pagetop_htmx::prelude::*;
use crate::ADMIN_USERS_PATH; use crate::ADMIN_USERS_PATH;
use crate::ANONYMOUS_ROLE_ID;
use crate::AUTHENTICATED_ROLE_ID;
use crate::LOCALES_USER; use crate::LOCALES_USER;
use crate::account::{Account, UserStatus}; use crate::account::{Account, UserStatus};
use crate::component::admin::{ use crate::component::admin::{
@ -111,8 +109,7 @@ fn search_bar(current_query: Option<String>) -> Html {
// **< available_roles >**************************************************************************** // **< available_roles >****************************************************************************
// Roles asignables desde la UI de usuarios: excluye "anonymous" (nunca se asigna explícitamente) // Roles asignables desde la UI de usuarios: todos salvo los de sistema, que nunca se asignan.
// y "authenticated" (implícito, nunca se asigna).
async fn available_roles(selected: &[i32]) -> Result<Vec<(i32, String, bool)>, AuthError> { async fn available_roles(selected: &[i32]) -> Result<Vec<(i32, String, bool)>, AuthError> {
let items = role_admin::list_roles(&role_admin::RoleListParams { let items = role_admin::list_roles(&role_admin::RoleListParams {
sort: role_admin::RoleSortField::Weight, sort: role_admin::RoleSortField::Weight,
@ -121,7 +118,7 @@ async fn available_roles(selected: &[i32]) -> Result<Vec<(i32, String, bool)>, A
.await?; .await?;
Ok(items Ok(items
.into_iter() .into_iter()
.filter(|r| r.id != ANONYMOUS_ROLE_ID && r.id != AUTHENTICATED_ROLE_ID) .filter(|r| !crate::is_system_role(r.id))
.map(|r| { .map(|r| {
let checked = selected.contains(&r.id); let checked = selected.contains(&r.id);
(r.id, r.label, checked) (r.id, r.label, checked)

View file

@ -196,11 +196,19 @@ fn declare_admin_pages(bag: &mut PageBag) {
// **< Roles de sistema (fijos) >******************************************************************* // **< Roles de sistema (fijos) >*******************************************************************
// Sembrados con id fijo en `migration/m20260629_000002_create_roles.rs` y bloqueados (`locked`); // 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; 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; 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 >********************************************************************************** // **< Extension >**********************************************************************************
/// Implementa la extensión `pagetop-user`. /// Implementa la extensión `pagetop-user`.
@ -249,6 +257,9 @@ impl Extension for User {
m20260629_000006_create_user_tokens, m20260629_000006_create_user_tokens,
)?; )?;
permission::build_registry(); 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; auth::seed_initial_data().await;
#[cfg(feature = "demo-data")] #[cfg(feature = "demo-data")]
demo::seed_demo_data().await; demo::seed_demo_data().await;

View file

@ -4,18 +4,27 @@
//! peticiones a rutas de la aplicación antes de que lleguen al handler, excepto en las de archivos //! 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 //! estáticos (ver [`pagetop::core::extension::Extension::configure_static_files`]). Inserta
//! [`pagetop::auth::CurrentUser`] y, si el usuario está autenticado, el [`crate::account::Account`] //! [`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 pagetop::prelude::*;
use crate::account::Account; use crate::account::{Account, PermissionSet};
use crate::session; 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<PermissionSet>);
/// Resuelve la sesión del usuario e inyecta los tipos de identidad en las extensiones de la /// Resuelve la sesión del usuario e inyecta los tipos de identidad en las extensiones de la
/// petición HTTP. /// petición HTTP.
/// ///
/// - Siempre inserta [`pagetop::auth::CurrentUser`] (anónimo o autenticado). /// - 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. /// - Si se ha prorrogado una sesión iniciada con "recordarme", renueva su cookie en la respuesta.
pub(crate) async fn session_middleware( pub(crate) async fn session_middleware(
mut req: web::Request, mut req: web::Request,
@ -25,9 +34,16 @@ pub(crate) async fn session_middleware(
session::resolve_session(req.headers()).await; session::resolve_session(req.headers()).await;
req.extensions_mut().insert(current_user); req.extensions_mut().insert(current_user);
if let Some(account) = maybe_account { match maybe_account {
Some(account) => {
req.extensions_mut().insert(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; 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 /// 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, /// 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( pub(crate) fn check_rbac_permission(
request: &pagetop::web::HttpRequest, request: &pagetop::web::HttpRequest,
perm: PermissionRef, perm: PermissionRef,
granted: &mut bool, granted: &mut bool,
) { ) {
let Some(account) = request.extension::<Account>() else { let has_permission = match request.extension::<Account>() {
return; Some(account) => account.has_permission(perm),
None => request
.extension::<AnonymousPermissions>()
.is_some_and(|anonymous| anonymous.0.contains(perm.key().as_ref())),
}; };
if account.has_permission(perm) { if has_permission {
*granted = true; *granted = true;
} }
} }

View file

@ -11,6 +11,7 @@ use pagetop_seaorm::db::{
use crate::entity::{role, role_permission, user_role}; use crate::entity::{role, role_permission, user_role};
use crate::error::AuthError; use crate::error::AuthError;
use crate::permission; use crate::permission;
use crate::session;
// **< listado >************************************************************************************ // **< listado >************************************************************************************
@ -292,5 +293,10 @@ pub(crate) async fn set_role_permissions(
}) })
}) })
.await .await
.map_err(flatten_txn_err) .map_err(flatten_txn_err)?;
if role_id == crate::ANONYMOUS_ROLE_ID {
session::invalidate_anonymous_permissions();
}
Ok(())
} }

View file

@ -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. /// Reemplaza por completo el conjunto de roles asignados a un usuario.
/// ///
/// "authenticated" ([`crate::AUTHENTICATED_ROLE_ID`]) nunca se almacena: es implícito para toda /// Los roles de sistema nunca se almacenan, por lo que se descartan si llegan en `role_ids`:
/// cuenta autenticada, por lo que se descarta si llega 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> { pub(crate) async fn set_user_roles(user_id: i32, role_ids: &[i32]) -> Result<(), AuthError> {
find_user(user_id).await?; find_user(user_id).await?;
let mut role_ids: Vec<i32> = role_ids let mut role_ids: Vec<i32> = role_ids
.iter() .iter()
.copied() .copied()
.filter(|id| *id != crate::AUTHENTICATED_ROLE_ID) .filter(|id| !crate::is_system_role(*id))
.collect(); .collect();
role_ids.sort_unstable(); role_ids.sort_unstable();
role_ids.dedup(); role_ids.dedup();

View file

@ -1,13 +1,18 @@
//! Gestión de sesiones de usuario (creación, carga, prórroga y destrucción). //! 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::prelude::*;
use pagetop_seaorm::db::query::Expr; use pagetop_seaorm::db::query::Expr;
use pagetop_seaorm::db::{ColumnTrait, DbErr, EntityTrait, QueryFilter, QuerySelect, Set, dbconn}; use pagetop_seaorm::db::{ColumnTrait, DbErr, EntityTrait, QueryFilter, QuerySelect, Set, dbconn};
use crate::AUTHENTICATED_ROLE_ID;
use crate::account::{Account, PermissionSet, UserStatus}; use crate::account::{Account, PermissionSet, UserStatus};
use crate::config::SETTINGS; use crate::config::SETTINGS;
use crate::entity::{role, role_permission, session, user, user_role}; use crate::entity::{role, role_permission, session, user, user_role};
use crate::{ANONYMOUS_ROLE_ID, AUTHENTICATED_ROLE_ID};
// **< Generación de session ID >******************************************************************* // **< Generación de session ID >*******************************************************************
@ -182,6 +187,76 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option<Account>,
(current_user, Some(account), renewed_cookie) (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<PermissionSet>)>,
}
static ANONYMOUS_CACHE: RwLock<AnonymousCache> = 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<PermissionSet> {
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::<String>()
.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". // Tiempo sin uso tras el que caduca una sesión, según se iniciara o no con "recordarme".
fn idle_period(remember: bool) -> Duration { fn idle_period(remember: bool) -> Duration {
Duration::seconds(if remember { Duration::seconds(if remember {