✨ (auth): Añade permisos tipados
Sustituye las claves de permiso `&str` sueltas por el trait `Permission` (clave, etiqueta y grupo), y añade `require_permission()` para cortar un handler con `ErrorPage::AccessDenied` antes de construir nada. Para que `require_permission()` pueda fallar sin un `Context` previo, `ErrorPage` pasa a envolver `Option<HttpRequest>`, `Context::new()` recibe ahora `HttpRequest` sin `Option`, y se añade `Context::admin()` para la plantilla de administración.
This commit is contained in:
parent
ea0dc021ce
commit
747e64ce34
10 changed files with 297 additions and 120 deletions
187
src/auth.rs
187
src/auth.rs
|
|
@ -1,31 +1,44 @@
|
|||
//! Identidad del usuario y sistema de autorización extensible.
|
||||
//!
|
||||
//! Define el tipo mínimo [`CurrentUser`] que PageTop inyecta en el [`Context`] de cada petición.
|
||||
//! Incluye también la acción [`CheckPermission`] para que las extensiones puedan implementar sus
|
||||
//! propios modelos de permisos, y la función auxiliar [`has_permission()`].
|
||||
//! Define el tipo [`CurrentUser`] que PageTop inyecta en el [`Context`] con la información mínima
|
||||
//! sobre el usuario que ejecuta la petición actual ([`HttpRequest`]).
|
||||
//!
|
||||
//! Incluye la acción [`CheckPermission`] para que las extensiones puedan implementar sus propios
|
||||
//! modelos de permisos. Y también las funciones auxiliares [`has_permission()`] y
|
||||
//! [`require_permission()`] para validar en el comienzo de cada handler, antes de construir ni
|
||||
//! ejecutar nada, si la petición está autorizada.
|
||||
//!
|
||||
//! La resolución concreta del usuario (sesión en BD, LDAP, OAuth, ...) y la lógica de permisos
|
||||
//! (RBAC, grupos LDAP, ...) son responsabilidad de las extensiones de autenticación. Un concepto
|
||||
//! como "administrador" que tiene todos los permisos no es responsabilidad del core: cada extensión
|
||||
//! decide si existe y, si es así, lo aplica dentro de su propio handler [`CheckPermission`].
|
||||
//! como "administrador" que tiene todos los permisos no es responsabilidad de PageTop: cada
|
||||
//! extensión decide si existe y, si es así, lo aplica dentro de su propio handler
|
||||
//! [`CheckPermission`].
|
||||
//!
|
||||
//! [`Context`]: crate::core::component::Context
|
||||
|
||||
use crate::core::action::{ActionDispatcher, ActionKey, try_dispatch_actions};
|
||||
use crate::core::component::Context;
|
||||
use crate::{UniqueId, Weight};
|
||||
use crate::locale::L10n;
|
||||
use crate::response::ErrorPage;
|
||||
use crate::web::HttpRequest;
|
||||
use crate::{CowStr, UniqueId, Weight};
|
||||
|
||||
// **< CurrentUser >********************************************************************************
|
||||
|
||||
/// Identidad mínima del usuario que ejecuta la petición actual.
|
||||
///
|
||||
/// Se almacena automáticamente en el [`Context`] a partir de la petición HTTP (ver
|
||||
/// [`Context::new()`](crate::core::component::Context::new)). La identidad se extrae de las
|
||||
/// extensiones de la petición, que una extensión de autenticación inyecta mediante su middleware.
|
||||
/// Se almacena automáticamente en el [`Context`] a partir de la petición HTTP. La identidad se
|
||||
/// extrae de las extensiones de la petición, que una extensión de autenticación inyecta mediante su
|
||||
/// middleware.
|
||||
///
|
||||
/// Se accede con [`Contextual::current_user()`](crate::core::component::Contextual::current_user).
|
||||
/// Se accede usando [`Contextual::current_user()`].
|
||||
///
|
||||
/// Los datos extendidos del usuario autenticado (roles, permisos, cuenta completa, ...) son
|
||||
/// responsabilidad de la extensión de autenticación y se obtienen a través de
|
||||
/// [`HttpRequest::extension`](crate::web::HttpRequest::extension).
|
||||
/// [`HttpRequest::extension`].
|
||||
///
|
||||
/// [`Context`]: crate::core::component::Context
|
||||
/// [`Contextual::current_user()`]: crate::core::component::Contextual::current_user
|
||||
/// [`HttpRequest::extension`]: crate::web::HttpRequest::extension
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum CurrentUser {
|
||||
/// Usuario no autenticado.
|
||||
|
|
@ -67,31 +80,93 @@ impl CurrentUser {
|
|||
}
|
||||
}
|
||||
|
||||
// **< Permission >*********************************************************************************
|
||||
|
||||
/// Clave tipada de un permiso de acceso.
|
||||
///
|
||||
/// Cada extensión que lo requiera puede definir su propio enum de permisos e implementar este trait
|
||||
/// para obtener la clave textual que finalmente se compara contra su modelo de permisos (RBAC en
|
||||
/// base de datos, grupos LDAP, ...).
|
||||
///
|
||||
/// # Ejemplo
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// # use pagetop::auth::Permission;
|
||||
/// # use pagetop::CowStr;
|
||||
/// #[derive(Clone, Copy, Debug)]
|
||||
/// pub enum MyPermission {
|
||||
/// EditPosts,
|
||||
/// DeletePosts,
|
||||
/// }
|
||||
///
|
||||
/// impl Permission for MyPermission {
|
||||
/// fn key(&self) -> CowStr {
|
||||
/// match self {
|
||||
/// Self::EditPosts => "my_extension.edit_posts".into(),
|
||||
/// Self::DeletePosts => "my_extension.delete_posts".into(),
|
||||
/// }
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
pub trait Permission: Send + Sync {
|
||||
/// Clave única del permiso (p. ej. `"my_extension.edit_posts"`).
|
||||
fn key(&self) -> CowStr;
|
||||
|
||||
/// Descripción breve para humanos (p. ej. en una pantalla de asignación de permisos a roles).
|
||||
///
|
||||
/// Por defecto devuelve la propia clave; una extensión que registre sus permisos en un catálogo
|
||||
/// visible debería sobrescribirlo con un texto traducible.
|
||||
fn label(&self) -> L10n {
|
||||
L10n::n(self.key())
|
||||
}
|
||||
|
||||
/// Identificador estable de la categoría del permiso, usado para agrupar en un catálogo (p.
|
||||
/// ej. `"administration"`). Por defecto no pertenece a ningún grupo.
|
||||
fn group(&self) -> &'static str {
|
||||
""
|
||||
}
|
||||
|
||||
/// Título traducible de [`group()`](Self::group), mostrado en la UI de administración.
|
||||
///
|
||||
/// Por defecto reutiliza el propio identificador del grupo como texto fijo.
|
||||
fn group_label(&self) -> L10n {
|
||||
L10n::n(self.group())
|
||||
}
|
||||
}
|
||||
|
||||
/// Referencia estática a un permiso de acceso.
|
||||
///
|
||||
/// Es el tipo que recorre toda la API de autorización ([`has_permission()`],
|
||||
/// [`require_permission()`] o [`CheckPermission`]).
|
||||
pub type PermissionRef = &'static dyn Permission;
|
||||
|
||||
// **< CheckPermission >****************************************************************************
|
||||
|
||||
/// Tipo de función para comprobar si el usuario actual tiene un permiso concreto.
|
||||
///
|
||||
/// Se invoca con:
|
||||
///
|
||||
/// - `cx`: el contexto de renderizado desde el que se puede acceder a la petición HTTP y a
|
||||
/// cualquier dato inyectado por el middleware de autenticación.
|
||||
/// - `key`: clave del permiso a comprobar (p. ej. `"myapp.edit_posts"`).
|
||||
/// - `request`: petición HTTP desde la que se accede a los datos inyectados por el middleware de
|
||||
/// autenticación.
|
||||
/// - `perm`: permiso a comprobar; el handler usará [`Permission::key()`] para identificarlo contra
|
||||
/// su propio modelo de permisos.
|
||||
/// - `granted`: referencia mutable; el handler debe asignarla a `true` si concede el permiso.
|
||||
pub type FnCheckPermission = fn(cx: &Context, key: &str, granted: &mut bool);
|
||||
pub type FnActionCheckPerm = fn(request: &HttpRequest, perm: PermissionRef, granted: &mut bool);
|
||||
|
||||
/// Acción para comprobar si el usuario actual tiene un permiso concreto.
|
||||
///
|
||||
/// Las extensiones de autenticación registran handlers de esta acción para implementar su modelo de
|
||||
/// permisos. Los handlers son aditivos: si cualquiera de ellos asigna `granted = true`, el permiso
|
||||
/// se concede.
|
||||
/// Las extensiones de autenticación pueden registrar su handler sobre esta acción para implementar
|
||||
/// su modelo de permisos. Los handlers son aditivos de tal forma que si cualquiera de ellos asigna
|
||||
/// `granted = true`, el permiso se concede.
|
||||
///
|
||||
/// # Ejemplo
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// # use pagetop::prelude::*;
|
||||
/// fn check_my_permissions(cx: &Context, key: &str, granted: &mut bool) {
|
||||
/// // Leer datos extendidos de autenticación desde las extensiones de la petición.
|
||||
/// // Si el usuario tiene el permiso, asignar `*granted = true`.
|
||||
/// fn check_my_permissions(request: &HttpRequest, perm: PermissionRef, granted: &mut bool) {
|
||||
/// // Leer los datos extendidos de autenticación inyectados en la petición.
|
||||
/// // Comparar `perm.key()` contra el modelo propio.
|
||||
/// // Si concede el permiso, asignar `*granted = true`.
|
||||
/// }
|
||||
///
|
||||
/// pub struct MyAuth;
|
||||
|
|
@ -104,7 +179,7 @@ pub type FnCheckPermission = fn(cx: &Context, key: &str, granted: &mut bool);
|
|||
/// }
|
||||
/// ```
|
||||
pub struct CheckPermission {
|
||||
f: FnCheckPermission,
|
||||
f: FnActionCheckPerm,
|
||||
weight: Weight,
|
||||
}
|
||||
|
||||
|
|
@ -116,7 +191,7 @@ impl ActionDispatcher for CheckPermission {
|
|||
|
||||
impl CheckPermission {
|
||||
/// Registra una nueva acción para la comprobación de permisos.
|
||||
pub fn new(f: FnCheckPermission) -> Self {
|
||||
pub fn new(f: FnActionCheckPerm) -> Self {
|
||||
CheckPermission { f, weight: 0 }
|
||||
}
|
||||
|
||||
|
|
@ -128,12 +203,12 @@ impl CheckPermission {
|
|||
|
||||
// Despacha las acciones registradas con salida anticipada en cuanto una concede el permiso.
|
||||
#[inline]
|
||||
pub(crate) fn check(cx: &Context, key: &str) -> bool {
|
||||
pub(crate) fn check(request: &HttpRequest, perm: PermissionRef) -> bool {
|
||||
let mut granted = false;
|
||||
try_dispatch_actions(
|
||||
&ActionKey::new(UniqueId::of::<Self>(), None, None),
|
||||
|action: &Self| {
|
||||
(action.f)(cx, key, &mut granted);
|
||||
(action.f)(request, perm, &mut granted);
|
||||
if granted {
|
||||
std::ops::ControlFlow::Break(())
|
||||
} else {
|
||||
|
|
@ -160,14 +235,62 @@ impl CheckPermission {
|
|||
///
|
||||
/// ```rust,no_run
|
||||
/// # use pagetop::prelude::*;
|
||||
/// # #[derive(Clone, Copy, Debug)]
|
||||
/// # enum MyPermission { Edit }
|
||||
/// # impl Permission for MyPermission {
|
||||
/// # fn key(&self) -> CowStr { "myapp.edit".into() }
|
||||
/// # }
|
||||
/// async fn my_handler(request: HttpRequest) -> Result<Markup, ErrorPage> {
|
||||
/// let mut page = Page::new(request.clone());
|
||||
/// if !has_permission(page.context(), "myapp.edit") {
|
||||
/// return Err(ErrorPage::NotFound(request));
|
||||
/// if !has_permission(&request, &MyPermission::Edit) {
|
||||
/// return Err(ErrorPage::NotFound(Some(request)));
|
||||
/// }
|
||||
/// page.render().await
|
||||
/// Page::new(request).render().await
|
||||
/// }
|
||||
/// ```
|
||||
pub fn has_permission(cx: &Context, key: &str) -> bool {
|
||||
CheckPermission::check(cx, key)
|
||||
pub fn has_permission(request: &HttpRequest, perm: PermissionRef) -> bool {
|
||||
CheckPermission::check(request, perm)
|
||||
}
|
||||
|
||||
// **< require_permission >*************************************************************************
|
||||
|
||||
/// Comprueba un permiso y devuelve `Err(ErrorPage::AccessDenied)` si se deniega.
|
||||
///
|
||||
/// Ejecuta [`has_permission()`] para el caso más habitual: detener un handler con una respuesta 403
|
||||
/// en cuanto falta el permiso, sin repetir el `if`/`return` en cada punto de comprobación. Se hace
|
||||
/// directamente sobre la petición, antes de construir ni ejecutar nada (`Context`, `Page`,
|
||||
/// consultas a datos, etc.), para no hacer ningún trabajo si la petición no está autorizada.
|
||||
///
|
||||
/// Si la aplicación necesita ocultar la existencia del recurso a quien no tiene permiso (devolver
|
||||
/// un 404 en vez de un 403), no se puede reutilizar esta función: hay que llamar a
|
||||
/// `has_permission()` directamente, como en su propio ejemplo.
|
||||
///
|
||||
/// # Ejemplo
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// # use pagetop::prelude::*;
|
||||
/// # #[derive(Clone, Copy, Debug)]
|
||||
/// # enum MyPermission { Edit }
|
||||
/// # impl Permission for MyPermission {
|
||||
/// # fn key(&self) -> CowStr { "myapp.edit".into() }
|
||||
/// # }
|
||||
/// async fn my_handler(request: HttpRequest) -> Result<Markup, ErrorPage> {
|
||||
/// // Comprueba si la petición está autorizada.
|
||||
/// require_permission(&request, &MyPermission::Edit)?;
|
||||
///
|
||||
/// // Ejecuta las instrucciones propias de la petición.
|
||||
/// Page::new(request)
|
||||
/// .with_child(Html::with(|_| html! { p { "You have permission!" } }))
|
||||
/// .render()
|
||||
/// .await
|
||||
/// }
|
||||
/// ```
|
||||
// `ErrorPage` incluye `Option<HttpRequest>` en cada variante y es el tipo de error ya establecido
|
||||
// para toda la respuesta HTTP; boxearlo aquí sólo para esta función no compensa.
|
||||
#[allow(clippy::result_large_err)]
|
||||
pub fn require_permission(request: &HttpRequest, perm: PermissionRef) -> Result<(), ErrorPage> {
|
||||
if has_permission(request, perm) {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(ErrorPage::AccessDenied(Some(request.clone())))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue