Implémenter l’authentification basée sur les formulaires dans une application ASP.NET à l’aide de C#.NET

Article
07/17/2023

Cet article explique comment implémenter l’authentification basée sur les formulaires à l’aide d’une base de données pour stocker les utilisateurs. Il fait référence aux espaces de noms de bibliothèque de classes Microsoft .NET Framework suivants :

System.Data.SqlClient
System.Web.Security

Version d’origine du produit : ASP.NET
Numéro de la base de connaissances d’origine : 301240

Configuration requise

La liste suivante décrit le matériel, les logiciels, l’infrastructure réseau et les Service Packs recommandés dont vous avez besoin :

Visual Studio .NET
Internet Information Services (IIS) version 5.0 ou ultérieure
SQL Server

Créer une application ASP.NET à l’aide de C# .NET

Ouvrez Visual Studio .NET.
Créez une application web ASP.NET et spécifiez le nom et l’emplacement.

Configurer les paramètres de sécurité dans le fichier Web.config

Cette section montre comment ajouter et modifier les <authentication> sections de configuration et <authorization> pour configurer l’application ASP.NET pour utiliser l’authentification basée sur les formulaires.

Dans l’Explorateur de solutions, ouvrez le fichier Web.config.
Remplacez le mode d’authentification par Formulaires.
Insérez la <Forms> balise et renseignez les attributs appropriés. Copiez le code suivant, puis sélectionnez Coller au format HTML dans le menu Modifier pour coller le code dans la <authentication> section du fichier :
```
<authentication mode="Forms">
    <forms name=".ASPXFORMSDEMO" loginUrl="logon.aspx"
        protection="All" path="/" timeout="30" />
</authentication>
```
Refusez l’accès à l’utilisateur anonyme dans la <authorization> section comme suit :
```
<authorization>
    <deny users ="?" />
    <allow users = "*" />
</authorization>
```

Créer un exemple de table de base de données pour stocker les détails des utilisateurs

Cette section montre comment créer un exemple de base de données pour stocker le nom d’utilisateur, le mot de passe et le rôle des utilisateurs. Vous avez besoin de la colonne de rôle si vous souhaitez stocker les rôles d’utilisateur dans la base de données et implémenter la sécurité basée sur les rôles.

Dans le menu Démarrer , sélectionnez Exécuter, puis tapez bloc-notes pour ouvrir le Bloc-notes.

Mettez en surbrillance le code de script SQL suivant, cliquez avec le bouton droit sur le code, puis sélectionnez Copier. Dans le Bloc-notes, sélectionnez Coller dans le menu Modifier pour coller le code suivant :

if exists (select * from sysobjects where id =
object_id(N'[dbo].[Users]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
    drop table [dbo].[Users]
GO
CREATE TABLE [dbo].[Users] ([uname] [varchar] (15) NOT NULL,
    [Pwd] [varchar] (25) NOT NULL,
    [userRole] [varchar] (25) NOT NULL,
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Users] WITH NOCHECK ADD
    CONSTRAINT [PK_Users] PRIMARY KEY NONCLUSTERED
    ([uname]
    ) ON [PRIMARY]
GO

INSERT INTO Users values('user1','user1','Manager')
INSERT INTO Users values('user2','user2','Admin')
INSERT INTO Users values('user3','user3','User')
GO

Enregistrez le fichier en tant que Users.sql.
Sur l’ordinateur SQL Server, ouvrez Users.sql dans l’Analyseur de requête. Dans la liste des bases de données, sélectionnez pubs, puis exécutez le script. Cette opération crée un exemple de table users et remplit la table dans la base de données Pubs à utiliser avec cet exemple d’application.

Créer une page Logon.aspx

Ajoutez un nouveau formulaire web au projet nommé Logon.aspx.
Ouvrez la page Logon.aspx dans l’éditeur et basculez vers l’affichage HTML.

Copiez le code suivant et utilisez l’option Coller au format HTML du menu Edition pour insérer le code entre les <form> balises :

<h3>
    <font face="Verdana">Logon Page</font>
</h3>
<table>
    <tr>
        <td>Email:</td>
        <td><input id="txtUserName" type="text" runat="server"></td>
        <td><ASP:RequiredFieldValidator ControlToValidate="txtUserName"
            Display="Static" ErrorMessage="*" runat="server" 
            ID="vUserName" /></td>
    </tr>
    <tr>
        <td>Password:</td>
        <td><input id="txtUserPass" type="password" runat="server"></td>
        <td><ASP:RequiredFieldValidator ControlToValidate="txtUserPass"
        Display="Static" ErrorMessage="*" runat="server"
        ID="vUserPass" />
        </td>
    </tr>
    <tr>
        <td>Persistent Cookie:</td>
        <td><ASP:CheckBox id="chkPersistCookie" runat="server" autopostback="false" /></td>
        <td></td>
    </tr>
</table>
<input type="submit" Value="Logon" runat="server" ID="cmdLogin"><p></p>
<asp:Label id="lblMsg" ForeColor="red" Font-Name="Verdana" Font-Size="10" runat="server" />

Ce formulaire web est utilisé pour présenter un formulaire d’ouverture de session aux utilisateurs afin qu’ils puissent fournir leur nom d’utilisateur et leur mot de passe pour se connecter à l’application.

Basculez en mode Création, puis enregistrez la page.

Codez le gestionnaire d’événements afin qu’il valide les informations d’identification de l’utilisateur

Cette section présente le code placé dans la page code-behind (Logon.aspx.cs).

Double-cliquez sur Ouverture de session pour ouvrir le fichier Logon.aspx.cs .
Importez les espaces de noms requis dans le fichier code-behind :
```
using System.Data.SqlClient;
using System.Web.Security;
```

Créez une ValidateUser fonction pour valider les informations d’identification de l’utilisateur en recherchant dans la base de données. Veillez à modifier la Connection chaîne pour qu’elle pointe vers votre base de données.

private bool ValidateUser( string userName, string passWord )
{
    SqlConnection conn;
    SqlCommand cmd;
    string lookupPassword = null;

    // Check for invalid userName.
    // userName must not be null and must be between 1 and 15 characters.
    if ( ( null == userName ) || ( 0 == userName.Length ) || ( userName.Length > 15 ))
    {
        System.Diagnostics.Trace.WriteLine( "[ValidateUser] Input validation of userName failed." );
        return false;
    }

    // Check for invalid passWord.
    // passWord must not be null and must be between 1 and 25 characters.
    if ( ( null == passWord ) || ( 0 == passWord.Length ) || ( passWord.Length > 25 ))
    {
        System.Diagnostics.Trace.WriteLine( "[ValidateUser] Input validation of passWord failed." );
        return false;
    }

    try
    {
        // Consult with your SQL Server administrator for an appropriate connection
        // string to use to connect to your local SQL Server.
        conn = new SqlConnection( "server=localhost;Integrated Security=SSPI;database=pubs" );
        conn.Open();

        // Create SqlCommand to select pwd field from users table given supplied userName.
        cmd = new SqlCommand( "Select pwd from users where uname=@userName", conn );
        cmd.Parameters.Add( "@userName", SqlDbType.VarChar, 25 );
        cmd.Parameters["@userName"].Value = userName;

        // Execute command and fetch pwd field into lookupPassword string.
        lookupPassword = (string) cmd.ExecuteScalar();

        // Cleanup command and connection objects.
        cmd.Dispose();
        conn.Dispose();
    }
    catch ( Exception ex )
    {
        // Add error handling here for debugging.
        // This error message should not be sent back to the caller.
        System.Diagnostics.Trace.WriteLine( "[ValidateUser] Exception " + ex.Message );
    }

    // If no password found, return false.
    if ( null == lookupPassword )
    {
        // You could write failed login attempts here to event log for additional security.
        return false;
    }

    // Compare lookupPassword and input passWord, using a case-sensitive comparison.
    return ( 0 == string.Compare( lookupPassword, passWord, false ));
}

Vous pouvez utiliser l’une des deux méthodes pour générer le cookie d’authentification par formulaire et rediriger l’utilisateur vers une page appropriée dans l’événement cmdLogin_ServerClick . Un exemple de code est fourni pour les deux scénarios. Utilisez l’un ou l’autre d’entre eux en fonction de vos besoins.

Appelez la RedirectFromLoginPage méthode pour générer automatiquement le cookie d’authentification par formulaire et rediriger l’utilisateur vers une page appropriée dans l’événement cmdLogin_ServerClick :

private void cmdLogin_ServerClick(object sender, System.EventArgs e)
{
    if (ValidateUser(txtUserName.Value,txtUserPass.Value))
        FormsAuthentication.RedirectFromLoginPage(txtUserName.Value, chkPersistCookie.Checked);
    else
        Response.Redirect("logon.aspx", true);
}

Générez le ticket d’authentification, chiffrez-le, créez un cookie, ajoutez-le à la réponse et redirigez l’utilisateur. Cette opération vous donne plus de contrôle sur la façon dont vous créez le cookie. Vous pouvez également inclure des données personnalisées avec le FormsAuthenticationTicket dans ce cas.

private void cmdLogin_ServerClick(object sender, System.EventArgs e)
{
    if (ValidateUser(txtUserName.Value,txtUserPass.Value))
    {
        FormsAuthenticationTicket tkt;
        string cookiestr;
        HttpCookie ck;
        tkt = new FormsAuthenticationTicket(1, txtUserName.Value, DateTime.Now,
        DateTime.Now.AddMinutes(30), chkPersistCookie.Checked, "your custom data");
        cookiestr = FormsAuthentication.Encrypt(tkt);
        ck = new HttpCookie(FormsAuthentication.FormsCookieName, cookiestr);
        if (chkPersistCookie.Checked)
            ck.Expires=tkt.Expiration;
        ck.Path = FormsAuthentication.FormsCookiePath;
        Response.Cookies.Add(ck);

        string strRedirect;
        strRedirect = Request["ReturnUrl"];
        if (strRedirect==null)
            strRedirect = "default.aspx";
        Response.Redirect(strRedirect, true);
    }
    else
        Response.Redirect("logon.aspx", true);
}

Assurez-vous que le code suivant est ajouté à la InitializeComponent méthode dans le code généré par le web Form Designer :
```
this.cmdLogin.ServerClick += new System.EventHandler(this.cmdLogin_ServerClick);
```

Créer une page Default.aspx

Cette section crée une page de test vers laquelle les utilisateurs sont redirigés après s’être authentifiés. Si les utilisateurs accèdent à cette page sans se connecter au préalable à l’application, ils sont redirigés vers la page d’ouverture de session.

Renommez la page WebForm1.aspx existante en tant que Default.aspx et ouvrez-la dans l’éditeur.
Basculez vers la vue HTML et copiez le code suivant entre les <form> balises :
```
<input type="submit" Value="SignOut" runat="server" id="cmdSignOut">
```
Ce bouton permet de se déconnecter de la session d’authentification par formulaire.
Basculez en mode Création, puis enregistrez la page.
Importez les espaces de noms requis dans le fichier code-behind :
```
using System.Web.Security;
```
Double-cliquez sur SignOut pour ouvrir la page code-behind (Default.aspx.cs) et copiez le code suivant dans le gestionnaire d’événements cmdSignOut_ServerClick :
```
private void cmdSignOut_ServerClick(object sender, System.EventArgs e)
{
    FormsAuthentication.SignOut();
    Response.Redirect("logon.aspx", true);
}
```
Assurez-vous que le code suivant est ajouté à la InitializeComponent méthode dans le code généré par le web Form Designer :
```
this.cmdSignOut.ServerClick += new System.EventHandler(this.cmdSignOut_ServerClick);
```
Enregistrez et compilez le projet. Vous pouvez maintenant utiliser l’application.

Notes supplémentaires

Vous pouvez stocker les mots de passe en toute sécurité dans une base de données. Vous pouvez utiliser la FormsAuthentication fonction utilitaire de classe nommée HashPasswordForStoringInConfigFile pour chiffrer les mots de passe avant de les stocker dans la base de données ou le fichier de configuration.
Vous pouvez stocker les informations de connexion SQL dans le fichier de configuration (Web.config) afin de pouvoir les modifier facilement si nécessaire.
Vous pouvez envisager d’ajouter du code pour empêcher les pirates qui tentent d’utiliser différentes combinaisons de mots de passe de se connecter. Par exemple, vous pouvez inclure une logique qui n’accepte que deux ou trois tentatives d’ouverture de session. Si les utilisateurs ne peuvent pas se connecter dans certaines tentatives, vous pouvez définir un indicateur dans la base de données pour ne pas leur permettre de se connecter tant que les utilisateurs ne réactivent pas leur compte en visitant une autre page ou en appelant votre ligne de support. En outre, vous devez ajouter la gestion des erreurs appropriée si nécessaire.
Étant donné que l’utilisateur est identifié en fonction du cookie d’authentification, vous pouvez utiliser ssl (Secure Sockets Layer) sur cette application afin que personne ne puisse tromper le cookie d’authentification et toute autre information précieuse transmise.
L’authentification basée sur les formulaires nécessite que votre client accepte ou active les cookies sur son navigateur.
Le paramètre de délai d’expiration de la <authentication> section de configuration contrôle l’intervalle auquel le cookie d’authentification est régénéré. Vous pouvez choisir une valeur qui offre de meilleures performances et une meilleure sécurité.
Certains proxys et caches intermédiaires sur Internet peuvent mettre en cache les réponses du serveur Web qui contiennent Set-Cookie des en-têtes, qui sont ensuite retournés à un autre utilisateur. Étant donné que l’authentification basée sur les formulaires utilise un cookie pour authentifier les utilisateurs, ce comportement peut amener les utilisateurs à emprunter accidentellement (ou intentionnellement) l’identité d’un autre utilisateur en recevant un cookie d’un proxy intermédiaire ou d’un cache qui n’était pas prévu à l’origine pour eux.