Rollenbasierte Autorisierung in ASP.NET Core

Wenn die Identität eines Benutzers nach der Authentifizierung erstellt wird, gehört der Benutzer möglicherweise zu einer oder mehreren Rollen und spiegelt verschiedene Autorisierungen wider, die der Benutzer auf Daten zugreifen und Vorgänge ausführen muss. Beispielsweise kann Tracy zu den Rollen "Administrator" und "Benutzer" mit Zugriff auf administrative Webseiten in der App gehören, während Scott nur zur Rolle "Benutzer" gehört und keinen Zugriff auf administrative Daten oder Vorgänge hat. Wie diese Rollen erstellt und verwaltet werden, hängt vom Back-End-System des Autorisierungsprozesses ab. Rollen werden dem Entwickler über ClaimsPrincipal.IsInRole. AddRoles muss aufgerufen werden, um beim Einrichten des Identitätssystems der App Rollendienste hinzuzufügen.

Obwohl Rollen Ansprüche sind, sind nicht alle Ansprüche auch Rollen. Je nach Identitätsherausgeber kann eine Rolle aus einer Gruppe von Benutzern bestehen, die Ansprüche für Gruppenmitglieder geltend machen können, sowie aus einem tatsächlichen Anspruch auf eine Identität. Ansprüche sollen jedoch Informationen zu einzelnen Benutzer*innen sein. Die Verwendung von Rollen zum Hinzufügen von Ansprüchen zu einem/einer Benutzer*in kann die Grenze zwischen den Benutzer*innen und ihren individuellen Ansprüchen verwischen. Diese Verwirrung besteht darin, dass die Single-Page-Anwendungsvorlagen (SINGLE-Page Application, SPA) nicht für Rollen konzipiert sind. Darüber hinaus kann für Organisationen, die von einem lokalen Legacysystem migrieren, die Verbreitung von Rollen im Laufe der Jahre bedeuten, dass ein Rollenanspruch möglicherweise zu groß sein kann, um in einem token enthalten zu sein, das von einem SPA verwendet werden kann. Informationen zum Sichern von SPAs finden Sie unter Verwenden Identity zum Sichern eines Web-API-Back-Ends für SPAs.

Dieser Artikel verwendet BlazorRazor Komponentenbeispiele und konzentriert sich auf Blazor Autorisierungsszenarien. Weitere Blazor Anleitungen finden Sie in den folgenden Ressourcen:

• ASP.NET Core Blazor Authentifizierung und Autorisierung
• ASP.NET Core Blazor WebAssembly mit Microsoft Entra ID-Gruppen und -Rollen

Informationen Razor zu Seiten und MVC-Richtlinien, die für alle Releaseversionen von ASP.NET Core gelten, finden Sie in den folgenden Ressourcen:

• Rollenbasierte Autorisierung in ASP.NET Kernseiten Razor
• Rollenbasierte Autorisierung in ASP.NET Core MVC

Beispiel-App

Das Blazor Web App Beispiel für diesen Artikel ist die BlazorWebAppRolesWithIdentity Beispiel-App (dotnet/AspNetCore.Docs.Samples GitHub-Repository) (herunterladen). Die Beispiel-App verwendet Seeded-Konten mit vorkonfigurierten Rollen, um die meisten Beispiele in diesem Artikel zu veranschaulichen. Weitere Informationen finden Sie in der README-Datei des Beispiels (README.md).

Rollendienste zu Identity hinzufügen

builder.Services.AddDefaultIdentity<IdentityUser>( ... )
    .AddRoles<IdentityRole>()
    ...

builder.Services.AddIdentityCore<IdentityUser>()
    .AddRoles<IdentityRole>()
    ...

services.AddDefaultIdentity<IdentityUser>()
    .AddRoles<IdentityRole>()
    ...

services.AddIdentityCore<IdentityUser>()
    .AddRoles<IdentityRole>()
    ...

Rollenbasierte Autorisierungsprüfungen

Rollenbasierte Autorisierungsprüfungen:

• Sie sind deklarativ und geben Rollen an, deren Mitglied der/die aktuelle Benutzer*in sein muss, um auf die angeforderte Ressource zugreifen zu können.
• Werden auf Razor Komponenten (Beispiele in diesem Artikel), Razor Seiten oder MVC-Controller oder Aktionen innerhalb eines Controllers angewendet.

Die AuthorizeView Komponente unterstützt die rollenbasierte Autorisierung. In diesem Abschnitt werden grundlegende Konzepte behandelt. Vollständige Abdeckung finden Sie unter ASP.NET Kernauthentifizierung Blazor und Autorisierung.

Verwenden Sie für die rollenbasierte Autorisierung von Inhalten in Razor Komponenten den AuthorizeView.Roles Parameter.

Im folgenden Beispiel:

• Der Benutzer muss über eine Rollenberechtigung entweder für die Admin oder SuperUser Rollen verfügen, um den Inhalt der ersten AuthorizeView Komponente anzuzeigen.
• Um sowohl Admin- als auch SuperUser-Rollenansprüche zu verlangen, werden im zweiten Beispiel AuthorizeView-Komponenten geschachtelt.

Pages/RoleChecksWithAuthorizeView.razor:

@page "/role-checks-with-authorizeview"

<h3>Role Checks with AuthorizeView</h3>

<AuthorizeView Roles="Admin, SuperUser">
    <p>User: @context.User.Identity?.Name</p>
    <p>You have an 'Admin' or 'SuperUser' role claim.</p>
</AuthorizeView>

<AuthorizeView Roles="Admin">
    <p>User: @context.User.Identity?.Name</p>
    <p>You have the 'Admin' role claim.</p>
    <AuthorizeView Roles="SuperUser" Context="innerContext">
        <p>User: @innerContext.User.Identity?.Name</p>
        <p>You have both 'Admin' and 'SuperUser' role claims.</p>
    </AuthorizeView>
</AuthorizeView>

Der vorangehende Code richtet einen Context für die innere AuthorizeView-Komponente ein, um einen AuthenticationState-Kontextkonflikt zu verhindern. Auf den AuthenticationState-Kontext wird im äußeren AuthorizeView mit dem Standardansatz für den Zugriff auf den Kontext zugegriffen (@context.User). Auf den Kontext wird im inneren AuthorizeView mit dem benannten innerContext-Kontext (@innerContext.User) zugegriffen.

Das [Authorize] Attribut unterstützt die rollenbasierte Autorisierung für ganze Razor Komponenten. Verwenden Sie den Parameter AuthorizeAttribute.Roles. Der folgende Code beschränkt den Komponentenzugriff auf Benutzer, die Mitglied der Admin Rolle sind.

Pages/RequireAdminRoleWithAuthorizeAttribute.razor:

@page "/require-admin-role-with-authorize-attribute"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Roles = "Admin")]

<h1>Require 'Admin' role with [Authorize] attribute</h1>

<p>You can only see this if you're in the 'Admin' role.</p>

Mehrere Rollen können als durch Trennzeichen getrennte Liste angegeben werden. Im folgenden Beispiel ist der Zugriff auf Benutzer beschränkt, die Mitglieder der Admin Rolle oder Rolle SuperUser sind.

Pages/RequireAdminOrSuperUserRoleWithAuthorizeAttribute.razor:

@page "/require-admin-or-superuser-role-with-authorize-attribute"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Roles = "Admin, SuperUser")]

<h1>Require 'Admin' or 'SuperUser' role with [Authorize] attribute</h1>

<p>
    You can only see this if you're in the 'Admin' role or the 'SuperUser' role.
</p>

Wenn mehrere Attribute angewendet werden, muss der Benutzer Mitglied aller angegebenen Rollen sein. Im folgenden Beispiel sind beideAdminRollenSuperUser erforderlich.

Pages/RequireAdminAndSuperUserRolesWithAuthorizeAttributes.razor:

@page "/require-admin-and-superuser-roles-with-authorize-attributes"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Roles = "Admin")]
@attribute [Authorize(Roles = "SuperUser")]

<h1>Require 'Admin' and 'SuperUser' roles with [Authorize] attributes</h1>

<p>
    You can only see this if you're in both the 'Admin' role 
    and the 'SuperUser' role.
</p>

Beim Rollenabgleich wird in der Regel die Groß-/Kleinschreibung beachtet, da Rollennamen mithilfe von .NET-Zeichenfolgenvergleichen gespeichert und verglichen werden. Beispielsweise wird Admin (Großbuchstabe A) nicht als die gleiche Rolle wie admin (Kleinbuchstaben a) behandelt. Weitere Informationen finden Sie unter Anspruchsbasierte Autorisierung in ASP.NET Core.

Richtlinienbasierte Autorisierungsprüfungen

Rollenanforderungen können mithilfe der Richtliniensyntax ausgedrückt werden, wobei die App eine Richtlinie beim Start als Teil der Autorisierungsdienstkonfiguration registriert.

Im folgenden Beispiel:

• Die RequireAdminRole Richtlinie gibt an, dass Benutzer in der Admin Rolle sein müssen.
• Die RequireSuperUserRole Richtlinie gibt an, dass Benutzer in der SuperUser Rolle sein müssen.

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("RequireAdminRole",
         policy => policy.RequireRole("Admin"))
    .AddPolicy("RequireSuperUserRole",
         policy => policy.RequireRole("SuperUser"));

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("RequireAdminRole",
        policy => policy.RequireRole("Admin"));
    options.AddPolicy("RequireSuperUserRole",
        policy => policy.RequireRole("SuperUser"));
});

services.AddAuthorization(options =>
{
    options.AddPolicy("RequireAdminRole",
        policy => policy.RequireRole("Admin"));
    options.AddPolicy("RequireSuperUserRole",
        policy => policy.RequireRole("SuperUser"));
});

Verwenden Sie für die richtlinienbasierte Autorisierung mithilfe einer AuthorizeView Komponente den AuthorizeView.Policy Parameter mit einem einzelnen Richtliniennamen.

Pages/PassRequireAdminRolePolicy.razor:

@page "/pass-requireadminrole-policy-with-authorizeview"

<h1>Pass 'RequireAdminRole' policy with AuthorizeView</h1>

<AuthorizeView Policy="RequireAdminRole">
    <p>You satisfy the 'RequireAdminRole' policy.</p>
</AuthorizeView>

Für den Fall, dass der Benutzer eine von mehreren Richtlinien erfüllen muss, erstellen Sie eine Richtlinie, die bestätigt, dass der Benutzer andere Richtlinien erfüllt.

Um den Fall zu behandeln, in dem der Benutzer mehrere Richtlinien gleichzeitig erfüllen muss, führen Sie eine der folgenden Ansätze aus:

• Erstellen Sie eine Richtlinie für AuthorizeView, die bestätigt, dass der Benutzer mehrere andere Richtlinien erfüllt.

• Verschachteln Sie die Richtlinien innerhalb mehrerer AuthorizeView-Komponenten.

  Pages/PassRequireAdminRoleAndRequireSuperUserRolePoliciesWithAuthorizeViews.razor:

  @page "/pass-requireadminrole-and-requiresuperuserrole-policies-with-authorizeviews"
  
  <h1>
      Pass 'RequireAdminRole' and 'RequireSuperUserRole' policies with AuthorizeViews
  </h1>
  
  <AuthorizeView Policy="RequireAdminRole">
      <AuthorizeView Policy="RequireSuperUserRole" Context="innerContext">
          <p>
              You satisfy the 'RequireAdminRole' and 
              'RequireSuperUserRole' policies.
          </p>
      </AuthorizeView>
  </AuthorizeView>
  

Wenn beide Roles Bedingungen festgelegt sind und Policy festgelegt sind, ist die Autorisierung nur erfolgreich, wenn beide Bedingungen erfüllt sind. Das heißt, der Benutzer muss mindestens einer der angegebenen Rollen angehören und die von der Richtlinie definierten Anforderungen erfüllen.

Wenn weder Roles noch Policy angegeben wird, verwendet AuthorizeView die Standardrichtlinie:

• Authentifizierte (angemeldete) Benutzer werden autorisiert.
• Nicht authentifizierte (abgemeldete) Benutzer werden nicht autorisiert.

Im Gegensatz zum Rollenabgleich, bei dem in der Regel die Groß-/Kleinschreibung beachtet wird, wird bei der Namenssuche von ASP.NET Core-Richtlinien in der Regel die Groß-/Kleinschreibung nicht beachtet, sodass RequireAdminRole und requireadminrole auf dieselbe Richtlinie verweisen.

Richtlinien werden mithilfe der Razor Eigenschaft für das [Authorize] auf eine gesamte Komponente angewendet.

Pages/PassRequireAdminRolePolicyWithAuthorizeAttribute.razor:

@page "/pass-requireadminrole-policy-with-authorize-attribute"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "RequireAdminRole")]

<h1>Pass RequireAdminRole policy with [Authorize] attribute</h1>

<p>You can only see this if the 'RequireAdminRole' policy is satisfied.</p>

Um mehrere zulässige Rollen in einer Anforderung anzugeben, geben Sie die Rollen als Parameter für die RequireRole Methode an. Im folgenden Beispiel werden Benutzer berechtigt, wenn sie zu den Rollen AdminoderSuperUser gehören.

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("ElevatedRights", policy =>
        policy.RequireRole("Admin", "SuperUser"));

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy =>
        policy.RequireRole("Admin", "SuperUser"));
});

services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy =>
        policy.RequireRole("Admin", "SuperUser"));
});

Wenn die Richtlinie alle vorherigen Rollen erfordern soll, verketten Sie die Rollen entweder mit dem Richtlinien-Generator, oder geben Sie sie einzeln in einer Lambda-Anweisung an den Richtlinien-Generator an.

Verkettet mit dem Richtlinien-Generator:

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("ElevatedRights", policy => 
        policy
            .RequireRole("Admin")
            .RequireRole("SuperUser"));

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("ElevatedRights",
        policy =>
        {
            policy.RequireRole("Admin");
            policy.RequireRole("SuperUser");
        });

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy => 
        policy
            .RequireRole("Admin")
            .RequireRole("SuperUser"));
});

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights",
        policy =>
        {
            policy.RequireRole("Admin");
            policy.RequireRole("SuperUser");
        });
});

services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights", policy => 
        policy
            .RequireRole("Admin")
            .RequireRole("SuperUser"));
});

services.AddAuthorization(options =>
{
    options.AddPolicy("ElevatedRights",
        policy =>
        {
            policy.RequireRole("Admin");
            policy.RequireRole("SuperUser");
        });
});

Sicherheitsgruppen für die Windows-Authentifizierung als App-Rollen

Das User.Identity ist typischerweise ein WindowsIdentity bei der Verwendung der Windows-Authentifizierung, und Sie können die SID-Gruppenansprüche abrufen oder überprüfen, ob sich ein Benutzer mit dem folgenden Code in einer Rolle befindet, wobei der {DOMAIN} Platzhalter die Domäne und {SID GROUP NAME} ist der SID-Gruppenname.

if (User.Identity is WindowsIdentity windowsIdentity)
{
    var groups = windowsIdentity.Groups;

    // If needed, obtain a list of the SID groups
    var securityGroups = 
        groups.Select(g => g.Translate(typeof(NTAccount)).ToString()).ToList();

    // If needed, obtain the user's Windows identity name
    var windowsIdentityName = windowsIdentity.Name;

    // Check if the user is in a specific SID group
    if (User.IsInRole(@"{DOMAIN}\{SID GROUP NAME}"))
    {
        // User is in the specified group
    }
    else
    {
        // User isn't in the specified group
    }
}
else
{
    // The user isn't authenticated with Windows Authentication
}

Weitere Ressourcen

• ASP.NET Core Blazor Authentifizierung und Autorisierung
• ASP.NET Core Blazor WebAssembly mit Microsoft Entra ID-Gruppen und -Rollen
• Rollenbasierte Autorisierung in ASP.NET Kernseiten Razor
• Rollenbasierte Autorisierung in ASP.NET Core MVC
• Erweitern oder Hinzufügen von benutzerdefinierten Ansprüchen, einschließlich Rollenansprüchen, mithilfe von IClaimsTransformation