Zusätzliche serverseitige Sicherheitsszenarios für ASP.NET Core Blazor

In diesem Artikel wird erläutert, wie Sie Blazor serverseitig für zusätzliche Sicherheitsszenarios konfigurieren, einschließlich der Tokenübergabe an eine Blazor-App.

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 Typen string?, TodoItem[]?, WeatherForecast[]? und IEnumerable<GitHubBranch>? in den Beispielen des Artikels.

Übergeben von Token an eine serverseitige Blazor-App

Die Aktualisierung dieses Abschnitts für Blazor-Web-Apps steht noch aus Aktualisierung des Abschnitts zur Übergabe von Token in Blazor-Web-Apps (dotnet/AspNetCore.Docs #31691). Weitere Informationen finden Sie unter Problem bei der Bereitstellung eines Zugriffstokens für HttpClient im interaktiven Servermodus (dotnet/aspnetcore #52390).

Zeigen Sie für Blazor Server die Version 7.0 dieses Artikels an.

Festlegen des Authentifizierungsschemas

Für eine App, die mehr als eine Authentifizierungsmiddleware verwendet und daher über mehr als ein Authentifizierungsschema verfügt, kann das von Blazor verwendete Schema explizit in der Endpunktkonfiguration der Program-Datei festgelegt werden. Im folgenden Beispiel wird das OpenID Connect-Schema (OIDC) festgelegt:

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

app.MapRazorComponents<App>().RequireAuthorization(
    new AuthorizeAttribute
    {
        AuthenticationSchemes = OpenIdConnectDefaults.AuthenticationScheme
    })
    .AddInteractiveServerRenderMode();

Verbindungshandler zum Erfassen von Benutzern für benutzerdefinierte Dienste

Verwenden Sie einen CircuitHandler, um einen Benutzer aus dem AuthenticationStateProvider zu erfassen und den Benutzer in einem Dienst festzulegen. Wenn Sie den Benutzer aktualisieren möchten, registrieren Sie einen Rückruf bei AuthenticationStateChanged, und stellen Sie einen Task in die Warteschlange, um den neuen Benutzer abzurufen und den Dienst zu aktualisieren. Im folgenden Beispiel wird dieser Ansatz veranschaulicht.

Im folgenden Beispiel:

• OnConnectionUpAsync wird jedes Mal aufgerufen, wenn die Verbindung wiederhergestellt wird, wobei der Benutzer für die Lebensdauer der Verbindung festgelegt wird. Nur die OnConnectionUpAsync-Methode ist erforderlich, es sei denn, Sie implementieren Updates über einen Handler für Authentifizierungsänderungen (AuthenticationChanged im folgenden Beispiel).
• OnCircuitOpenedAsync wird aufgerufen, um den Handler für geänderte Authentifizierung (AuthenticationChanged) anzufügen, um den Benutzer zu aktualisieren.
• Der catch-Block des UpdateAuthentication-Tasks führt keine Aktion für Ausnahmen aus, da es keine Möglichkeit gibt, sie zu diesem Zeitpunkt bei der Codeausführung zu melden. Wenn eine Ausnahme vom Task ausgelöst wird, wird die Ausnahme an anderer Stelle in der App gemeldet.

UserService.cs:

using System.Security.Claims;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Components.Server.Circuits;

public class UserService
{
    private ClaimsPrincipal currentUser = new(new ClaimsIdentity());

    public ClaimsPrincipal GetUser()
    {
        return currentUser;
    }

    internal void SetUser(ClaimsPrincipal user)
    {
        if (currentUser != user)
        {
            currentUser = user;
        }
    }
}

internal sealed class UserCircuitHandler : CircuitHandler, IDisposable
{
    private readonly AuthenticationStateProvider authenticationStateProvider;
    private readonly UserService userService;

    public UserCircuitHandler(
        AuthenticationStateProvider authenticationStateProvider,
        UserService userService)
    {
        this.authenticationStateProvider = authenticationStateProvider;
        this.userService = userService;
    }

    public override Task OnCircuitOpenedAsync(Circuit circuit, 
        CancellationToken cancellationToken)
    {
        authenticationStateProvider.AuthenticationStateChanged += 
            AuthenticationChanged;

        return base.OnCircuitOpenedAsync(circuit, cancellationToken);
    }

    private void AuthenticationChanged(Task<AuthenticationState> task)
    {
        _ = UpdateAuthentication(task);

        async Task UpdateAuthentication(Task<AuthenticationState> task)
        {
            try
            {
                var state = await task;
                userService.SetUser(state.User);
            }
            catch
            {
            }
        }
    }

    public override async Task OnConnectionUpAsync(Circuit circuit, 
        CancellationToken cancellationToken)
    {
        var state = await authenticationStateProvider.GetAuthenticationStateAsync();
        userService.SetUser(state.User);
    }

    public void Dispose()
    {
        authenticationStateProvider.AuthenticationStateChanged -= 
            AuthenticationChanged;
    }
}

In der Program-Datei:

using Microsoft.AspNetCore.Components.Server.Circuits;
using Microsoft.Extensions.DependencyInjection.Extensions;

...

builder.Services.AddScoped<UserService>();
builder.Services.TryAddEnumerable(
    ServiceDescriptor.Scoped<CircuitHandler, UserCircuitHandler>());

Verwenden Sie den Dienst in einer Komponente, um den Benutzer abzurufen:

@inject UserService UserService

<h1>Hello, @(UserService.GetUser().Identity?.Name ?? "world")!</h1>

Um Benutzer*innen in Middleware für MVC, Razor Pages und in anderen ASP.NET Core-Szenarien festzulegen, rufen Sie SetUser für UserService in benutzerdefinierter Middleware auf, wenn die Authentifizierungsmiddleware ausgeführt wird, oder legen Sie Benutzer*innen mit einer IClaimsTransformation-Implementierung fest. Im folgenden Beispiel wird der Middlewareansatz übernommen.

UserServiceMiddleware.cs:

public class UserServiceMiddleware
{
    private readonly RequestDelegate next;

    public UserServiceMiddleware(RequestDelegate next)
    {
        this.next = next ?? throw new ArgumentNullException(nameof(next));
    }

    public async Task InvokeAsync(HttpContext context, UserService service)
    {
        service.SetUser(context.User);
        await next(context);
    }
}

Rufen Sie unmittelbar vor dem Aufruf von app.MapRazorComponents<App>() in der Program-Datei die Middleware auf:

app.UseMiddleware<UserServiceMiddleware>();

Zugreifen auf AuthenticationStateProvider in Middleware für ausgehende Anforderungen

Auf den Authentifizierungszustandsanbieter (AuthenticationStateProvider) eines delegierenden Handlers (DelegatingHandler) für einen HTTP-Client (HttpClient), der mit IHttpClientFactory erstellt wurde, kann in Middleware für ausgehende Anforderungen mithilfe eines Leitungsaktivitätshandlers zugegriffen werden.

Hinweis

Allgemeine Anleitungen zum Definieren von delegierenden Handlern für HTTP-Anforderungen von HttpClient-Instanzen, die mit IHttpClientFactory in ASP.NET Core-Apps erstellt wurden, finden Sie in den folgenden Abschnitten des Artikels zum Stellen von HTTP-Anforderungen mithilfe von IHttpClientFactory in ASP.NET Core:

• Middleware für ausgehende Anforderungen
• Verwenden von DI in Middleware für ausgehende Anforderungen

Im folgenden Beispiel wird AuthenticationStateProvider verwendet, um einen benutzerdefinierten Benutzernamenheader für authentifizierte Benutzer*innen an ausgehende Anforderungen anzufügen.

Implementieren Sie zunächst die CircuitServicesAccessor-Klasse im folgenden Abschnitt des Artikels zur Blazor-Abhängigkeitsinjektion (Dependency Injection, DI):

Zugreifen auf serverseitige Blazor-Dienste aus einem anderen DI-Bereich

Verwenden Sie CircuitServicesAccessor, um auf AuthenticationStateProvider in der DelegatingHandler-Implementierung zuzugreifen.

AuthenticationStateHandler.cs:

public class AuthenticationStateHandler : DelegatingHandler
{
    readonly CircuitServicesAccessor circuitServicesAccessor;

    public AuthenticationStateHandler(
        CircuitServicesAccessor circuitServicesAccessor)
    {
        this.circuitServicesAccessor = circuitServicesAccessor;
    }

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var authStateProvider = circuitServicesAccessor.Services
            .GetRequiredService<AuthenticationStateProvider>();
        var authState = await authStateProvider.GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            request.Headers.Add("X-USER-IDENTITY-NAME", user.Identity.Name);
        }

        return await base.SendAsync(request, cancellationToken);
    }
}

Registrieren Sie AuthenticationStateHandler in der Program-Datei, und fügen Sie den Handler zum IHttpClientFactory-Element hinzu, mit dem HttpClient-Instanzen erstellt werden:

builder.Services.AddTransient<AuthenticationStateHandler>();

builder.Services.AddHttpClient("HttpMessageHandler")
    .AddHttpMessageHandler<AuthenticationStateHandler>();