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

Artikel
01/25/2022
7 Minuten Lesedauer

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

System.Data.SqlClient
System.Web.Security

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

Anforderungen

In der folgenden Liste werden die empfohlenen Hardware-, Software-, Netzwerkinfrastruktur- und Service Packs beschrieben, 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> Abschnitte und Konfigurationsabschnitte hinzufügen und ändern, um die ASP.NET Anwendung für die Verwendung der <authorization> 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 den Zugriff auf den anonymen Benutzer im <authorization> Abschnitt wie folgt:
```
<authorization>
    <deny users ="?" />
    <allow users = "*" />
</authorization>
```

Erstellen einer Beispieldatenbanktabelle zum Speichern von Benutzerdetails

In diesem Abschnitt wird gezeigt, wie Sie eine Beispieldatenbank zum Speichern des Benutzernamens, des Kennworts und der Rolle für die Benutzer erstellen. Sie benötigen die Rollenspalte, wenn Sie Benutzerrollen in der Datenbank speichern und rollenbasierte Sicherheit implementieren möchten.

Wählen Sie im Startmenü "Ausführen" aus, und geben Sie dann 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 in 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 Seite Logon.aspx

Fügen Sie dem Projekt ein neues Webformular mit dem Namen Logon.aspx 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 zur Verfügung zu stellen, 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 die Benutzeranmeldeinformationen überprüft werden.

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

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

Erstellen Sie eine ValidateUser Funktion zum Überprüfen der Benutzeranmeldeinformationen, indem Sie in der Datenbank suchen. Stellen Sie sicher, dass Sie die Zeichenfolge so ändern, dass Connection 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 Formularauthentifizierungscookie zu generieren und den Benutzer zu einer entsprechenden Seite im cmdLogin_ServerClick Ereignis umzuleiten. Beispielcode wird für beide Szenarien bereitgestellt. Verwenden Sie beide gemäß Ihren Anforderungen.

Rufen Sie die RedirectFromLoginPage Methode auf, um das Formularauthentifizierungscookie automatisch zu generieren und den Benutzer zu einer entsprechenden Seite für das Ereignis umzuleiten: 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);
}

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 bietet Ihnen mehr Kontrolle darüber, wie Sie das Cookie erstellen. Sie können auch benutzerdefinierte Daten zusammen mit den FormsAuthenticationTicket in diesem Fall 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 Methode im Code, den der Webformular-Designer generiert, der folgende Code hinzugefügt InitializeComponent wird:
```
this.cmdLogin.ServerClick += new System.EventHandler(this.cmdLogin_ServerClick);
```

Erstellen einer Default.aspx-Seite

In diesem Abschnitt wird eine Testseite erstellt, zu der 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 Seite WebForm1.aspx 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 "SignOut", um die CodeBehind-Seite (Default.aspx.cs) zu öffnen, und kopieren Sie den folgenden Code im cmdSignOut_ServerClick Ereignishandler:
```
private void cmdSignOut_ServerClick(object sender, System.EventArgs e)
{
    FormsAuthentication.SignOut();
    Response.Redirect("logon.aspx", true);
}
```
Stellen Sie sicher, dass der Methode im Code, den der Webformular-Designer generiert, der folgende Code hinzugefügt InitializeComponent wird:
```
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 verwenden, HashPasswordForStoringInConfigFile die benannt ist, 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 einfach ändern können.
Sie können das Hinzufügen von Code in Betracht ziehen, um zu verhindern, dass sich Hacker, die versuchen, verschiedene Kombinationen von Kennwörtern zu verwenden, anmelden. Sie können beispielsweise Logik einschließen, die nur zwei oder drei Anmeldeversuche akzeptiert. Wenn sich Benutzer bei einigen Versuchen nicht anmelden können, sollten Sie ein Kennzeichen in der Datenbank festlegen, damit sie sich erst anmelden können, wenn die Benutzer ihre Konten erneut aktivieren, indem sie eine andere Seite besuchen oder Ihre Supportzeile aufrufen. Außerdem sollten Sie bei Bedarf eine entsprechende Fehlerbehandlung hinzufügen.
Da der Benutzer basierend auf dem Authentifizierungscookie identifiziert wird, sollten Sie secure Sockets Layer (SSL) für diese Anwendung verwenden, damit niemand das Authentifizierungscookie und alle anderen wertvollen Informationen, die übertragen werden, verwirren kann.
Die formularbasierte Authentifizierung erfordert, dass Ihr Client Cookies in ihrem Browser akzeptiert oder aktiviert.
Der Timeoutparameter des <authentication> Konfigurationsabschnitts steuert das Intervall, in dem das Authentifizierungscookie 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 Set-Cookie zwischenspeichern, die Header enthalten, die dann an einen anderen Benutzer zurückgegeben werden. Da die formularbasierte Authentifizierung ein Cookie zur Authentifizierung von Benutzern verwendet, 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 empfangen, der ursprünglich nicht für sie vorgesehen war.