Scenari di sicurezza aggiuntivi sul lato server ASP.NET Core Blazor

Questo articolo illustra come configurare il lato Blazor server per scenari di sicurezza aggiuntivi, tra cui come passare token a un'app Blazor .

Nota

Gli esempi di codice in questo articolo adottano tipi di riferimento nullable (NRT) e l'analisi statica dello stato null del compilatore .NET, supportati in ASP.NET Core in .NET 6 o versione successiva. Quando la destinazione è ASP.NET Core 5.0 o versioni precedenti, rimuovere la designazione di tipo Null (?) dai string?tipi , WeatherForecast[]?TodoItem[]?, e IEnumerable<GitHubBranch>? negli esempi dell'articolo.

Passare token a un'app lato Blazor server

L'aggiornamento di questa sezione per Blazor App Web è in sospeso nella sezione Update per il passaggio di token in Blazor App Web (dotnet/AspNetCore.Docs #31691). Per altre informazioni, vedere Problema di fornitura di token di accesso a HttpClient in modalità Interactive Server (dotnet/aspnetcore #52390).

Per Blazor Server, visualizzare la versione 7.0 di questo articolo.

Impostare lo schema di autenticazione

Per un'app che usa più middleware di autenticazione e pertanto ha più schemi di autenticazione, lo schema usato Blazor può essere impostato in modo esplicito nella configurazione dell'endpoint del Program file. Nell'esempio seguente viene impostato lo schema OIDC (OpenID Connessione):

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Gestore del circuito per acquisire gli utenti per i servizi personalizzati

Usare un CircuitHandler oggetto per acquisire un utente da AuthenticationStateProvider e impostare l'utente in un servizio. Se si vuole aggiornare l'utente, registrare un callback in e accodare AuthenticationStateChanged un Task oggetto per ottenere il nuovo utente e aggiornare il servizio. Nell'esempio seguente viene illustrato l'approccio .

Nell'esempio seguente :

• OnConnectionUpAsync viene chiamato ogni volta che il circuito si riconnette, impostando l'utente per la durata della connessione. È necessario solo il OnConnectionUpAsync metodo, a meno che non si implementino gli aggiornamenti tramite un gestore per le modifiche di autenticazione (AuthenticationChanged nell'esempio seguente).
• OnCircuitOpenedAsync viene chiamato per collegare il gestore di autenticazione modificato, AuthenticationChanged, per aggiornare l'utente.
• Il catch blocco dell'attività UpdateAuthentication non esegue alcuna azione sulle eccezioni perché non è possibile segnalarle a questo punto nell'esecuzione del codice. Se viene generata un'eccezione dall'attività, l'eccezione viene segnalata altrove nell'app.

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

Nel file Program:

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

...

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

Usare il servizio in un componente per ottenere l'utente:

@inject UserService UserService

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

Per impostare l'utente nel middleware per MVC, Razor Pages e in altri scenari di ASP.NET Core, chiamare SetUserUserService in middleware personalizzato dopo l'esecuzione del middleware di autenticazione o impostare l'utente con un'implementazione IClaimsTransformation . Nell'esempio seguente viene adottato l'approccio middleware.

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

Immediatamente prima della chiamata a app.MapRazorComponents<App>() nel Program file, chiamare il middleware:

app.UseMiddleware<UserServiceMiddleware>();

Accesso AuthenticationStateProvider nel middleware delle richieste in uscita

È AuthenticationStateProvider possibile accedere a da un oggetto DelegatingHandler per HttpClient creato con IHttpClientFactory nel middleware delle richieste in uscita usando un gestore di attività del circuito.

Nota

Per indicazioni generali sulla definizione dei gestori di delega per le richieste HTTP per le istanze HttpClient create usando IHttpClientFactory nelle app ASP.NET Core, vedere le sezioni seguenti di Effettuare richieste HTTP usando IHttpClientFactory in ASP.NET Core:

• Middleware delle richieste in uscita
• Usare l'inserimento delle dipendenze nel middleware delle richieste in uscita

Nell'esempio seguente viene AuthenticationStateProvider usato per associare un'intestazione di nome utente personalizzata per gli utenti autenticati alle richieste in uscita.

Implementare prima di tutto la classe nella sezione seguente dell'articolo inserimento delle dipendenze :First, implement the CircuitServicesAccessor class in the following section of the Blazor dependency injection (DI) article:

Accedere ai servizi lato Blazor server da un ambito di inserimento delle dipendenze diverso

CircuitServicesAccessor Usare per accedere all'oggetto AuthenticationStateProvider nell'implementazioneDelegatingHandler.

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 Nel file registrare AuthenticationStateHandler e aggiungere il gestore all'oggetto IHttpClientFactory che crea HttpClient istanze:

builder.Services.AddTransient<AuthenticationStateHandler>();

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