Guide pratique pour implémenter des Access Control en fonction du rôle (RBAC) dans une application ASP.NET prenant en compte les revendications à l’aide de WIF et d’ACS

Article
11/09/2015

Mise à jour : 19 juin 2015

S’applique à : Azure

S'applique à

Microsoft Azure Active Directory Access Control (également appelé Access Control Service ou ACS)
Windows® Identity Foundation (WIF)
ASP.NET

Résumé

Cette rubrique explique comment implémenter l’autorisation de Access Control basée sur des rôles (RBAC) dans les applications web prenant en charge les revendications ASP.NET à l’aide de WIF et d’ACS.

Contenu

Objectifs
Vue d’ensemble
Résumé des étapes
Étape 1 : création d'une application web ASP.NET simple prenant en charge les revendications
Étape 2 : configuration des revendications de rôle dans ACS
Étape 3 : implémentation des vérifications des rôles dans une application web ASP.NET
Étape 4 : implémentation d'une transformation des revendications à l'aide du type ClaimsAuthenticationManager personnalisé
Étape 5 – Tester votre travail
Éléments associés

Objectifs

Configurez les revendications de rôle à l’aide d’ACS.
Transformer des revendications de rôle à l'aide du type ClaimsAuthenticationManager.
Implémentez des vérifications de contrôle d’accès en fonction du rôle à l’aide de la méthode IsInRole et des attributs PrinciaplPermission.

Vue d’ensemble

Le contrôle d'accès basé sur les rôles est une méthode largement répandue visant à restreindre l'accès à certaines applications. Dans ASP.NET applications web, cette approche est implémentée à l’aide de la méthode IsInRole, de l’attribut PrincipalPermission ou des demandes, qui ont été disponibles depuis ASP.NET 1.0. Vous pouvez utiliser des revendications pour l’autorisation, conservant ainsi des pratiques bien établies tout en utilisant de nouvelles technologies, telles que WIF et ACS. Un composant d'exécution et un Kit de développement logiciel (SDK) de WIF sont disponibles pour téléchargement à cette adresse :

Résumé des étapes

Étape 1 : création d'une application web ASP.NET simple prenant en charge les revendications
Étape 2 : configuration des revendications de rôle dans ACS
Étape 3 : implémentation des vérifications des rôles dans une application web ASP.NET
Étape 4 : implémentation d'une transformation des revendications à l'aide du type ClaimsAuthenticationManager personnalisé
Étape 5 – Tester votre travail

Étape 1 : création d'une application web ASP.NET simple prenant en charge les revendications

Cette étape vous indique comment créer une application web ASP.NET de base qui sera utilisée comme base pour l'implémentation du contrôle d'accès basé sur les rôles.

Pour créer une application web ASP.NET simple

Exécutez Visual Studio en tant qu'administrateur avec des privilèges élevés. Ces derniers sont nécessaires pour pouvoir utiliser WIF.
Créez une application web ASP.NET vide.
Ajoutez le formulaire web aspx et attribuez-lui un nom (par exemple, default.aspx).

Étape 2 : configuration des revendications de rôle dans ACS

Cette étape vous montre comment configurer les revendications de rôle sur le portail de gestion ACS à l’aide de groupes de règles. Reportez-vous à comment : implémenter une logique de transformation de jeton à l’aide de règles pour une procédure pas à pas complète.

Pour configurer les revendications de rôle sur le portail de gestion ACS

Sur la page Modifier l'application par partie de confiance, faites défiler le contenu jusqu'à la section Groupes de règles, puis cliquez sur le lien du groupe souhaité. Assurez-vous qu'il est sélectionné.
Sur la page Modifier le groupe de règles, faites défiler le contenu jusqu'à la section Règle, puis cliquez sur le lien Ajouter une règle.
Sur la page Ajouter une règle de revendication, faites défiler le contenu jusqu'à la section Type de revendication sortante, sélectionnez la case d'option Sélectionner le type, puis choisissez le type de revendication suivant.
```
https://schemas.microsoft.com/ws/2008/06/identity/claims/role
```
Dans la section Valeur de revendication sortante, cliquez sur Entrer une valeur, puis entrez le texte suivant en tant que valeur dans la zone de texte :
Utilisateur
Facultatif (recommandé) : ajoutez une description, puis cliquez sur Enregistrer.

Vous venez de configurer la revendication de rôle Utilisateur, qui peut désormais être ajoutée à n'importe quel jeton. Ce scénario peut différer en fonction de vos besoins. Pour plus d’informations sur la configuration de règles plus complexes, consultez Guide pratique pour implémenter une logique de transformation de jeton à l’aide de règles.

Étape 3 : implémentation des vérifications des rôles dans une application web ASP.NET

Cette étape vous indique comment implémenter le contrôle d'accès basé sur les rôles.

Pour implémenter le contrôle d'accès basé sur les rôles sur une page web ASP.NET

Ajoutez une référence à l'assembly Microsoft.IdentityModel.
Ouvrez le code en arrière-plan du fichier default.aspx.cs.

À l'aide des déclarations, ajoutez les éléments suivants.

using System.Security.Permissions;
using System.Threading;
using Microsoft.IdentityModel.Claims;
using System.Security;

Indiquez la demande suivante dans le gestionnaire d'événements Page_Load. Cet attribut vérifie si le rôle Utilisateur est affecté à l'utilisateur actuel. Si ce n'est pas le cas, une exception est envoyée.
```
[PrincipalPermission(SecurityAction.Demand, Role = "User")]
```
Ajoutez le code suivant au corps du gestionnaire d'événements Page_Load. Il est strictement identique à la demande indiquée dans le code.
```
PrincipalPermission p = new PrincipalPermission(null, "User");
   p.Demand();
```
Ajoutez le code suivant au corps de l'événement Page_Load. Contrairement au code précédent, ce code ne génère pas d'exception. La méthode IsInRole renvoie à la place un indicateur booléen signalant si l'utilisateur actuel possède le rôle spécifié.
```
if (!User.IsInRole("User"))
                throw new SecurityException("Access is denied.");
```

Le code complet doit ressembler à ce qui suit.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

using System.Security.Permissions;
using System.Threading;
using Microsoft.IdentityModel.Claims;
using System.Security;

namespace WebIsInRoleACS
{
    public partial class _default : System.Web.UI.Page
    {
        //THIS SHOULD THROW AN EXCEPTION
        [PrincipalPermission(SecurityAction.Demand, Role = "User")]
        protected void Page_Load(object sender, EventArgs e)
        {

            //THIS SHOULD THROW AN EXCEPTION
            PrincipalPermission p = new PrincipalPermission(null, "User");
            p.Demand();

            //THIS RETURNS BOOL
            if (!User.IsInRole("User"))
                throw new SecurityException("Access is denied.");
        }
    }
}

Étape 4 : implémentation d'une transformation des revendications à l'aide du type ClaimsAuthenticationManager personnalisé

Il s’agit d’une étape facultative. Cette étape montre comment transformer des revendications à l’aide de ClaimsAuthenticationManager, qui fait partie du pipeline WIF qui s’exécute dans le contexte de l’application ASP.NET, par opposition aux règles de transformation de revendications qui s’exécutent sur ACS, comme décrit à l’étape 2 : configurer les revendications de rôle dans acS.

Pour implémenter la transformation des revendications à l'aide d'un type ClaimsAuthenticationManager personnalisé

Ajoutez le projet Bibliothèque de classes à la solution Visual Studio, puis attribuez-lui un nom (par exemple, MyClaimsTransformationModule).
Ajoutez une référence à l'assembly Microsoft.IdentityModel.
Ajoutez une référence à l'assembly System.IdentityModel.
Créez une classe, puis attribuez-lui un nom (par exemple, ClaimsTransformationModule).

Ajoutez les déclarations suivantes à la classe.

using Microsoft.IdentityModel.Claims;
using System.Security.Principal;

Dérivez la classe du type ClaimsAuthenticationManager.

Remplacez sa méthode Authenticate (il s'agit de l'emplacement auquel la transformation des revendications sera effectuée). Le code de la méthode Authenticate peut être basé sur celui ci-après.

if (incomingPrincipal != null && incomingPrincipal.Identity.IsAuthenticated == true)
{
    //DECIDE ON SOME CRITERIA IF CURRENT USER DESERVES THE ROLE
    //IClaimsIdentity identity = (IClaimsIdentity)incomingPrincipal.Identity;
    ((IClaimsIdentity)incomingPrincipal.Identity).Claims.Add(
        new Claim(ClaimTypes.Role, "Admin"));
}
return incomingPrincipal;

Basculez vers l'application ASP.NET et configurez votre type ClaimsAuthenticationManager personnalisé dans le fichier web.config associé.

  <microsoft.identityModel>
    <service>
      <claimsAuthenticationManager type="MyClaimsTransformationModule.ClaimsTransformationModule, MyClaimsTransformationModule" />

Assurez-vous que l'application peut localiser l'assembly créé. Pour y parvenir facilement, placez-le dans le dossier Bin de l'application.

Étape 5 – Tester votre travail

Cette étape montre comment s'assurer que la solution fonctionne. Pour tester votre solution, appuyez sur la touche F5. Votre application web ASP.NET doit s'exécuter en mode débogage (vous pouvez ajouter des points d'arrêt afin de vous assurer que le code s'exécute correctement dans Visual Studio). Tout d'abord, vous devez être dirigé vers la page d'authentification du fournisseur d'identité configuré pour la fédération. Une fois l'authentification terminée, vous devez être redirigé vers la page Default.aspx sans qu'aucune exception ne soit lancée. Cela signifie ainsi que toutes les demandes de sécurité relatives au rôle Utilisateur ont été satisfaites.

Guide pratique pour implémenter l’autorisation des revendications dans une application prenant en compte les revendications ASP.NET à l’aide de WIF et d’ACS