Vorgehensweise: Erstellen von GenericPrincipal-Objekten bei der Formularauthentifizierung

Artikel
04/18/2008

* * *

Auf dieser Seite

Zielsetzung
Betrifft
Verwendung dieses Moduls
Zusammenfassung
Benötigte Kenntnisse
Erstellen einer Webanwendung mit einer Anmeldeseite
Konfigurieren der Webanwendung für die Formularauthentifizierung
Erzeugen eines Authentifizierungstickets für authentifizierte Benutzer
Erstellen der Objekte "GenericPrincipal" und "FormsIdentity"
Testen der Anwendung
Weitere Ressourcen

Zielsetzung

Themenbereiche:

Erstellen einer Webanwendung, in der die Formularauthentifizierung verwendet und ein GenericPrincipal-Objekt mit der Identität und den Rollen des authentifizierten Benutzers gefüllt wird, um eine rollenbasierte .NET-Autorisierung vorzunehmen

Betrifft

Die Informationen in diesem Modul gelten für folgende Produkte und Technologien:

Microsoft Windows® XP oder Windows 2000 Server (mit Service Pack 3) und höhere Betriebssysteme
Microsoft .NET Framework Version 1.0 (mit Service Pack 2) und höhere Versionen
Microsoft Visual Studio® 1.0 .NET und höhere Versionen
Microsoft Visual C#® .NET

Verwendung dieses Moduls

Empfehlungen für eine erfolgreiche Arbeit mit diesem Modul:

Sie müssen über Erfahrung in Visual C# .NET und Visual Studio .NET verfügen.
Sie müssen über Erfahrung mit der Entwicklungsumgebung Visual Studio .NET verfügen.
Sie sollten über Erfahrung in der Entwicklung von Webanwendungen mithilfe von ASP.NET verfügen.
Lesen Sie Modul 3, "Authentifizierung und Autorisierung". Hier werden die rollenbasierte .NET-Sicherheit eingeführt und das GenericPrincipal-Objekt beschrieben.
Lesen Sie Modul 8, "ASP.NET-Sicherheit". Hier werden GenericPrincipal und die rollenbasierte .NET-Sicherheit in .NET-Webanwendungen ausführlich beschrieben.
Lesen Sie "Vorgehensweise: Verwenden der Formularauthentifizierung mit der Active Directory". Hier erhalten Sie Informationen zum Abrufen von Benutzerkontoinformationen aus der Active Directory.
Lesen Sie "Vorgehensweise: Verwenden der Formularauthentifizierung mit SQL Server 2000". Hier erhalten Sie Informationen zur Verwendung von SQL Server 2000 als Benutzerkontendatenbank.

Zusammenfassung

Um innerhalb einer Webanwendung die rollenbasierte Sicherheit in Microsoft .NET mit einem benutzerdefinierten Authentifizierungsmechanismus zu verwenden, der nicht auf Windows-Konten basiert, müssen Sie die direkte Verantwortung für die Erstellung von ASP.NET-Authentifizierungstickets und für die Konfiguration von IPrincipal-Instanzen übernehmen. Diese stellen die Identitäten und Rollen der authentifizierten Benutzer dar.

In diesem Modul wird die Erstellung einer Webanwendung beschrieben, in der die Formularauthentifizierung verwendet wird, um Benutzer zu authentifizieren und ein Authentifizierungsticket zu erstellen, das Benutzer- und Rolleninformationen enthält. Darüber hinaus wird dargestellt, wie diese Informationen in GenericPrincipal- und FormsIdentity-Objekten zugeordnet werden, so dass sie für die Autorisierungslogik in Ihrer Anwendung verwendet werden können.

Benötigte Kenntnisse

Bei Anwendungen, die mit Formularauthentifizierung arbeiten, wird häufig die GenericPrincipal-Klasse (in Verbindung mit der FormsIdentity-Klasse) zum Erstellen eines nicht Windows-spezifischen Autorisierungsschemas unabhängig von einer Windows-Domäne verwendet.

Für die Anwendung bestehen in diesem Zusammenhang die folgenden Möglichkeiten:

Verwenden der Formularauthentifizierung zur Anforderung der Anmeldeinformationen der Benutzer (Benutzername und Kennwort).
Überprüfen der übergebenen Anmeldeinformationen anhand eines Datenspeichers, z. B. einer Datenbank oder des Verzeichnisdienstes Microsoft Active Directory®.
Erstellen der Objekte GenericPrincipal und FormsIdentity basierend auf Werten, die aus dem Datenspeicher abgerufen wurden. Diese können Details zur Rollenmitgliedschaft eines Benutzers umfassen.
Verwenden dieser Objekte zum Treffen von Autorisierungsentscheidungen.

Nachstehend wird erläutert, wie eine formularbasierte Webanwendung erstellt wird, die den Benutzer authentifiziert und ein benutzerdefiniertes Formularauthentifizierungsticket erstellt, das Benutzer- und Rolleninformationen umfasst. Darüber hinaus wird gezeigt, wie diese Informationen den Objekten GenericPrincipal und FormsIdentity zugeordnet und die neuen Objekte mit dem HTTP-Webanforderungskontext verbunden werden. Dadurch ist es möglich, die Objekte in die Autorisierungslogik der Anwendung zu integrieren.

In diesem Modul steht die Erstellung der Objekte GenericPrincipal und FormsIdentity sowie die Verarbeitung des Formularauthentifizierungstickets im Mittelpunkt. Informationen zur Authentifizierung von Benutzern für die Active Directory und SQL Server 2000 finden Sie in den folgenden Modulen dieses Handbuches:

Erstellen einer Webanwendung mit einer Anmeldeseite

Mit diesem Verfahren wird eine neue ASP.NET-Webanwendung erstellt. Die Anwendung enthält zwei Seiten, eine Standardseite, auf die nur authentifizierte Benutzer zugreifen können, und eine Anmeldeseite für die Eingabe der Anmeldeinformationen.

So erstellen Sie eine Webanwendung mit einer Anmeldeseite
1. Starten Sie Visual Studio .NET und erstellen Sie eine neue Visual C# ASP.NET-Webanwendung mit Namen GenericPrincipalApp.
2. Benennen Sie WebForm1.aspx in Logon.aspx um.
3. Fügen Sie Logon.aspx die folgenden Steuerelemente hinzu, um ein Anmeldeformular zu erstellen.
  
  Tabelle 1: Die Steuerelemente für Logon.aspx
  
  Typ des Steuerelements Text ID
  
  Bezeichnungsfeld Benutzername: -
  
  Bezeichnungsfeld Kennwort -
  
  Textfeld - txtUserName
  
  Textfeld - txtPassword
  
  Schaltfläche Anmelden btnLogon
4. Legen Sie die TextMode-Eigenschaft des Textfeldsteuerelements txtPassword auf Kennwort fest.
5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf GenericPrincipalApp, zeigen Sie auf Hinzufügen und klicken Sie dann auf Web Form hinzufügen.
6. Geben Sie default.aspx als neuen Namen des Formulars ein und klicken Sie dann auf Öffnen.

Typ des Steuerelements	Text	ID
Bezeichnungsfeld	Benutzername:	-
Bezeichnungsfeld	Kennwort	-
Textfeld	-	txtUserName
Textfeld	-	txtPassword
Schaltfläche	Anmelden	btnLogon

Konfigurieren der Webanwendung für die Formularauthentifizierung

So bearbeiten Sie die Datei Web.config der Anwendung, um die Anwendung für die Formularauthentifizierung zu konfigurieren
1. Öffnen Sie Web.config im Projektmappen-Explorer.
2. Suchen Sie das <authentication>-Element, und ändern Sie das mode-Attribut in Formulare.
3. Fügen Sie das folgende <Formulare>-Element als untergeordnetes Element des <authentication>-Elements hinzu, und legen Sie die Attribute loginUrl, name, timeout und path wie nachstehend gezeigt fest:
```
<authentication mode="Formulare">
 <forms loginUrl="logon.aspx" name="AuthCookie" timeout="60" path="/">
 </forms>
</authentication>
```
4. Fügen Sie das folgende <authorization>-Element unterhalb des <authentication>-Elements hinzu. Dies sorgt dafür, dass nur authentifizierte Benutzer auf die Anwendung zugreifen können. Das im Vorfeld eingerichtete loginUrl-Attribut des <authentication>-Elements leitet nicht authentifizierte Anforderungen auf die Seite Logon.aspx um.
```
<authorization> 
 <deny users="?" />
 <allow users="*" />
</authorization>
```

Erzeugen eines Authentifizierungstickets für authentifizierte Benutzer

In diesem Verfahren wird der Code zum Erzeugen des Authentifizierungstickets für authentifizierte Benutzer geschrieben. Das Authentifizierungsticket ist eine Art Cookie, das vom FormsAuthenticationModule von ASP.NET verwendet wird.

Der Authentifizierungscode umfasst in der Regel das Nachschlagen des übergebenen Benutzernamens und des Kennworts, und zwar entweder in einer benutzerdefinierten Datenbank oder in der Active Directory.

Weitere Informationen darüber finden Sie in den folgenden Modulen dieses Handbuches:

So erzeugen Sie ein Authentifizierungsticket für authentifizierte Benutzer

Öffnen Sie die Datei Logon.aspx.cs und fügen Sie am Anfang der Datei unterhalb der vorhandenen using-Anweisungen die folgenden using-Anweisungen hinzu:
```
using System.Web.Security;
```

Fügen Sie der WebForm1-Klasse die folgende private Hilfsmethode mit Namen IsAuthenticated hinzu, die verwendet wird, um die Benutzernamen und Kennwörter für die Authentifizierung der Benutzer zu überprüfen. In diesem Code wird davon ausgegangen, dass sämtliche Kombinationen aus Benutzername und Kennwort gültig sind.

private bool IsAuthenticated( string username, string password )
{
  // Suchcode zugunsten größerer Klarheit weggelassen
  // Mit diesem Code werden normalerweise die Kombination aus Benutzernamen und Kennwort
  // anhand einer SQL-Datenbank oder anhand von Active Directory überprüft
  // Authentifizierten Benutzer simulieren
  return true;
}

Fügen Sie die nachstehende private Hilfsmethode mit Namen GetRoles hinzu, die verwendet wird, um die Rollen abzurufen, denen der Benutzer angehört.

private string GetRoles( string username, string password )
{
  // Suchcode zugunsten größerer Klarheit weggelassen
  // Mit diesem Code wird normalerweise die Rollenliste aus einer
  Datenbanktabelle nachgeschlagen.
  // Wenn der Benutzer anhand von Active Directory authentifiziert wurde, 
  // können die Sicherheitsgruppen und/oder Verteilerlisten, zu denen der Benutzer 
  gehört, stattdessen 
  // verwendet werden

  // Mit dieser GetRoles-Methode wird eine durch einen senkrechten Balken (Pipe) getrennte 
  Zeichenfolge zurückgegeben, die Rollen enthält,
  // und kein Array, da das Format der Zeichenfolge 
  für 
  // die Speicherung als Benutzerdaten im Authentifizierungsticket/Cookie geeignet ist.
  return "Senior Manager|Manager|Mitarbeiter";
}

Zeigen Sie das Formular Logon.aspx im Entwurfsmodus an und doppelklicken Sie auf die Schaltfläche Anmelden, um einen Ereignishandler für das Klickereignis zu erstellen.
Fügen Sie einen Aufruf der IsAuthenticated-Methode hinzu und übergeben Sie den Benutzernamen und das Kennwort, der bzw. das im Anmeldeformular eingegeben wurde. Weisen Sie den Rückgabewert einer Variablen vom Typ bool zu, die angibt, ob der Benutzer authentifiziert werden konnte oder nicht.
```
bool isAuthenticated = IsAuthenticated( txtUserName.Text, 
                                txtPassword.Text );
```
Fügen Sie einen Aufruf der GetRoles-Methode hinzu, um für den Fall, dass der Benutzer authentifiziert wird, die Rollenliste des Benutzers abzurufen.
```
if (isAuthenticated == true )
{
  string roles = GetRoles( txtUserName.Text, txtPassword.Text );
```

Erstellen Sie ein neues Formularauthentifizierungsticket, das den Benutzernamen, eine Ablaufzeit und die Liste der Rollen, denen der Benutzer angehört, enthält. Beachten Sie, dass die UserData-Eigenschaft des Authentifizierungstickets verwendet wird, um die Rollenliste des Benutzers zu speichern. Beachten Sie zudem, dass mit dem folgenden Code ein nicht persistentes Ticket erstellt wird, obwohl es vom Anwendungsszenario abhängig ist, ob das Ticket/Cookie persistent ist oder nicht.

  // Create the authentication ticket
  FormsAuthenticationTicket authTicket = new 
      FormsAuthenticationTicket(1,                          // Version
                                txtUserName.Text,           // Benutzername
                                DateTime.Now,               // Erstellung
                                DateTime.Now.AddMinutes(60),// Ablauf
                                false,                      // Permanent
                                roles );                    // Benutzerdaten

Fügen Sie Code zum Erstellen einer verschlüsselten Zeichenfolgendarstellung des Tickets hinzu und speichern Sie diese als Datenwert in einem HttpCookie-Objekt.

  // Verschlüsseln Sie nun das Ticket.
  string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
  // Erstellen Sie ein Cookie, und fügen Sie das verschlüsselte Ticket dem  
  // Cookie in Form von Daten hinzu.
  HttpCookie authCookie = 
              new HttpCookie(FormsAuthentication.FormsCookieName,
                              encryptedTicket);

Fügen Sie das Cookie der Cookieauflistung hinzu, die an den Browser des Benutzers zurückgegeben wird.

  // Fügen Sie das Cookie der Sammlung ausgehender Cookies hinzu. 
  Response.Cookies.Add(authCookie);

Leiten Sie den Benutzer auf die ursprünglich angeforderte Seite um.

  // Leiten Sie den Benutzer auf die ursprünglich angeforderte Seite um.
  Response.Redirect( FormsAuthentication.GetRedirectUrl(
                                                txtUserName.Text, 
                                                false ));
}

Erstellen der Objekte "GenericPrincipal" und "FormsIdentity"

Mit diesem Verfahren wird ein Ereignishandler für die Anwendungsauthentifizierung implementiert: Basierend auf den Informationen im Authentifizierungsticket werden die Objekte GenericPrincipal und FormsIdentity erstellt.

So erstellen Sie die Objekte "GenericPrincipal" und "FormsIdentity"

Öffnen Sie global.asax im Projektmappen-Explorer.
Wechseln Sie in die Codeansicht und fügen Sie am Anfang der Datei die folgenden using-Anweisungen hinzu:
```
using System.Web.Security;
using System.Security.Principal;
```

Suchen Sie den Ereignishandler Application_AuthenticateRequest und fügen Sie den folgenden Code hinzu, um aus der mit der Anforderung übergebenen Cookieauflistung den Formularauthentifizierungscookie abzurufen.

// Extrahieren Sie das Formularauthentifizierungs-Cookie
string cookieName = FormsAuthentication.FormsCookieName;
HttpCookie authCookie = Context.Request.Cookies[cookieName];

if(null == authCookie)
{
  // Es ist kein Authentfizierungscookie vorhanden.
  return;
}

Fügen Sie den folgenden Code hinzu, um das Authentifizierungsticket aus dem Formularauthentifizierungscookie zu extrahieren und zu entschlüsseln.

FormsAuthenticationTicket authTicket = null;
try
{
  authTicket = FormsAuthentication.Decrypt(authCookie.Value);
}
catch(Exception ex)
{
  // Protokollieren Sie Ausnahmedetails (aus Gründen der Überschaubarkeit ausgelassen)
  return;
}

if (null == authTicket)
{
  // Cookie konnte nicht entschlüsselt werden.
  return; 
}

Fügen Sie den folgenden Code hinzu, um die per Pipe getrennte Liste der Rollennamen auszulesen, die bei der ursprünglichen Authentifizierung des Benutzers an das Ticket angehängt wurde.

// Bei der Erstellung des Tickets wurde der UserData-Eigenschaft eine
// durch einen senkrechten Balken (Pipe) getrennte Zeichenfolge der Rollennamen zugewiesen.
string[] roles = authTicket.UserData.Split(new char[]{'|'});

Fügen Sie den folgenden Code hinzu, um das FormsIdentity-Objekt mit dem Benutzernamen zu erstellen, der dem Ticketnamen entnommen wurde, und um ein GenericPrincipal-Objekt zu erstellen, das diese Identität zusammen mit der Rollenliste des Benutzers enthält.

// Erstellen Sie ein Identitätsobjekt
FormsIdentity id = new FormsIdentity( authTicket ); 

// Dieser Prinzipal wird über die gesamte Anforderung hinweg übertragen.
GenericPrincipal principal = new GenericPrincipal(id, roles);
// Fügen Sie das neue Prinzipalobjekt an das aktuelle HttpContext-Objekt an
Context.User = principal;

Testen der Anwendung

Mit diesem Verfahren wird der Seite default.aspx Code hinzugefügt, um Informationen aus dem GenericPrincipal-Objekt anzuzeigen, das an das aktuelle HttpContext-Objekt angefügt wurde. So wird sichergestellt, dass das Objekt ordnungsgemäß erstellt und der aktuellen Webanforderung zugewiesen wurde. Anschließend erstellen und testen Sie die Anwendung.

So testen Sie die Anwendung
1. Doppelklicken Sie im Projektmappen-Explorer auf default.aspx.
2. Doppelklicken Sie auf das Webformular default.aspx, um den Ereignishandler zum Laden der Seite anzuzeigen.
3. Führen Sie einen Bildlauf zum Anfang der Datei durch und fügen Sie unterhalb der vorhandenen using-Anweisungen die folgende using-Anweisung hinzu.
```
using System.Security.Principal;
```
4. Kehren Sie zum Ereignishandler für das Laden der Seite zurück und fügen Sie den folgenden Code hinzu, um den Identitätsnamen anzuzeigen, der dem GenericPrincipal-Objekt zugewiesen wurde, das mit der aktuellen Webanforderung zusammenhängt.
```
IPrincipal p = HttpContext.Current.User;
Response.Write( "Authentifizierte Identität: " + 
 p.Identity.Name );
Response.Write( "" );
```
5. Fügen Sie den folgenden Code hinzu, um die Rollenmitgliedschaft der aktuell authentifizierten Identität zu prüfen.
```
if ( p.IsInRole("Senior Manager") )
 Response.Write( "Benutzer befindet sich in der Rolle "Senior Manager"" );
else
 Response.Write( "Benutzer befindet sich nicht in der Rolle "Senior Manager"" );

if ( p.IsInRole("Manager") )
 Response.Write( "Benutzer befindet sich in der Rolle "Manager"" );
else
 Response.Write( "Benutzer befindet sich nicht in der Rolle "Manager"" );

if ( p.IsInRole("Mitarbeiter") )
 Response.Write( "Benutzer befindet sich in der Rolle "Mitarbeiter"" );
else
 Response.Write( "Benutzer befindet sich nicht in der Rolle "Mitarbeiter"" );

if ( p.IsInRole("Verkauf") )
 Response.Write( "Benutzer befindet sich in der Rolle "Verkauf"" );
else
 Response.Write( "Benutzer befindet sich nicht in der Rolle "Verkauf"" );
```
6. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf default.aspx und dann auf Als Startseite festlegen.
7. Klicken Sie im Menü Erstellen auf Projektmappe erstellen. Beheben Sie sämtliche Buildfehler.
8. Drücken Sie Strg+F5, um die Anwendung auszuführen. Da default.aspx als Startseite konfiguriert ist, ist dies auch die zuerst angeforderte Seite.
9. Wenn Sie auf die Anmeldeseite umgeleitet werden (da Sie anfänglich ja nicht über ein Authentifizierungsticket verfügen), geben Sie irgendeinen Benutzernamen und ein beliebiges Kennwort ein und klicken Sie dann auf Anmelden.
10. Vergewissern Sie sich, dass Sie auf die Seite default.aspx umgeleitet werden und dass die Benutzeridentität und die korrekten Rollendetails angezeigt werden. Der Benutzer sollte ein Mitglied der Rollen Senior Manager, Manager und Mitarbeiter sein, jedoch kein Mitglied der Rolle Verkauf.

Weitere Ressourcen

Weitere Informationen hierzu finden Sie in den folgenden ähnlichen Modellen in diesem Handbuch: