Ověřování a autorizace ASP.NET Core Blazor

Pokud musí být zaručeno vynucení autorizačního pravidla, neimplementujte kontroly autorizace v kódu na straně klienta. Sestavte Blazor Web App, které se spoléhá pouze na serverové vykreslování (SSR) pro kontrolu autorizace a prosazování pravidel.

Pokud musí být zaručeno vynucení autorizačního pravidla a zabezpečení dat a kódu, nevyvíjejte aplikaci na straně klienta. Vytvořte aplikaci Blazor Server.

ASP.NET Core Identity je navržená tak, aby fungovala v kontextu komunikace požadavků a odpovědí HTTP, což obecně není Blazor komunikační model klient-server aplikace. Aplikace ASP.NET Core, které pro správu uživatelů využívají ASP.NET Core Identity, by měly pro uživatelské rozhraní související s Razor, jako je registrace uživatele, přihlášení, odhlášení a další úlohy správy uživatelů, místo komponent Razor využívat Identity Pages. Vytváření Razor komponent, které přímo zpracovávají Identity úlohy, je možné v několika scénářích, ale microsoft je nedoporučuje ani nepodporuje.

Abstrakce ASP.NET Core, jako jsou SignInManager<TUser> a UserManager<TUser>, se v komponentách Razor nepodporují. Další informace o použití ASP.NET Core Identity s Blazor naleznete v tématu Scaffold ASP.NET Core Identity do aplikace na straně serveru Blazor.

Podpora ochrany proti padělání

Šablona Blazor :

• Přidá antiforgery služby automaticky, když AddRazorComponents je volána v Program souboru.
• Přidá antiforgery middleware voláním UseAntiforgery do kanálu zpracování požadavků v Program souboru a vyžaduje ochranu koncového bodu proti padělání, aby se zmírnily hrozby pro padělání požadavků mezi weby (CSRF/XSRF). UseAntiforgery je voláno po UseHttpsRedirection. Volání UseAntiforgery musí být umístěno po voláních do UseAuthentication a UseAuthorization, pokud jsou k dispozici.

Komponenta AntiforgeryToken vykreslí antiforgery token jako skryté pole a tato komponenta se automaticky přidá do instancí formuláře (EditForm). Další informace najdete v přehledu ASP.NET Core Blazor formulářů.

Služba AntiforgeryStateProvider poskytuje přístup k tokenu proti padělání přidruženému k aktuální relaci. Vložte službu a zavolejte její GetAntiforgeryToken() metodu k získání aktuálního AntiforgeryRequestToken. Další informace najdete v tématu Zavolejte webové rozhraní API z aplikace ASP.NET CoreBlazor.

Blazor ukládá tokeny spojené se žádostí do stavu komponenty, což zaručuje, že tokeny proti padělání jsou k dispozici interaktivním komponentám, i když nemají přístup k této žádosti.

Další informace naleznete v následujících zdrojích:

• Prevence útoků XSRF/CSRF (Cross-Site Request Forgery) v ASP.NET Core: Tento článek je primárním článkem o ASP.NET Core, který se vztahuje na serverovou stranu Blazor Server, projekt Blazor Web Appserveru a Blazor integraci s MVC/Razor Pages.
• Přehled formulářů Blazor ASP.NET Core: Oddíl podpory antiforgery článku se týká podpory antiforgery ve formuláříchBlazor.

Blazor Identity Uživatelské rozhraní (jednotlivé účty)

Blazorpodporuje generování úplného BlazorIdentity uživatelského rozhraní, když zvolíte možnost ověřování pro jednotlivé účty.

Šablona Blazor Web App tvoří Identity kód pro databázi SQL Serveru. Verze příkazového řádku používá SQLite a obsahuje databázi SQLite pro Identity.

Šablona:

• Podporuje interaktivní vykreslování na straně serveru (interaktivní SSR) a scénáře vykreslování na straně klienta (CSR) s ověřenými uživateli.
• Přidá IdentityRazor komponenty a související logiku pro rutinní úlohy ověřování, jako je přihlášení a odhlášení uživatelů. Komponenty Identity také podporují pokročilé Identity funkce, jako je potvrzení účtu a obnovení hesla a vícefaktorové ověřování pomocí aplikace třetí strany. Všimněte si, že Identity samotné komponenty nepodporují interaktivitu.
• IdentityPřidá související balíčky a závislosti.
• Odkazuje na Identity balíčky v souboru _Imports.razor.
• Vytvoří vlastní třídu uživatele Identity (ApplicationUser).
• Vytvoří a zaregistruje EF Core kontext databáze (ApplicationDbContext).
• Konfiguruje směrování pro předdefinované Identity koncové body.
• Zahrnuje Identity ověřování a obchodní logiku.

Pro kontrolu komponent architektury přejděte do složek a ve složce , která je v šabloně projektu (referenční zdroj).

Když zvolíte režim interaktivního automatického vykreslování WebAssembly nebo Interactive Auto Render, server zpracuje všechny požadavky na ověřování a autorizaci a Identity komponenty se na serveru Blazor Web Appv hlavním projektu vykreslují staticky.

Architektura poskytuje vlastní AuthenticationStateProvider v projektech serveru a klienta .Client pro předání stavu ověření uživatele do prohlížeče. Projekt serveru volá AddAuthenticationStateSerialization, zatímco projekt klienta volá AddAuthenticationStateDeserialization. Ověřování na serveru namísto klienta umožňuje aplikaci mít přístup ke stavu ověřování během předběžného vykreslování a před inicializací prostředí .NET WebAssembly. Vlastní AuthenticationStateProvider implementace používají službu Persistent Component State Service (PersistentComponentState) k serializaci stavu ověřování do komentářů HTML a pak jej číst zpět z WebAssembly pro vytvoření nové instance AuthenticationState. Další informace najdete v části Správa stavu ověřování.Blazor Web App

Pouze pro řešení interaktivního serveru je (referenční zdroj) serverová strana AuthenticationStateProvider, která revaliduje razítko zabezpečení pro připojeného uživatele každých 30 minut, kdy je připojen interaktivní okruh.

Když zvolíte režim interaktivního automatického vykreslování WebAssembly nebo Interactive Auto Render, server zpracuje všechny požadavky na ověřování a autorizaci a Identity komponenty se na serveru Blazor Web Appv hlavním projektu vykreslují staticky. Šablona projektu obsahuje třídu (referenční zdroj) v .Client projektu, která synchronizuje stav ověřování uživatele mezi serverem a prohlížečem. Třída je vlastní implementace AuthenticationStateProvider. Zprostředkovatel používá službu Trvalý stav součástí (PersistentComponentState) k předvykreslení stavu ověřování a k jeho zachování na stránce.

V hlavním projektu Blazor Web App je poskytovatel stavu ověřování nazván buď IdentityRevalidatingAuthenticationStateProvider (referenční zdroj) (pouze řešení pro interaktivitu serveru) nebo PersistingRevalidatingAuthenticationStateProvider (referenční zdroj) (řešení pro WebAssembly nebo automatickou interaktivitu).

Blazor Identity závisí na DbContext instancích, které nevytvořila továrna, což je záměrné, protože stačí, aby DbContext komponenty šablony Identity projektu vykreslovány staticky bez podpory interaktivity.

Pro podrobnou informaci o tom, jak se globální interaktivní režimy vykreslování aplikují na komponenty jiné než Identity a zároveň vynucují statické SSR pro Identity komponenty, se podívejte na režimy vykreslování v ASP.NET CoreBlazor.

Další informace o trvalém předrenderovaném stavu naleznete v tématu Prerender ASP.NET Core Razor komponenty.

Správa stavu ověřování v Blazor Web Apps

Tato část se týká Blazor Web Appkteré přijímají:

• Jednotlivé účty
• Vykreslování na straně klienta (CSR, interaktivita založená na WebAssembly).

Zprostředkovatel stavu ověřování na straně klienta se používá jenom uvnitř Blazor a není integrovaný se systémem ověřování ASP.NET Core. Během předdefinování respektuje metadata definovaná na stránce a používá ověřovací systém ASP.NET Core k určení, Blazor jestli je uživatel ověřený. Když uživatel přejde z jedné stránky na jinou, použije se zprostředkovatel ověřování na straně klienta. Když uživatel aktualizuje stránku (znovu načíst celou stránku), není zprostředkovatel stavu ověřování na straně klienta zapojen do rozhodnutí o ověření na serveru. Vzhledem k tomu, že stav uživatele není serverem trvalý, dojde ke ztrátě stavu ověřování udržovaného na straně klienta.

Nejlepší způsob řešení je provést ověřování v rámci systému ověřování ASP.NET Core. Poskytovatel autentizačního stavu na straně klienta se pouze stará o zrcadlení uživatelského stavu ověření. Příklady, jak toho dosáhnout použitím zprostředkovatelů stavu ověřování, jsou demonstrovány šablonou Blazor Web App projektu a popsány níže.

V souboru projektu na straně serveru volejte , který serializuje vrácené serverovým pomocí služby trvalého stavu komponenty ().

builder.Services.AddRazorComponents()
    .AddInteractiveWebAssemblyComponents()
    .AddAuthenticationStateSerialization();

Rozhraní API serializuje pouze název na straně serveru a deklarace identity rolí pro přístup v prohlížeči. Pokud chcete zahrnout všechny nároky, nastavte SerializeAllClaims na true ve volání AddAuthenticationStateSerialization na straně serveru:

builder.Services.AddRazorComponents()
    .AddInteractiveWebAssemblyComponents()
    .AddAuthenticationStateSerialization(
        options => options.SerializeAllClaims = true);

V souboru projektu klienta (.Client) volejte AddAuthenticationStateDeserialization, což přidá AuthenticationStateProvider, kde je AuthenticationState deserializován ze serveru pomocí AuthenticationStateData a služby pro trvalý stav komponent ()PersistentComponentState. V projektu serveru by mělo být odpovídající volání na AddAuthenticationStateSerialization.

builder.Services.AddAuthorizationCore();
builder.Services.AddCascadingAuthenticationState();
builder.Services.AddAuthenticationStateDeserialization();

• PersistingRevalidatingAuthenticationStateProvider (referenční zdroj): Pro Blazor Web Appuživatele, kteří přijímají interaktivní vykreslování na straně serveru (interaktivní SSR) a vykreslování na straně klienta (CSR). Jedná se o serverovou stranu AuthenticationStateProvider , která aktualizuje razítko zabezpečení pro připojeného uživatele každých 30 minut, kdy je připojený interaktivní okruh. Používá také službu Trvalého stavu komponenty k přenesení stavu ověřování ke klientovi, který je pak během životnosti CSR neměnný.

• PersistingServerAuthenticationStateProvider (referenční zdroj): Pro Blazor Web Appty, které přijímají pouze CSR. Jedná se o serverovou stranu AuthenticationStateProvider, která používá službu Stavu trvalých komponent ke proudění stavu ověření do klienta, což je pak zajištěno po celou dobu životnosti CSR.

• PersistentAuthenticationStateProvider (referenční zdroj): Pro Blazor Web Appy, které přijímají CSR. Jedná se o klientaAuthenticationStateProvider, který určuje stav autentizace uživatele hledáním dat uložených ve stránce při jejím vykreslení na serveru. Tento stav ověřování je neměnný po celou dobu životnosti CSR. Pokud se uživatel potřebuje přihlásit nebo odhlásit, je nutné znovu načíst celou stránku. To poskytuje jenom uživatelské jméno a e-mail pro účely zobrazení. Nezahrnuje tokeny k autentizaci na serveru při samostatném zpracování následných požadavků, což se řeší samostatně pomocí cookie zahrnutého v HttpClient požadavcích na server.

Lešení Identity

Další informace o generování uživatelského rozhraní do aplikace na straně Identity serveru najdete v tématu Generování uživatelského rozhraní BlazorIdentity v projektech ASP.NET Core.

Vytvoření základní struktury Identity do serverové aplikace Blazor.

• Bez stávající autorizace
• S autorizací

V souboru Program:

builder.Services.AddScoped<ExampleService>();

V Startup.ConfigureServices z Startup.cs:

services.AddScoped<ExampleService>();

@page "/inject-auth-state-provider"
@inherits OwningComponentBase
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>Inject <code>AuthenticationStateProvider</code> Example</h1>

<p>@message</p>

@code {
    private string? message;
    private ExampleService? ExampleService { get; set; }

    protected override async Task OnInitializedAsync()
    {
        ExampleService = ScopedServices.GetRequiredService<ExampleService>();

        message = await ExampleService.ExampleMethod(AuthenticationStateProvider);
    }
}

@page "/inject-auth-state-provider"
@inject AuthenticationStateProvider AuthenticationStateProvider
@inherits OwningComponentBase

<h1>Inject <code>AuthenticationStateProvider</code> Example</h1>

<p>@message</p>

@code {
    private string? message;
    private ExampleService? ExampleService { get; set; }

    protected override async Task OnInitializedAsync()
    {
        ExampleService = ScopedServices.GetRequiredService<ExampleService>();

        message = await ExampleService.ExampleMethod(AuthenticationStateProvider);
    }
}

• Zakázání předběžného vykreslování: Indikujte režim vykreslování s parametrem prerender nastaveným false na komponentu nejvyšší úrovně v hierarchii komponent aplikace, která není kořenovou komponentou.

  Poznámka:

  Interaktivní vytvoření kořenové komponenty, například App komponenty, není podporováno. Proto není možné předřazování přímo zakázat komponentou App .

  U aplikací založených na šabloně projektu Blazor Web App je prerendering obvykle zakázán, pokud se komponenta Routes používá v komponentě App (Components/App.razor):

  <Routes @rendermode="new InteractiveServerRenderMode(prerender: false)" />
  

  Zakažte také předběžné předkreslování pro komponentu HeadOutlet :

  <HeadOutlet @rendermode="new InteractiveServerRenderMode(prerender: false)" />
  

  Můžete také selektivně řídit režim vykreslování použitý u Routes instance komponenty. Jako příklad se podívejte na režimy vykreslováníBlazor ASP.NET Core.

• Zakázat předrenderování: Otevřete soubor _Host.cshtml a změňte atribut render-mode pomocníka komponenty Tag Helper na Server:

  <component type="typeof(App)" render-mode="Server" />
  

Doba platnosti adresy URL dočasného přesměrování

Tato část se týká Blazor Web Apps.

Pomocí možnosti RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration můžete získat nebo nastavit dobu platnosti ochrany dat ASP.NET Core pro dočasné URL přesměrování generované renderováním na straně Blazor serveru. Používají se jenom přechodně, takže životnost musí být dostatečná, aby klient získal adresu URL a začal na ni navigovat. Měla by však být dostatečně dlouhá, aby umožňovala nerovnoměrnou distribuci hodin mezi servery. Výchozí hodnota je pět minut.

V následujícím příkladu je hodnota prodloužena na sedm minut:

builder.Services.AddRazorComponents(options => 
    options.TemporaryRedirectionUrlValidityDuration = 
        TimeSpan.FromMinutes(7));

Zabezpečte data v Blazor Web Apps pomocí interaktivního automatického vykreslování.

Když Blazor Web App přijme vykreslování na straně serveru (SSR) a vykreslování na straně klienta (CSR) pro komponenty nebo celou aplikaci, která určuje interaktivní režim automatického vykreslování, autorizace pro přístup k komponentám a datům se použije v dvou místech. Komponenta při vykreslení na serveru omezuje přístup k sobě samé (a ke všem datům, která získává) na základě autorizačního atributu v definičním souboru komponenty (@attribute [Authorize]). Při vykreslení komponenty na klientovi je přístup k datům omezen prostřednictvím koncových bodů webového rozhraní API serveru, které jsou volány z klienta. Při zabezpečení přístupu k datům v obou umístěních je potřeba věnovat pozornost, aby se zabránilo nesprávnému přístupu k datům.

Představte si následující scénář, ve kterém komponenta zobrazuje zabezpečená data o počasí. Následující příklad můžete prozkoumat a demonstrovat v běžící ukázkové aplikaci pomocí vzorku BlazorWebAppEntra (.NET 9 nebo novější) nebo vzorku BlazorWebAppOidc (.NET 8 nebo novější) v GitHub úložišti vzorků Blazor (dotnet/blazor-samples) (jak stáhnout).

Projekt klienta udržuje třídu WeatherForecast, která uchovává data o počasí:

public sealed class WeatherForecast(DateOnly date, int temperatureC, string summary)
{
    public DateOnly Date { get; set; } = date;
    public int TemperatureC { get; set; } = temperatureC;
    public string? Summary { get; set; } = summary;
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

Rozhraní klientského projektu IWeatherForecaster definuje metodu GetWeatherForecastAsync pro získání dat o počasí:

public interface IWeatherForecaster
{
    Task<IEnumerable<WeatherForecast>> GetWeatherForecastAsync();
}

Služba ClientWeatherForecaster projektu klienta implementuje IWeatherForecaster. Metoda GetWeatherForecastAsync volá webové rozhraní API v serverovém projektu na koncovém bodě /weather-forecast pro data o počasí.

internal sealed class ClientWeatherForecaster(HttpClient httpClient) 
    : IWeatherForecaster
{
    public async Task<IEnumerable<WeatherForecast>> GetWeatherForecastAsync() =>
        await httpClient.GetFromJsonAsync<WeatherForecast[]>("/weather-forecast") ??
            throw new IOException("No weather forecast!");
}

Klientský projekt udržuje Weather komponentu, která:

• Vynucuje autorizaci pomocí atributu [Authorize].
• Používá trvalou službu stavu komponent (PersistentComponentState) k zachování dat předpovědi počasí, když komponenta přejde ze statického na interaktivní SSR na serveru.

@page "/weather"
@using Microsoft.AspNetCore.Authorization
@using BlazorWebAppEntra.Client.Weather
@attribute [Authorize]
@implements IDisposable
@inject PersistentComponentState ApplicationState
@inject IWeatherForecaster WeatherForecaster

<PageTitle>Weather</PageTitle>

<h1>Weather</h1>

<p>This component demonstrates showing data.</p>

@if (forecasts == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>Date</th>
                <th aria-label="Temperature in Celsius">Temp. (C)</th>
                <th aria-label="Temperature in Fahrenheit">Temp. (F)</th>
                <th>Summary</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var forecast in forecasts)
            {
                <tr>
                    <td>@forecast.Date.ToShortDateString()</td>
                    <td>@forecast.TemperatureC</td>
                    <td>@forecast.TemperatureF</td>
                    <td>@forecast.Summary</td>
                </tr>
            }
        </tbody>
    </table>
}

@code {
    private IEnumerable<WeatherForecast>? forecasts;
    private PersistingComponentStateSubscription persistingSubscription;

    protected override async Task OnInitializedAsync()
    {
        persistingSubscription = ApplicationState.RegisterOnPersisting(PersistData);

        if (!ApplicationState.TryTakeFromJson<IEnumerable<WeatherForecast>>(
            nameof(forecasts), out var restoredData))
        {
            forecasts = await WeatherForecaster.GetWeatherForecastAsync();
        }
        else
        {
            forecasts = restoredData!;
        }
    }

    private Task PersistData()
    {
        ApplicationState.PersistAsJson(nameof(forecasts), forecasts);

        return Task.CompletedTask;
    }

    void IDisposable.Dispose() => persistingSubscription.Dispose();
}

Serverový projekt implementuje IWeatherForecaster jako ServerWeatherForecaster, což generuje a vrací simulovaná data o počasí prostřednictvím metody GetWeatherForecastAsync.

public class ServerWeatherForecaster() : IWeatherForecaster
{
    public readonly string[] summaries =
    [
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", 
        "Sweltering", "Scorching"
    ];

    public async Task<IEnumerable<WeatherForecast>> GetWeatherForecastAsync()
    {
        // Simulate asynchronous loading to demonstrate streaming rendering
        await Task.Delay(500);

        return Enumerable.Range(1, 5).Select(index =>
            new WeatherForecast
            (
                DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                Random.Shared.Next(-20, 55),
                summaries[Random.Shared.Next(summaries.Length)]
            ))
        .ToArray();
    }
}

Serverový projekt udržuje zabezpečený koncový bod webového rozhraní API pro volání dat o počasí klienta:

app.MapGet("/weather-forecast", (
    [FromServices] IWeatherForecaster WeatherForecaster) =>
{
    return WeatherForecaster.GetWeatherForecastAsync();
}).RequireAuthorization();

Při použití předchozího přístupu existují dva systémy, které uživatelům poskytují zabezpečená data o počasí:

• Když se komponenta Weather vykresluje na serveru, metoda GetWeatherForecastAsync služby ServerWeatherForecaster se používá přímo k získání dat o počasí. Zabezpečení dat je vynuceno atributem [Authorize] komponenty. Stručně řečeno, komponenta vynucuje zabezpečení dat o počasí.
• Při vykreslení komponenty Weatherna klientuse služba ClientWeatherForecaster používá k volání webového rozhraní API na zabezpečený koncový bod /weather-forecast, který aplikuje metodu rozšíření RequireAuthorization. Pokud má uživatel oprávnění pro přístup k datům o počasí, koncový bod používá službu ServerWeatherForecaster k volání GetWeatherForecastAsync. Data se vrátí klientovi. Stručně řečeno, zabezpečení dat o počasí vynucuje koncový bod webového rozhraní API serverové aplikace.

Předchozí přístup funguje dobře, když požadavky na zabezpečení webového rozhraní API odpovídají požadavkům na zabezpečení komponenty. Stejné zásady autorizace se dají použít například pro koncový bod webového rozhraní API i pro komponentu.

Složité scénáře vyžadují další plánování a implementaci. Například serverové webové rozhraní API, které má více volajících s různými přístupovými oprávněními, vyžaduje sofistikovanější zásady autorizace, jednu nebo více dalších zásad nebo další koncové body s různými požadavky na přístup.

Při sestavování zabezpečení aplikací, které přijímají interaktivní automatické vykreslování, mějte na paměti, že zabezpečení implementované pro koncové body webového rozhraní API serveru nezabezpečí implementaci služby serveru, která se používá při vykreslení komponenty na serveru a přistupuje k datům prostřednictvím služby. Pečlivě zvažte rozdíl mezi přístupem k datům na serveru během SSR a přístupem k datům v požadavku klientského webového rozhraní API během csr. Strategicky použijte zabezpečení, abyste se vyhnuli nesprávnému přístupu k datům.

Příklady v ukázkovém úložišti GitHub Blazor (dotnet/blazor-samples), jak stáhnout (), které demonstrují přístup popsaný v této části:

• BlazorWebAppOidc
• BlazorWebAppOidcBff
• BlazorWebAppEntra

AuthenticationStateProvider je základní služba používaná komponentou AuthorizeView a kaskádovými ověřovacími službami k získání stavu ověřování pro uživatele.

AuthenticationStateProvider je základní služba používaná komponentou AuthorizeView a CascadingAuthenticationState komponentou k získání stavu ověřování uživatele.

@page "/claims-principal-data"
@using System.Security.Claims
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>ClaimsPrincipal Data</h1>

<button @onclick="GetClaimsPrincipalData">Get ClaimsPrincipal Data</button>

<p>@authMessage</p>

@if (claims.Any())
{
    <ul>
        @foreach (var claim in claims)
        {
            <li>@claim.Type: @claim.Value</li>
        }
    </ul>
}

<p>@surname</p>

@code {
    private string? authMessage;
    private string? surname;
    private IEnumerable<Claim> claims = Enumerable.Empty<Claim>();

    private async Task GetClaimsPrincipalData()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            authMessage = $"{user.Identity.Name} is authenticated.";
            claims = user.Claims;
            surname = user.FindFirst(c => c.Type == ClaimTypes.Surname)?.Value;
        }
        else
        {
            authMessage = "The user is NOT authenticated.";
        }
    }
}

V předchozím příkladu:

• ClaimsPrincipal.Claims vrací uživatelské nároky (claims) pro zobrazení v uživatelském rozhraní.
• Řádek, který získá příjmení uživatele (surname), volá ClaimsPrincipal.FindAll s predikátem pro filtrování uživatelských nároků.

@page "/claims-principal-data"
@using System.Security.Claims
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>ClaimsPrincipal Data</h1>

<button @onclick="GetClaimsPrincipalData">Get ClaimsPrincipal Data</button>

<p>@authMessage</p>

@if (claims.Any())
{
    <ul>
        @foreach (var claim in claims)
        {
            <li>@claim.Type: @claim.Value</li>
        }
    </ul>
}

<p>@surname</p>

@code {
    private string? authMessage;
    private string? surname;
    private IEnumerable<Claim> claims = Enumerable.Empty<Claim>();

    private async Task GetClaimsPrincipalData()
    {
        var authState = await AuthenticationStateProvider
            .GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            authMessage = $"{user.Identity.Name} is authenticated.";
            claims = user.Claims;
            surname = user.FindFirst(c => c.Type == ClaimTypes.Surname)?.Value;
        }
        else
        {
            authMessage = "The user is NOT authenticated.";
        }
    }
}

@page "/cascade-auth-state"

<h1>Cascade Auth State</h1>

<p>@authMessage</p>

@code {
    private string authMessage = "The user is NOT authenticated.";

    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user?.Identity is not null && user.Identity.IsAuthenticated)
            {
                authMessage = $"{user.Identity.Name} is authenticated.";
            }
        }
    }
}

@page "/cascade-auth-state"

<h1>Cascade Auth State</h1>

<p>@authMessage</p>

@code {
    private string authMessage = "The user is NOT authenticated.";

    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user?.Identity is not null && user.Identity.IsAuthenticated)
            {
                authMessage = $"{user.Identity.Name} is authenticated.";
            }
        }
    }
}

Nastavte kaskádový parametr Task<AuthenticationState> pomocí kaskádových ověřovacích stavových služeb AuthorizeRouteView.

Když vytvoříte Blazor aplikaci z jedné ze Blazor projektových šablon s povoleným ověřováním, aplikace zahrnuje AuthorizeRouteView a volání AddCascadingAuthenticationState, jak je ukázáno v následujícím příkladu. Klientská Blazor aplikace obsahuje i požadované registrace služeb. Další informace jsou uvedeny v části Přizpůsobení neoprávněného obsahu pomocí komponenty Router.

<Router ...>
    <Found ...>
        <AuthorizeRouteView RouteData="routeData" 
            DefaultLayout="typeof(Layout.MainLayout)" />
        ...
    </Found>
</Router>

Program V souboru zaregistrujte kaskádové stavové služby ověřování:

builder.Services.AddCascadingAuthenticationState();

Nastavte kaskádový parametr pomocí komponent a .

Když vytvoříte Blazor aplikaci z jedné ze Blazor šablon projektu s povoleným ověřováním, aplikace obsahuje komponenty AuthorizeRouteView a CascadingAuthenticationState, uvedené v následujícím příkladu. Klientská aplikace Blazor obsahuje také požadované registrace služeb. Dodatečné informace jsou uvedeny v části Přizpůsobení neoprávněného obsahu pomocí komponenty Router.

<CascadingAuthenticationState>
    <Router ...>
        <Found ...>
            <AuthorizeRouteView RouteData="routeData" 
                DefaultLayout="typeof(MainLayout)" />
            ...
        </Found>
    </Router>
</CascadingAuthenticationState>

V aplikaci na straně Blazor klienta přidejte do Program souboru autorizační služby:

builder.Services.AddAuthorizationCore();

V aplikaci na straně Blazor klienta přidejte do Program souboru možnosti a autorizační služby:

builder.Services.AddOptions();
builder.Services.AddAuthorizationCore();

Razor součásti Blazor Web App nikdy nezobrazují obsah <NotAuthorized>, pokud autorizace selže na straně serveru během statického serverového vykreslování (statické SSR). Na serverové straně ASP.NET Core kanál zpracovává autorizaci na serveru. Ke zpracování neautorizovaných požadavků použijte techniky na straně serveru. Další informace najdete v tématu režimy vykreslování v ASP.NET CoreBlazor.

Autorizace prostředků

Chcete-li autorizovat uživatele k prostředkům, předejte údaje o směrování požadavku do parametru Resource v rámci AuthorizeRouteView.

Router.Found V obsahu požadované trasy:

<AuthorizeRouteView Resource="routeData" RouteData="routeData" 
    DefaultLayout="typeof(MainLayout)" />

Další informace o tom, jak se údaje o stavu autorizace předávají a využívají v procedurální logice, najdete v části Zveřejnění stavu ověřování jako kaskádového parametru.

Když AuthorizeRouteView obdrží data směrování pro prostředek, zásady autorizace mají přístup ke komponentám RouteData.PageType a RouteData.RouteValues, které umožňují použití vlastní logiky pro rozhodování o autorizaci.

V následujícím příkladu se v EditUser vytvoří politika AuthorizationOptions pro konfiguraci autorizační služby aplikace (AddAuthorizationCore) s následující logikou:

• Určete, zda existuje směrovací hodnota s klíčem id. Pokud klíč existuje, hodnota trasy je uložená v value.
• V proměnné s názvem id uložte value jako řetězec nebo nastavte prázdnou hodnotu řetězce (string.Empty).
• Pokud id není prázdný řetězec, ověřte, že tato zásada je splněná (vrátí true), pokud hodnota řetězce má na začátku EMP. V opačném případě ověřte, že tato zásada selže (vrátí false).

V souboru Program:

• Přidejte obory názvů pro Microsoft.AspNetCore.Components a System.Linq:

  using Microsoft.AspNetCore.Components;
  using System.Linq;
  

• Přidejte zásady:

  options.AddPolicy("EditUser", policy =>
      policy.RequireAssertion(context =>
      {
          if (context.Resource is RouteData rd)
          {
              var routeValue = rd.RouteValues.TryGetValue("id", out var value);
              var id = Convert.ToString(value, 
                  System.Globalization.CultureInfo.InvariantCulture) ?? string.Empty;
  
              if (!string.IsNullOrEmpty(id))
              {
                  return id.StartsWith("EMP", StringComparison.InvariantCulture);
              }
          }
  
          return false;
      })
  );
  

Předchozí příklad je přehnaně zjednodušená zásada autorizace, která slouží pouze k demonstraci tohoto konceptu na funkčním příkladu. Další informace o vytváření a konfiguraci zásad autorizace najdete v tématu Autorizace na základě zásad v ASP.NET Core.

V následující komponentě EditUser má prostředek v /users/{id}/edit parametr trasy pro identifikátor uživatele ({id}). Tento komponent využívá předchozí zásady autorizace EditUser k určení, zda hodnota trasy id začíná EMP. Pokud id má na začátku EMP, zásada je splněná a přístup ke komponentě je autorizovaný. Pokud id začíná jinou hodnotou než EMP nebo pokud id je prázdný řetězec, zásada selže a komponenta se nenačte.

EditUser.razor:

@page "/users/{id}/edit"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "EditUser")]

<h1>Edit User</h1>

<p>The "EditUser" policy is satisfied! <code>Id</code> starts with 'EMP'.</p>

@code {
    [Parameter]
    public string? Id { get; set; }
}

@page "/users/{id}/edit"
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize(Policy = "EditUser")]

<h1>Edit User</h1>

<p>The "EditUser" policy is satisfied! <code>Id</code> starts with 'EMP'.</p>

@code {
    [Parameter]
    public string? Id { get; set; }
}

<Router ...>
    <Found ...>
        <AuthorizeRouteView ...>
            <NotAuthorized>
                ...
            </NotAuthorized>
            <Authorizing>
                ...
            </Authorizing>
        </AuthorizeRouteView>
    </Found>
</Router>

Obsah Authorized a NotAuthorized může obsahovat libovolné položky, například jiné interaktivní komponenty.

builder.Services.AddCascadingAuthenticationState();

<CascadingAuthenticationState>
    <Router ...>
        <Found ...>
            <AuthorizeRouteView ...>
                <NotAuthorized>
                    ...
                </NotAuthorized>
                <Authorizing>
                    ...
                </Authorizing>
            </AuthorizeRouteView>
        </Found>
    </Router>
</CascadingAuthenticationState>

NotFoundObsah souboru , Authorizeda NotAuthorized může obsahovat libovolné položky, například jiné interaktivní komponenty.

@page "/procedural-logic"
@inject IAuthorizationService AuthorizationService

<h1>Procedural Logic Example</h1>

<button @onclick="@DoSomething">Do something important</button>

@code {
    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    private async Task DoSomething()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user is not null)
            {
                if (user.Identity is not null && user.Identity.IsAuthenticated)
                {
                    // ...
                }

                if (user.IsInRole("Admin"))
                {
                    // ...
                }

                if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
                    .Succeeded)
                {
                    // ...
                }
            }
        }
    }
}

@page "/procedural-logic"
@inject IAuthorizationService AuthorizationService

<h1>Procedural Logic Example</h1>

<button @onclick="@DoSomething">Do something important</button>

@code {
    [CascadingParameter]
    private Task<AuthenticationState>? authenticationState { get; set; }

    private async Task DoSomething()
    {
        if (authenticationState is not null)
        {
            var authState = await authenticationState;
            var user = authState?.User;

            if (user is not null)
            {
                if (user.Identity is not null && user.Identity.IsAuthenticated)
                {
                    // ...
                }

                if (user.IsInRole("Admin"))
                {
                    // ...
                }

                if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
                    .Succeeded)
                {
                    // ...
                }
            }
        }
    }
}

• Serverové prostředky a Blazor Web App prostředky
  • Rychlý start: Přidání přihlašování účtem Microsoft do webové aplikace ASP.NET Core
  • Rychlý start : Ochrana webového rozhraní API ASP.NET Core pomocí platformy Microsoft Identity Platform
  • Konfigurace ASP.NET Core pro práci s proxy servery a nástroji pro vyrovnávání zatížení: Obsahuje pokyny k:
    • Použití middlewaru Forwarded Headers k zachování informací o schématu HTTPS napříč proxy servery a interními sítěmi
    • Další scénáře a případy použití, včetně manuální konfigurace schématu, změn cesty požadavku pro správné směrování požadavků a předávání schématu požadavků pro Linuxové a jiné než IIS reverzní proxy servery.
• Dokumentace k platformě Microsoft Identity Platform
  • Přehled
  • protokoly OAuth 2.0 a OpenID Connect na platformě Microsoft identity
  • Platforma Microsoft Identity a tok autorizačního kódu OAuth 2.0
  • ID tokeny platformy Microsoft Identity
  • přístupové tokeny platformy Microsoft Identity Platform
• Témata zabezpečení ASP.NET Core
• Konfigurace ověřování Windows v ASP.NET Core
• IHttpContextAccessor/HttpContext v aplikacích ASP.NET Core Blazor
• Sestavení vlastní verze knihovny Authentication.MSAL JavaScript
• Awesome Blazor: Odkazy na komunitní ukázky pro ověřování
• Ověřování a autorizace ASP.NET Core Blazor Hybrid

• Prostředky na straně Blazor serveru
  • Rychlý start: Přidání přihlašování účtem Microsoft do webové aplikace ASP.NET Core
  • Rychlý start : Ochrana webového rozhraní API ASP.NET Core pomocí platformy Microsoft Identity Platform
  • Konfigurace ASP.NET Core pro práci s proxy servery a nástroji pro vyrovnávání zatížení: Obsahuje pokyny k:
    • Použití middlewaru Forwarded Headers k zachování informací o schématu HTTPS napříč proxy servery a interními sítěmi
    • Další scénáře a případy použití, včetně ruční konfigurace schématu, změn cesty požadavku pro správné směrování a předávání schématu požadavků pro linuxové a ne-IIS reverzní proxy servery.
• Dokumentace k platformě Microsoft Identity Platform
  • Přehled
  • protokoly OAuth 2.0 a OpenID Connect na platformě Microsoft identity
  • Platforma Microsoft Identity a tok autorizačního kódu OAuth 2.0
  • ID tokeny platformy Microsoft Identity
  • přístupové tokeny platformy Microsoft Identity Platform
• Témata zabezpečení ASP.NET Core
• IHttpContextAccessor/HttpContext v aplikacích ASP.NET Core Blazor
• Konfigurace ověřování Windows v ASP.NET Core
• Sestavení vlastní verze knihovny Authentication.MSAL JavaScript
• Awesome Blazor: Odkazy na komunitní ukázky pro ověřování