9.5.3 Seguridad basada en directivas

Puedes utilizar la clase de .NET OperationAuthorizationRequirement la cual nos facilita registrar todos los posibles permisos que maneja tu aplicación. Creamos una clase Operaciones en nuestra carpeta Core y agregamos los tipos de permisos que manejará nuestra aplicación.

Operaciones.cs

public static class Operaciones
{
    public static OperationAuthorizationRequirement Crear = new
            OperationAuthorizationRequirement
    { Name = "Crear" };
    public static OperationAuthorizationRequirement Modificar = new
            OperationAuthorizationRequirement
    { Name = "Modificar" };
    public static OperationAuthorizationRequirement Borrar = new
            OperationAuthorizationRequirement
    { Name = "Borrar" };
    public static OperationAuthorizationRequirement Consultar = new
            OperationAuthorizationRequirement
    { Name = "Consultar" };
}

Creamos una clase PermisoDTO el cual nos indica que tabla deseamos validar, y también indicamos una variable SoloAdministradores en el cual si esta en true esta tabla sólo es accesible a los usuarios con el rol de Administrador.

PermisoDTO.cs

namespace CaducaRest.DTO;

/// <summary>
/// Permite validar los permisos de cada servicio
/// </summary>
public class PermisoDTO
{
    /// <summary>
    /// Nombre de la tabla a validar
    /// </summary>
    public string Tabla { get; set; }

    /// <summary>
    /// Si esta en true se requiere permiso de Administrador
    /// </summary>
    public bool EsAdministrador { get; set; } = false;
}

Creamos nuestra clase RolTablaPermisoDAO la cual nos va a ayudar a validar que el usuario tenga acceso a la tabla de acuerdo a su rol, para la operación a realizar

RolTablaPermisoDAO.cs

using System.Linq;
using CaducaRest.Models;
using CaducaRest.Resources;

namespace CaducaRest.DAO;

public class TablaRolPermisoDAO
{
    private readonly CaducaContext contexto;
    private readonly LocService localizacion;

    public TablaRolPermisoDAO(CaducaContext context, LocService localize)
    {
        this.contexto = context;
        this.localizacion = localize;
    }

    public bool TienePermiso(int usuarioId, string tabla,
                             string operacion)
    {
       var test= from Tabla in contexto.Tabla select Tabla.Nombre;
        var permiso = (from Tabla in contexto.Tabla
                       join TablaPermiso in contexto.TablaPermiso
                         on Tabla.Id equals TablaPermiso.TablaId
                       join Permiso in contexto.Permiso
                         on TablaPermiso.PermisoId equals Permiso.Id
                       join RolTablaPermiso in contexto.RolTablaPermiso
                         on TablaPermiso.Id equals RolTablaPermiso.TablaPermisoId
                       join UsuarioRol in contexto.UsuarioRol
                         on RolTablaPermiso.RolId equals UsuarioRol.RolId
                       where Tabla.Nombre == tabla
                          && Permiso.Nombre == operacion
                          && UsuarioRol.UsuarioId == usuarioId
                          && RolTablaPermiso.TienePermiso
                       select RolTablaPermiso.Id).FirstOrDefault();                     
        return permiso>0;
    }
}

Para nuestras reglas personalizadas es necesario crear una clase que herede de AuthorizationHandler, la cual recibe como objetos genéricos un objeto de la clase OperationAuthorizationRequirement y cualquier otro dato adicional en nuestro caso es nuestra clase PermisoDTO. Agregamos una clase llamada PermisoEditHandler en nuestra carpeta Core

PermisoEditHandler.cs

using System;
using System.Security.Claims;
using System.Threading.Tasks;
using CaducaRest.DTO;
using CaducaRest.Models;
using CaducaRest.DAO;
using CaducaRest.Resources;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization.Infrastructure;

namespace CaducaRest.Core
{
    public class PermisoEditHandler : AuthorizationHandler
                          <OperationAuthorizationRequirement, PermisoDTO>
    {
        private readonly CaducaContext contexto;
        private readonly LocService _localizer;

        public PermisoEditHandler(CaducaContext context,
                                  LocService localizer)
        {
            contexto = context;
            _localizer = localizer;
        }

        protected override Task HandleRequirementAsync(
                       AuthorizationHandlerContext context, 
                       OperationAuthorizationRequirement operacion,
                       PermisoDTO recurso)
        {
            var usuarioId = Convert.ToInt32(context.User
                     .FindFirst(c => c.Type == ClaimTypes.Sid).Value);
            //Se revisa si en el token se incluye el claim con el
            // id del usuario
            if (!context.User.HasClaim(c => c.Type == ClaimTypes.Sid))
                 context.Fail();
            RolDAO rolDAO = new RolDAO(contexto, _localizer);
            bool esAdministrador = rolDAO.EsAdministrador(usuarioId);
            //Si el recurso requiere un usuario administrador 
            // se valida que el usuario sea de tipo administrador
            // si no es asi, mandar error
            if (recurso.RequiereAdministrador && !esAdministrador)
                     context.Fail();
            else
            {                 
                if (!esAdministrador)
                {
                    //Se revisa si el usuario tiene autorización para realizar la acción
                    RolTablaPermisoDAO rolTablaPermisoDAO = new RolTablaPermisoDAO(contexto, _localizer);
                    if (!rolTablaPermisoDAO.TienePermiso(usuarioId, recurso.Tabla, operacion.Name))
                        context.Fail();
                    else
                        context.Succeed(operacion);
                }
                context.Succeed(operacion);
            }
            return Task.CompletedTask;
        }
    }
}

En nuestro archivo CategoriasController agregamos un objeto de la clase PermisoDTO indicando la tabla Categoria, y le indicamos que este servicio no requiere de un usuario Administrador.

Agregamos al archivo de recursos los siguientes mensajes de error:

Clave	Valor
ForbiddenUpdate	No tienes permiso para actualizar {0}. Por favor solicita el acceso.
ForbiddenAdd	No tienes permiso para agregar {0}. Por favor solicita el acceso.
ForbiddenDelete	No tienes permiso para borrar {0}. Por favor solicita el acceso.

En nuestro servicio get, agregamos la validación

CategoriasController.cs

public class CategoriasController : ControllerBase
{
    public CategoriasController(CaducaContext context,
                                LocService localizer,
                                IAuthorizationService authorizationService)
    {
            //Código
            permisoDTO = new PermisoDTO
            {
                Tabla = "Categoria",
                RequiereAdministrador = false
            };
    }
    
    [HttpGet]
    [Authorize(Roles = "Administrador, Vendedor")]
    public async Task<List<Categoria>> GetCategoriaAsync()
    {
        //Agregamos nuestra validación personalizada
        var authorizationResult = await _authorizationService
                 .AuthorizeAsync(User, permisoDTO, Operaciones.Consultar);
        //Si el resultado no fue exitoso regresamos una lista vacia
        if (!authorizationResult.Succeeded)
            return new List<Categoria>();
        return await categoriaDAO.ObtenerTodoAsync();
    } 
    
    [HttpPut("{id}")]
    [Authorize(Roles = "Administrador")]
    public async Task<IActionResult> PutCategoria([FromRoute] int id, 
                                           [FromBody] Categoria categoria)
    {
         var authorizationResult = await _authorizationService
                  .AuthorizeAsync(User, permisoDTO, Operaciones.Modificar);
         //Si el resultado no fue exitoso regresamos error
         if (!authorizationResult.Succeeded)
             return StatusCode(403, String.Format(
                this.localizacion.GetLocalizedHtmlString("ForbiddenUpdate"),
                      "La categoría"));  
        //Código   
    } 
    
    [HttpPost]
    [Authorize(Roles = "Administrador")]
    public async Task<IActionResult> PostCategoria(
                                        [FromBody] Categoria categoria)
    {
        var authorizationResult = await _authorizationService
                .AuthorizeAsync(User, permisoDTO, Operaciones.Crear);
        //Si el resultado no fue exitoso regresamos una lista vacia
        if (!authorizationResult.Succeeded)
            return StatusCode(403, String.Format(this.localizacion.
                 GetLocalizedHtmlString("ForbiddenAdd"), "La categoría"));
        //Código         
     }
     
     [HttpDelete("{id}")]
     [Authorize(Roles = "Administrador")]
     public async Task<IActionResult> DeleteCategoria([FromRoute] int id)
     {
         var authorizationResult = await _authorizationService
                     .AuthorizeAsync(User, permisoDTO, Operaciones.Borrar);
         //Si el resultado no fue exitoso regresamos una lista vacia
         if (!authorizationResult.Succeeded)
              return StatusCode(403, String.Format(this.localizacion.
                     GetLocalizedHtmlString("ForbiddenDelete"),
                      "La categoría"));
        //Código
}

Puedes ver la documentación oficial aquí

Autorización basada en recursos en ASP.NET Coredocsmsft

Esta es la recomendación en la página oficial de microsoft, puedes realizar la validación con filtros como explicaré en el siguiente capítulo