Další scénáře zabezpečení na straně serveru ASP.NET Core Blazor

Tento článek vysvětluje, jak nakonfigurovat serverovou stranu Blazor pro další scénáře zabezpečení, včetně způsobu předávání tokenů do Blazor aplikace.

Poznámka:

Příklady kódu v tomto článku přijímají referenční typy s možnou hodnotou null (NRT) a statickou analýzu stavu null-stav kompilátoru .NET, které jsou podporovány v ASP.NET Core v .NET 6 nebo novější. Pokud cílíte na ASP.NET Core 5.0 nebo starší, odeberte z WeatherForecast[]?string?TodoItem[]?příkladů článku označení typu null (?) a IEnumerable<GitHubBranch>? typy.

Předání tokenů do aplikace na straně Blazor serveru

Aktualizace tohoto oddílu pro Blazor Web Apps čeká na aktualizaci oddílu o předávání tokenů ve Blazor službě Web Apps (dotnet/AspNetCore.Docs č. 31691). Další informace najdete v tématu Problém s poskytnutím přístupového tokenu httpClient v režimu interaktivního serveru (dotnet/aspnetcore #52390).

Projděte Blazor Serversi část tohoto článku verze 7.0.

Nastavení schématu ověřování

Pro aplikaci, která používá více než jeden middleware ověřování a má tedy více než jedno schéma ověřování, lze schéma, které Blazor používá, explicitně nastavit v konfiguraci koncového Program bodu souboru. Následující příklad nastaví schéma OpenID Připojení (OIDC):

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Obslužná rutina okruhu pro zachycení uživatelů pro vlastní služby

CircuitHandler Použijte k zachycení uživatele ze AuthenticationStateProvider služby a nastavení uživatele ve službě. Pokud chcete aktualizovat uživatele, zaregistrujte zpětná volání do AuthenticationStateChanged fronty a Task získejte nového uživatele a aktualizujte službu. Následující příklad ukazuje přístup.

V následujícím příkladu:

• OnConnectionUpAsync se volá při každém opětovném připojení okruhu a nastavení uživatele po dobu životnosti připojení. OnConnectionUpAsync Pouze metoda se vyžaduje, pokud neimplementujete aktualizace prostřednictvím obslužné rutiny pro změny ověřování (AuthenticationChangedv následujícím příkladu).
• OnCircuitOpenedAsync je volána pro připojení ověřovací změněné obslužné rutiny , AuthenticationChangedaktualizovat uživatele.
• Blok catchUpdateAuthentication úlohy nemá žádnou akci na výjimky, protože v tomto okamžiku není způsob, jak je v tomto okamžiku vyhlásit. Pokud je z úlohy vyvoláná výjimka, je výjimka hlášena jinde v aplikaci.

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

V souboru Program:

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

...

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

Pomocí služby v komponentě získejte uživatele:

@inject UserService UserService

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

Pokud chcete nastavit uživatele v middlewaru pro MVC, Razor Pages a v jiných scénářích ASP.NET Core, zavolejte SetUserUserService ve vlastním middlewaru po spuštění middlewaru ověřování nebo nastavte uživatele s implementací IClaimsTransformation . Následující příklad přijímá přístup middlewaru.

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

Bezprostředně před voláním app.MapRazorComponents<App>() do Program souboru zavolejte middleware:

app.UseMiddleware<UserServiceMiddleware>();

Přístup AuthenticationStateProvider k middlewaru odchozích požadavků

K AuthenticationStateProvider middlewaru DelegatingHandler odchozích požadavků se dá přistupovat z příkazu for HttpClient created with IHttpClientFactory a circuit activity handler.

Poznámka:

Obecné pokyny k definování delegování obslužných rutin pro požadavky HTTP podle HttpClient instancí vytvořených IHttpClientFactory v aplikacích ASP.NET Core najdete v následujících částech Vytváření požadavků HTTP pomocí IHttpClientFactory v ASP.NET Core:

• Middleware odchozích požadavků
• Použití DI v middlewaru odchozích požadavků

Následující příklad používá AuthenticationStateProvider k připojení vlastní hlavičky uživatelského jména pro ověřené uživatele k odchozím požadavkům.

Nejprve implementujte CircuitServicesAccessor třídu v následující části Blazor článku injektáž závislostí (DI):

Přístup ke službám na straně Blazor serveru z jiného oboru DI

CircuitServicesAccessor Použijte k přístupu k implementaci AuthenticationStateProviderDelegatingHandler.

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

Program V souboru zaregistrujte AuthenticationStateHandler a přidejte obslužnou rutinu do IHttpClientFactory instance, která vytváří HttpClient instance:

builder.Services.AddTransient<AuthenticationStateHandler>();

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