ASP.NET Core på serversidan och Blazor Web App ytterligare säkerhetsscenarier

I den här artikeln beskrivs hur du konfigurerar Blazor på serversidan för ytterligare säkerhetsscenarier, inklusive hur du skickar token till en Blazor app.

Not

Kodexemplen i den här artikeln använder nullbara referenstyper (NRT) och .NET-kompilatorn null-state static analysis, som stöds i ASP.NET Core i .NET 6 eller senare. När du riktar in dig på ASP.NET Core 5.0 eller tidigare tar du bort null-typbeteckningen (?) från string?, TodoItem[]?, WeatherForecast[]?och IEnumerable<GitHubBranch>? typerna i artikelns exempel.

Skicka tokens till en Blazor-app på server-sidan

För Blazor Web Appska vägledning om hur du skickar token till Razor komponenter hanteras i dokumentationen (dotnet/AspNetCore.Docs #31691) 2025 för en förhandsversion av .NET 10.

För mer information, se följande ämnen:

• Access AuthenticationStateProvider i mellanprogram för utgående begäran (dotnet/aspnetcore #52379): Det här är det aktuella problemet med att åtgärda överföring av tokens i Blazor Web Apps, för närvarande schemalagd för .NET 10 (sent 2025).
• Problem med att tillhandahålla åtkomsttoken till HttpClient i interaktivt serverläge (dotnet/aspnetcore #52390): Det här problemet stängdes som en dubblett av föregående problem, men det innehåller användbara diskussionsstrategier och potentiella lösningar.

För Blazor Serverkan du visa 7.0-versionen av den här artikeln.

Ange autentiseringsschemat

För en app som använder mer än ett mellanprogram för autentisering och därmed har fler än ett autentiseringsschema kan schemat som Blazor använder uttryckligen anges i slutpunktskonfigurationen för Program-filen. I följande exempel anges OIDC-schemat (OpenID Connect):

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Kretshanterare för att samla in användare för anpassade tjänster

Använd en CircuitHandler för att samla in en användare från AuthenticationStateProvider och ange användaren i en tjänst. Om du vill uppdatera användaren registrerar du ett återanrop till AuthenticationStateChanged och begär en Task för att hämta den nya användaren och uppdatera tjänsten. I följande exempel visas metoden.

I följande exempel:

• OnConnectionUpAsync anropas varje gång kretsen återansluter och anger användaren för anslutningens livslängd. Endast metoden OnConnectionUpAsync krävs om du inte implementerar uppdateringar via en hanterare för autentiseringsändringar (AuthenticationChanged i följande exempel).
• OnCircuitOpenedAsync anropas för att koppla den ändrade autentiseringshanteraren AuthenticationChangedför att uppdatera användaren.
• Blocket catch för aktiviteten UpdateAuthentication vidtar inga åtgärder för undantag eftersom det inte finns något sätt att rapportera dem vid den här tidpunkten i programkörningen. Om ett undantag genereras från aktiviteten rapporteras undantaget någon annanstans i appen.

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() => currentUser;

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

internal sealed class UserCircuitHandler(
        AuthenticationStateProvider authenticationStateProvider,
        UserService userService) 
        : CircuitHandler, IDisposable
{
    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;
    }
}

I filen Program:

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

...

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

Använd tjänsten i en komponent för att hämta användaren:

@inject UserService UserService

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

För att ange användaren i mellanlagring för MVC, "Razor Pages", och i andra ASP.NET Core-scenarier, anropa SetUser på UserService i en anpassad mellanlagring efter att autentiseringsmellanlagringen har körts, eller ange användaren med en IClaimsTransformation implementation. I följande exempel används middlewaremetoden.

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

Anropa mellanprogrammet direkt innan anropet till app.MapRazorComponents<App>() i filen Program:

app.UseMiddleware<UserServiceMiddleware>();

Åtkomst AuthenticationStateProvider i middleware för utgående förfrågningar

AuthenticationStateProvider från en DelegatingHandler för HttpClient som skapats med IHttpClientFactory kan nås i mellanprogram för utgående begäran med hjälp av en kretsaktivitetshanterare.

Not

Allmän vägledning om hur du definierar delegering av hanterare för HTTP-begäranden av HttpClient instanser som skapats med IHttpClientFactory i ASP.NET Core-appar finns i följande avsnitt i Gör HTTP-begäranden med IHttpClientFactory i ASP.NET Core:

• Mellanprogram för utgående förfrågan
• Använd DI i mellanprogram för utgående begäran

I följande exempel används AuthenticationStateProvider för att koppla ett anpassat användarnamnhuvud för autentiserade användare till utgående begäranden.

Implementera klassen CircuitServicesAccessor först i följande avsnitt i artikeln Blazor beroendeinjektion (DI):

Åtkomst till Blazor tjänster på serversidan från ett annat DI-omfång

Använd CircuitServicesAccessor för att komma åt AuthenticationStateProvider i implementeringen av DelegatingHandler.

AuthenticationStateHandler.cs:

public class AuthenticationStateHandler(
    CircuitServicesAccessor circuitServicesAccessor) 
    : DelegatingHandler
{
    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);
    }
}

I filen Program registrerar du AuthenticationStateHandler och lägger till hanteraren i IHttpClientFactory som skapar HttpClient instanser:

builder.Services.AddTransient<AuthenticationStateHandler>();

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