Mejores prácticas para roles frente a notificaciones en ASP.NET Identity

Soy completamente nuevo en el uso de claimsin ASP.NETIdentityy quiero tener una idea de las mejores prácticas en el uso de Roles and/or Claims.

Después de toda esta lectura, todavía tengo preguntas como ...

P: ¿Ya no usamos roles?
P: Si es así, ¿por qué se siguen ofreciendo funciones?
P: ¿Deberíamos utilizar únicamente reclamaciones?
P: ¿Debemos usar Roles & Claims juntos?

Mi pensamiento inicial es que "deberíamos" usarlos juntos. Veo Claimscomo subcategorías a las Rolesque apoyan.

POR EJEMPLO:
Rol:
Reclamaciones contables : CanUpdateLedger, CanOnlyReadLedger, CanDeleteFromLedger

P: ¿Están destinados a ser mutuamente excluyentes?
P: ¿O es mejor ir SOLO a reclamos y "calificar completamente" sus reclamos?
P: Entonces, ¿cuáles son las mejores prácticas aquí?

EJEMPLO: Usar roles y reclamos juntos
Por supuesto, tendría que escribir su propia lógica de atributos para esto ...

[Authorize(Roles="Accounting")]
[ClaimAuthorize(Permission="CanUpdateLedger")]
public ActionResult CreateAsset(Asset entity)
{
    // Do stuff here

    return View();
}

EJEMPLO: Calificación total de sus reclamos

[ClaimAuthorize(Permission="Accounting.Ledger.CanUpdate")]
public ActionResult CreateAsset(Asset entity)
{
    // Do stuff here

    return View();
}

Un rol es una categoría simbólica que agrupa a los usuarios que comparten los mismos niveles de privilegios de seguridad. La autorización basada en roles requiere primero identificar al usuario, luego determinar los roles a los que está asignado el usuario y finalmente comparar esos roles con los roles que están autorizados para acceder a un recurso.

Por el contrario, una afirmación no se basa en el grupo, sino en la identidad.

de la documentación de Microsoft :

Cuando se crea una identidad, se le pueden asignar una o más reclamaciones emitidas por una parte de confianza. Un reclamo es un par de nombre-valor que representa lo que es el sujeto, no lo que el sujeto puede hacer.

Un control de seguridad puede determinar posteriormente el derecho a acceder a un recurso en función del valor de una o más reclamaciones.

Usted puede utilizar tanto en concierto, o usar un tipo en algunas situaciones y la otra en otras situaciones. Depende principalmente de la interacción con otros sistemas y su estrategia de gestión. Por ejemplo, podría ser más fácil para un administrador administrar una lista de usuarios asignados a un rol que administrar quién tiene asignado un reclamo específico. Los reclamos pueden ser muy útiles en un escenario RESTful donde puede asignar un reclamo a un cliente, y el cliente puede presentar el reclamo de autorización en lugar de pasar el nombre de usuario y la contraseña para cada solicitud.

Como @Claies explicó perfectamente, las reclamaciones podrían ser más descriptivas y tienen un tipo de rol profundo. Pienso en ellos como sus identificaciones de roles. Tengo una identificación de gimnasio, así que pertenezco al rol de miembros. También estoy en las lecciones de kickboxing, así que tengo un reclamo de identificación de kickboxing para ellos. Mi aplicación necesitaría la declaración de un nuevo rol para adaptarse a mis derechos como miembro. En cambio, tengo identificadores para cada clase de grupo a la que pertenezco, en lugar de muchos tipos nuevos de membresía. Es por eso que las afirmaciones me quedan mejor.

Hay un gran video explicativo de Barry Dorrans, que habla de la ventaja de usar reclamos sobre roles. También afirma que los roles todavía están en .NET para compatibilidad con versiones anteriores. El video es muy informativo sobre la forma en que funcionan las reclamaciones, los roles, las políticas, la autorización y la autenticación.

Puede encontrarlo aquí: Autorización de ASP.NET Core con Barr Dorrans

Después de haber utilizado varias técnicas de autenticación y autorización durante décadas, mi aplicación MVC actual utiliza la siguiente metodología.

Las reclamaciones se utilizan para todas las autorizaciones. A los usuarios se les asigna un rol (son posibles varios roles, pero no los necesito) - más abajo.

Como es práctica común, se utiliza una clase de atributo ClaimsAuthorize. Dado que la mayoría de las acciones del controlador son CRUD, tengo una rutina en la generación de la base de datos de código primero que itera todas las acciones del controlador y crea tipos de reclamaciones para cada atributo de acción del controlador de lectura / edición / creación / eliminación. Por ejemplo, de

[ClaimsAuthorize("SomeController", "Edit")]
[HttpPost]

Para usar en una vista MVC, una clase de controlador base presenta elementos de bolsa de vista

        protected override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            // get user claims
            var user = filterContext.HttpContext.User as System.Security.Claims.ClaimsPrincipal;

            if (user != null)
            {
                // Get all user claims on this controller. In this controler base class, [this] still gets the descendant instance type, hence name
                List<Claim> claims = user.Claims.Where(c => c.Type == this.GetType().Name).ToList();

                // set Viewbag with default authorisations on this controller
                ViewBag.ClaimRead = claims.Any(c => c.Value == "Read");
                ViewBag.ClaimEdit = claims.Any(c => c.Value == "Edit");
                ViewBag.ClaimCreate = claims.Any(c => c.Value == "Create");
                ViewBag.ClaimDelete = claims.Any(c => c.Value == "Delete");
            }

            base.OnActionExecuting(filterContext);
        }

Para los menús del sitio web y otras acciones ajenas al controlador, tengo otros reclamos. Por ejemplo, si un usuario puede ver un campo monetario en particular.

bool UserHasSpecificClaim(string claimType, string claimValue)
{
    // get user claims
    var user = this.HttpContext.User as System.Security.Claims.ClaimsPrincipal;

    if (user != null)
    {
        // Get the specific claim if any
        return user.Claims.Any(c => c.Type == claimType && c.Value == claimValue);
    }

    return false;
}

public bool UserHasTradePricesReadClaim
{
    get
    {
        return UserHasSpecificClaim("TradePrices", "Read");
    }
}

Entonces, ¿dónde encajan los roles?

Tengo una tabla que vincula un rol a un conjunto (predeterminado) de reclamaciones. Al configurar la autorización del usuario, el valor predeterminado es otorgar al usuario los reclamos de su función. Cada usuario puede tener más o menos reclamos que el predeterminado. Para simplificar la edición, la lista de reclamos se muestra por controlador y acciones (en una fila), y luego se enumeran otros reclamos. Los botones se utilizan con un poco de Javascript para seleccionar un conjunto de acciones para minimizar el "clic" requerido para seleccionar reclamos. En Guardar, se eliminan las reclamaciones de los usuarios y se agregan todas las reclamaciones seleccionadas. La aplicación web carga reclamos solo una vez, por lo que cualquier cambio debe provocar una recarga dentro de estos datos estáticos.

Por lo tanto, los administradores pueden seleccionar qué reclamos están en cada rol y qué reclamos tiene un usuario después de establecerlos en un rol y esos reclamos predeterminados. El sistema tiene solo una pequeña cantidad de usuarios, por lo que administrar estos datos es sencillo

Para comprender la diferencia entre roles y reclamos, puede enfrentar la limitación de roles y sentir cómo los reclamos surgen de estos problemas, así que le doy 2 escenarios para reconocer el poder de los reclamos donde el rol no puede resolver estos problemas:

1- su sitio tiene dos módulos (páginas, servicio ..etc) el primer módulo para niños (menores de 18 años) el otro para adultos (mayores de 18 años) su identidad de usuario tiene reclamo de cumpleaños

debe crear una política sobre este reclamo para que la autorización para cada módulo se otorgue en este valor y si la edad del usuario supera los 18 años, puede ir al módulo de adultos y no antes de esta edad.

El rol es un tipo de datos booleano que puede tener o no el rol el rol no tenía valores malty

2- su sitio tiene rol de usuario y no desea evitar el acceso de los usuarios para realizar algún mantenimiento sin cambiar el código

en las reclamaciones, puede crear una política de UnderConstrain que, si el usuario verdadero no puede ver la página, autorice la propiedad para el usuario de rol.