Skenario keamanan tambahan ASP.NET Core Blazor sisi server

Artikel ini menjelaskan cara mengonfigurasi sisi Blazor server untuk skenario keamanan tambahan, termasuk cara meneruskan token ke Blazor aplikasi.

Catatan

Contoh kode dalam artikel ini mengadopsi jenis referensi nullable (NRTs) dan .NET compiler null-state static analysis, yang didukung di ASP.NET Core di .NET 6 atau yang lebih baru. Saat menargetkan ASP.NET Core 5.0 atau yang lebih lama, hapus penunjukan jenis null (?) dari string?TodoItem[]?, , WeatherForecast[]?, dan IEnumerable<GitHubBranch>? jenis dalam contoh artikel.

Meneruskan token ke aplikasi sisi Blazor server

Memperbarui bagian ini untuk Blazor Web Apps sedang menunggu bagian Pembaruan tentang meneruskan token di Blazor Web Apps (dotnet/AspNetCore.Docs #31691). Untuk informasi selengkapnya, lihat Masalah saat menyediakan Token Akses ke HttpClient dalam mode Server Interaktif (dotnet/aspnetcore #52390).

Untuk Blazor Server, lihat versi 7.0 dari bagian artikel ini.

Mengatur skema autentikasi

Untuk aplikasi yang menggunakan lebih dari satu Middleware Autentikasi dan dengan demikian memiliki lebih dari satu skema autentikasi, skema yang Blazor digunakan dapat diatur secara eksplisit dalam konfigurasi Program titik akhir file. Contoh berikut mengatur skema OpenID Connect (OIDC):

using Microsoft.AspNetCore.Authentication.OpenIdConnect;

...

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

Penanganan sirkuit untuk menangkap pengguna untuk layanan kustom

CircuitHandler Gunakan untuk mengambil pengguna dari AuthenticationStateProvider dan mengatur pengguna dalam layanan. Jika Anda ingin memperbarui pengguna, daftarkan panggilan balik ke AuthenticationStateChanged dan antrekan Task untuk mendapatkan pengguna baru dan perbarui layanan. Contoh berikut menunjukkan pendekatan.

Dalam contoh berikut:

• OnConnectionUpAsync dipanggil setiap kali sirkuit terhubung kembali, mengatur pengguna selama masa pakai koneksi. Hanya metode yang OnConnectionUpAsync diperlukan kecuali Anda menerapkan pembaruan melalui handler untuk perubahan autentikasi (AuthenticationChanged dalam contoh berikut).
• OnCircuitOpenedAsync dipanggil untuk melampirkan handler yang diubah autentikasi, AuthenticationChanged, untuk memperbarui pengguna.
• catch Blok UpdateAuthentication tugas tidak mengambil tindakan pada pengecualian karena tidak ada cara untuk melaporkannya pada saat ini dalam eksekusi kode. Jika pengecualian dilemparkan dari tugas, pengecualian dilaporkan di tempat lain di aplikasi.

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

Dalam file Program:

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

...

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

Gunakan layanan dalam komponen untuk mendapatkan pengguna:

@inject UserService UserService

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

Untuk mengatur pengguna di middleware untuk MVC, Razor Pages, dan dalam skenario ASP.NET Core lainnya, panggil SetUserUserService di middleware kustom setelah Middleware Autentikasi berjalan, atau atur pengguna dengan IClaimsTransformation implementasi. Contoh berikut mengadopsi pendekatan 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);
    }
}

Segera sebelum panggilan ke app.MapRazorComponents<App>()Program dalam file, panggil middleware:

app.UseMiddleware<UserServiceMiddleware>();

Akses AuthenticationStateProvider di middleware permintaan keluar

AuthenticationStateProvider dari DelegatingHandler untuk HttpClient dibuat dengan IHttpClientFactory dapat diakses dalam middleware permintaan keluar menggunakan handler aktivitas sirkuit.

Catatan

Untuk panduan umum tentang mendefinisikan penangan untuk permintaan HTTP berdasarkan HttpClient instans yang dibuat menggunakan IHttpClientFactory di aplikasi ASP.NET Core, lihat bagian berikut membuat permintaan HTTP menggunakan IHttpClientFactory di ASP.NET Core:

• Middleware permintaan keluar
• Menggunakan DI dalam middleware permintaan keluar

Contoh berikut menggunakan AuthenticationStateProvider untuk melampirkan header nama pengguna kustom untuk pengguna terautentikasi ke permintaan keluar.

Pertama, terapkan CircuitServicesAccessor kelas di bagian berikut dari Blazor artikel injeksi dependensi (DI):

Mengakses layanan sisi Blazor server dari cakupan DI yang berbeda

CircuitServicesAccessor Gunakan untuk mengakses AuthenticationStateProvider dalam DelegatingHandler implementasi.

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 Dalam file, daftarkan AuthenticationStateHandler dan tambahkan handler ke IHttpClientFactory yang membuat instansHttpClient:

builder.Services.AddTransient<AuthenticationStateHandler>();

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