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.

Notera

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å .NET 5 eller tidigare tar du bort null-typbeteckningen (?) från typerna string?, TodoItem[]?, WeatherForecast[]?och IEnumerable<GitHubBranch>? i artikelns exempel.

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

Det här avsnittet gäller för Blazor Web Apps. För att se Blazor Server, visa .NET 7-versionen av den här avsnittet av artikeln.

Om du bara vill använda åtkomsttoken för att göra webb-API-anrop från en Blazor Web App med en namngiven HTTP-klient läser du avsnittet Använda en tokenhanterare för webb-API-anrop , som förklarar hur du använder en DelegatingHandler implementering för att koppla en användares åtkomsttoken till utgående begäranden. Följande vägledning i det här avsnittet gäller för utvecklare som behöver åtkomsttoken, uppdateringstoken och andra autentiseringsegenskaper på serversidan för andra ändamål.

Om du vill spara token och andra autentiseringsegenskaper för användning på serversidan i Blazor Web Apps rekommenderar vi att du använder IHttpContextAccessor/HttpContext (IHttpContextAccessor, HttpContext). Läsning av token från HttpContext, inklusive som en kaskaderande parameter, stöds för att hämta token med IHttpContextAccessor för användning under interaktiv serverrendering om token hämtas under statisk återgivning på serversidan (statisk SSR) eller förrendering. Token uppdateras dock inte om användaren autentiserar efter att kretsen har upprättats, eftersom HttpContext fångas vid starten av SignalR-anslutningen. Dessutom innebär användningen av AsyncLocal<T> av IHttpContextAccessor att du måste vara noga med att inte förlora körningskontexten innan du läser HttpContext. Mer information finns i IHttpContextAccessor/HttpContext i ASP.NET Core Blazor-appar.

I en tjänstklass får du åtkomst till medlemmarna i namnområdet Microsoft.AspNetCore.Authentication för att visa metoden på GetTokenAsyncHttpContext. En alternativ metod, som kommenteras ut i följande exempel, är att anropa AuthenticateAsync på HttpContext. För den returnerade AuthenticateResult.Propertiesanropar du GetTokenValue.

using Microsoft.AspNetCore.Authentication;

public class AuthenticationProcessor(IHttpContextAccessor httpContextAccessor)
{
    public async Task<string?> GetAccessToken()
    {
        if (httpContextAccessor.HttpContext is null)
        {
            throw new Exception("HttpContext not available");
        }

        // Approach 1: Call 'GetTokenAsync'
        var accessToken = await httpContextAccessor.HttpContext
            .GetTokenAsync("access_token");

        // Approach 2: Authenticate the user and call 'GetTokenValue'
        /*
        var authResult = await httpContextAccessor.HttpContext.AuthenticateAsync();
        var accessToken = authResult?.Properties?.GetTokenValue("access_token");
        */

        return accessToken;
    }
}

Tjänsten är registrerad i serverprojektets Program fil:

builder.Services.AddScoped<AuthenticationProcessor>();

AuthenticationProcessor kan injiceras i tjänster på serversidan, till exempel i en DelegatingHandler för en förkonfigurerad HttpClient. Följande exempel är endast i demonstrationssyfte eller om du behöver utföra särskild bearbetning i tjänsten eftersom du bara kan mata in AuthenticationProcessor och hämta token direkt för att anropa externa webb-API:er (mer information om hur du använder IHttpContextAccessor direkt för att anropa webb-API:er finns i IHttpContextAccessor avsnittet Använda en tokenhanterare för webb-API-anrop).

using System.Net.Http.Headers;

public class TokenHandler(AuthenticationProcessor authProcessor) : 
    DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var accessToken = authProcessor.GetAccessToken();

        request.Headers.Authorization =
            new AuthenticationHeaderValue("Bearer", accessToken);

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

Tokenhanteraren är registrerad och fungerar som delegeringshanterare för en namngiven Program HTTP-klient i filen:

builder.Services.AddHttpContextAccessor();

builder.Services.AddScoped<TokenHandler>();

builder.Services.AddHttpClient("ExternalApi",
      client => client.BaseAddress = new Uri(builder.Configuration["ExternalApiUri"] ?? 
          throw new Exception("Missing base address!")))
      .AddHttpMessageHandler<TokenHandler>();

Försiktighet

Se till att token aldrig överförs och hanteras av klienten (projektet .Client), till exempel i en komponent som implementerar interaktiv automatisk rendering och renderas på klienten eller av en tjänst på klientsidan. Be alltid klienten anropa servern (projektet) för att bearbeta begäranden med token. Token och andra autentiseringsdata bör aldrig lämna servern.

Interaktiva automatiska komponenter finns i ASP.NET Core-autentisering Blazor och -auktorisering, som visar hur du lämnar åtkomsttoken och andra autentiseringsegenskaper på servern. Överväg också att använda Backend-for-Frontend-mönstret (BFF), som antar en liknande anropsstruktur och beskrivs i Säkra en ASP.NET Core Blazor Web App med OpenID Connect (OIDC) för OIDC-leverantörer och Säkra en ASP.NET Core Blazor Web App med Microsoft Entra ID för Microsoft Identity Web med Entra.

Använda en tokenhanterare för webb-API-anrop

Följande metod syftar till att koppla en användares åtkomsttoken till utgående begäranden, särskilt för att göra webb-API-anrop till externa webb-API-appar. Metoden visas för en Blazor Web App som använder global interaktiv serverrendering, men samma allmänna metod gäller för Blazor Web Apps som använder det globala läget för interaktiv automatisk återgivning. Det viktiga begreppet är att åtkomst till HttpContext genom att använda IHttpContextAccessor endast utförs på servern.

En demonstration av vägledningen i det här avsnittet finns i exempelapparna BlazorWebAppOidc och BlazorWebAppOidcServer (.NET 8 eller senare) i Blazor GitHub-exempellagringsplatsen. Exemplen använder ett globalt interaktivt återgivningsläge och OIDC-autentisering med Microsoft Entra utan att använda Entra-specifika paket. Exemplen visar hur du skickar en JWT-åtkomsttoken för att anropa ett säkert webb-API.

Microsofts identitetsplattform med Microsoft Identity webbpaket för Microsoft Entra ID tillhandahåller ett API för att anropa webb-API:er från Blazor Web App med automatisk tokenhantering och förnyelse. Mer information finns i Skydda en ASP.NET Core Blazor Web App med Microsoft Entra-ID och exempelapparna BlazorWebAppEntraBlazorWebAppEntraBff (.NET 9 eller senare) på Blazor GitHub-exempellagringsplatsen.

Underklass DelegatingHandler för att koppla en användares åtkomsttoken till utgående begäranden. Tokenhanteraren körs bara på servern, så att använda HttpContext är säkert.

TokenHandler.cs:

using System.Net.Http.Headers;
using Microsoft.AspNetCore.Authentication;

public class TokenHandler(IHttpContextAccessor httpContextAccessor) : 
    DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        if (httpContextAccessor.HttpContext is null)
        {
            throw new Exception("HttpContext not available");
        }

        var accessToken = await httpContextAccessor.HttpContext.GetTokenAsync("access_token");

        if (accessToken is null)
        {
            throw new Exception("No access token");
        }

        request.Headers.Authorization =
            new AuthenticationHeaderValue("Bearer", accessToken);

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

Notera

Information om hur du får åtkomst till en AuthenticationStateProvider från en DelegatingHandlerfinns i avsnittet Åtkomst AuthenticationStateProvider i mellanprogram för utgående begäran .

I projektets Program fil registreras tokenhanteraren (TokenHandler) som en begränsad tjänst och anges som en namngiven HTTP-klients meddelandehanterare med AddHttpMessageHandler.

I följande exempel {HTTP CLIENT NAME} är platshållaren namnet på HttpClient, och {BASE ADDRESS} platshållaren är webb-API:ets basadress-URI. Mer information om AddHttpContextAccessorfinns i IHttpContextAccessor/HttpContext i ASP.NET Core-apparBlazor.

I Program.cs:

builder.Services.AddHttpContextAccessor();

builder.Services.AddScoped<TokenHandler>();

builder.Services.AddHttpClient("{HTTP CLIENT NAME}",
      client => client.BaseAddress = new Uri("{BASE ADDRESS}"))
      .AddHttpMessageHandler<TokenHandler>();

Exempel:

builder.Services.AddScoped<TokenHandler>();

builder.Services.AddHttpClient("ExternalApi",
      client => client.BaseAddress = new Uri("https://localhost:7277"))
      .AddHttpMessageHandler<TokenHandler>();

Du kan ange HTTP-klientens basadress från konfigurationen med builder.Configuration["{CONFIGURATION KEY}"], där {CONFIGURATION KEY}-platshållaren är konfigurationsnyckeln.

new Uri(builder.Configuration["ExternalApiUri"] ?? throw new IOException("No URI!"))

Ange appsettings.json där du specificerar ExternalApiUri. I följande exempel anges värdet till localhost-adressen för det externa webb-API:et till https://localhost:7277:

"ExternalApiUri": "https://localhost:7277"

Nu kan en HttpClient som skapats av en komponent göra säkra webb-API-begäranden. I följande exempel {REQUEST URI} är den relativa begärande-URI:n och {HTTP CLIENT NAME} platshållaren är namnet på HttpClient:

using var request = new HttpRequestMessage(HttpMethod.Get, "{REQUEST URI}");
var client = ClientFactory.CreateClient("{HTTP CLIENT NAME}");
using var response = await client.SendAsync(request);

Exempel:

using var request = new HttpRequestMessage(HttpMethod.Get, "/weather-forecast");
var client = ClientFactory.CreateClient("ExternalApi");
using var response = await client.SendAsync(request);

Ytterligare funktioner planeras för Blazor, som spåras av Access AuthenticationStateProvider i middleware för utgående begäran (dotnet/aspnetcore #52379). Problem med att tillhandahålla åtkomsttoken till HttpClient i interaktivt serverläge (dotnet/aspnetcore #52390) är ett stängt problem som innehåller användbara diskussioner och potentiella lösningsstrategier för avancerade användningsfall.

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.

Notera

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:

using Microsoft.AspNetCore.Components.Authorization;

public class AuthenticationStateHandler(
    CircuitServicesAccessor circuitServicesAccessor) 
    : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var authStateProvider = circuitServicesAccessor.Services?
            .GetRequiredService<AuthenticationStateProvider>();

        if (authStateProvider is null)
        {
            throw new Exception("AuthenticationStateProvider not available");
        }

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