Authentifizierung und Autorisierung in ASP.NET Core Blazor

Wenn die Erzwingung von Autorisierungsregelen gewährleistet sein muss, implementieren Sie keine Autorisierungsprüfungen im clientseitigen Code. Erstellen Sie eine Blazor Web App, die nur auf serverseitigem Rendering (SSR) für Autorisierungsprüfungen und die Regelerzwingung basiert.

Wenn die Erzwingung von Autorisierungsregeln und die Sicherheit von Daten und Code gewährleistet sein müssen, entwickeln Sie keine clientseitige App. Entwickeln Sie eine Blazor Server-App.

ASP.NET Core Identity ist für die Arbeit im Kontext der HTTP-Anforderungs- und -Antwortkommunikation konzipiert, was in der Regel nicht dem Blazor-Modell für die Kommunikation zwischen App-Client und Server entspricht. ASP.NET Core-Apps, welche die Benutzerverwaltung mit ASP.NET Core Identity umsetzen, sollten für eine Razor Benutzeroberfläche Razor Seiten anstelle von Identity Komponenten verwenden, z. B. Benutzerregistrierung, Anmelden, Abmelden und andere Benutzerverwaltungsaufgaben. Das Erstellen von Razor-Komponenten, die Identity-Aufgaben direkt verarbeiten, ist für mehrere Szenarien möglich, wird aber von Microsoft weder empfohlen noch unterstützt.

ASP.NET Core-Abstraktionen, wie z. B. SignInManager<TUser> und UserManager<TUser>, werden nicht in Razor Komponenten unterstützt. Weitere Informationen zur Verwendung von ASP.NET Core Identity mit Blazor finden Sie unter ASP.NET Core Identity in eine serverseitige Blazor App einbauen.

Unterstützung des Schutzes vor Fälschung

Die Blazor-Vorlage:

• Fügt Antiforgerydienste automatisch hinzu, wenn AddRazorComponents in der Program-Datei aufgerufen wird.
• Fügt Middleware für Fälschungsschutz durch den Aufruf von UseAntiforgery in seiner Anforderungsverarbeitungspipeline in der Program-Datei hinzu und erfordert einen Fäschlungsschutz am Endpunkt, um die Bedrohungen durch websiteübergreifende Anforderungsfälschung (CSRF/XSRF) abzuschwächen. UseAntiforgery wird nach UseHttpsRedirectionaufgerufen. Ein Anruf muss UseAntiforgery nach anrufen, sofern vorhanden, an UseAuthentication und UseAuthorization.

Die AntiforgeryToken-Komponente rendert ein Token zum Schutz gegen Fälschungen als ausgeblendetes Feld. Diese Komponente wird automatisch hinzugefügt, um Instanzen (EditForm) zu bilden. Weitere Informationen finden Sie unter Übersicht über ASP.NET Core Blazor Formulare.

Der AntiforgeryStateProvider-Dienst bietet Zugriff auf ein Token zum Schutz vor Fälschungen, das der aktuellen Sitzung zugeordnet ist. Fügen Sie den Dienst ein, und rufen Sie die GetAntiforgeryToken()-Methode auf, um die aktuelle AntiforgeryRequestToken abzurufen. Weitere Informationen finden Sie unter Aufrufen einer Web-API über eine ASP.NET Core Blazor-App.

Blazor speichert Anforderungstoken im Komponentenstatus, wodurch sichergestellt wird, dass Token zum Schutz vor Fälschungen für interaktive Komponenten verfügbar sind, auch wenn sie keinen Zugriff auf die Anforderung haben.

Weitere Informationen finden Sie in den folgenden Ressourcen:

• Verhindern von CSRF-Angriffen in ASP.NET Core: Dieser Artikel ist der primäre ASP.NET Core-Artikel zum Thema, der für serverseitige Blazor Server, das Serverprojekt von Blazor Web Apps und die Blazor-Integration mit MVC/Razor-Seiten gilt.
• Übersicht über ASP.NET Core Blazor-Formulare: Im Abschnitt Antiforgeryunterstützung dieses Artikels werden Blazor-Formulare für Antiforgeryunterstützung behandelt.

IHttpContextAccessor muss mit interaktivem Rendering vermieden werden, da kein gültiger HttpContext verfügbar ist.

IHttpContextAccessor kann für Komponenten verwendet werden, die auf dem Server statisch gerendert werden. Es wird jedoch empfohlen, dies nach Möglichkeit zu vermeiden.

HttpContext kann nur in statisch gerenderten Stammkomponenten für allgemeine Aufgaben als kaskadierender Parameter verwendet werden, z. B. beim Überprüfen und Ändern von Headern oder anderen Eigenschaften in der App-Komponente (Components/App.razor). Der Wert lautet immer null zum interaktiven Rendern.

[CascadingParameter]
public HttpContext? HttpContext { get; set; }

Für Szenarios, in denen HttpContext in interaktiven Komponenten erforderlich ist, empfehlen wir, die Daten über den permanenten Komponentenstatus vom Server zu übertragen. Weitere Informationen finden Sie unter ASP.NET core serverseitigen und Blazor Web App zusätzlichen Sicherheitsszenarien.

Verwenden Sie IHttpContextAccessor/HttpContext nicht direkt oder indirekt in den Razor-Komponenten serverseitiger Blazor-Apps. Blazor-Apps werden außerhalb des ASP.NET Core-Pipelinekontexts ausgeführt. Die Verfügbarkeit von HttpContext in IHttpContextAccessor kann nicht sichergestellt, und es ist auch nicht gewährleistet, dass HttpContext den Kontext zum Starten der Blazor-App enthält.

Der empfohlene Ansatz für das Übergeben des Anforderungsstatus an die Blazor-App erfolgt über Stammkomponentenparameter während des anfänglichen Renderings der App. Alternativ kann die App die Daten in einen bereichsbezogenen Dienst im Initialisierungslebenszyklusereignis der Stammkomponente kopieren, um sie in der gesamten App zu verwenden. Weitere Informationen finden Sie unter ASP.NET core serverseitigen und Blazor Web App zusätzlichen Sicherheitsszenarien.

Ein wichtiger Aspekt der serverseitigen Blazor-Sicherheit ist, dass Benutzer:innen, die an eine bestimmte Verbindung angefügt sind, möglicherweise irgendwann aktualisiert werden, nachdem die Blazor-Verbindung hergestellt wurde, IHttpContextAccessor aber nicht aktualisiert wird. Weitere Informationen zur Behebung dieser Situation mit benutzerdefinierten Diensten finden Sie unter ASP.NET core serverseitigen und Blazor Web App zusätzlichen Sicherheitsszenarien.

BlazorIdentity-Benutzeroberfläche (einzelne Konten)

Blazor unterstützt das Generieren einer vollständigen Blazor-basierten Identity-Benutzeroberfläche, wenn Sie die Authentifizierungsoption für einzelne Konten auswählen.

Die Blazor Web App-Vorlage erstellt ein Identity-Codegerüst für eine SQL Server-Datenbank. Die Befehlszeilenversion verwendet SQLite und enthält eine SQLite-Datenbank für Identity.

Die -Vorlage:

• Unterstützt Szenarien für interaktives serverseitiges Rendering (interactive SSR) und clientseitiges Rendering (CSR) mit authentifizierten Benutzenden.
• Fügt IdentityRazor-Komponenten und zugehörige Logik für routinemäßige Authentifizierungsaufgaben hinzu, wie z. B. das An- und Abmelden von Benutzenden. Die Identity-Komponenten unterstützen auch erweiterte Identity-Funktionen, wie z. B. Kontobestätigung und Kennwortwiederherstellung und Multi-Faktor-Authentifizierung mithilfe einer Drittanbieter-App. Beachten Sie, dass die Identity-Komponenten selbst keine Interaktivität unterstützen.
• Fügt die zu Identity zugehörigen Pakete und Abhängigkeiten hinzu
• Verweist auf die Identity-Pakete in _Imports.razor
• Erstellt eine benutzerdefinierte Identity-Klasse für Benutzer*innen (ApplicationUser).
• Erstellt und registriert einen EF Core-Datenbankkontext (ApplicationDbContext).
• Konfiguriert das Routing für die integrierten Identity-Endpunkte.
• Umfasst die Validierungs- und Geschäftslogik von Identity

Um die Blazor-Komponenten des Identity-Frameworks zu untersuchen, greifen Sie darauf in den Ordnern Pages und Shared des Ordners Account in der Blazor Web App-Projektvorlage (Verweisquelle) zu.

Wenn Sie die interaktiven WebAssembly- oder interaktiven Auto-Rendermodi auswählen, verarbeitet der Server alle Authentifizierungs- und Autorisierungsanforderungen und die Identity-Komponenten werden statisch auf dem Server im Hauptprojekt der Blazor Web App gerendert.

Das Framework stellt einen benutzerdefiniertenAuthenticationStateProvider sowohl im Server- als auch im Clientprojekt (.Client) bereit, um den Authentifizierungsstatus des der Benutzerin oder des Benutzers an den Browser zu übertragen. Das Serverprojekt ruft AddAuthenticationStateSerialization auf, während das Clientprojekt AddAuthenticationStateDeserialization aufruft. Die Authentifizierung auf dem Server statt auf dem Client ermöglicht der Anwendung den Zugriff auf den Authentifizierungsstatus während des Prerenderings und vor der Initialisierung der .NET WebAssembly-Laufzeit. Die benutzerdefinierten AuthenticationStateProvider-Implementierungen verwenden den Dienst Persistent Component State (PersistentComponentState), um den Authentifizierungsstatus in HTML-Kommentare zu serialisieren und ihn dann von WebAssembly zurückzulesen, um eine neue AuthenticationState-Instanz zu erstellen. Weitere Informationen finden Sie im Abschnitt Verwalten des Authentifizierungsstatus in Blazor Web Apps.

Nur für Interactive Server-Lösungen handelt es sich bei IdentityRevalidatingAuthenticationStateProvider (Referenzquelle) um einen serverseitigen AuthenticationStateProvider, der alle 30 Minuten den Sicherheitsstempel für das verbundene Benutzerkonto revalidiert, solange eine interaktive Verbindung besteht.

Wenn Sie die interaktiven WebAssembly- oder interaktiven Auto-Rendermodi auswählen, verarbeitet der Server alle Authentifizierungs- und Autorisierungsanforderungen und die Identity-Komponenten werden statisch auf dem Server im Hauptprojekt der Blazor Web App gerendert. Die Projektvorlage enthält eine PersistentAuthenticationStateProvider-Klasse (Verweisquelle) im .Client-Projekt, um den Authentifizierungsstatus von Benutzer*innen zwischen dem Server und dem Browser zu synchronisieren. Die Klasse ist eine benutzerdefinierte Implementierung von AuthenticationStateProvider. Der Anbieter verwendet den Dienst Persistent Component State (PersistentComponentState), um den Authentifizierungsstatus zu prerendern und auf der Seite beizubehalten.

Im Hauptprojekt einer Blazor Web App heißt der Authentifizierungsstatusanbieter entweder IdentityRevalidatingAuthenticationStateProvider (Verweisquelle) (nur Serverinteraktivitätslösungen) oder PersistingRevalidatingAuthenticationStateProvider (Verweisquelle) (WebAssembly- oder Auto-Interaktivitätslösungen).

BlazorIdentity hängt von DbContext Instanzen ab, die nicht von einer Factoryerstellt wurden, was beabsichtigt ist, da DbContext die Komponenten der Projektvorlage Identity ausreichen, um statisch zu rendern, ohne Interaktivität zu unterstützen.

Eine Beschreibung, wie globale interaktive Rendermodi auf Nicht-Identity-Komponenten angewandt werden und gleichzeitig statisches SSR für die Identity-Komponenten erzwungen wird, finden Sie unter ASP.NET Core-Rendermodi Blazor.

Weitere Informationen zum Speichern des vorab gerenderten Status finden Sie unter Vorabrendern von ASP.NET Core Razor-Komponenten.

Verwalten des Authentifizierungsstatus in Blazor Web Apps

Dieser Abschnitt gilt für Blazor Web Apps, die Folgendes nutzen:

• Individuelle Konten
• Clientseitiges Rendering (CSR, WebAssembly-basierte Interaktivität).

Ein clientseitiger Authentifizierungsstatusanbieter wird nur in Blazor verwendet und nicht in das ASP.NET Core-Authentifizierungssystem integriert. Beim Vorabrendering berücksichtigt Blazor die auf der Seite definierten Metadaten und verwendet das ASP.NET Core-Authentifizierungssystem, um zu ermitteln, ob der/die Benutzer*in authentifiziert ist. Wenn Benutzer*innen von einer Seite zu einer anderen navigieren, wird ein clientseitiger Authentifizierungsanbieter verwendet. Wenn Benutzer*innen die Seite aktualisieren (Neuladen der ganzen Seite), ist der clientseitige Authentifizierungsstatusanbieter nicht an der Authentifizierungsentscheidung auf dem Server beteiligt. Da der Status der Benutzer*innen vom Server nicht beibehalten wird, gehen alle clientseitig verwalteten Authentifizierungsstatus verloren.

Um dies zu beheben sollten Sie am besten die Authentifizierung im ASP.NET Core-Authentifizierungssystem durchzuführen. Der clientseitige Authentifizierungsstatusanbieter hat dann nur noch die Aufgabe, den Authentifizierungsstatus der Benutzer*innen anzuzeigen. Beispiele dafür, wie Sie dies mit verschiedenen Authentifizierungsstatusanbietern erreichen, finden Sie in der Projektvorlage für Blazor Web App und in der Beschreibung unten.

Rufen Sie in der Datei Program des Serverprojekts AddAuthenticationStateSerialization auf. Dadurch wird die AuthenticationState serialisiert, die vom Server AuthenticationStateProvider zurückgegeben wird. Dies geschieht mithilfe des Diensts Persistent Component State (PersistentComponentState):

builder.Services.AddRazorComponents()
    .AddInteractiveWebAssemblyComponents()
    .AddAuthenticationStateSerialization();

Die API serialisiert nur die serverseitigen Namens- und Rollenansprüche für den Zugriff im Browser. Um alle Ansprüche einzuschließen, legen Sie SerializeAllClaims auf true fest (im serverseitigen Aufruf AddAuthenticationStateSerialization):

builder.Services.AddRazorComponents()
    .AddInteractiveWebAssemblyComponents()
    .AddAuthenticationStateSerialization(
        options => options.SerializeAllClaims = true);

Rufen Sie im Client (.Client) in der Projektdatei ProgramAddAuthenticationStateDeserialization auf, das einen AuthenticationStateProvider hinzufügt, wo der AuthenticationState deserialisiert wird. Dies geschieht mit AuthenticationStateData und dem Dienst Persistent Component State (PersistentComponentState). Es sollte ein entsprechender Aufruf von AddAuthenticationStateSerialization im Serverprojekt vorhanden sein.

builder.Services.AddAuthorizationCore();
builder.Services.AddCascadingAuthenticationState();
builder.Services.AddAuthenticationStateDeserialization();

• PersistingRevalidatingAuthenticationStateProvider (Verweisquelle): Für Blazor Web Apps, die das interaktive serverseitige Rendering (interactive SSR) und das clientseitige Rendering (CSR) nutzen. Dies ist ein serverseitiger AuthenticationStateProvider, der alle 30 Minuten den Sicherheitsstempel für Benutzer*innen mit einer interaktiven Verbindung zurückgibt. Außerdem wird der Dienst für den persistenten Komponentenstatus verwendet, um den Authentifizierungsstatus an den Client zu senden, der dann für die Lebensdauer des CSR festgelegt wird.

• PersistingServerAuthenticationStateProvider (Verweisquelle): Für Blazor Web Apps, die nur CSR nutzen. Dies ist ein serverseitiger AuthenticationStateProvider, der den Dienst für den persistenten Komponentenstatus verwendet, um den Authentifizierungsstatus an den Client zu senden, der dann für die Lebensdauer des CSR festgelegt wird.

• PersistentAuthenticationStateProvider (Verweisquelle): Für Blazor Web Apps, die CSR nutzen. Dies ist ein clientseitiger AuthenticationStateProvider, der den Authentifizierungsstatus der Benutzer*innen bestimmt, indem nach Daten gesucht wird, die auf der Seite gespeicherten wurden, als diese auf dem Server gerendert wurde. Dieser Authentifizierungsstatus ist für die Lebensdauer des CSR unveränderlich. Wenn sich Benutzer*innen an- oder abmelden muss, muss die Seite vollständig neu geladen werden. Dies stellt nur einen Benutzernamen und eine E-Mail für die Anzeige bereit. Es sind keine Token enthalten, die sich beim Senden von nachfolgenden Anforderungen beim Server authentifizieren und separat mithilfe eines cookie aus den HttpClient-Anforderungen an den Server verarbeitet werden.

Gerüst Identity

Weitere Informationen zum Gerüstbau für Identity in einer serverseitigen Blazor-App finden Sie unter Gerüstbau für Identity in ASP.NET Core-Projekten.

Gerüstbau für Identity in einer serverseitigen Blazor-App:

• Ohne vorhandene Autorisierung
• Mit Autorisierung

Gehen Sie in der Program-Datei folgendermaßen vor:

builder.Services.AddScoped<ExampleService>();

In Startup.ConfigureServices von Startup.cs:

services.AddScoped<ExampleService>();

@page "/inject-auth-state-provider"
@inherits OwningComponentBase
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>Inject <code>AuthenticationStateProvider</code> Example</h1>

<p>@message</p>

@code {
    private string? message;
    private ExampleService? ExampleService { get; set; }

    protected override async Task OnInitializedAsync()
    {
        ExampleService = ScopedServices.GetRequiredService<ExampleService>();

        message = await ExampleService.ExampleMethod(AuthenticationStateProvider);
    }
}

@page "/inject-auth-state-provider"
@inject AuthenticationStateProvider AuthenticationStateProvider
@inherits OwningComponentBase

<h1>Inject <code>AuthenticationStateProvider</code> Example</h1>

<p>@message</p>

@code {
    private string? message;
    private ExampleService? ExampleService { get; set; }

    protected override async Task OnInitializedAsync()
    {
        ExampleService = ScopedServices.GetRequiredService<ExampleService>();

        message = await ExampleService.ExampleMethod(AuthenticationStateProvider);
    }
}

• Vorabrendering deaktivieren: Geben Sie den Rendermodus der Komponente auf der höchsten Ebene in der App-Hierarchie an, die keine Stammkomponente ist. Legen Sie den Parameter prerender dabei auf false fest.

  Hinweis

  Die Interaktivität einer Stammkomponente, wie z. B. der App-Komponente, wird nicht unterstützt. Daher kann die Voreinstellung nicht direkt von der App-Komponente deaktiviert werden.

  Bei Apps, die auf der Blazor Web App-Projektvorlage basieren, ist das Voarabrendering in der Regel deaktiviert, wenn die Routes-Komponente in der App-Komponente (Components/App.razor) verwendet wird:

  <Routes @rendermode="new InteractiveServerRenderMode(prerender: false)" />
  

  Deaktivieren Sie außerdem das Vorabrendering für die HeadOutlet-Komponente:

  <HeadOutlet @rendermode="new InteractiveServerRenderMode(prerender: false)" />
  

  Sie können den auf die Routes-Komponenteninstanz angewendeten Rendermodus auch selektiv steuern. Siehe z. B. ASP.NET Core Blazor Rendermodi.

• Deaktivieren des Vorabrenderings: Öffnen Sie die _Host.cshtml-Datei, und ändern Sie das render-mode-Attribut des Komponententag-Hilfsprogramms in Server:

  <component type="typeof(App)" render-mode="Server" />
  

Gültigkeitsdauer der temporären Umleitungs-URL

Dieser Abschnitt gilt für Blazor Web Apps.

Verwenden Sie die Option RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration, um die Gültigkeitsdauer des ASP.NET Core Data Protection für temporäre Umleitungs-URLs festzulegen, die durch das Blazor-serverseitige Rendering ausgegeben werden. Diese werden nur vorübergehend verwendet, sodass die Lebensdauer nur lang genug sein muss, damit ein Client die URL empfängt und mit der Navigation zu dieser beginnt. Sie sollte jedoch auch lang genug sein, um eine serverübergreifende Zeitdehnung zu ermöglichen. Der Standardwert beträgt 5 Minuten.

Im folgenden Beispiel wird der Wert auf sieben Minuten verlängert:

builder.Services.AddRazorComponents(options => 
    options.TemporaryRedirectionUrlValidityDuration = 
        TimeSpan.FromMinutes(7));

AuthenticationStateProvider ist der zugrunde liegende Dienst, der von der AuthorizeView-Komponente und kaskadierenden Authentifizierungsdiensten verwendet wird, um den Authentifizierungsstatus für Benutzer*innen abzurufen.

AuthenticationStateProvider ist der zugrunde liegende Dienst, der von der AuthorizeView- und der CascadingAuthenticationState-Komponente verwendet wird, um den Authentifizierungsstatus für einen Benutzer abzurufen.

@page "/claims-principal-data"
@using System.Security.Claims
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>ClaimsPrincipal Data</h1>

<button @onclick="GetClaimsPrincipalData">Get ClaimsPrincipal Data</button>

<p>@authMessage</p>

@if (claims.Any())
{
    <ul>
        @foreach (var claim in claims)
        {
            <li>@claim.Type: @claim.Value</li>
        }
    </ul>
}

<p>@surname</p>

@code {
    private string? authMessage;
    private string? surname;
    private IEnumerable<Claim> claims = Enumerable.Empty<Claim>();

    private async Task GetClaimsPrincipalData()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            authMessage = $"{user.Identity.Name} is authenticated.";
            claims = user.Claims;
            surname = user.FindFirst(c => c.Type == ClaimTypes.Surname)?.Value;
        }
        else
        {
            authMessage = "The user is NOT authenticated.";
        }
    }
}

Im vorherigen Beispiel:

• ClaimsPrincipal.Claims gibt die Benutzeransprüche (claims) zurück, die auf der Benutzeroberfläche angezeigt werden sollen.
• Die Zeile, die den Nachnamen des Benutzers oder der Benutzerin (surname) abruft, ruft ClaimsPrincipal.FindAll mit einem Prädikat auf, um die Benutzeransprüche zu filtern.

@page "/claims-principal-data"
@using System.Security.Claims
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>ClaimsPrincipal Data</h1>

<button @onclick="GetClaimsPrincipalData">Get ClaimsPrincipal Data</button>

<p>@authMessage</p>

@if (claims.Any())
{
    <ul>
        @foreach (var claim in claims)
        {
            <li>@claim.Type: @claim.Value</li>
        }
    </ul>
}

<p>@surname</p>

@code {
    private string? authMessage;
    private string? surname;
    private IEnumerable<Claim> claims = Enumerable.Empty<Claim>();

    private async Task GetClaimsPrincipalData()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            authMessage = $"{user.Identity.Name} is authenticated.";
            claims = user.Claims;
            surname = user.FindFirst(c => c.Type == ClaimTypes.Surname)?.Value;
        }
        else
        {
            authMessage = "The user is NOT authenticated.";
        }
    }
}

@page "/cascade-auth-state"

<h1>Cascade Auth State</h1>

<p>@authMessage</p>

@code {
    private string authMessage = "The user is NOT authenticated.";

    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user?.Identity is not null && user.Identity.IsAuthenticated)
            {
                authMessage = $"{user.Identity.Name} is authenticated.";
            }
        }
    }
}

@page "/cascade-auth-state"

<h1>Cascade Auth State</h1>

<p>@authMessage</p>

@code {
    private string authMessage = "The user is NOT authenticated.";

    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user?.Identity is not null && user.Identity.IsAuthenticated)
            {
                authMessage = $"{user.Identity.Name} is authenticated.";
            }
        }
    }
}

Richten Sie den Task<AuthenticationState>-Kaskadierungsparameter mithilfe der AuthorizeRouteView und kaskadierender Authentifizierungsstatusdienste ein.

Wenn Sie eine Blazor-App aus einer der Blazor-Projektvorlagen mit aktivierter Authentifizierung erstellen, enthält die App die AuthorizeRouteView und den Aufruf an AddCascadingAuthenticationState, der im folgenden Beispiel gezeigt wird. Eine clientseitige Blazor-App umfasst auch die erforderlichen Dienstregistrierungen. Weitere Informationen finden Sie im Abschnitt Anpassen von nicht autorisierten Inhalten mit der Router-Komponente.

<Router ...>
    <Found ...>
        <AuthorizeRouteView RouteData="routeData" 
            DefaultLayout="typeof(Layout.MainLayout)" />
        ...
    </Found>
</Router>

Registrieren Sie in der Program-Datei kaskadierende Authentifizierungsstatusdienste:

builder.Services.AddCascadingAuthenticationState();

Richten Sie den Task<AuthenticationState>-Kaskadierungsparameter mithilfe der AuthorizeRouteView und CascadingAuthenticationState-Komponenten ein.

Wenn Sie eine Blazor-App aus einer der Blazor-Projektvorlagen mit aktivierter Authentifizierung erstellen, enthält die App die Komponenten AuthorizeRouteView und CascadingAuthenticationState, die im folgenden Beispiel gezeigt werden. Eine clientseitige Blazor-App umfasst auch die erforderlichen Dienstregistrierungen. Weitere Informationen finden Sie im Abschnitt Anpassen von nicht autorisierten Inhalten mit der Router-Komponente.

<CascadingAuthenticationState>
    <Router ...>
        <Found ...>
            <AuthorizeRouteView RouteData="routeData" 
                DefaultLayout="typeof(MainLayout)" />
            ...
        </Found>
    </Router>
</CascadingAuthenticationState>

Fügen Sie der Blazor-Datei in einer clientseitigen Program-App Autorisierungsdienste hinzu:

builder.Services.AddAuthorizationCore();

Fügen Sie der Blazor-Datei in einer clientseitigen Program-App Optionen und Autorisierungsdienste hinzu:

builder.Services.AddOptions();
builder.Services.AddAuthorizationCore();

Razor Komponenten von Blazor Web Apps zeigen niemals <NotAuthorized>-Inhalte an, wenn die Autorisierung während des statischen serverseitigen Renderings (statischer SSR) serverseitig fehlschlägt. Die serverseitige ASP.NET Core-Pipeline verarbeitet die Autorisierung auf dem Server. Verwenden Sie serverseitige Techniken, um nicht autorisierte Anforderungen zu verarbeiten. Weitere Informationen finden Sie unter ASP.NET Core Blazor-Rendermodi.

Ressourcenautorisierung

Wenn Sie Benutzer*innen für Ressourcen autorisieren möchten, übergeben Sie die Routendaten der Anforderung an den Resource-Parameter von AuthorizeRouteView.

Im Router.Found-Inhalt für eine angeforderte Route:

<AuthorizeRouteView Resource="routeData" RouteData="routeData" 
    DefaultLayout="typeof(MainLayout)" />

Weitere Informationen dazu, wie Autorisierungsstatusdaten übergeben und in der prozeduralen Logik verwendet werden, finden Sie im Abschnitt Verfügbar machen des Authentifizierungsstatus als kaskadierender Parameter.

Wenn AuthorizeRouteView die Routendaten für die Ressource empfängt, haben Autorisierungsrichtlinien Zugriff auf RouteData.PageType und RouteData.RouteValues, die es benutzerdefinierter Logik ermöglichen, Autorisierungsentscheidungen zu treffen.

Im folgenden Beispiel wird in EditUser eine AuthorizationOptions-Richtlinie für die Konfiguration des Autorisierungsdiensts der App (AddAuthorizationCore) mit der folgenden Logik erstellt:

• Ermitteln Sie, ob ein Routenwert mit dem Schlüssel id vorhanden ist. Wenn der Schlüssel vorhanden ist, wird der Routenwert in value gespeichert.
• Speichern Sie id in einer Variablen mit dem Namen value als Zeichenfolge, oder legen Sie einen leeren Zeichenfolgenwert fest (string.Empty).
• Bestätigen Sie, dass die Richtlinie erfüllt ist (geben Sie id zurück), wenn true keine leere Zeichenfolge ist und der Wert der Zeichenfolge mit EMP beginnt. Andernfalls bestätigen Sie, dass die Richtlinie fehlschlägt (geben Sie false zurück).

Gehen Sie in der Program-Datei folgendermaßen vor:

• Fügen Sie für Microsoft.AspNetCore.Components und System.Linq Namespaces hinzu:

  using Microsoft.AspNetCore.Components;
  using System.Linq;
  

• Fügen Sie die Richtlinie hinzu:

  options.AddPolicy("EditUser", policy =>
      policy.RequireAssertion(context =>
      {
          if (context.Resource is RouteData rd)
          {
              var routeValue = rd.RouteValues.TryGetValue("id", out var value);
              var id = Convert.ToString(value, 
                  System.Globalization.CultureInfo.InvariantCulture) ?? string.Empty;
  
              if (!string.IsNullOrEmpty(id))
              {
                  return id.StartsWith("EMP", StringComparison.InvariantCulture);
              }
          }
  
          return false;
      })
  );
  

Beim obigen Beispiel handelt es sich um eine stark vereinfachte Autorisierungsrichtlinie, die lediglich verwendet wird, um das Konzept anhand eines funktionierenden Beispiels zu veranschaulichen. Weitere Informationen zum Erstellen und Konfigurieren von Autorisierungsrichtlinien finden Sie unter Richtlinienbasierte Autorisierung in ASP.NET Core.

In der folgenden EditUser-Komponente verfügt die Ressource unter /users/{id}/edit über einen Routenparameter für den Bezeichner des Benutzers ({id}). Die Komponente verwendet die vorstehende EditUser-Autorisierungsrichtlinie, um zu ermitteln, ob der Routenwert für id mit EMP beginnt. Wenn id mit EMP beginnt, ist die Richtlinie erfolgreich, und der Zugriff auf die Komponente ist autorisiert. Wenn id mit einem anderen Wert als EMP beginnt, oder wenn id eine leere Zeichenfolge ist, schlägt die Richtlinie fehl, und die Komponente wird nicht geladen.

EditUser.razor:

@page "/users/{id}/edit"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "EditUser")]

<h1>Edit User</h1>

<p>The "EditUser" policy is satisfied! <code>Id</code> starts with 'EMP'.</p>

@code {
    [Parameter]
    public string? Id { get; set; }
}

@page "/users/{id}/edit"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "EditUser")]

<h1>Edit User</h1>

<p>The "EditUser" policy is satisfied! <code>Id</code> starts with 'EMP'.</p>

@code {
    [Parameter]
    public string? Id { get; set; }
}

<Router ...>
    <Found ...>
        <AuthorizeRouteView ...>
            <NotAuthorized>
                ...
            </NotAuthorized>
            <Authorizing>
                ...
            </Authorizing>
        </AuthorizeRouteView>
    </Found>
</Router>

Der Inhalt von Authorized und NotAuthorized kann beliebige Elemente beinhalten, wie beispielsweise andere interaktive Komponenten.

builder.Services.AddCascadingAuthenticationState();

<CascadingAuthenticationState>
    <Router ...>
        <Found ...>
            <AuthorizeRouteView ...>
                <NotAuthorized>
                    ...
                </NotAuthorized>
                <Authorizing>
                    ...
                </Authorizing>
            </AuthorizeRouteView>
        </Found>
    </Router>
</CascadingAuthenticationState>

Der Inhalt von NotFound, Authorized und NotAuthorized kann beliebige Elemente beinhalten, wie beispielsweise andere interaktive Komponenten.

@page "/procedural-logic"
@inject IAuthorizationService AuthorizationService

<h1>Procedural Logic Example</h1>

<button @onclick="@DoSomething">Do something important</button>

@code {
    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    private async Task DoSomething()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user is not null)
            {
                if (user.Identity is not null && user.Identity.IsAuthenticated)
                {
                    // ...
                }

                if (user.IsInRole("Admin"))
                {
                    // ...
                }

                if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
                    .Succeeded)
                {
                    // ...
                }
            }
        }
    }
}

@page "/procedural-logic"
@inject IAuthorizationService AuthorizationService

<h1>Procedural Logic Example</h1>

<button @onclick="@DoSomething">Do something important</button>

@code {
    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    private async Task DoSomething()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user is not null)
            {
                if (user.Identity is not null && user.Identity.IsAuthenticated)
                {
                    // ...
                }

                if (user.IsInRole("Admin"))
                {
                    // ...
                }

                if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
                    .Succeeded)
                {
                    // ...
                }
            }
        }
    }
}

• Serverseitige und Blazor Web App Ressourcen
  • Schnellstart: Hinzufügen von „Bei Microsoft anmelden“ zu einer ASP.NET Core-Web-App
  • identity
  • Konfigurieren von ASP.NET Core zur Verwendung mit Proxyservern und Lastenausgleich: Umfasst Hinweise zu:
    • der Verwendung der Middleware für weitergeleitete Header, um HTTPS-Schemainformationen für Proxyserver und interne Netzwerke zu schützen
    • zusätzlichen Szenarios und Anwendungsfällen, einschließlich der manuellen Schemakonfiguration, Änderungen von Anforderungspfaden für fehlerfreies Routing von Anforderungen und der Weiterleitung des Anforderungsschemas für Linux- und Nicht-IIS-Reverseproxys.
• Dokumentation zur Microsoft identity-Plattform
  • Übersicht
  • OAuth 2.0- und OpenID Connect-Protokolle auf der Microsoft identity-Plattform
  • Microsoft identity-Plattform und der OAuth 2.0-Autorisierungscodeflow
  • ID-Token der Microsoft identity-Plattform
  • Zugriffstoken der Microsoft identity-Plattform
• Sicherheitsaspekte für ASP.NET Core
• Konfigurieren der Windows-Authentifizierung in ASP.NET Core
• Erstellen einer benutzerdefinierten Version der Authentication.MSAL-JavaScript-Bibliothek
• Nützliche Ressourcen für Blazor: Authentifizierung – Beispiellinks für die Community
• Authentifizierung und Autorisierung in ASP.NET Core Blazor Hybrid

• Serverseitige Blazor Ressourcen
  • Schnellstart: Hinzufügen von „Bei Microsoft anmelden“ zu einer ASP.NET Core-Web-App
  • identity
  • Konfigurieren von ASP.NET Core zur Verwendung mit Proxyservern und Lastenausgleich: Umfasst Hinweise zu:
    • der Verwendung der Middleware für weitergeleitete Header, um HTTPS-Schemainformationen für Proxyserver und interne Netzwerke zu schützen
    • zusätzlichen Szenarios und Anwendungsfällen, einschließlich der manuellen Schemakonfiguration, Änderungen von Anforderungspfaden für fehlerfreies Routing von Anforderungen und der Weiterleitung des Anforderungsschemas für Linux- und Nicht-IIS-Reverseproxys.
• Dokumentation zur Microsoft identity-Plattform
  • Übersicht
  • OAuth 2.0- und OpenID Connect-Protokolle auf der Microsoft identity-Plattform
  • Microsoft identity-Plattform und der OAuth 2.0-Autorisierungscodeflow
  • ID-Token der Microsoft identity-Plattform
  • Zugriffstoken der Microsoft identity-Plattform
• Sicherheitsaspekte für ASP.NET Core
• Konfigurieren der Windows-Authentifizierung in ASP.NET Core
• Erstellen einer benutzerdefinierten Version der Authentication.MSAL-JavaScript-Bibliothek
• Nützliche Ressourcen für Blazor: Authentifizierung – Beispiellinks für die Community