Autres scénarios de sécurité ASP.NET Core Blazor côté serveur

Cet article explique comment configurer Blazor côté serveur pour d’autres scénarios de sécurité, notamment comment passer des jetons à une application Blazor.

Remarque

Les exemples de code de cet article utilisent les types de référence null (NRT, nullable reference types) et l'analyse statique de l'état null du compilateur .NET, qui sont pris en charge dans ASP.NET Core 6 et ses versions ultérieures. Lorsque vous ciblez ASP.NET Core 5.0 ou version antérieure, supprimez la désignation de type Null (?) des types string?, TodoItem[]?, WeatherForecast[]? et IEnumerable<GitHubBranch>? dans les exemples de l’article.

Passer des jetons à une application Blazor côté serveur

La mise à jour de cette section pour Blazor Web Apps dépend du résultat de Mettre à jour la section sur le passage de jetons dans Blazor Web Apps (dotnet/AspNetCore.Docs #31691). Pour plus d’informations, consultez Problème de remise d’un jeton d’accès à HttpClient en mode Serveur interactif (dotnet/aspnetcore #52390).

Pour Blazor Server, consultez la version 7.0 de cette section de l’article.

Définir le schéma d’authentification

Pour une application qui utilise plusieurs intergiciels d’authentification et qui a donc plusieurs schémas d’authentification, le schéma utilisé par Blazor peut être explicitement défini dans la configuration du point de terminaison du fichier Program. L’exemple suivant définit le schéma OpenID Connect (OIDC) :

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Gestionnaire de circuit pour capturer des utilisateurs des services personnalisés

Utilisez un CircuitHandler pour capturer un utilisateur à partir du AuthenticationStateProvider et définissez l’utilisateur dans un service. Si vous souhaitez mettre à jour l’utilisateur, inscrivez un rappel vers AuthenticationStateChanged et mettez en file d’attente un Task pour obtenir le nouvel utilisateur et mettre à jour le service. L'exemple suivant illustre l’approche.

Dans l’exemple suivant :

• OnConnectionUpAsync est appelé chaque fois que le circuit se reconnecte, définissant l’utilisateur pour la durée de vie de la connexion. Seule la méthode OnConnectionUpAsync est obligatoire, sauf si vous implémentez des mises à jour via un gestionnaire des modifications de l’authentification (AuthenticationChanged dans l’exemple suivant).
• OnCircuitOpenedAsync est appelé pour joindre le gestionnaire de l’authentification modifiée, AuthenticationChanged, pour mettre à jour l’utilisateur.
• Le bloc catch de la tâche UpdateAuthentication n’effectue aucune action sur les exceptions, car il n’existe aucun moyen de les signaler à ce stade dans l’exécution du code. Si une exception est levée à partir de la tâche, l’exception est signalée ailleurs dans l’application.

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

Dans le fichier Program :

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

...

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

Utilisez le service dans un composant pour obtenir l’utilisateur :

@inject UserService UserService

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

Pour définir l’utilisateur dans l’intergiciel pour MVC, Pages Razor et dans d’autres scénarios d’ASP.NET Core, appelez SetUser sur le UserService dans l’intergiciel personnalisé une fois l’intergiciel d’authentification exécuté ou définissez l’utilisateur avec une implémentation IClaimsTransformation. L’exemple suivant adopte l’approche d’intergiciel.

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

Juste avant l’appel à app.MapRazorComponents<App>() dans le fichier Program, appelez l’intergiciel :

app.UseMiddleware<UserServiceMiddleware>();

Accès AuthenticationStateProvider dans l’intergiciel de requête sortante

Le AuthenticationStateProvider d’un DelegatingHandler pour HttpClient créé avec IHttpClientFactory est accessible dans un intergiciel de requête sortant à l’aide d’un gestionnaire d’activités de circuit.

Remarque

Pour obtenir des conseils généraux sur la définition de gestionnaires pour les requêtes HTTP par HttpClient instances créées à l’aide de IHttpClientFactory dans les applications ASP.NET Core, consultez les sections suivantes de Effectuer des requêtes HTTP à l’aide d’IHttpClientFactory dans ASP.NET Core :

• Intergiciel de requête sortante
• Utiliser DI dans l’intergiciel de requêtes sortantes

L’exemple suivant utilise AuthenticationStateProvider pour attacher un en-tête de nom d’utilisateur personnalisé pour les utilisateurs authentifiés aux requêtes sortantes.

Tout d’abord, implémentez la classe CircuitServicesAccessor dans la section suivante de l’article d’injection de dépendances (DI) Blazor :

Accéder aux services côté serveurBlazor à partir d’une autre étendue de DI

Utilisez le CircuitServicesAccessor pour accéder au AuthenticationStateProvider dans l’implémentation DelegatingHandler.

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

Dans le fichier Program, inscrivez AuthenticationStateHandler et ajoutez le gestionnaire à IHttpClientFactory qui crée des instances HttpClient :

builder.Services.AddTransient<AuthenticationStateHandler>();

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