Servicios REST con .NET Core
  • Servicios REST con ASP.NET Core y Entity Framework Core
  • 1. Introducción
    • 1.1 Instalación Visual Studio Community
    • 1.2 Instalación de SQL Server en Mac
    • 1.3 Extensión Intellicode
    • 1.4 Aplicación de ejemplo
  • 2. Explicación de Conceptos
    • 2.1 Servicios REST
      • 2.1.1 OData
      • 2.1.2 GraphQL
    • 2.2 Entity Framework para versiones de tu base de datos
    • 2.3 Paquetes Nuget
    • 2.4 Archivo de recursos
    • 2.5 Estructura de los Proyectos .Net Core
    • 2.6 Código Limpio
    • 2.7 Programación asíncrona
    • 2.8 Git
    • 2.9 ¿Qué es Scrum?
      • 2.9.1 Personas
      • 2.9.2 Roles Scrum
      • 2.9.3 Backlog
      • 2.9.4 Reuniones del Scrum
  • 3. Control de código fuente y Scrum con Azure DevOps
    • 3.1 Introducción a Azure DevOps
      • 3.1.1 Crear un nuevo Proyecto en Azure DevOps
      • 3.1.2 Agregando personas al equipo de trabajo
      • 3.1.3 Agregando los sprints y la capacidad de trabajo
      • 3.1.4 Crear el Backlog y asignar User Stories al Sprint
      • 3.1.5 Crear Prototipos
      • 3.1.6 Conectar a Azure DevOps desde Visual Studio
        • 3.1.6.1 Crear tu proyecto con Visual Studio Community y sincronizarlo a Azure DevOps
      • 3.1.7 Consultar tus tareas pendientes
        • 3.1.7.1 Tareas y Dashboards con Azure DevOps
        • 3.1.7.2 Consultar tus tareas desde Visual Studio Community
      • 3.1.8 Trabajando con Ramas (Branches)
        • 3.1.8.1 Crear la rama desarrollo desde Azure DevOps
          • 3.1.8.1 Crear una rama(branch) desde tu tarea en Azure DevOps
        • 3.1.8.2 Como trabajar con ramas (branches) desde Visual Studio Community
        • 3.1.8.3 Crear el Pull Request con Azure DevOps
      • 3.1.9 Retrospectiva del Sprint
      • 3.1.10 Agregando una Wiki
    • 3.2 Integrando tu código fuente a GitHub
      • 3.2.1 Trabajando con ramas en GitHub
      • 3.2.2 Sincronizar los cambios del código con GitHub y Visual Studio
      • 3.3 Trabajando con Branches (Ramas) con Visual Studio
        • 3.3.1 Branches con Visual Studio
        • 3.3.2 Creando un template para tus PR (Pull Request)
        • 3.3.3 Protegiendo tu branch
  • 4. Creando tu primer servicio
    • 4.1 Crear las base de datos y los usuarios en MySQL
    • 4.2 Crear la tabla Categoría y sus validaciones
    • 4.3 Creando el servicio Categorias
    • 4.4 Probando tus servicios con POSTMAN
    • 4.5 Documentar y Probar tus servicios con Swagger
      • 4.5.1 Configurar Swagger
      • 4.5.2 Comentarios XML
      • 4.5.3 Generando la página de documentación
    • 4.6 Agregando índices
    • 4.7 Mejorando tu código
      • 4.7.1 Creando Objetos de Accesos a Datos
      • 4.7.2 Creando tus mensajes de error en diferentes idiomas
      • 4.7.3 Cambiando el formato del Json de los servicios
  • 5. Agregando el servicio para los productos
    • 5.1 Crear la tabla de Productos
    • 5.2 Formas de cargar información de tablas relacionadas
    • 5.3 Crear llaves fóraneas e índices
    • 5.4 Creando el servicio Productos
    • 5.5 Validar Reglas Mejorando tu código
      • 5.5.1 Agregando una excepción a todos nuestros servicios
      • 5.5.2 Agregando clases genéricas para validar y/o consultar información
      • 5.5.3 Alternativa para validar reglas con ef core
  • 6. Cambiar de base de datos a SQL Server
    • 6.1 Cambiar la base de datos a SQL Server
    • 6.2 Cambiar a SQL Server en Azure
  • 7. Crear servicios con OData
    • 7.1.1 Creando el modelo Clientes
    • 7.1.2 Creando el modelo ClienteCategoría
    • 7.1.3 Agregando paquete Nuget para OData
    • 7.1.4 Configurar el EDM Model
    • 7.1.5 Configurar el servicio OData y llaves foráneas
    • 7.1.6 Creando el Controller para clientes
    • 7.1.7 Configurar y probar los servicios con OData
    • 7.1.8 Práctica Crear el servicio para ClientesCategorias
    • 7.1.9 Recomendaciones de seguridad y rendimiento a tomar en cuenta con OData
  • 8. GraphQL
    • 8.1.1 Creando la tabla Caducidad
    • 8.1.2 Creando el query
    • 8.1.3 Configurando y probando graphQL
    • 8.1.4 Creando la Mutation
    • 8.1.5 Probando nuestros servicios con Postman
  • 9. Seguridad
    • 9.1 Json Web Tokens
    • 9.2 Seguridad basada en roles y usuarios
      • 9.2.1 Creando nuestra tabla roles e insertando los roles principales
      • 9.2.2 Consideraciones de seguridad para almacenar tus passwords
      • 9.2.3 Creando las tablas para manejar la seguridad
      • 9.2.4 Agregando usuarios y roles
    • 9.3 Agregando seguridad a nuestros servicios
    • 9.4 Creando nuestro servicio de login y generar el token
    • 9.5 ¿Cómo agregar seguridad basada en roles a los Servicios REST?
      • 9.5.1 Seguridad basada en claims
      • 9.5.2 Creando las tablas para validar permisos por cada tabla
      • 9.5.3 Seguridad basada en directivas
      • 9.5.4 Seguridad con Action Filters
    • 9.6 Guardando el historial de cambios
    • 9.7 Refrescando tu token
    • 9.8 Seguridad Mejorando tu código
      • 9.8.1 ¿Cómo limitar el número de intentos incorrectos en el login?
      • 9.8.2 ¿Cómo obtener la ciudad del usuario por medio de la IP?
      • 9.8.3 Habilitando CORS
  • 10. Pruebas Unitarias
    • 10.1 Agregando el proyecto de pruebas unitarias
    • 10.2 Crear una prueba unitaria
      • 10.2.1 Ejecutando las pruebas unitarias
    • 10.3 Agregando una base de datos en memoria para nuestras pruebas unitarias
    • 10.4 Agregando la referencia de nuestro proyecto CaducaRest
      • 10.4.1 Agregando paquetes nuget necesarios
    • 10.5 Configurando Clases para Objetos Sustitutos
      • 10.5.1 Configurando el Contexto para utilizar la base de datos en Memoria
      • 10.5.2 Configurando el objeto para sustituir mensajes de Error por idioma
    • 10.6 Agregando pruebas para las Categorías
  • 11. Integración continua
    • 11.1 ¿Qué es la integración continua?
    • 11.2 Subir tu código fuente a BitBucket
      • 11.2.1 Integración continua y pruebas automáticas con Bitbucket
    • 11.3 Integración continua y pruebas automáticas en Azure DevOps
  • 12. Pruebas de integración
    • 12.1 ¿Qué es SpecFlow?
    • 12.2 Agregando el proyecto de pruebas de integración
    • 12.3 Configurando Specflow
    • 12.4 Creando pruebas para el login
    • 12.5 Agregando las pruebas de Integración a Azure Devops
    • 12.6 Specflow Mejorando tu código
      • 12.6.1 Cambiando las pruebas a español
      • 12.6.2 Pasando tablas a nuestras pruebas
      • 12.6.3 Agregar los passwords como variables de ambiente
      • 12.6.4 Probando con SQLite
      • 12.6.5 Agregando diferentes parámetros con MSTest
      • 12.6.6 Generando el reporte living doc de specflow
  • 13. Integración continua con Postman
    • 13.1 Recomendaciones para probar tus servicios
    • 13.2 Instrucciones básicas para probar con Postman
    • 13.3 Crear colecciones en Postman
    • 13.4 Agregar pruebas a tus servicios
    • 13.5 Crear environments
    • 13.6 Agregando datos de prueba con archivos .csv
    • 13.7 Exportando tus colecciones y ejecutarlas con Newman.
    • 13.8 Agregando las colecciones de postman al pipeline
  • 14. Pruebas de usuario
    • 14.1 Page Object Model
    • 14.2 ¿Qué es Selenium?
      • 14.2.1 Selenium Instrucciones básicas
      • 14.2.2 Agregando el proyecto de pruebas de usuario
    • 14.3 ¿Qué es Cypress?
      • 14.3.1 Cypress Instrucciones básicas
    • 14.4 ¿Qué es Playwright?
      • 14.4.1 Playwright Instrucciones básicas
  • 15. Despliegue Continuo con Azure DevOps y Azure
    • 15.1 Crear un App Service en Azure
    • 15.2 Generando Artifacts en Azure Pipelines
    • 15.3 Generando el Release en Azure Pipelines al App Service de Azure
    • 15.4 Ejecutando las colecciones de Postman después del release
    • 15.5 Agregando las pruebas de usuario en Azure Pipelines
  • 16. Instalación en Windows Server e IIS
    • 16.1 Instalar IIS en Windows Server
    • 16.2 Instalación del ASP.NET Core Module/Hosting Bundle
    • 16.3 Crea el Sitio Web en IIS
  • 17. Instalación en Linux
    • 17.1 Creando una máquina virtual linux en Azure
    • 17.2 Habilitando el acceso remoto
    • 17.3 Configura linux para .Net Core
    • 17.4 Instalando mysql
    • 17.5 Instalando Nginx y configurando tu servicio
    • 17.6 Instalando un certificado SSL gratuito con CertBot
    • 17.7 Agregando diferentes subdominios
  • 18. Docker
Powered by GitBook
On this page

Was this helpful?

  1. 9. Seguridad
  2. 9.5 ¿Cómo agregar seguridad basada en roles a los Servicios REST?

9.5.3 Seguridad basada en directivas

Previous9.5.2 Creando las tablas para validar permisos por cada tablaNext9.5.4 Seguridad con Action Filters

Last updated 2 years ago

Was this helpful?

Puedes utilizar la clase de .NET 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í

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

OperationAuthorizationRequirement
LogoAutorización basada en recursos en ASP.NET Coredocsmsft