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, quita 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 Blazor Web App está pendiente de Actualización de la sección sobre cómo pasar tokens en Blazor Web App (dotnet/AspNetCore.Docs #31691). Para obtener más información, consulta Problema al proporcionar un token de acceso a HttpClient en modo de servidor interactivo (dotnet/aspnetcore #52390).

Para Blazor Server, consulta 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

Usa un CircuitHandler para capturar un usuario del AuthenticationStateProvider y establecer el usuario en un servicio. Si deseas actualizar el usuario, registra una devolución de llamada a AuthenticationStateChanged y pon en cola 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() => 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;
    }
}

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

Usa 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, llama 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, llama 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, consulta 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, implementa 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

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

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

builder.Services.AddTransient<AuthenticationStateHandler>();

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