Exporter (0) Imprimer
Développer tout

Procédure : Implémenter IPrincipal

Dernière mise à jour le 31 août 2004
Sur cette page

Objectifs Objectifs
S'applique à S'applique à
Résumé Résumé
Points à connaître Points à connaître
Créer une application Web simple Créer une application Web simple
Configurer l'application Web en vue d'une authentification par formulaires Configurer l'application Web en vue d'une authentification par formulaires
Générer un ticket d'authentification pour les utilisateurs authentifiés Générer un ticket d'authentification pour les utilisateurs authentifiés
Créer une classe d'implémentation et d'extension de Iprincipal Créer une classe d'implémentation et d'extension de Iprincipal
Créer l'objet CustomPrincipal Créer l'objet CustomPrincipal
Tester l'application Tester l'application
Ressources supplémentaires Ressources supplémentaires

Objectifs

Ce module vous permet d'effectuer l'opération suivante :

  • créer une classe qui implémente l'interface IPrincipal à utiliser avec la sécurité par rôle .NET.

S'applique à

Ce module s'applique aux produits et technologies suivants :

  • Microsoft Windows® XP ou Windows 2000 Server (avec le Service Pack 3) et systèmes d'exploitation ultérieurs

  • .NET Framework version 1.0 (avec le Service Pack 2) et versions ultérieures

  • Microsoft Visual C#® .NET

Résumé

L'environnement Microsoft® .NET Framework fournit deux implémentations de l'interface IPrincipal : WindowsPrincipal et GenericPrincipal. Ces classes proposent des fonctionnalités de vérification de l'autorisation par rôle suffisantes pour la plupart des scénarios d'application.

Cependant, dans certaines circonstances, vous serez amené à développer votre propre implémentation IPrincipal afin d'obtenir des fonctionnalités personnalisées. Ce module décrit comment implémenter une classe IPrincipal personnalisée afin de l'utiliser pour l'autorisation par rôle dans une application ASP.NET qui fait appel à l'authentification par formulaires.

Points à connaître

L'environnement .NET Framework fournit les classes WindowsPrincipal et GenericPrincipal, qui offrent des fonctionnalités simples de vérification de rôle destinées respectivement aux mécanismes d'authentification Windows et non Windows. Ces deux classes implémentent l'interface IPrincipal. Pour être utilisé dans le cadre de l'autorisation, l'environnement ASP.NET nécessite que ces objets soient stockés dans HttpContext.User. Dans le cas des applications Windows, ils doivent être stockés dans Thread.CurrentPrincipal.

Les fonctionnalités proposées par ces classes s'avèrent suffisantes pour la plupart des scénarios d'application. Les applications peuvent explicitement appeler la méthode IPrincipal.IsInRole pour réaliser des vérifications de rôle par programmation. La méthode Demand de la classe PrincipalPermission, lorsqu'elle est utilisée pour demander si un appelant appartient à un rôle particulier (de manière déclarative ou impérative) appelle également IPrincipal.IsInRole.

Dans certains cas, vous serez amené à développer vos propres implémentations Principal en créant une classe qui implémente l'interface IPrincipal. Toute classe qui implémente IPrincipal peut être utilisée pour l'autorisation .NET.

Vous trouverez ci-dessous les raisons nécessitant l'implémentation de votre propre classe IPrincipal :

  • Vous souhaitez bénéficier de fonctionnalités étendues de vérification des rôles. Vous souhaitez disposer de méthodes qui vous permettent de vérifier si les différents utilisateurs sont membres de plusieurs rôles. Par exemple :

    CustomPrincipal.IsInAllRoles( "Rôle1", "Rôle2", "Rôle3" )
    CustomPrincipal.IsInAnyRole( "Rôle1", "Rôle2", "Rôle3" )
    
  • Vous voulez implémenter une méthode ou une propriété supplémentaire qui renvoie une liste de rôles dans un tableau. Par exemple :

    string[] roles = CustomPrincipal.Roles;
    
  • Vous voulez que votre application respecte la logique de hiérarchie des rôles. Il semble normal qu'un directeur (Direction générale), par exemple, soit situé plus haut dans la hiérarchie qu'un responsable d'équipe (Responsable). Vous pouvez effectuer des tests à l'aide de méthodes comme celle qui suit.

    CustomPrincipal.IsInHigherRole("Responsable");
    CustomPrincipal.IsInLowerRole("Responsable");
    
  • Vous voulez implémenter une initialisation différée des listes de rôles. Vous pourriez, par exemple, charger de façon dynamique la liste de rôles uniquement lors d'une demande de vérification des rôles.

Ce module décrit comment implémenter une classe IPrincipal personnalisée afin de l'utiliser pour l'autorisation par rôle dans une application ASP.NET qui fait appel à l'authentification par formulaires.

Créer une application Web simple

Au cours de cette procédure, vous allez créer une application Web ASP.NET. L'application contiendra deux pages, une par défaut, à laquelle seuls les utilisateurs authentifiés peuvent accéder, et une page de connexion permettant de recueillir les informations d'identification de l'utilisateur.

  • Pour créer une application Web simple

    1. Démarrez Visual Studio .NET et créez une application Web C# ASP.NET nommée CustomPrincipalApp.

    2. Renommez WebForm1.aspx en Logon.aspx.

    3. Ajoutez à Logon.aspx les contrôles mentionnés dans le tableau 1 pour créer un formulaire de connexion.

      Tableau 1 : Contrôles Logon.aspx

      Type de contrôle

      Texte

      ID

      Étiquette

      Nom d'utilisateur :

      -

      Étiquette

      Mot de passe

      -

      Zone de texte

      -

      txtUserName

      Zone de texte

      -

      txtPassword

      Bouton

      Connexion

      btnLogon

    4. Attribuez la valeur Password à la propriété TextMode du contrôle de zone de texte du mot de passe.

    5. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur CustomPrincipalApp, pointez sur Ajouter et cliquez sur Ajouter un formulaire Web.

    6. Adoptez default.aspx comme nom du nouveau formulaire et cliquez sur Ouvrir.

Configurer l'application Web en vue d'une authentification par formulaires

  • Pour modifier le fichier Web.config et configurer l'application en vue d'une authentification par formulaires

    1. Utilisez l'Explorateur de solutions pour ouvrir Web.config.

    2. Recherchez l'élément <authentication> et remplacez la valeur de l'attribut mode par Forms.

    3. Ajoutez l'élément <forms> suivant en tant qu'enfant de l'élément <authentication> et définissez les attributs loginUrl, name, timeout et path comme illustré ci-dessous :

      <authentication mode="Forms">
        <forms loginUrl="logon.aspx" name="AuthCookie" timeout="60" path="/">
        </forms>
      </authentication>
      
    4. Ajoutez l'élément <authorization> suivant sous l'élément <authentication>. Ainsi, seuls les utilisateurs authentifiés peuvent accéder à l'application. L'attribut loginUrl défini précédemment pour l'élément <authentication> redirige les demandes non authentifiées vers la page Logon.aspx.

      <authorization> 
        <deny users="?" />
        <allow users="*" />
      </authorization>
      

Générer un ticket d'authentification pour les utilisateurs authentifiés

Lors de cette procédure, du code est écrit pour générer un ticket d'authentification destiné aux utilisateurs authentifiés. Le ticket d'authentification constitue un type de cookie utilisé par le module FormsAuthenticationModule de ASP.NET.

Le code d'authentification implique généralement la recherche du nom d'utilisateur et du mot de passe dans une base de données personnalisée ou dans Microsoft Active Directory®.

Pour plus d'informations sur ces recherches, consultez les modules suivants du présent guide :

  • « Procédure : Utiliser l'authentification par formulaires avec Active Directory ».

  • « Procédure : Utiliser l'authentification par formulaires avec SQL Server 2000 ».

  • Pour générer un ticket d'authentification à l'attention des utilisateurs authentifiés

    1. Ouvrez le fichier Logon.aspx.cs et ajoutez l'instruction using suivante en haut du fichier, sous les instructions using existantes.

      using System.Web.Security;
      
    2. Ajoutez la méthode utile privée suivante à la classe WebForm1 nommée IsAuthenticated, destinée à valider les noms et les mots de passe des utilisateurs dans le cadre de l'authentification de ces derniers. Dans ce code, nous considérons que toutes les associations entre noms d'utilisateurs et mots de passe sont valides.

      private bool IsAuthenticated( string username, string password )
      {
        // Code de recherche omis pour plus de clarté.
        // Ce code entraînerait normalement la validation de la combinaison nom d'utilisateur-
        // mot de passe auprès d'une base de données SQL ou de Active Directory.
        // Simuler un utilisateur authentifié.
        return true;
      }
      
    3. Ajoutez la méthode utile privée suivante nommée GetRoles, qui permet d'obtenir l'ensemble des rôles auxquels l'utilisateur appartient.

      private string GetRoles( string username, string password )
      {
        // Code de recherche omis pour plus de clarté.
        // Ce code entraînerait normalement une recherche de la liste des rôles dans une table de base de données.
        // Si l'utilisateur était authentifié auprès de Active Directory, les
        // groupes de sécurité et/ou les listes de distribution auxquels l'utilisateur appartient 
        // pourraient être utilisés.
      
        // Cette méthode GetRoles renvoie une chaîne délimitée par des canaux contenant des rôles
        // plutôt qu'un tableau, car le format de la chaîne est 
        pratique
        // pour le stockage dans le ticket/cookie d'authentification en tant que données utilisateur.
        return "Direction générale|Responsable|Employé";
      }
      
    4. Affichez le formulaire Logon.aspx en mode Concepteur, puis double-cliquez sur le bouton Connexion pour créer un gestionnaire d'événements de clic.

    5. Ajoutez un appel à la méthode IsAuthenticated, en fournissant le nom d'utilisateur et le mot de passe capturés au moyen du formulaire de connexion. Attribuez la valeur renvoyée à une variable de type bool, qui indique si l'utilisateur a été authentifié.

      bool isAuthenticated = IsAuthenticated( txtUserName.Text, 
                                              txtPassword.Text );
      
    6. Si l'utilisateur est authentifié, ajoutez un appel à la méthode GetRoles pour obtenir la liste des rôles de l'utilisateur.

      if (isAuthenticated == true )
      {
        string roles = GetRoles( txtUserName.Text, txtPassword.Text );
      
    7. Créez un ticket d'authentification par formulaires qui contient le nom d'utilisateur, un délai d'expiration, ainsi que la liste des rôles auxquels l'utilisateur appartient. Notez que la propriété des données utilisateur associée au ticket d'authentification est employée pour stocker la liste des rôles de l'utilisateur. Notez également que le code suivant crée un ticket non persistant (le fait que le ticket ou cookie soit persistant ou non dépend du scénario de votre application).

        // Créer le ticket d'authentification
        FormsAuthenticationTicket authTicket = new 
             FormsAuthenticationTicket(1,                          // version
                                       txtUserName.Text,           // nom d'utilisateur
                                       DateTime.Now,               // création
                                       DateTime.Now.AddMinutes(60),// Expiration
                                       false,                      // Persistant
                                       roles );                    // Données utilisateur
      
    8. Ajoutez du code pour créer une représentation de chaîne cryptée du ticket et stockez ce code en tant que données dans un objet HttpCookie.

        // Crypter le ticket maintenant.
        string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
        // Créer un cookie et ajouter le ticket crypté au 
        // cookie sous forme de données.
        HttpCookie authCookie = 
                     new HttpCookie(FormsAuthentication.FormsCookieName,
                                    encryptedTicket);
      
    9. Ajoutez le cookie à la liste de cookies renvoyée vers le navigateur de l'utilisateur.

        // Ajouter le cookie à l'ensemble de cookies sortants. 
        Response.Cookies.Add(authCookie); 
      
    10. Redirigez l'utilisateur vers la page demandée à l'origine.

        // Rediriger l'utilisateur vers la page demandée à l'origine.
        Response.Redirect( FormsAuthentication.GetRedirectUrl(
                                                      txtUserName.Text, 
                                                      false ));
      }
      

Créer une classe d'implémentation et d'extension de Iprincipal

Cette procédure permet de créer une classe qui implémente l'interface IPrincipal. Elle ajoute également des méthodes et des propriétés supplémentaires à la classe pour fournir des fonctionnalités d'autorisation par rôle supplémentaire.

  • Pour créer une classe qui implémente et étend IPrincipal

    1. Ajoutez une nouvelle classe nommée CustomPrincipal au projet en cours.

    2. Ajoutez l'instruction using suivante en haut du fichier CustomPrincipal.cs.

      using System.Security.Principal;
      
    3. Extrayez la classe CustomPrincipal de l'interface IPrincipal.

      public class CustomPrincipal : IPrincipal
      
    4. Ajoutez les variables de membre privé suivantes à la classe pour gérer l'objet IIdentity associé à l'objet Principal et à la liste de rôles de cet objet.

      private IIdentity _identity;
      private string [] _roles;
      
    5. Modifiez le constructeur par défaut de la classe pour accepter un objet IIdentity et un tableau de rôles. Utilisez les valeurs fournies pour initialiser les variables de membre privé comme illustré ci-dessous.

      public CustomPrincipal(IIdentity identity, string [] roles)
      {
        _identity = identity;
        _roles = new string[roles.Length];
        roles.CopyTo(_roles, 0);
        Array.Sort(_roles);
      }
      
    6. Implémentez la méthode IsInRole et la propriété Identity définies par l'interface IPrincipal comme illustré ci-dessous.

      // Implémentation IPrincipal
      public bool IsInRole(string role)
      {
        return Array.BinarySearch( _roles, role ) >= 0 ? true : false;
      }
      public IIdentity Identity
      {
        get
        {
          return _identity;
        }
      }
      
    7. Ajoutez les deux méthodes publiques suivantes, qui fournissent des fonctionnalités étendues de vérification par rôle.

      // Vérifie si un objet Principal se trouve dans tous les rôles indiqués.
      public bool IsInAllRoles( params string [] roles )
      {
        foreach (string searchrole in roles )
        {
          if (Array.BinarySearch(_roles, searchrole) < 0 )
            return false;
        }
        return true;
      }
      // Vérifie si un objet Principal se trouve dans l'un des rôles indiqués.
      public bool IsInAnyRoles( params string [] roles )
      {
        foreach (string searchrole in roles )
        {
          if (Array.BinarySearch(_roles, searchrole ) > 0 )
            return true;
        }
        return false;
      }
      

Créer l'objet CustomPrincipal

Cette procédure permet d'implémenter un gestionnaire d'événements d'authentification d'application et de construire un objet CustomPrincipal pour représenter l'utilisateur authentifié, d'après les informations contenues dans le ticket d'authentification.

  • Pour construire l'objet CustomPrincipal

    1. Dans l'Explorateur de solutions, ouvrez global.asax.

    2. Affichez le code et ajoutez les instructions using suivantes en haut du fichier.

      using System.Web.Security;
      using System.Security.Principal;
      
    3. Recherchez le gestionnaire d'événements Application_AuthenticateRequest et ajoutez le code suivant pour obtenir le cookie d'authentification par formulaires à partir de l'ensemble de cookies transmis avec la demande.

      // Extraire le cookie d'authentification par formulaires.
      string cookieName = FormsAuthentication.FormsCookieName;
      HttpCookie authCookie = Context.Request.Cookies[cookieName];
      
      if(null == authCookie)
      {
        // Il n'existe aucun cookie d'authentification.
        return;
      } 
      
    4. Ajoutez le code suivant pour extraire et décrypter le ticket d'authentification à partir du cookie d'authentification par formulaires.

      FormsAuthenticationTicket authTicket = null;
      try
      {
        authTicket = FormsAuthentication.Decrypt(authCookie.Value);
      }
      catch(Exception ex)
      {
        // Enregistrer dans le journal les informations d'exception (omis pour simplifier).
        return;
      }
      
      if (null == authTicket)
      {
        // Échec du décryptage du cookie.
        return; 
      } 
      
    5. Ajoutez le code suivant pour analyser la liste de noms de rôles séparée par des canaux et jointe au ticket lors de l'authentification initiale de l'utilisateur.

      // Lorsque le ticket a été créé, la propriété UserData a été attribuée à
      // la chaîne de noms de rôles délimitée par des canaux.
      string[] roles = authTicket.UserData.Split('|');
      
    6. Ajoutez le code suivant pour créer un objet FormsIdentity avec le nom d'utilisateur obtenu à partir du nom de ticket, ainsi qu'un objet CustomPrincipal contenant cette identité ainsi que la liste des rôles de l'utilisateur.

      // Créer un objet Identity.
      FormsIdentity id = new FormsIdentity( authTicket ); 
      
      // Cet objet Principal sera transmis dans l'ensemble de la demande.
      CustomPrincipal principal = new CustomPrincipal(id, roles);
      // Associer le nouvel objet Principal à l'objet HttpContext actuel.
      Context.User = principal;
      

Tester l'application

Cette procédure permet d'ajouter du code à la page default.aspx pour afficher des informations à partir de l'objet CustomPrincipal associé à l'objet HttpContext actuel, afin de vérifier que cet objet a été correctement construit et attribué à la demande Web en cours. Il teste également la fonctionnalité par rôle prise en charge par la nouvelle classe.

  • Pour tester l'application

    1. Dans l'Explorateur de solutions, double-cliquez sur default.aspx.

    2. Double-cliquez sur le formulaire Web default.aspx pour afficher le gestionnaire d'événements de chargement de page.

    3. Faites défiler la page jusqu'en haut du fichier et ajoutez l'instruction using suivante sous les instructions using existantes.

      using System.Security.Principal;
      
    4. Revenez au gestionnaire d'événements de chargement de page et insérez le code suivant pour ajouter le nom de l'identité joint à l'objet CustomPrincipal associé à la demande Web en cours.

      CustomPrincipal cp = HttpContext.Current.User as CustomPrincipal;
      Response.Write( "L'identité authentifiée est : " +  
                      cp.Identity.Name );
      Response.Write( "<p>" );
      
    5. Ajoutez le code suivant pour tester l'appartenance à des rôles de l'identité actuellement authentifiée, à l'aide de la méthode IsInRole standard et des méthodes IsInAnyRoles et IsInAllRoles supplémentaires prises en charge par la classe CustomPrincipal.

      if ( cp.IsInRole("Direction générale") )
      {
        Response.Write( cp.Identity.Name + " appartient au " + "rôle Direction générale" );
        Response.Write( "<p>" );            
      }
      
        if ( cp.IsInAnyRoles("Direction générale", "Responsable", "Employé", "
        Ventes") )
        {
          Response.Write( cp.Identity.Name + " appartient à l'un des rôles indiqués");
          Response.Write( "<p>" );
        }
        if ( cp.IsInAllRoles("Direction générale", "Responsable", "Employé", "
        Ventes") )
        {
          Response.Write( cp.Identity.Name + " appartient à TOUS les rôles indiqués" );
          Response.Write( "<p>" );
        }
        else
        {
          Response.Write( cp.Identity.Name + 
                          " n'appartient à aucun rôle indiqué" );
          Response.Write("<p>");
        }
      
        if ( cp.IsInRole("Ventes") )
          Response.Write( "L'utilisateur appartient au rôle Ventes<p>" );
        else
          Response.Write( "L'utilisateur n'appartient pas au rôle Ventes<p>" );
      
    6. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur default.aspx et cliquez sur Définir comme page de démarrage.

    7. Dans le menu Générer, choisissez Générer la solution.

    8. Appuyez sur les touches CTRL+F5 pour exécuter l'application. Puisque default.aspx a été configurée comme page de démarrage, il s'agit de la page demandée à l'origine.

    9. Lorsque vous êtes redirigé vers la page de connexion (car vous ne possédez pas de ticket d'authentification à l'origine), entrez un nom d'utilisateur et un mot de passe (quels qu'ils soient), puis cliquez sur Connexion.

    10. Vérifiez que vous êtes redirigé vers default.aspx et que l'identité de l'utilisateur et les informations de rôle affichées sont correctes. L'utilisateur est membre des rôles Direction générale, Responsable et Employés, mais pas du rôle Ventes.

Ressources supplémentaires

Pour plus d'informations sur l'authentification par formulaires, consultez les modules suivants du présent guide :

  • « Procédure : Créer des objets GenericPincipal avec l'authentification par formulaires ».

  • « Procédure : Utiliser l'authentification par formulaires avec Active Directory ».

  • « Procédure : Utiliser l'authentification par formulaires avec SQL Server 2000 ».

Afficher:
© 2014 Microsoft