Implementieren der formularbasierten Authentifizierung in einer ASP.NET-Anwendung mithilfe von C#.NET

Artikel
03/20/2024

In diesem Artikel wird veranschaulicht, wie Die formularbasierte Authentifizierung mithilfe einer Datenbank zum Speichern der Benutzer implementiert wird. Sie bezieht sich auf die folgenden Namespaces der Microsoft .NET Framework-Klassenbibliothek:

System.Data.SqlClient
System.Web.Security

Originale Produktversion: ASP.NET
Ursprüngliche KB-Nummer: 301240

Anforderungen

In der folgenden Liste sind die empfohlenen Hardware, Software, Netzwerkinfrastruktur und Service Packs aufgeführt, die Sie benötigen:

Visual Studio .NET
Internetinformationsdienste (IIS) Version 5.0 oder höher
SQL Server

Erstellen einer ASP.NET-Anwendung mithilfe von C# .NET

Öffnen Sie Visual Studio .NET.
Erstellen Sie eine neue ASP.NET Webanwendung, und geben Sie den Namen und speicherort an.

Konfigurieren von Sicherheitseinstellungen in der Web.config-Datei

In diesem Abschnitt wird veranschaulicht, wie Sie die <authentication> Konfigurationsabschnitte und hinzufügen und <authorization> ändern, um die ASP.NET Anwendung für die Verwendung der formularbasierten Authentifizierung zu konfigurieren.

Öffnen Sie im Projektmappen-Explorer die Datei Web.config.
Ändern Sie den Authentifizierungsmodus in Forms.
Fügen Sie das <Forms> Tag ein, und füllen Sie die entsprechenden Attribute aus. Kopieren Sie den folgenden Code, und wählen Sie dann im Menü Bearbeiten die Option Als HTML einfügen aus, um den Code in den <authentication> Abschnitt der Datei einzufügen:
```
<authentication mode="Forms">
    <forms name=".ASPXFORMSDEMO" loginUrl="logon.aspx"
        protection="All" path="/" timeout="30" />
</authentication>
```
Verweigern Sie dem anonymen Benutzer im Abschnitt den <authorization> Zugriff wie folgt:
```
<authorization>
    <deny users ="?" />
    <allow users = "*" />
</authorization>
```

Erstellen einer Beispieldatenbanktabelle zum Speichern von Benutzerdetails

In diesem Abschnitt wird gezeigt, wie Sie eine Beispieldatenbank erstellen, um den Benutzernamen, das Kennwort und die Rolle für die Benutzer zu speichern. Sie benötigen die Rollenspalte, wenn Sie Benutzerrollen in der Datenbank speichern und rollenbasierte Sicherheit implementieren möchten.

Wählen Sie im Menü Start die Option Ausführen aus, und geben Sie editor ein, um Editor zu öffnen.

Markieren Sie den folgenden SQL-Skriptcode, klicken Sie mit der rechten Maustaste auf den Code, und wählen Sie dann Kopieren aus. Wählen Sie im Editor im Menü Bearbeiten die Option Einfügen aus, um den folgenden Code einzufügen:

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

Speichern Sie die Datei als Users.sql.
Öffnen Sie auf dem SQL Server Computer Users.sql in Query Analyzer. Wählen Sie in der Liste der Datenbanken Pubs aus, und führen Sie das Skript aus. Dieser Vorgang erstellt eine Beispieltabelle für Benutzer und füllt die Tabelle in der Pubs-Datenbank auf, die mit dieser Beispielanwendung verwendet werden soll.

Erstellen einer Logon.aspx-Seite

Fügen Sie dem Projekt mit dem Namen Logon.aspx ein neues Webformular hinzu.
Öffnen Sie die seite Logon.aspx im Editor, und wechseln Sie zur HTML-Ansicht.

Kopieren Sie den folgenden Code, und verwenden Sie die Option Als HTML einfügen im Menü Bearbeiten , um den Code zwischen den <form> Tags einzufügen:

<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" />

Dieses Webformular wird verwendet, um Benutzern ein Anmeldeformular vorzustellen, damit sie ihren Benutzernamen und ihr Kennwort angeben können, um sich bei der Anwendung anzumelden.

Wechseln Sie zur Entwurfsansicht, und speichern Sie die Seite.

Codieren sie den Ereignishandler so, dass er die Benutzeranmeldeinformationen überprüft.

In diesem Abschnitt wird der Code vorgestellt, der auf der CodeBehind-Seite (Logon.aspx.cs) platziert wird.

Doppelklicken Sie auf Anmelden , um die Logon.aspx.cs Datei zu öffnen.
Importieren Sie die erforderlichen Namespaces in die CodeBehind-Datei:
```
using System.Data.SqlClient;
using System.Web.Security;
```

Erstellen Sie eine ValidateUser Funktion, um die Benutzeranmeldeinformationen zu überprüfen, indem Sie in der Datenbank suchen. Stellen Sie sicher, dass Sie die Connection Zeichenfolge so ändern, dass sie auf Ihre Datenbank verweist.

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 ));
}

Sie können eine von zwei Methoden verwenden, um das Formularauthentifizierungscookies zu generieren und den Benutzer auf eine entsprechende Seite im cmdLogin_ServerClick Ereignis umzuleiten. Für beide Szenarien wird Beispielcode bereitgestellt. Verwenden Sie beides gemäß Ihren Anforderungen.

Rufen Sie die RedirectFromLoginPage -Methode auf, um das Formularauthentifizierungscookies automatisch zu generieren und den Benutzer auf eine entsprechende Seite im cmdLogin_ServerClick Ereignis umzuleiten:

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);
}

Generieren Sie das Authentifizierungsticket, verschlüsseln Sie es, erstellen Sie ein Cookie, fügen Sie es der Antwort hinzu, und leiten Sie den Benutzer um. Dieser Vorgang gibt Ihnen mehr Kontrolle über die Art und Weise, wie Sie das Cookie erstellen. In diesem Fall können Sie auch benutzerdefinierte Daten zusammen mit dem FormsAuthenticationTicket einschließen.

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);
}

Stellen Sie sicher, dass der folgende Code der -Methode in dem InitializeComponent Code hinzugefügt wird, den das WebFormular Designer generiert:
```
this.cmdLogin.ServerClick += new System.EventHandler(this.cmdLogin_ServerClick);
```

Erstellen einer Default.aspx Seite

In diesem Abschnitt wird eine Testseite erstellt, auf die Benutzer nach der Authentifizierung umgeleitet werden. Wenn Benutzer zu dieser Seite navigieren, ohne sich zuerst bei der Anwendung anzumelden, werden sie zur Anmeldeseite umgeleitet.

Benennen Sie die vorhandene WebForm1.aspx Seite in Default.aspx um, und öffnen Sie sie im Editor.
Wechseln Sie zur HTML-Ansicht, und kopieren Sie den folgenden Code zwischen den <form> Tags:
```
<input type="submit" Value="SignOut" runat="server" id="cmdSignOut">
```
Diese Schaltfläche wird verwendet, um sich von der Formularauthentifizierungssitzung abzumelden.
Wechseln Sie zur Entwurfsansicht, und speichern Sie die Seite.
Importieren Sie die erforderlichen Namespaces in die CodeBehind-Datei:
```
using System.Web.Security;
```
Doppelklicken Sie auf Abmelden , um die CodeBehind-Seite (Default.aspx.cs) zu öffnen, und kopieren Sie den folgenden Code in den cmdSignOut_ServerClick Ereignishandler:
```
private void cmdSignOut_ServerClick(object sender, System.EventArgs e)
{
    FormsAuthentication.SignOut();
    Response.Redirect("logon.aspx", true);
}
```
Stellen Sie sicher, dass der folgende Code der -Methode in dem InitializeComponent Code hinzugefügt wird, den das WebFormular Designer generiert:
```
this.cmdSignOut.ServerClick += new System.EventHandler(this.cmdSignOut_ServerClick);
```
Speichern und kompilieren Sie das Projekt. Sie können jetzt die Anwendung verwenden.

Zusätzliche Hinweise

Möglicherweise möchten Sie Kennwörter sicher in einer Datenbank speichern. Sie können die FormsAuthentication Klassenhilfsprogrammfunktion namens HashPasswordForStoringInConfigFile verwenden, um die Kennwörter zu verschlüsseln, bevor Sie sie in der Datenbank oder Konfigurationsdatei speichern.
Möglicherweise möchten Sie die SQL-Verbindungsinformationen in der Konfigurationsdatei (Web.config) speichern, damit Sie sie bei Bedarf problemlos ändern können.
Sie können erwägen, Code hinzuzufügen, um zu verhindern, dass sich Hacker, die verschiedene Kombinationen von Kennwörtern verwenden, anmelden. Beispielsweise können Sie Logik einschließen, die nur zwei oder drei Anmeldeversuche akzeptiert. Wenn sich Benutzer bei einigen Versuchen nicht anmelden können, sollten Sie ein Flag in der Datenbank festlegen, damit sie sich nicht anmelden können, bis die Benutzer ihre Konten erneut aktivieren, indem Sie eine andere Seite besuchen oder Ihre Supportzeile aufrufen. Außerdem sollten Sie bei Bedarf eine geeignete Fehlerbehandlung hinzufügen.
Da der Benutzer anhand des Authentifizierungscookies identifiziert wird, sollten Sie Secure Sockets Layer (SSL) für diese Anwendung verwenden, damit niemand das Authentifizierungscookies und andere wertvolle Informationen, die übertragen werden, täuschen kann.
Die formularbasierte Authentifizierung erfordert, dass Ihr Client Cookies im Browser akzeptiert oder aktiviert.
Der Timeoutparameter des <authentication> Konfigurationsabschnitts steuert das Intervall, in dem das Authentifizierungscookies neu generiert wird. Sie können einen Wert auswählen, der eine bessere Leistung und Sicherheit bietet.
Bestimmte zwischengeschaltete Proxys und Caches im Internet können Webserverantworten zwischenspeichern, die Header enthalten Set-Cookie , die dann an einen anderen Benutzer zurückgegeben werden. Da die formularbasierte Authentifizierung ein Cookie verwendet, um Benutzer zu authentifizieren, kann dieses Verhalten dazu führen, dass Benutzer versehentlich (oder absichtlich) die Identität eines anderen Benutzers annehmen, indem sie ein Cookie von einem zwischengeschalteten Proxy oder Cache erhalten, das ursprünglich nicht für sie vorgesehen war.