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

Artikel
07/30/2024

In diesem Artikel wird das Implementieren der formularbasierten Authentifizierung mithilfe einer Datenbank zum Speichern der Benutzer veranschaulicht. Sie bezieht sich auf die folgenden Microsoft .NET Framework-Klassenbibliotheksnamespaces:

System.Data.SqlClient
System.Web.Security

Ursprüngliche 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 Datei "Web.config"

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

Öffnen Sie in Projektmappen-Explorer die Datei "Web.config".
Ändern Sie den Authentifizierungsmodus in Formulare.
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" "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>
```
Den Zugriff auf den anonymen Benutzer im <authorization> Abschnitt wie folgt verweigern:
```
<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 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 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 der Abfrageanalyse. Wählen Sie in der Liste der Datenbanken Pubs aus, und führen Sie das Skript aus. Dieser Vorgang erstellt eine Beispielbenutzertabelle 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 ein neues Webformular mit dem Namen Logon.aspx hinzu.
Öffnen Sie die Logon.aspx Seite 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 zu präsentieren, damit sie ihren Benutzernamen und ihr Kennwort angeben können, um sich bei der Anwendung anzumelden.

Weitere Informationen finden Sie unter RequiredFieldValidator Class.

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 dargestellt, 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 der 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. Beispielcode wird für beide Szenarien bereitgestellt. Verwenden Sie eine davon gemäß Ihrer Anforderung.

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 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 Folgende Code der InitializeComponent Methode im Code hinzugefügt wird, den der 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 als 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 der CodeBehind-Datei:
```
using System.Web.Security;
```
Doppelklicken Sie auf "SignOut ", um die CodeBehind-Seite (Default.aspx.cs) zu öffnen, und kopieren Sie den cmdSignOut_ServerClick folgenden Code im 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 InitializeComponent Methode im Code hinzugefügt wird, den der 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 Klassenhilfsfunktion verwenden, die benannt ist HashPasswordForStoringInConfigFile , 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 Code hinzufügen, um Hacker zu verhindern, die versuchen, verschiedene Kombinationen von Kennwörtern zu verwenden, sich anzumelden. Sie können z. B. Logik einschließen, die nur zwei oder drei Anmeldeversuche akzeptiert. Wenn sich Benutzer bei einigen Versuchen nicht anmelden können, möchten Sie möglicherweise ein Flag 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 geeignete Fehlerbehandlungen hinzufügen.
Da der Benutzer basierend auf dem Authentifizierungscookies identifiziert wird, sollten Sie secure Sockets Layer (SSL) für diese Anwendung verwenden, damit niemand das Authentifizierungscookies und andere wertvolle Informationen täuschen kann, die übertragen werden.
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 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 zum Authentifizieren von Benutzern verwendet, kann dieses Verhalten dazu führen, dass Benutzer versehentlich (oder absichtlich) einen anderen Benutzer annehmen, indem sie ein Cookie von einem zwischengeschalteten Proxy oder Cache erhalten, der ursprünglich nicht für sie vorgesehen war.

Freigeben über