Exporter (0) Imprimer
Développer tout

Procédure : Créer des objets GenericPincipal avec l'authentification par formulaires

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 avec une page de connexion Créer une application Web avec une page de connexion
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
Construire des objets GenericPrincipal et FormsIdentity Construire des objets GenericPrincipal et FormsIdentity
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 application Web qui utilise l'authentification par formulaires et fournit à un objet GenericPrincipal l'identité et les rôles de l'utilisateur authentifié en vue d'une autorisation 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

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

  • Microsoft Visual Studio® 1.0 .NET et versions ultérieures

  • Microsoft Visual C#® .NET

Résumé

Pour faire appel à la sécurité par rôle .NET Microsoft® dans une application Web lorsque vous utilisez un mécanisme d'authentification personnalisé ne reposant pas sur les comptes Windows, vous devez vous charger directement de la création des tickets d'authentification ASP.NET et de la configuration des instances IPrincipal. Ces instances correspondent aux identités et aux rôles des utilisateurs authentifiés.

Ce module décrit comment créer une application Web qui fait appel à l'authentification par formulaires pour authentifier les utilisateurs et comment créer un ticket d'authentification contenant des informations sur les utilisateurs et les rôles. Vous découvrirez également comment convertir ces informations en objets GenericPrincipal et FormsIdentity, afin d'utiliser ces derniers dans la logique d'autorisation de votre application.

Points à connaître

Les applications qui font appel à l'authentification par formulaires utilisent souvent la classe GenericPrincipal (en association avec la classe FormsIdentity), pour créer un modèle d'autorisation spécifique aux applications non Windows, indépendantes d'un domaine Windows.

Une application peut, par exemple :

  • utiliser l'authentification par formulaires pour obtenir des informations d'identification sur un utilisateur (nom d'utilisateur et mot de passe) ;

  • valider auprès d'un magasin de données (une base de données ou un service d'annuaire Microsoft® Active Directory®, par exemple) les informations d'identification fournies ;

  • créer des objets GenericPrincipal et FormsIdentity en fonction des valeurs récupérées dans le magasin de données (celles-ci peuvent contenir les informations d'appartenance d'un utilisateur à un rôle) ;

  • utiliser ces objets pour prendre des décisions concernant l'autorisation.

Ce module décrit la création d'une application Web Windows Forms, qui authentifie les utilisateurs et crée un ticket d'authentification par formulaires personnalisé contenant des informations sur l'utilisateur et le rôle associé. Il vous indique également comment convertir ces informations en objets GenericPrincipal et FormsIdentity, mais aussi comment associer les nouveaux objets au contexte de demande Web HTTP, afin de les intégrer dans la logique d'autorisation de votre application.

Ce module traite de la construction des objets GenericPrincipal et FormsIdentity et du traitement du ticket d'authentification par formulaires. Pour plus d'informations sur l'authentification des utilisateurs auprès de Active Directory et de SQL Server 2000, 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 »

Créer une application Web avec une page de connexion

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 pourront accéder et une page de connexion qui servira à collecter les informations d'identification des utilisateurs.

  • Pour créer une application Web avec une page de connexion

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

    2. Renommez WebForm1.aspx en Logon.aspx.

    3. Ajoutez les contrôles suivants à Logon.aspx 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 GenericPrincipalApp, 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 le fichier 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 est l'un des types de cookies utilisés 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 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, utilisée pour 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 et 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 utilisé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 ));
      }
      

Construire des objets GenericPrincipal et FormsIdentity

Cette procédure permet d'implémenter un gestionnaire d'événements d'authentification d'application et de construire les objets GenericPrincipal et FormsIdentity d'après les informations contenues dans le ticket d'authentification.

  • Pour construire les objets GenericPrincipal et FormsIdentity

    1. Dans l'Explorateur de solutions, ouvrez le fichier 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(new char[]{'|'});
      
    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 GenericPrincipal 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.
      GenericPrincipal principal = new GenericPrincipal(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 GenericPrincipal associé à l'objet HttpContext actuel, afin de vérifier que cet objet a été correctement construit et attribué à la demande Web en cours. Vous devez ensuite générer et tester l'application.

  • 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 GenericPrincipal associé à la demande Web en cours.

      IPrincipal p = HttpContext.Current.User;
      Response.Write( "L'identité authentifiée est : " +  
                      p.Identity.Name );
      Response.Write( "<p>" );
      
    5. Ajoutez le code suivant afin de tester l'appartenance au rôle pour l'identité authentifiée en cours.

      if ( p.IsInRole("Direction générale") )
        Response.Write( "L'utilisateur appartient au rôle Direction générale<p>" );
      else
        Response.Write( "L'utilisateur n'appartient pas au rôle Direction générale<p>" );
      
      if ( p.IsInRole("Responsable") )
        Response.Write( "L'utilisateur appartient au rôle Responsable<p>" );
      else
        Response.Write( "L'utilisateur n'appartient pas au rôle Responsable<p>" );
      
      if ( p.IsInRole("Employé") )
        Response.Write( "L'utilisateur appartient au rôle Employé<p>" );
      else
        Response.Write( "L'utilisateur n'appartient pas au rôle Employé<p>" );
      
      if ( p.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. Supprimez les éventuelles erreurs de génération.

    8. Appuyez sur les touches Ctrl+F5 pour exécuter l'application. Puisque la page default.aspx a été adopté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 correctes sont affichées. L'utilisateur doit être 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, 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 ».

Afficher:
© 2014 Microsoft