Share via

Schützen von serverseitigen Blazor-Apps als ASP.NET Core-Anwendungen

  • Artikel

Hinweis

Dies ist nicht die neueste Version dieses Artikels. Informationen zum aktuellen Release finden Sie in der .NET 8-Version dieses Artikels.

Wichtig

Diese Informationen beziehen sich auf ein Vorabversionsprodukt, das vor der kommerziellen Freigabe möglicherweise noch wesentlichen Änderungen unterliegt. Microsoft gibt keine Garantie, weder ausdrücklich noch impliziert, hinsichtlich der hier bereitgestellten Informationen.

Informationen zum aktuellen Release finden Sie in der .NET 8-Version dieses Artikels.

In diesem Artikel wird erläutert, wie Sie serverseitige Blazor-Apps als ASP.NET Core-Anwendungen schützen.

Das Schützen von serverseitigen Blazor-Apps funktioniert genau wie bei ASP.NET Core-Apps. Weitere Informationen finden Sie in den Artikeln unter Sicherheitsaspekte für ASP.NET Core.

Der Authentifizierungskontext wird nur beim Starten der App eingerichtet, d. h. wenn die App zum ersten Mal eine Verbindung mit dem WebSocket herstellt. Der Authentifizierungskontext wird für die Lebensdauer der Verbindung beibehalten. Apps ändern den Authentifizierungsstatus des Benutzers regelmäßig, derzeit standardmäßig alle 30 Minuten.

Wenn die App Benutzer für benutzerdefinierte Dienste erfassen oder auf Updates des Benutzers reagieren muss, lesen Sie Zusätzliche Sicherheitsszenarios für ASP.NET Core Blazor (serverseitig).

Blazor unterscheidet sich von herkömmlichen servergerenderten Web-Apps, die neue HTTP-Anforderungen mit cookies bei jeder Seitennavigation ausgeben. Die Authentifizierung wird bei Navigationsereignissen überprüft. cookies sind jedoch nicht beteiligt. Cookies werden nur gesendet, wenn eine HTTP-Anforderung an einen Server vorgenommen wird, was nicht der Fall ist, wenn der Benutzer in einer Blazor-App navigiert. Während der Navigation wird der Authentifizierungsstatus des Benutzers innerhalb der Blazor-Verbindung überprüft, den Sie mithilfe der RevalidatingAuthenticationStateProvider-Abstraktion jederzeit auf dem Server aktualisieren können.

Wichtig

Das Implementieren eines benutzerdefinierten NavigationManager zum Erzielen der Authentifizierungsvalidierung während der Navigation wird nicht empfohlen. Wenn die App während der Navigation benutzerdefinierte Authentifizierungsstatuslogik ausführen muss, verwenden Sie einen benutzerdefinierten AuthenticationStateProvider.

Hinweis

Die Codebeispiele in diesem Artikel verwenden Nullwerte zulassende Verweistypen (Nullable Reference Types, NRTs) und die statische Analyse des NULL-Zustands des .NET-Compilers, die in ASP.NET Core in .NET 6 oder höher unterstützt werden. Entfernen Sie bei ASP.NET Core 5.0 oder früher die NULL-Typbezeichnung (?) aus den Beispielen in diesem Artikel.

Projektvorlage

Erstellen Sie eine neue serverseitige Blazor-App, indem Sie die Anleitung unter Tools für ASP.NET Core Blazor befolgen.

Nachdem Sie die Vorlage für serverseitige Apps ausgewählt und das Projekt konfiguriert haben, wählen Sie unter Authentifizierungstyp die Authentifizierung der App aus:

  • Keine (Standardwert): Keine Authentifizierung.
  • Einzelne Konten: Benutzerkonten werden mithilfe von ASP.NET Core Identity in der App gespeichert.
  • Keine (Standardwert): Keine Authentifizierung.
  • Einzelne Konten: Benutzerkonten werden mithilfe von ASP.NET Core Identity in der App gespeichert.
  • Microsoft Identity Platform: Weitere Informationen finden Sie unter ASP.NET Core Blazor-Authentifizierung und -Autorisierung.
  • Windows: Verwenden Sie die Windows-Authentifizierung.

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 standardmäßig und enthält eine SQLite-Datenbank für Identity.

Die Vorlage führt folgende Aktionen durch:

  • Fügt IdentityRazor-Komponenten und zugehörige Logik für routinebasierte Authentifizierungsaufgaben hinzu, z. B. das Anmelden und Abmelden von Benutzer*innen.
  • 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 Identity-Komponenten des Blazor-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. 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 die PersistentComponentState-Klasse, um den Authentifizierungsstatus vorab zu rendern und auf der Seite zu speichern.

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.

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).

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.

Weitere Informationen zur BlazorIdentity Benutzeroberfläche und Anleitungen zum Integrieren externer Anmeldungen über soziale Websites finden Sie unter Neuerungen bei Identität in .NET 8.

Hinweis

Dokumentationslinks zur .NET-Referenzquelle laden in der Regel den Standardbranch des Repositorys, der die aktuelle Entwicklung für das nächste Release von .NET darstellt. Um ein Tag für ein bestimmtes Release auszuwählen, wählen Sie diesen mit der Dropdownliste Switch branches or tags (Branches oder Tags wechseln) aus. Weitere Informationen finden Sie unter How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Auswählen eines Versionstags von ASP.NET Core-Quellcode (dotnet/AspNetCore.Docs #26205)).

Verwalten des Authentifizierungsstatus in Blazor-Web-Apps

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

  • Interaktives serverseitiges Rendering (interaktives SSR) und CSR
  • Clientseitiges Rendering (CSR)

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-Apps:

Hinweis

Dokumentationslinks zur .NET-Referenzquelle laden in der Regel den Standardbranch des Repositorys, der die aktuelle Entwicklung für das nächste Release von .NET darstellt. Um ein Tag für ein bestimmtes Release auszuwählen, wählen Sie diesen mit der Dropdownliste Switch branches or tags (Branches oder Tags wechseln) aus. Weitere Informationen finden Sie unter How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Auswählen eines Versionstags von ASP.NET Core-Quellcode (dotnet/AspNetCore.Docs #26205)).

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:

Zusätzliche Ansprüche und Token von externen Anbietern

Informationen zum Speichern zusätzlicher Ansprüche von externen Anbietern finden Sie unter Beibehalten zusätzlicher Ansprüche und Token von externen Anbietern in ASP.NET Core.

Azure App Service für Linux mit Identity Server

Geben Sie den Zertifikataussteller explizit an, wenn Sie eine Bereitstellung auf Azure App Service für Linux mit Identity Server durchführen. Weitere Informationen finden Sie unter Verwenden von Identity zum Sichern eines Web-API-Back-Ends für SPAs.

Implementieren einer benutzerdefinierten Instanz von AuthenticationStateProvider

Wenn die App einen benutzerdefinierten Anbieter erfordert, implementieren Sie AuthenticationStateProvider, und überschreiben Sie GetAuthenticationStateAsync.

Im folgenden Beispiel werden alle Benutzer mit dem Benutzernamen mrfibuli authentifiziert.

CustomAuthStateProvider.cs:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    public override Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var identity = new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.Name, "mrfibuli"),
        }, "Custom Authentication");

        var user = new ClaimsPrincipal(identity);

        return Task.FromResult(new AuthenticationState(user));
    }
}

Der CustomAuthStateProvider-Dienst wird in der Program-Datei registriert:

using Microsoft.AspNetCore.Components.Authorization;

...

builder.Services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Der CustomAuthStateProvider-Dienst wird in der Program-Datei nach dem Aufruf von AddServerSideBlazor registriert:

using Microsoft.AspNetCore.Components.Authorization;

...

builder.Services.AddServerSideBlazor();

...

builder.Services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Der CustomAuthStateProvider-Dienst wird in Startup.ConfigureServices von Startup.csnach dem Aufruf von AddServerSideBlazor registriert:

using Microsoft.AspNetCore.Components.Authorization;

...

services.AddServerSideBlazor();

...

services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Bestätigen Sie, oder fügen Sie ein AuthorizeRouteView zur Router-Komponente hinzu.

In der Routes-Komponente (Components/Routes.razor):

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

Fügen Sie der Dienstauflistung in der Program-Datei kaskadierende Authentifizierungszustanddienste hinzu:

builder.Services.AddCascadingAuthenticationState();

Hinweis

Wenn Sie eine Blazor-App aus einer der Blazor-Projektvorlagen mit aktivierter Authentifizierung erstellen, enthält die App AuthorizeRouteView und den AddCascadingAuthenticationState-Aufruf. Weitere Informationen finden Sie unter ASP.NET Core Blazor-Authentifizierung und Autorisierung mit zusätzlichen Informationen im Abschnitt Anpassen nicht autorisierter Inhalte mit der Routerkomponente.

Bestätigen Sie, oder fügen Sie der Router-Komponente AuthorizeRouteView und CascadingAuthenticationState hinzu:

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

Hinweis

Wenn Sie eine Blazor-App aus einer der Blazor-Projektvorlagen mit aktivierter Authentifizierung erstellen, enthält die App die im Beispiel oben gezeigten Komponenten AuthorizeRouteView und CascadingAuthenticationState. Weitere Informationen finden Sie unter ASP.NET Core Blazor-Authentifizierung und Autorisierung mit zusätzlichen Informationen im Abschnitt Anpassen nicht autorisierter Inhalte mit der Routerkomponente.

Ein AuthorizeView-Element zeigt den Namen des authentifizierten Benutzers in einer beliebigen Komponente:

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

Anleitungen zur Verwendung von AuthorizeView finden Sie unter ASP.NET Core Blazor-Authentifizierung und -Autorisierung.

Benachrichtigung über Änderungen des Authentifizierungsstatus

Ein benutzerdefinierter AuthenticationStateProvider kann NotifyAuthenticationStateChanged für die AuthenticationStateProvider-Basisklasse aufrufen, um Consumer über die Änderung des Authentifizierungsstatus zu benachrichtigen.

Das folgende Beispiel basiert auf der Implementierung eines benutzerdefinierten AuthenticationStateProvider, wie in der Anleitung im Abschnitt Implementieren eines benutzerdefinierten AuthenticationStateProvider beschrieben.

Die folgende CustomAuthStateProvider-Implementierung macht eine benutzerdefinierte Methode (AuthenticateUser) verfügbar, um einen Benutzer anzumelden und Consumer über die Änderung des Authentifizierungsstatus zu benachrichtigen.

CustomAuthStateProvider.cs:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    public override Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var identity = new ClaimsIdentity();
        var user = new ClaimsPrincipal(identity);

        return Task.FromResult(new AuthenticationState(user));
    }

    public void AuthenticateUser(string userIdentifier)
    {
        var identity = new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.Name, userIdentifier),
        }, "Custom Authentication");

        var user = new ClaimsPrincipal(identity);

        NotifyAuthenticationStateChanged(
            Task.FromResult(new AuthenticationState(user)));
    }
}

In einer Komponente:

  • Der Angreifer kann AuthenticationStateProvider einschleusen.
  • Fügen Sie ein Feld hinzu, das den Bezeichner des Benutzers enthält.
  • Fügen Sie eine Schaltfläche und eine Methode hinzu, um den AuthenticationStateProvider in CustomAuthStateProvider umzuwandeln und AuthenticateUser mit dem Bezeichner des Benutzers aufzurufen.
@inject AuthenticationStateProvider AuthenticationStateProvider

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        ((CustomAuthStateProvider)AuthenticationStateProvider)
            .AuthenticateUser(userIdentifier);
    }
}

@inject AuthenticationStateProvider AuthenticationStateProvider

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        ((CustomAuthStateProvider)AuthenticationStateProvider)
            .AuthenticateUser(userIdentifier);
    }
}

Der oben beschriebene Ansatz kann erweitert werden, um Benachrichtigungen über Authentifizierungsstatusänderungen über einen benutzerdefinierten Dienst auszulösen. Im folgenden AuthenticationService wird der Anspruchsprinzipal des aktuellen Benutzers in einem Sicherungsfeld (currentUser) mit einem Ereignis (UserChanged) verwaltet, das von AuthenticationStateProvider abonniert werden kann, wobei das Ereignis NotifyAuthenticationStateChanged aufruft. Mit der zusätzlichen Konfiguration weiter unten in diesem Abschnitt kann AuthenticationService in eine Komponente mit Logik eingefügt werden, die festlegt, dass der CurrentUser das UserChanged-Ereignis auslöst.

using System.Security.Claims;

public class AuthenticationService
{
    public event Action<ClaimsPrincipal>? UserChanged;
    private ClaimsPrincipal? currentUser;

    public ClaimsPrincipal CurrentUser
    {
        get { return currentUser ?? new(); }
        set
        {
            currentUser = value;

            if (UserChanged is not null)
            {
                UserChanged(currentUser);
            }
        }
    }
}

Registrieren Sie in der Program-Datei AuthenticationService im Dependency-Injection-Container zum Einfügen von Abhängigkeiten:

builder.Services.AddScoped<AuthenticationService>();

Registrieren Sie in Startup.ConfigureServices von Startup.cs den AuthenticationService im Abhängigkeitsinjektionscontainer:

services.AddScoped<AuthenticationService>();

Der folgende CustomAuthStateProvider abonniert das AuthenticationService.UserChanged-Ereignis. GetAuthenticationStateAsync gibt den Authentifizierungsstatus des Benutzers oder der Benutzerin zurück. Zunächst basiert der Authentifizierungsstatus auf dem Wert von AuthenticationService.CurrentUser. Wenn sich ein*e Benutzer*in ändert, wird ein neuer Authentifizierungsstatus mit dem*der neuen Benutzer*in (new AuthenticationState(newUser)) für Anrufe von GetAuthenticationStateAsync erstellt:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    private AuthenticationState authenticationState;

    public CustomAuthStateProvider(AuthenticationService service)
    {
        authenticationState = new AuthenticationState(service.CurrentUser);

        service.UserChanged += (newUser) =>
        {
            authenticationState = new AuthenticationState(newUser);

            NotifyAuthenticationStateChanged(
                Task.FromResult(new AuthenticationState(newUser)));
        };
    }

    public override Task<AuthenticationState> GetAuthenticationStateAsync() =>
        Task.FromResult(authenticationState);
}

Die SignIn-Methode der folgenden Komponente erstellt einen Anspruchsprinzipal für den Bezeichner des Benutzers, der auf AuthenticationService.CurrentUser festgelegt werden soll:

@inject AuthenticationService AuthenticationService

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        var currentUser = AuthenticationService.CurrentUser;

        var identity = new ClaimsIdentity(
            new[]
            {
                new Claim(ClaimTypes.Name, userIdentifier),
            },
            "Custom Authentication");

        var newUser = new ClaimsPrincipal(identity);

        AuthenticationService.CurrentUser = newUser;
    }
}

@inject AuthenticationService AuthenticationService

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        var currentUser = AuthenticationService.CurrentUser;

        var identity = new ClaimsIdentity(
            new[]
            {
                new Claim(ClaimTypes.Name, userIdentifier),
            },
            "Custom Authentication");

        var newUser = new ClaimsPrincipal(identity);

        AuthenticationService.CurrentUser = newUser;
    }
}

Injizieren Sie AuthenticationStateProvider für Dienste, die einer Komponente zugeordnet sind.

Versuchen Sie nicht, AuthenticationStateProvider innerhalb eines benutzerdefinierten Bereichs aufzulösen, da dies zur Erstellung einer neuen Instanz von AuthenticationStateProvider führt, die nicht ordnungsgemäß initialisiert wird.

Um auf AuthenticationStateProvider innerhalb eines Diensts zuzugreifen, der einer Komponente zugeordnet ist, injizieren Sie AuthenticationStateProvider mit der @inject-Direktive oder dem [Inject]-Attribut und übergeben den Wert als Parameter an den Dienst. Dieser Ansatz stellt sicher, dass die richtige, initialisierte Instanz von AuthenticationStateProvider für jede Benutzer-App-Instanz verwendet wird.

ExampleService.cs:

public class ExampleService
{
    public async Task<string> ExampleMethod(AuthenticationStateProvider authStateProvider)
    {
        var authState = await authStateProvider.GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            return $"{user.Identity.Name} is authenticated.";
        }
        else
        {
            return "The user is NOT authenticated.";
        }
    }
}

Registrieren Sie den Dienst als bereichsbezogen. In einer serverseitigen Blazor-App verfügen bereichsbezogene Dienste über eine Lebensdauer, die der Dauer der Clientverbindung entspricht.

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

builder.Services.AddScoped<ExampleService>();

In Startup.ConfigureServices von Startup.cs:

services.AddScoped<ExampleService>();

In der folgenden InjectAuthStateProvider-Komponente:

InjectAuthStateProvider.razor:

@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);
    }
}

Weitere Informationen finden Sie in den Anleitungen zu OwningComponentBase unter ASP.NET Core Blazor-Abhängigkeitsinjektion.

Anzeige nicht autorisierter Inhalte beim Vorabendern mit einem benutzerdefinierten AuthenticationStateProvider

Um zu verhindern, dass unzulässige Inhalte, z.B. Inhalte in einer AuthorizeViewKomponente, während des Prerenderings mit einer benutzerdefinierten AuthenticationStateProvider Anwendung angezeigt werden, wählen Sie einen der folgenden Ansätze:

  • 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 Anwendungen, die auf der Blazor-Webanwendungs-Projektvorlage basieren, wird die Vorabeinstellung in der Regel deaktiviert, wobei 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 das Prerendering auch selektiv deaktivieren, indem Sie den auf die Routes-Komponenteninstanz angewendeten Rendermodus genau steuern. Weitere Informationen finden Sie unter 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" />
  • Authentifizieren des Benutzers auf dem Server, bevor die App gestartet wird: Bei diesem Ansatz muss die App mit der Identity-basierten Anmeldeseite oder -ansicht auf die anfängliche Anforderung eines Benutzers reagieren und alle Anforderungen an Blazor-Endpunkte verhindern, bis sie authentifiziert werden. Weitere Informationen finden Sie unter Erstellen einer ASP.NET Core-App mit Benutzerdaten, die durch Autorisierung geschützt sind. Nach der Authentifizierung werden nicht autorisierte Inhalte in vorab gerenderten Razor-Komponenten nur angezeigt, wenn der Benutzer wirklich nicht berechtigt ist, den Inhalt anzuzeigen.

User State management

Trotz des Worts „State“ (Zustand) im Namen dient AuthenticationStateProvider nicht zum Speichern des allgemeinen Benutzerzustands. AuthenticationStateProvider gibt nur den Authentifizierungsstatus des Benutzers für die App an, ob er bei der App angemeldet ist und in welchem Namen er angemeldet ist.

Die Authentifizierung verwendet dieselbe ASP.NET Core IdentityAuthentifizierung wie Razor Pages- und MVC-Apps. Der für ASP.NET Core Identity gespeicherte Benutzerzustand wird an Blazor übermittelt, ohne der App zusätzlichen Code hinzuzufügen. Befolgen Sie die Anleitungen in den ASP.NET Core Identity-Artikeln und den Tutorials für die Identity-Features, die in den Blazor-Teilen der App wirksam werden sollen.

Anleitungen zur allgemeinen Zustandsverwaltung außerhalb von ASP.NET Core Identity finden Sie unter ASP.NET Core Blazor-Zustandsverwaltung.

Zusätzliche Sicherheitsabstraktionen

Zwei zusätzliche Abstraktionen sind an der Verwaltung des Authentifizierungsstatus beteiligt:

Hinweis

Dokumentationslinks zur .NET-Referenzquelle laden in der Regel den Standardbranch des Repositorys, der die aktuelle Entwicklung für das nächste Release von .NET darstellt. Um ein Tag für ein bestimmtes Release auszuwählen, wählen Sie diesen mit der Dropdownliste Switch branches or tags (Branches oder Tags wechseln) aus. Weitere Informationen finden Sie unter How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Auswählen eines Versionstags von ASP.NET Core-Quellcode (dotnet/AspNetCore.Docs #26205)).

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 Datenschutzes für temporäre Umleitungs-URLs abzurufen oder festzulegen, die von serverseitigem Blazor-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));

Zusätzliche Ressourcen