Otros escenarios de seguridad de Blazor en ASP.NET Core del lado servidor

En este artículo se explica cómo configurar Blazor del lado servidor para escenarios de seguridad adicionales, incluido cómo pasar tokens a una aplicación Blazor.

Nota:

En los ejemplos de código de este artículo se adoptan tipos de referencia que admiten un valor NULL (NRT) y análisis estático de estado NULL del compilador de .NET, que se admiten en ASP.NET Core en .NET 6 o posterior. Al tener como destino ASP.NET Core 5.0 o versiones anteriores, quite la designación de tipo null (?) de los tipos string?, TodoItem[]?, WeatherForecast[]? y IEnumerable<GitHubBranch>? de los ejemplos del artículo.

Paso de tokens a una aplicación Blazor del lado servidor

La actualización de esta sección para Web Apps de Blazor está pendiente de Actualización de la sección sobre cómo pasar tokens en Web Apps de Blazor (dotnet/AspNetCore.Docs #31691). Para obtener más información, vea Problema al proporcionar un token de acceso a HttpClient en modo de servidor interactivo (dotnet/aspnetcore #52390).

Para Blazor Server, vea la versión 7.0 de este artículo.

Establecimiento del esquema de autenticación

En una aplicación que usa más de un middleware de autenticación (y que, por tanto, tiene más de un esquema de autenticación), el esquema que Blazor usa se puede establecer de forma explícita en la configuración del punto de conexión del archivo Program. En el ejemplo siguiente se establece el esquema OpenID Connect (OIDC):

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Controlador de circuito para capturar usuarios para servicios personalizados

Use un CircuitHandler para capturar un usuario del AuthenticationStateProvider y establecer el usuario en un servicio. Si desea actualizar el usuario, registre una devolución de llamada a AuthenticationStateChanged y ponga en cola una Task para obtener el nuevo usuario y actualizar el servicio. Este método se describe en el siguiente ejemplo.

En el ejemplo siguiente:

• OnConnectionUpAsync se llama cada vez que el circuito se vuelve a conectar, y establece el usuario durante la vigencia de la conexión. Solo se requiere el método OnConnectionUpAsync a menos que implemente actualizaciones a través de un controlador para cambios de autenticación (AuthenticationChanged en el ejemplo siguiente).
• OnCircuitOpenedAsync se llama para adjuntar el controlador cambiado de autenticación, AuthenticationChanged, para actualizar el usuario.
• El bloque catch de la tarea UpdateAuthentication no realiza ninguna acción sobre excepciones porque por ahora no hay ninguna manera de notificarlas en la ejecución del código. Si se produce una excepción desde la tarea, la excepción se notifica en otra parte de la aplicación.

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

En el archivo Program:

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

...

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

Use el servicio en un componente para obtener el usuario:

@inject UserService UserService

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

Para establecer el usuario en middleware para MVC, páginas de Razor y en otros escenarios de ASP.NET Core, llame a SetUser en el UserService en middleware personalizado después de que se ejecute el middleware de autenticación o establezca el usuario con una implementación de IClaimsTransformation. En el ejemplo siguiente se adopta el enfoque de 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);
    }
}

Inmediatamente antes de la llamada a app.MapRazorComponents<App>() en el archivo Program, llame al middleware:

app.UseMiddleware<UserServiceMiddleware>();

Acceso a AuthenticationStateProvider en el middleware de solicitud de salida

Se puede acceder a AuthenticationStateProvider de un DelegatingHandler para HttpClient creado con IHttpClientFactory en el middleware de solicitud de salida utilizando un controlador de actividad de circuito.

Nota:

Para obtener instrucciones generales sobre cómo definir controladores de delegación para solicitudes HTTP por HttpClient instancias creadas con IHttpClientFactory en aplicaciones ASP.NET Core, consulte las secciones siguientes de Realización de solicitudes HTTP mediante IHttpClientFactory en ASP.NET Core:

• Middleware de solicitud saliente
• Uso de la inserción de dependencias en el middleware de solicitud de salida

En el ejemplo siguiente se usa AuthenticationStateProvider para adjuntar un encabezado de nombre de usuario personalizado para los usuarios autenticados a las solicitudes de salida.

En primer lugar, implemente la clase CircuitServicesAccessor en la sección siguiente del artículo de inserción de dependencias (DI) Blazor:

Acceder a los servicios del Blazor servidor desde un ámbito DI diferente

Use CircuitServicesAccessor para acceder a AuthenticationStateProvider en la implementación de 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);
    }
}

En el archivo Program, registre AuthenticationStateHandler y agregue el controlador a IHttpClientFactory que crea instancias de HttpClient:

builder.Services.AddTransient<AuthenticationStateHandler>();

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