Meilleures pratiques pour les rôles et les revendications dans l'identité ASP.NET

Je suis complètement nouveau dans l'utilisation de claimsin ASP.NETIdentityet je souhaite avoir une idée des meilleures pratiques dans l'utilisation de Roles and/or Claims.

Après toute cette lecture, j'ai encore des questions comme ...

Q: N'utilisons-nous plus de rôles?
Q: Si oui, pourquoi les rôles sont-ils toujours offerts?
Q: Devrions-nous utiliser uniquement les réclamations?
Q: Devrions-nous utiliser les rôles et les revendications ensemble?

Ma première pensée est que nous «devrions» les utiliser ensemble. Je vois Claimscomme des sous-catégories à la Rolesqu'ils soutiennent.

PAR EXEMPLE:
Rôle:
Réclamations comptables : CanUpdateLedger, CanOnlyReadLedger, CanDeleteFromLedger

Q: Sont-ils destinés à s'exclure mutuellement?
Q: Ou est-il préférable de passer UNIQUEMENT aux réclamations et de vous qualifier pleinement?
Q: Quelles sont donc les meilleures pratiques ici?

EXEMPLE: Utilisation conjointe des rôles et des revendications
Bien sûr, vous devrez écrire votre propre logique d'attribut pour cela ...

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

    return View();
}

EXEMPLE: Qualification complète de vos réclamations

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

    return View();
}

Un rôle est une catégorie symbolique qui rassemble les utilisateurs partageant les mêmes niveaux de privilèges de sécurité. L'autorisation basée sur les rôles nécessite d'abord d'identifier l'utilisateur, puis de déterminer les rôles auxquels l'utilisateur est affecté, et enfin de comparer ces rôles aux rôles autorisés à accéder à une ressource.

En revanche, une revendication n'est pas basée sur un groupe, mais plutôt sur une identité.

à partir de la documentation Microsoft :

Lorsqu'une identité est créée, une ou plusieurs revendications peuvent lui être attribuées par une partie de confiance. Une revendication est une paire nom-valeur qui représente ce qu'est le sujet et non ce que le sujet peut faire.

Un contrôle de sécurité peut ultérieurement déterminer le droit d'accéder à une ressource en fonction de la valeur d'une ou plusieurs revendications.

Vous pouvez utiliser les deux en concert ou utiliser un type dans certaines situations et l'autre dans d'autres situations. Cela dépend principalement de l'interopérabilité avec d'autres systèmes et de votre stratégie de gestion. Par exemple, il peut être plus facile pour un responsable de gérer une liste d'utilisateurs affectés à un rôle que de gérer qui a une revendication spécifique attribuée. Les revendications peuvent être très utiles dans un scénario RESTful où vous pouvez attribuer une revendication à un client, et le client peut alors présenter la demande d'autorisation plutôt que de transmettre le nom d'utilisateur et le mot de passe pour chaque demande.

Comme @Claies l'a parfaitement expliqué, les revendications pourraient être plus descriptives et constituent une sorte de rôle profond. Je pense à eux comme à vos rôles. J'ai un identifiant de gym, donc j'appartiens au rôle des membres. Je suis également dans les cours de kickboxing, donc j'ai une demande d'identification de kickboxing pour eux. Ma candidature nécessiterait la déclaration d'un nouveau rôle pour correspondre à mes droits d'adhésion. Au lieu de cela, j'ai des identifiants pour chaque classe de groupe à laquelle j'appartiens, au lieu de beaucoup de nouveaux types d'adhésion. C'est pourquoi les réclamations me conviennent mieux.

Il y a une excellente vidéo d'explication de Barry Dorrans, qui parle de l'avantage d'utiliser des revendications sur les rôles. Il déclare également que les rôles sont toujours dans .NET pour une compatibilité descendante. La vidéo est très informative sur le fonctionnement des revendications, des rôles, des politiques, de l'autorisation et de l'authentification.

Vous pouvez le trouver ici: Autorisation ASP.NET Core avec Barr Dorrans

Ayant utilisé diverses techniques d'authentification et d'autorisation pendant des décennies, mon application MVC actuelle utilise la méthodologie suivante.

Les revendications sont utilisées pour toutes les autorisations. Les utilisateurs se voient attribuer un rôle (plusieurs rôles sont possibles mais je n'en ai pas besoin) - plus d'informations ci-dessous.

Comme c'est la pratique courante, une classe d'attribut ClaimsAuthorize est utilisée. Étant donné que la plupart des actions de contrôleur sont CRUD, j'ai une routine dans la génération de base de données code-first qui itère toutes les actions de contrôleur et crée des types de revendication pour chaque attribut d'action de contrôleur de Lire / Modifier / Créer / Supprimer. Par exemple de,

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

Pour une utilisation dans une vue MVC, une classe de contrôleur de base présente des éléments de sac de vue

        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);
        }

Pour les menus du site Web et d'autres actions non liées au contrôleur, j'ai d'autres réclamations. Par exemple, si un utilisateur peut afficher un champ monétaire particulier.

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");
    }
}

Alors, où se situent les rôles?

J'ai un tableau qui lie un rôle à un ensemble (par défaut) de revendications. Lors de la définition de l'autorisation utilisateur, la valeur par défaut est de donner à l'utilisateur les revendications de son rôle. Chaque utilisateur peut avoir plus ou moins de revendications que la valeur par défaut. Pour simplifier l'édition, la liste des revendications est affichée par contrôleur et actions (dans une ligne), avec d'autres revendications ensuite répertoriées. Les boutons sont utilisés avec un peu de Javascript pour sélectionner un ensemble d'actions afin de minimiser le «clic» requis pour sélectionner les revendications. Lors de l'enregistrement, les revendications des utilisateurs sont supprimées et toutes les revendications sélectionnées sont ajoutées. L'application Web ne charge les revendications qu'une seule fois, de sorte que toute modification doit entraîner un rechargement dans ces données statiques.

Les responsables peuvent donc sélectionner quelles revendications sont dans chaque rôle et quelles revendications un utilisateur a après leur attribution à un rôle et à ces revendications par défaut. Le système ne compte qu'un petit nombre d'utilisateurs, la gestion de ces données est donc simple

Pour comprendre la différence entre les rôles et les revendications, vous devez faire face à la limitation des rôles et pour sentir comment les revendications surmontent ces problèmes, alors allumez-moi vous donner 2 scénarios pour reconnaître le pouvoir des revendications où le rôle ne peut pas résoudre ces problèmes:

1- votre site doit comporter deux modules (pages, service ..etc) le premier module pour enfant (moins de 18 ans) l'autre pour adulte (plus de 18 ans) votre identité d'utilisateur a une demande d'anniversaire

vous devez créer une politique sur cette réclamation afin que l'autorisation pour chaque module soit donnée sur cette valeur et si l'âge de l'utilisateur dépasse les 18 ans, il peut accéder au module adulte et pas avant cet âge

Le rôle est un type de données booléen que vous pouvez avoir ou non le rôle Le rôle n'a pas de valeurs malty

2- votre site a un rôle d'utilisateur et vous ne voudrez pas empêcher l'accès des utilisateurs pour faire de la maintenance sans changer le code

dans les revendications, vous pouvez créer une stratégie UnderConstrain qui, si le véritable utilisateur ne peut pas afficher la page, donne à la propriété une autorisation pour l'utilisateur de rôle.