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

Article
07/30/2024

Cet article montre comment implémenter l’authentification basée sur des 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 du produit d’origine : ASP.NET
Numéro de la base de connaissances d’origine : 301240

Spécifications

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 sections et <authorization> les <authentication> sections de configuration pour configurer l’application ASP.NET pour utiliser l’authentification basée sur des formulaires.

Dans Explorateur de solutions, ouvrez le fichier Web.config.
Remplacez le mode d’authentification par Formulaire.
Insérez la <Forms> balise et remplissez les attributs appropriés. Copiez le code suivant, puis sélectionnez Coller en tant que code 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>
```
Refuser 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 des 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 le 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êtes. Dans la liste des bases de données, sélectionnez pubs et exécutez le script. Cette opération crée un exemple de table d’utilisateurs 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 en mode HTML.

Copiez le code suivant et utilisez l’option Coller en tant que code HTML dans le menu Modifier 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.

Pour plus d’informations, consultez La classe RequiredFieldValidator.

Basculez vers l’affichage Création et 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 . L’exemple de code est fourni pour les deux scénarios. Utilisez l’une ou l’autre d’entre elles en fonction de vos besoins.

Appelez la RedirectFromLoginPage méthode pour générer automatiquement le cookie d’authentification par formulaire et redirigez 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 permet de contrôler davantage la façon dont vous créez le cookie. Vous pouvez également inclure des données personnalisées ainsi que dans FormsAuthenticationTicket 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);
}

Vérifiez que le code suivant est ajouté à la InitializeComponent méthode dans le code généré par le Concepteur de formulaires web :
```
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 leur authentification. Si les utilisateurs accèdent à cette page sans se connecter d’abord à l’application, ils sont redirigés vers la page d’ouverture de session.

Renommez la page WebForm1.aspx existante comme Default.aspx, puis ouvrez-la dans l’éditeur.
Basculez en mode HTML et copiez le code suivant entre les <form> balises :
```
<input type="submit" Value="SignOut" runat="server" id="cmdSignOut">
```
Ce bouton est utilisé pour se déconnecter de la session d’authentification par formulaire.
Basculez vers l’affichage Création et 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), puis copiez le code suivant dans le cmdSignOut_ServerClick gestionnaire d’événements :
```
private void cmdSignOut_ServerClick(object sender, System.EventArgs e)
{
    FormsAuthentication.SignOut();
    Response.Redirect("logon.aspx", true);
}
```
Vérifiez que le code suivant est ajouté à la InitializeComponent méthode dans le code généré par le Concepteur de formulaires web :
```
this.cmdSignOut.ServerClick += new System.EventHandler(this.cmdSignOut_ServerClick);
```
Enregistrez et compilez le projet. Vous pouvez maintenant utiliser l’application.

Remarques supplémentaires

Vous souhaiterez peut-être stocker des 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 le 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 accepte seulement 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 les autoriser à se connecter tant que les utilisateurs n’ont pas réactivé leurs comptes en visitant une autre page ou en appelant votre ligne de support. En outre, vous devez ajouter la gestion des erreurs appropriée, le cas échéant.
Étant donné que l’utilisateur est identifié en fonction du cookie d’authentification, vous pouvez utiliser Secure Sockets Layer (SSL) 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 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ées à un autre utilisateur. Étant donné que l’authentification basée sur les formulaires utilise un cookie pour authentifier les utilisateurs, ce comportement peut entraîner l’emprunt d’identité accidentelle (ou intentionnellement) d’un autre utilisateur en recevant un cookie à partir d’un proxy intermédiaire ou d’un cache qui n’a pas été initialement destiné à eux.

Partager via