MSDN Library

Procédure : Utiliser l'authentification par formulaires avec Active Directory

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

Objectifs Objectifs
S'applique à S'applique à
Résumé Résumé
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
Développer un code d'authentification LDAP pour rechercher l'utilisateur dans Active Directory Développer un code d'authentification LDAP pour rechercher l'utilisateur dans Active Directory
Développer un code d'extraction de groupe LDAP pour rechercher les groupes auxquels l'utilisateur appartient Développer un code d'extraction de groupe LDAP pour rechercher les groupes auxquels l'utilisateur appartient
Authentifier l'utilisateur et créer un ticket d'authentification par formulaires Authentifier l'utilisateur et créer un ticket d'authentification par formulaires
Implémenter un gestionnaire de demandes d'authentification pour créer un objet GenericPrincipal Implémenter un gestionnaire de demandes d'authentification pour créer un objet GenericPrincipal
Tester l'application Tester l'application

Objectifs

Ce module vous permet d'effectuer les opérations suivantes :

  • créer une application qui utilise l'authentification par formulaires afin d'authentifier les utilisateurs auprès de Active Directory ;

  • obtenir à partir de Active Directory la liste des groupes et des listes de distribution auxquels un utilisateur authentifié appartient.

  • créer un objet GenericPrincipal associé avec la demande Web de l'utilisateur à l'aide de la propriété HttpContext.Current.User.

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

  • Active Directory

  • 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

  • Microsoft SQL Server? 2000 (avec le Service Pack 2) et versions ultérieures

Résumé

L'authentification par formulaires ASP.NET permet aux utilisateurs de s'identifier en entrant des informations d'identification (un nom d'utilisateur et un mot de passe) dans un formulaire Web. Lors de la réception de ces informations, l'application Web peut authentifier l'utilisateur en comparant les informations d'identification avec une source de données.

Ce module décrit comment authentifier des utilisateurs auprès du service d'annuaire Microsoft® Active Directory® à l'aide du protocole LDAP (Lightweight Directory Access Protocol). Vous apprendrez également à récupérer la liste des groupes de sécurité et des listes de distribution auxquelles l'utilisateur appartient ou encore à configurer un objet GenericPrincipal à utiliser avec l'autorisation .NET par rôle.

Créer une application Web avec une page de connexion

Cette procédure permet de créer une application Web Visual C# simple, qui contient une page de connexion offrant la possibilité à l'utilisateur d'entrer un nom d'utilisateur et un mot de passe, ainsi qu'une page par défaut qui affiche les informations de nom d'identité et d'appartenance aux groupes associées à la demande Web en cours.

  • 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 FormsAuthAD.

    2. Utilisez l'Explorateur de solutions pour renommer WebForm1.aspx en Logon.aspx.

    3. Ajoutez une nouvelle référence d'assembly au fichier System.DirectoryServices.dll. Vous disposez ainsi d'un accès à l'espace de noms System.DirectoryServices qui contient les types gérés destinés à faciliter l'interrogation et la manipulation de Active Directory.

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

      Tableau 1 : Contrôles Logon.aspx

      Type de contrôle

      Texte

      ID

      Étiquette

      Nom de domaine :

      -

      Étiquette

      Nom d'utilisateur :

      -

      Étiquette

      Mot de passe

      -

      Zone de texte

      -

      txtDomainName

      Zone de texte

      -

      txtUserName

      Zone de texte

      -

      txtPassword

      Bouton

      Connexion

      btnLogon

      Étiquette

       

      lblError

    5. Attribuez la valeur Password à la propriété TextMode.

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

    7. Dans le champ Nom, tapez default.aspx et cliquez sur Ouvrir.

    8. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur default.aspx et cliquez sur Définir comme page de démarrage.

    9. Double-cliquez sur default.aspx afin d'afficher le gestionnaire d'événements de chargement de page.

    10. Ajoutez le code suivant au gestionnaire d'événements pour afficher le nom d'identité associé à la requête Web en cours.

      Response.Write( HttpContext.Current.User.Identity.Name );
      

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

Cette procédure permet de modifier le fichier Web.config afin de configurer l'application en vue d'une authentification par formulaires.

  • Pour configurer l'application Web 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 d'authentification et définissez les attributs loginUrl, name, timeout et path comme illustré ci-dessous :

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

      <authorization> 
        <deny users="?" />
        <allow users="*" />
      </authorization>
      
    5. Enregistrez le fichier Web.config.

    6. Démarrez le composant logiciel enfichable IIS MMC (Microsoft Management Console).

    7. Cliquez avec le bouton droit sur le répertoire virtuel de l'application et cliquez sur Propriétés.

    8. Cliquez sur l'onglet Sécurité de répertoire, puis sur le bouton Modifier dans le groupe Connexions anonymes et contrôle d'authentification.

    9. Activez la case à cocher Accès anonyme et désactivez l'option Autoriser la vérification de mot de passe par IIS.

    10. Puisque le compte anonyme par défaut IUSR_MACHINE ne dispose d'aucune autorisation pour accéder à Active Directory, vous devez créer un compte doté de privilèges minimum et entrer les informations du compte dans la boîte de dialogue Méthodes d'authentification.

    11. Cliquez sur OK et de nouveau sur OK pour fermer la boîte de dialogue Propriétés.

    12. Revenez dans Visual Studio .NET et ajoutez un élément <identity> sous l'élément <authorization> dans le fichier Web.config. Attribuez ensuite la valeur true à l'attribut d'emprunt d'identité. ASP.NET emprunte alors l'identité du compte anonyme indiqué précédemment.

      <identity impersonate="true" />
      

      Avec cette configuration, toutes les demandes adressées à l'application sont exécutées sous le contexte de sécurité du compte anonyme configuré. L'utilisateur fournit des informations d'identification au moyen du formulaire Web afin de s'authentifier auprès de Active Directory, mais le compte utilisé pour accéder à Active Directory est alors le compte anonyme configuré.

Développer un code d'authentification LDAP pour rechercher l'utilisateur dans Active Directory

Cette procédure ajoute une nouvelle classe utile à l'application Web pour encapsuler le code LDAP. La classe fournit d'abord une méthode IsAuthenticated pour valider le domaine, le nom d'utilisateur et le mot de passe fournis par rapport à un objet utilisateur Active Directory.

  • Pour développer un code d'authentification LDAP afin de rechercher l'utilisateur dans Active Directory

    1. Ajoutez un nouveau fichier de classe C# nommé LdapAuthentication.cs.

    2. Ajoutez une référence à l'assembly System.DirectoryServices.dll.

    3. Ajoutez les instructions using suivantes en haut du fichier LdapAuthentication.cs.

      using System.Text;
      using System.Collections;
      using System.DirectoryServices;
      
    4. Renommez les espaces de noms existants en FormsAuthAD.

    5. Ajoutez deux chaînes privées à la classe LdapAuthentication : l'une pour conserver le chemin LDAP vers Active Directory et l'autre pour stocker un attribut de filtre utilisé pour les recherches dans Active Directory.

      private string _path;
      private string _filterAttribute;
      
    6. Ajoutez un constructeur public susceptible d'être utilisé pour initialiser le chemin Active Directory.

      public LdapAuthentication(string path)
      {
        _path = path;
      }
      
    7. Ajoutez la méthode IsAuthenticated suivante, qui accepte un nom de domaine, un nom d'utilisateur et un mot de passe en tant que paramètres, et renvoie bool pour indiquer si Active Directory contient un utilisateur avec un mot de passe correspondant. La méthode tente d'abord d'établir la liaison avec Active Directory à l'aide des informations d'identification fournies. Si la liaison est établie, la méthode utilise la classe gérée DirectorySearcher pour rechercher l'objet utilisateur indiqué. S'il est trouvé, le membre _path est mis à jour pour pointer vers l'objet utilisateur et le membre _filterAttribute est mis à jour à l'aide de l'attribut de nom commun de l'objet utilisateur.

      public bool IsAuthenticated(string domain, string username, string pwd)
      {
        string domainAndUsername = domain + @"\" + username;
        DirectoryEntry entry = new DirectoryEntry( _path, 
                                                   domainAndUsername, pwd);
      
        try
        { 
          // Effectuer une liaison avec l'objet AdsObject d'origine pour imposer l'authentification. 
          Object obj = entry.NativeObject;
          DirectorySearcher search = new DirectorySearcher(entry);
          search.Filter = "(SAMAccountName=" + username + ")";
          search.PropertiesToLoad.Add("cn");
          SearchResult result = search.FindOne();
          if(null == result)
          {
            return false;
          }
          // Mettre à jour le nouveau chemin de l'utilisateur dans l'annuaire.
          _path = result.Path;
          _filterAttribute = (String)result.Properties["cn"][0];
        }
        catch (Exception ex)
        {
          throw new Exception("Erreur lors de l'authentification de l'utilisateur. " + ex.Message);
        }
        return true;
      }
      

Développer un code d'extraction de groupe LDAP pour rechercher les groupes auxquels l'utilisateur appartient

Cette procédure étend la classe LdapAuthentication pour fournir une méthode GetGroups qui extrait ensuite la liste des groupes auxquels l'utilisateur actuel appartient. La méthode GetGroups renvoie la liste des groupes sous forme de chaîne séparée par des canaux, comme indiqué ci-dessous.

"Group1|Group2|Group3|"
  • Pour développer un code d'extraction de groupe LDAP afin de rechercher les groupes auxquels l'utilisateur appartient

    1. Ajoutez l'implémentation suivante de la méthode GetGroups à la classe LdapAuthentication.

      public string GetGroups()
      {
        DirectorySearcher search = new DirectorySearcher(_path);
        search.Filter = "(cn=" + _filterAttribute + ")";
        search.PropertiesToLoad.Add("memberOf");
        StringBuilder groupNames = new StringBuilder();
        try
        {
          SearchResult result = search.FindOne();
          int propertyCount = result.Properties["memberOf"].Count;
          String dn;
          int equalsIndex, commaIndex;
      
          for( int propertyCounter = 0; propertyCounter < propertyCount;
               propertyCounter++)
          {
            dn = (String)result.Properties["memberOf"][propertyCounter];
      
            equalsIndex = dn.IndexOf("=", 1);
            commaIndex = dn.IndexOf(",", 1);
            if (-1 == equalsIndex)
            {
              return null;
            }
            groupNames.Append(dn.Substring((equalsIndex + 1), 
                              (commaIndex - equalsIndex) - 1));
            groupNames.Append("|");
          }
        }
        catch(Exception ex)
        {
          throw new Exception("Erreur lors de la récupération des noms de groupes. " + ex.Message);
        } 
        return groupNames.ToString();
      }
      

Authentifier l'utilisateur et créer un ticket d'authentification par formulaires

Cette procédure implémente le gestionnaire d'événements btnLogon_Click pour authentifier les utilisateurs. Pour les utilisateurs authentifiés, vous devez ensuite créer un ticket d'authentification par formulaires qui contient la liste des groupes de l'utilisateur. Enfin, vous redirigez l'utilisateur vers la page d'origine demandée (avant la redirection vers la page de connexion).

  • Pour authentifier l'utilisateur et créer un ticket d'authentification par formulaires

    1. Revenez au formulaire Logon.aspx et double-cliquez sur le bouton Connexion pour créer un gestionnaire d'événements btnLogon_Click vide.

    2. Ajoutez l'instruction using suivante en haut du fichier, sous les instructions using existantes. Vous disposez ainsi d'un accès aux méthodes FormsAuthentication.

      using System.Web.Security;
      
    3. Ajoutez du code pour créer une instance de la classe LdapAuthentication initialisée et pointer vers votre annuaire LDAP Active Directory, comme dans le code suivant. Pensez à modifier le chemin afin qu'il indique votre serveur Active Directory.

      // Chemin vers votre serveur d'annuaire LDAP.
      // Contactez votre administrateur réseau pour obtenir un chemin valide.
      string adPath = "LDAP://votreNomEntreprise.com/DC=votreNomEntreprise,DC=com"; 
      LdapAuthentication adAuth = new LdapAuthentication(adPath);
      
    4. Ajoutez le code suivant pour suivre les étapes ci-dessous :

      1. Authentifiez l'appelant auprès de Active Directory.

      2. Extrayez la liste des groupes auxquels l'utilisateur appartient.

      3. Créez un ticket d'authentification par formulaires FormsAuthenticationTicket contenant la liste des groupes.

      4. Cryptez le ticket.

      5. Créez un cookie contenant le ticket crypté.

      6. Ajoutez le cookie à la liste de cookies renvoyée vers le navigateur de l'utilisateur.

        try
        {
          if(true == adAuth.IsAuthenticated(txtDomainName.Text, 
                                            txtUserName.Text, 
                                            txtPassword.Text))
          {
            // Extraire les groupes d'utilisateurs.
            string groups = adAuth.GetGroups();
            // Créer le ticket d'authentification.
            FormsAuthenticationTicket authTicket = 
                new FormsAuthenticationTicket(1,  // version
                                              txtUserName.Text,
                                              DateTime.Now, 
                                              DateTime.Now.AddMinutes(60),
                                              false, groups);
            // 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);
            // Ajouter le cookie à l'ensemble de cookies sortants. 
            Response.Cookies.Add(authCookie); 
        
            // Rediriger l'utilisateur vers la page demandée à l'origine.
            Response.Redirect(
                      FormsAuthentication.GetRedirectUrl(txtUserName.Text, 
                                                         false));
          }
          else
          {
            lblError.Text = 
                 "L'authentification a échoué. Vérifier le nom d'utilisateur et le mot de passe.";
          }
        }
        catch(Exception ex)
        {
          lblError.Text = "Erreur d'authentification. " + ex.Message;
        }
        

Implémenter un gestionnaire de demandes d'authentification pour créer un objet GenericPrincipal

Cette procédure implémente le gestionnaire d'événements Application_AuthenticateRequest dans global.asax et crée un objet GenericPrincipal pour l'utilisateur actuellement authentifié. Celui-ci contient la liste des groupes auxquels l'utilisateur appartient, liste qui a été extraite à partir du ticket FormsAuthenticationTicket figurant dans le cookie d'authentification. Enfin, vous devez associer l'objet GenericPrincipal à l'objet HttpContext en cours créé à chaque demande Web.

  • Pour implémenter un gestionnaire de demandes d'authentification afin de construire un objet GenericPricipal

    1. Utilisez l'Explorateur de solutions pour ouvrir le fichier global.asax.cs.

    2. 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 qui contient le ticket FormsAuthenticationTicket crypté, à 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 FormsAuthenticationTicket à partir du cookie.

      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 des noms de groupes 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 à
      // une chaîne de noms de groupes délimités par des canaux.
      String[] groups = authTicket.UserData.Split(new char[]{'|'});
      
    6. Ajoutez le code suivant pour créer un objet GenericIdentity avec le nom d'utilisateur obtenu à partir du nom de ticket, ainsi qu'un objet GenericPrincipal contenant cette identité avec la liste des groupes de l'utilisateur.

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

Tester l'application

Cette procédure utilise l'application Web pour interroger la page default.aspx. Vous êtes alors redirigé vers la page de connexion pour l'authentification. Si la connexion est établie, votre navigateur est redirigé vers la page default.aspx demandée à l'origine. La liste des groupes auxquels appartient l'utilisateur authentifié est ensuite extraite et affichée à partir de l'objet GenericPrincipal qui a été associé à la demande en cours par le processus d'authentification.

  • Pour tester l'application

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

    2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur default.aspx et cliquez sur Afficher dans le navigateur.

    3. Entrez un nom de domaine, un nom d'utilisateur et un mot de passe valides et cliquez sur Connexion.

    4. Si l'authentification réussit, vous êtes à nouveau redirigé vers default.aspx. Le code de cette page doit contenir le nom de l'utilisateur qui a été authentifié.
      Pour consulter la liste des groupes auxquels l'utilisateur authentifié appartient, ajoutez le code suivant à la fin du gestionnaire d'événements Application_AuthenticateRequest dans le fichier global.aspx.

      Response.Write("Groupes : " + authTicket.UserData + "<br>");
      
Afficher:
© 2016 Microsoft