Dodatkowe scenariusze zabezpieczeń po stronie serwera ASP.NET Core Blazor

W tym artykule wyjaśniono, jak skonfigurować po stronie Blazor serwera dodatkowe scenariusze zabezpieczeń, w tym sposób przekazywania tokenów do Blazor aplikacji.

Uwaga

Przykłady kodu w tym artykule przyjmują typy odwołań dopuszczających wartość null (NRTs) i statyczną analizę stanu null kompilatora platformy .NET, które są obsługiwane w programie ASP.NET Core na platformie .NET 6 lub nowszym. W przypadku określania wartości docelowej ASP.NET Core 5.0 lub starszej usuń oznaczenie typu null (?) z string?typów , TodoItem[]?, WeatherForecast[]?i IEnumerable<GitHubBranch>? w przykładach artykułu.

Przekazywanie tokenów do aplikacji po stronie Blazor serwera

Aktualizowanie tej sekcji dla Blazor usługi Web Apps oczekuje na aktualizację sekcji dotyczącej przekazywania tokenów w Blazor usłudze Web Apps (dotnet/AspNetCore.Docs #31691). Aby uzyskać więcej informacji, zobacz Problem z zapewnianiem tokenu dostępu do klienta HttpClient w trybie interaktywnym serwera (dotnet/aspnetcore #52390).

W przypadku Blazor Serverprogramu wyświetl wersję 7.0 tego artykułu.

Ustawianie schematu uwierzytelniania

W przypadku aplikacji, która używa więcej niż jednego oprogramowania pośredniczącego uwierzytelniania i w związku z tym ma więcej niż jeden schemat uwierzytelniania, schemat, który Blazor używa, można jawnie ustawić w konfiguracji punktu końcowego Program pliku. W poniższym przykładzie ustawiono schemat Połączenie OpenID (OIDC):

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Obsługa obwodu w celu przechwytywania użytkowników dla usług niestandardowych

Użyj elementu , CircuitHandler aby przechwycić użytkownika z obiektu AuthenticationStateProvider i ustawić użytkownika w usłudze. Jeśli chcesz zaktualizować użytkownika, zarejestruj wywołanie zwrotne i AuthenticationStateChanged utwórz kolejkę, Task aby uzyskać nowego użytkownika i zaktualizować usługę. W poniższym przykładzie pokazano podejście.

W poniższym przykładzie:

• OnConnectionUpAsync jest wywoływany za każdym razem, gdy obwód ponownie łączy się, ustawiając użytkownika na okres istnienia połączenia. Tylko metoda jest wymagana OnConnectionUpAsync , chyba że zaimplementujesz aktualizacje za pośrednictwem programu obsługi dla zmian uwierzytelniania (AuthenticationChanged w poniższym przykładzie).
• OnCircuitOpenedAsync Jest wywoływana w celu dołączenia zmienionej procedury obsługi uwierzytelniania, AuthenticationChanged, w celu zaktualizowania użytkownika.
• UpdateAuthentication Blok catch zadania nie podejmuje żadnych działań w przypadku wyjątków, ponieważ nie ma możliwości raportowania ich w tym momencie wykonywania kodu. Jeśli wyjątek jest zgłaszany z zadania, wyjątek jest zgłaszany w innym miejscu w aplikacji.

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

W pliku Program:

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

...

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

Użyj usługi w składniku, aby uzyskać użytkownika:

@inject UserService UserService

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

Aby ustawić użytkownika w oprogramowania pośredniczącego dla mvC, Razor stron i w innych scenariuszach ASP.NET Core, wywołaj SetUserUserService w niestandardowym oprogramowania pośredniczącego po uruchomieniu oprogramowania pośredniczącego uwierzytelniania lub ustaw użytkownika z implementacją IClaimsTransformation . Poniższy przykład stosuje podejście oprogramowania pośredniczącego.

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

Bezpośrednio przed wywołaniem app.MapRazorComponents<App>() metody w Program pliku wywołaj oprogramowanie pośredniczące:

app.UseMiddleware<UserServiceMiddleware>();

Dostęp AuthenticationStateProvider do oprogramowania pośredniczącego żądań wychodzących

Dostęp AuthenticationStateProvider do elementu z DelegatingHandler elementu dla HttpClient utworzonego IHttpClientFactory za pomocą można uzyskać w rozwiązaniu pośredniczącym żądań wychodzących przy użyciu programu obsługi działań obwodu.

Uwaga

Aby uzyskać ogólne wskazówki dotyczące definiowania procedur obsługi delegowania żądań HTTP dla HttpClient wystąpień utworzonych przy użyciu IHttpClientFactory w aplikacjach platformy ASP.NET Core, zobacz następujące sekcje w temacie Make HTTP requests using IHttpClientFactory in ASP.NET Core (Tworzenie żądań HTTP przy użyciu klasy IHttpClientFactory w usłudze ASP.NET Core):

• Oprogramowanie pośredniczące żądań wychodzących
• Używanie di w rozwiązaniu pośredniczącym żądań wychodzących

W poniższym przykładzie użyto AuthenticationStateProvider metody dołączania niestandardowego nagłówka nazwy użytkownika dla uwierzytelnionych użytkowników do żądań wychodzących.

Najpierw zaimplementuj klasę CircuitServicesAccessor w następującej Blazor sekcji artykułu wstrzykiwania zależności (DI):

Uzyskiwanie dostępu do usług po stronie Blazor serwera z innego zakresu di

Użyj elementu , CircuitServicesAccessor aby uzyskać dostęp do AuthenticationStateProvider elementu w implementacji 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);
    }
}

Program W pliku zarejestruj AuthenticationStateHandler program obsługi i dodaj do programu IHttpClientFactory , który tworzy HttpClient wystąpienia:

builder.Services.AddTransient<AuthenticationStateHandler>();

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