War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
Exportieren (0) Drucken
Alle erweitern
Erweitern Minimieren

Vorgehensweise: Implementieren von RBAC (Role Based Access Control, rollenbasierte Zugriffssteuerung) in einer Ansprüche unterstützenden ASP.NET-Anwendung mithilfe von WIF und ACS

Veröffentlicht: April 2011

Letzte Aktualisierung: Juni 2015

Betrifft: Azure

  • Zugriffssteuerung für Microsoft Azure Active Directory (auch Zugriffssteuerungsdienst oder ACS)

  • Windows® Identity Foundation (WIF)

  • ASP.NET

In diesem Thema wird die Implementierung von RBAC-Autorisierung (Role-Based Access Control, rollenbasierte Zugriffssteuerung) in Ansprüche unterstützende ASP.NET-Webanwendungen mithilfe von WIF und ACS erläutert.

  • Ziele

  • Überblick

  • Zusammenfassung der Schritte

  • Schritt 1 – Erstellen einer einfachen, Ansprüche unterstützenden ASP.NET-Webanwendung

  • Schritt 2 – Konfigurieren von Rollenansprüchen in ACS

  • Schritt 3 – Implementieren von Rollenüberprüfungen in einer ASP.NET-Webanwendung

  • Schritt 4 – Implementieren der Anspruchstransformation mithilfe einer benutzerdefinierten Komponente ClaimsAuthenticationManager

  • Schritt 5 – Testen der Lösung

  • Verwandte Elemente

  • Konfigurieren von Rollenansprüchen mithilfe von ACS.

  • Transformieren von Rollenansprüchen mithilfe von ClaimsAuthenticationManager.

  • Implementieren von rollenbasierten Zugriffssteuerungsüberprüfungen mithilfe der Methode IsInRole und der Attribute PrincipalPermission.

RBAC ist ein weit verbreiteter Ansatz zum Einschränken des Zugriffs in Anwendungen. In ASP.NET-Webanwendungen wird dieser Ansatz mithilfe der Methode IsInRole, des Attributs PrincipalPermission oder mithilfe von Anforderungen implementiert, die seit ASP.NET 1.0 verfügbar sind. Die können Ansprüche für die Autorisierung verwenden. Dabei werden bewährte Vorgehensweisen beibehalten und neue Technologien wie etwa WIF und ACS verwendet. Sie können das WIF-Laufzeitmodul und das SDK hier herunterladen:

  • Schritt 1 – Erstellen einer einfachen, Ansprüche unterstützenden ASP.NET-Webanwendung

  • Schritt 2 – Konfigurieren von Rollenansprüchen in ACS

  • Schritt 3 – Implementieren von Rollenüberprüfungen in einer ASP.NET-Webanwendung

  • Schritt 4 – Implementieren der Anspruchstransformation mithilfe einer benutzerdefinierten Komponente ClaimsAuthenticationManager

  • Schritt 5 – Testen der Lösung

Dieser Schritt zeigt das Erstellen einer ASP.NET-Basiswebanwendung, die als Grundlage für die Implementierung von RBAC verwendet wird.

  1. Starten Sie Visual Studio mit der Option Als Administrator ausführen. Diese Option ist für WIF erforderlich.

  2. Erstellen Sie eine neue, leere ASP.NET-Webanwendung.

  3. Fügen Sie das ASPX-Webformular hinzu, und geben Sie ihm einen Namen, z. B. default.aspx.

Dieser Schritt zeigt, wie Rollenansprüche im ACS-Verwaltungsportal mithilfe von Regelgruppen konfiguriert werden. Die vollständige schrittweise exemplarische Vorgehensweise finden Sie unter Vorgehensweise: Implementieren von Logik zur Tokentransformation mithilfe von Regeln.

  1. Führen Sie auf der Seite Anwendung der vertrauenden Seite bearbeiten einen Bildlauf nach unten bis zum Abschnitt Regelgruppen aus, und klicken Sie dann auf den Link der gewünschten Gruppe. Stellen Sie sicher, dass er ausgewählt ist.

  2. Führen Sie auf der Seite Regelgruppe bearbeiten einen Bildlauf nach unten bis zum Abschnitt Regeln aus, und klicken Sie dann auf den Link Regel hinzufügen.

  3. Führen Sie auf der Seite Anspruchsregel hinzufügen einen Bildlauf nach unten bis zum Abschnitt Ausgabeanspruchstyp aus, klicken Sie auf das Optionsfeld Typ auswählen, und wählen Sie dann den folgenden Anspruchstyp aus.

    http://schemas.microsoft.com/ws/2008/06/identity/claims/role
    
    
  4. Klicken Sie im Abschnitt Ausgabeanspruchswert auf Wert eingeben, und geben Sie dann den folgenden Text als Wert in das Textfeld ein:
    Benutzer

  5. Fügen Sie optional eine Beschreibung hinzu (empfohlen), und klicken Sie dann auf Speichern.

Sie haben soeben den Rollenanspruch User konfiguriert, der jedem beliebigen Token hinzugefügt werden kann. Abhängig von Ihren Anforderungen kann das Szenario ggf. abweichen. Weitere Informationen zum Konfigurieren komplexerer Regeln finden Sie unter Vorgehensweise: Implementieren von Logik zur Tokentransformation mithilfe von Regeln.

In diesem Schritt wird gezeigt, wie RBAC implementiert wird.

  1. Fügen Sie einen Verweis auf die Assembly Microsoft.IdentityModel hinzu.

  2. Öffnen Sie den Code für default.aspx.cs.

  3. Fügen Sie Folgendes mithilfe von Deklarationen hinzu.

    using System.Security.Permissions;
    using System.Threading;
    using Microsoft.IdentityModel.Claims;
    using System.Security;
    
    
  4. Statten Sie den Ereignishandler Page_Load mit der folgenden Sicherheitsanforderung aus. Dieses Attribut überprüft, ob der aktuelle Benutzer die Rolle User ausübt. Ist dies nicht der Fall, wird eine Ausnahme ausgelöst.

    [PrincipalPermission(SecurityAction.Demand, Role = "User")]
    
  5. Fügen Sie dem Textkörper des Ereignishandlers Page_Load den folgenden Code hinzu. Dies ist mit der im Code ausgedrückten Anforderung identisch.

    PrincipalPermission p = new PrincipalPermission(null, "User");
       p.Demand();
    
    
  6. Fügen Sie dem Textkörper des Ereignisses Page_Load den folgenden Code hinzu. Im Gegensatz zum vorherigen Code löst dieser Code keine Ausnahme aus. Stattdessen gibt IsInRole einen booleschen Wert zurück, der angibt, ob der aktuelle Benutzer die angegebene Rolle ausübt.

    if (!User.IsInRole("User"))
                    throw new SecurityException("Access is denied.");
    
    
  7. Der vollständige Code sollte dem folgenden Code ähnlich sehen.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Web.UI;
    using System.Web.UI.WebControls;
    
    using System.Security.Permissions;
    using System.Threading;
    using Microsoft.IdentityModel.Claims;
    using System.Security;
    
    namespace WebIsInRoleACS
    {
        public partial class _default : System.Web.UI.Page
        {
            //THIS SHOULD THROW AN EXCEPTION
            [PrincipalPermission(SecurityAction.Demand, Role = "User")]
            protected void Page_Load(object sender, EventArgs e)
            {
    
                //THIS SHOULD THROW AN EXCEPTION
                PrincipalPermission p = new PrincipalPermission(null, "User");
                p.Demand();
    
                //THIS RETURNS BOOL
                if (!User.IsInRole("User"))
                    throw new SecurityException("Access is denied.");
            }
        }
    }
    
    

Dies ist ein optionaler Schritt. In diesem Schritt wird die Transformation von Ansprüchen mithilfe von ClaimsAuthenticationManager gezeigt, einem Bestandteil der WIF-Pipeline, der im Kontext der ASP.NET-Anwendung ausgeführt wird. Die Anspruchstransformationsregeln werden im Gegensatz dazu wie in Schritt 2 – Konfigurieren von Rollenansprüchen in ACS beschrieben unter ACS ausgeführt.

  1. Fügen Sie der Visual Studio-Projektmappe das Projekt Klassenbibliothek hinzu, und geben Sie ihm dann einen Namen, z. B. MyClaimsTransformationModule.

  2. Fügen Sie einen Verweis auf die Assembly Microsoft.IdentityModel hinzu.

  3. Fügen Sie einen Verweis auf die Assembly System.IdentityModel hinzu.

  4. Erstellen Sie eine neue Klasse, und geben Sie ihr dann einen Namen, z. B. ClaimsTransformationModule.

  5. Fügen Sie der Klasse die folgenden Deklarationen hinzu.

    using Microsoft.IdentityModel.Claims;
    using System.Security.Principal;
    
    
  6. Leiten Sie die Klasse vom Typ ClaimsAuthenticationManager ab.

  7. Setzen Sie die Methode Authenticate außer Kraft (hier geschieht die Anspruchstransformation). Ihr Code für die Methode Authenticate kann auf dem folgenden Code basieren.

    if (incomingPrincipal != null && incomingPrincipal.Identity.IsAuthenticated == true)
    {
        //DECIDE ON SOME CRITERIA IF CURRENT USER DESERVES THE ROLE
        //IClaimsIdentity identity = (IClaimsIdentity)incomingPrincipal.Identity;
        ((IClaimsIdentity)incomingPrincipal.Identity).Claims.Add(
            new Claim(ClaimTypes.Role, "Admin"));
    }
    return incomingPrincipal;
    
    
  8. Wechseln Sie zur ASP.NET-Anwendung, und konfigurieren Sie dann Ihre benutzerdefinierte Komponente ClaimsAuthenticationManager in deren Datei web.config.

      <microsoft.identityModel>
        <service>
          <claimsAuthenticationManager type="MyClaimsTransformationModule.ClaimsTransformationModule, MyClaimsTransformationModule" />
    
    
  9. Stellen Sie sicher, dass die neue Assembly, die Sie erstellt haben, von der Anwendung gefunden wird. Die einfachste Methode besteht darin, die Assembly im Ordner bin der Anwendung zu speichern.

In diesem Schritt wird gezeigt, wie Sie bestätigen können, dass die Lösung funktioniert. Drücken Sie zum Testen Ihrer Lösung F5. Ihre ASP.NET-Webanwendung sollte im Debugmodus ausgeführt werden (Sie können Haltepunkte hinzufügen, um die Codeausführung in Visual Studio zu überprüfen). Zuerst sollten Sie auf die Authentifizierungsseite des Identitätsanbieters gelangen, der für den Verbund konfiguriert wurde. Nachdem die Authentifizierung abgeschlossen wurde, sollten Sie erneut an die Seite Default.aspx weitergeleitet werden, ohne dass eine Ausnahme ausgelöst wird. Dies bedeutet, dass alle Sicherheitsanforderungen für die Rolle User erfüllt wurden.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft