ASP.NET Core Blazor autentisering och auktorisering

Om tvingande av auktoriseringsregler måste garanteras ska du inte implementera auktoriseringskontroller i kod på klientsidan. Skapa en Blazor Web App som bara förlitar sig på rendering på serversidan (SSR) för auktoriseringskontroll och regelhantering.

Om tvingande av auktoriseringsregeln och säkerheten för data och kod måste garanteras ska du inte utveckla en app på klientsidan. Skapa en Blazor Server app.

ASP.NET Core Identity är utformat för att fungera inom ramen för HTTP-begäran och svarskommunikation, vilket vanligtvis inte är den kommunikationsmodell som används av Blazor-appklienten-servern. ASP.NET Core-appar som använder ASP.NET Core Identity för användarhantering bör använda Razor Pages i stället för Razor komponenter för Identity-relaterade användargränssnitt, till exempel användarregistrering, inloggning, utloggning och andra användarhanteringsuppgifter. Att skapa Razor komponenter som direkt hanterar Identity uppgifter är möjligt i flera scenarier men rekommenderas inte eller stöds inte av Microsoft.

ASP.NET Core-abstraktioner, till exempel SignInManager<TUser> och UserManager<TUser>, stöds inte i Razor komponenter. Mer information om hur du använder ASP.NET Core Identity med Blazorfinns i Scaffold ASP.NET Core Identity till en Blazor app på serversidan.

Stöd för att skydda mot förfalskning

Mallen Blazor:

• Lägger till antiforgery-tjänster automatiskt när AddRazorComponents anropas i filen Program.
• Lägger till Antiforgery Middleware genom att i UseAntiforgery-filen anropa Program i dess begäranbearbetningspipeline och kräver förfalskningsskydd på slutpunkten för att motverka hoten från cross-site request forgery (CSRF/XSRF). UseAntiforgery anropas efter UseHttpsRedirection. Ett anrop till UseAntiforgery måste göras efter anropen, om de finns, till UseAuthentication och UseAuthorization.

Komponenten AntiforgeryToken renderar en antiförfalskningstoken som ett dolt fält, och den här komponenten läggs automatiskt till i formulärinstanser (EditForm). För mer information, se översikten över ASP.NET Core Blazor-formulär.

Tjänsten AntiforgeryStateProvider ger åtkomst till en antiforgery-token som är associerad med den aktuella sessionen. Infoga tjänsten och anropa dess GetAntiforgeryToken() metod för att få den nuvarande AntiforgeryRequestToken. Mer information finns i Anropa ett webb-API från en ASP.NET Core Blazor-app.

Blazor lagrar begärandetoken i komponenttillstånd, vilket garanterar att antiforgery-token är tillgängliga för interaktiva komponenter, även om de inte har åtkomst till begäran.

Mer information finns i följande resurser:

• Prevent Cross-Site Request Forgery (XSRF/CSRF) attacker i ASP.NET Core: Den här artikeln är den primära artikeln ASP.NET Core i ämnet, som gäller för Blazor Serverpå serversidan, serverprojektet för Blazor Web Apps och Blazor integrering med MVC/Razor Pages.
• ASP.NET Core Blazor forms overview: Avsnittet Antiforgery support i artikeln avser stöd för Blazor formulär mot förfalskning.

IHttpContextAccessor bör vanligtvis undvikas med interaktiv återgivning eftersom en giltig HttpContext inte alltid är tillgänglig.

IHttpContextAccessor kan användas för komponenter som återges statiskt på servern. Vi rekommenderar dock att du undviker det om det är möjligt.

HttpContext kan användas som en sammanhängande parameter endast i statiskt renderade rotkomponenter för allmänna uppgifter, till exempel att inspektera och ändra rubriker eller andra egenskaper i komponenten App (Components/App.razor). Värdet är alltid null för interaktiv återgivning.

[CascadingParameter]
public HttpContext? HttpContext { get; set; }

För scenarier där HttpContext krävs i interaktiva komponenter rekommenderar vi att överföra data via ett beständigt tillstånd från servern. Mer information finns i ASP.NET Core-serversidan och Blazor Web App ytterligare säkerhetsscenarier.

Använd inte IHttpContextAccessor/HttpContext direkt eller indirekt i de Razor komponenterna i Blazor appar på serversidan. Blazor appar körs utanför ASP.NET Core-pipelinekontexten. Den HttpContext är inte garanterad att vara tillgänglig inom IHttpContextAccessoroch HttpContext är inte garanterat att ha kontexten som startade Blazor-appen.

Den rekommenderade metoden för att skicka begärans status till Blazor-appen är genom rotkomponentparametrar under appens initiala rendering. Alternativt kan appen kopiera data till en begränsad tjänst i rotkomponentens initieringslivscykelhändelse för användning i hela appen. Mer information finns i ASP.NET Core-serversidan och Blazor Web App ytterligare säkerhetsscenarier.

En viktig aspekt av Blazor säkerhet på serversidan är att användaren som är ansluten till en viss krets kan uppdateras någon gång efter att Blazor-kretsen har upprättats men IHttpContextAccessorinte uppdateras. Mer information om hur du hanterar den här situationen med anpassade tjänster finns i ASP.NET Core-serversidan och Blazor Web App ytterligare säkerhetsscenarier.

Blazor Identity användargränssnitt (enskilda konton)

Blazor stöder att generera ett fullständigt Blazor-baserat Identity-användargränssnitt när du väljer alternativet för autentisering för -individkonton.

Blazor Web App-mallen genererar Identity-kod för en SQL Server-databas. Kommandoradsversionen använder SQLite och innehåller en SQLite-databas för Identity.

Mallen:

• Har stöd för scenarier med interaktiv återgivning på serversidan (interaktiv SSR) och csr-scenarier (klientsidan) med autentiserade användare.
• Lägger till IdentityRazor komponenter och relaterad logik för rutinmässiga autentiseringsuppgifter, till exempel att logga in och ut användare. De Identity komponenterna stöder även avancerade Identity funktioner, till exempel kontobekräftelse och återställning av lösenord och multifaktorautentisering med hjälp av en app från tredje part. Observera att själva Identity komponenterna inte stöder interaktivitet.
• Lägger till Identity-relaterade paket och beroenden.
• Refererar till paketen Identity i _Imports.razor.
• Skapar en anpassad användarklass Identity (ApplicationUser).
• Skapar och registrerar en EF Core databaskontext (ApplicationDbContext).
• Konfigurerar routning för de inbyggda Identity slutpunkterna.
• Innehåller Identity validering och affärslogik.

Om du vill granska Blazor frameworks Identity-komponenter kan du komma åt dem i mapparna Pages och Shared i mappen Account i Blazor Web App-projektmallen (referenskälla).

När du väljer interaktiva webassembly- eller interaktiva autoåtergivningslägen hanterar servern alla autentiserings- och auktoriseringsbegäranden och Identity-komponenterna återges statiskt på servern i Blazor Web Apphuvudprojekt.

Ramverket tillhandahåller en anpassad AuthenticationStateProvider i både server- och klientprojekten (.Client) som överför användarens autentiseringsstatus till webbläsaren. Serverprojektet anropar AddAuthenticationStateSerialization, medan klientprojektet anropar AddAuthenticationStateDeserialization. Om du autentiserar på servern i stället för klienten kan appen komma åt autentiseringstillståndet under förinläsningen och innan .NET WebAssembly-körningen initieras. De anpassade AuthenticationStateProvider-implementeringarna använder tjänsten Persistent Component State (PersistentComponentState) för att serialisera autentiseringstillståndet till HTML-kommentarer och sedan läsa tillbaka det från WebAssembly för att skapa en ny AuthenticationState instans. Mer information finns i avsnittet Hantera autentiseringstillstånd i Blazor Web Apps.

Endast för interaktiva serverlösningar är IdentityRevalidatingAuthenticationStateProvider (referenskälla) en AuthenticationStateProvider på serversidan som omvalidar säkerhetsstämpeln för den anslutna användaren var 30:e minut som en interaktiv krets är ansluten.

När du väljer interaktiva webassembly- eller interaktiva autoåtergivningslägen hanterar servern alla autentiserings- och auktoriseringsbegäranden och Identity-komponenterna återges statiskt på servern i Blazor Web Apphuvudprojekt. Projektmallen innehåller en PersistentAuthenticationStateProvider -klass (referenskälla) i projektet .Client för att synkronisera användarens autentiseringstillstånd mellan servern och webbläsaren. Klassen är en anpassad implementering av AuthenticationStateProvider. Providern använder tjänsten Persistent Component State (PersistentComponentState) för att prerendera autentiseringstillståndet och spara det på sidan.

I huvudprojektet för en Blazor Web Appnamnges autentiseringstillståndsprovidern antingen IdentityRevalidatingAuthenticationStateProvider (referenskälla) (endast serverinteraktivitetslösningar) eller PersistingRevalidatingAuthenticationStateProvider (referenskälla) (webassembly- eller autointeraktivitetslösningar).

Blazor Identity beror på DbContext instanser som inte skapats av en fabrik, vilket är avsiktligt eftersom DbContext räcker för att projektmallens Identity komponenter ska kunna återges statiskt utan stöd för interaktivitet.

En beskrivning av hur globala interaktiva återgivningslägen tillämpas på icke-Identity komponenter samtidigt som statisk SSR tillämpas för de Identity komponenterna finns i ASP.NET Core Blazor återgivningslägen.

Mer information om hur du bevarar förinstallerat tillstånd finns i Prerender ASP.NET Core Razor-komponenter.

Hantera autentiseringstillstånd i Blazor Web Apps

Det här avsnittet gäller för Blazor Web Appsom antar:

• Enskilda konton
• Klientsidesrendering (CSR, WebAssembly-baserad interaktivitet).

En autentiseringstillståndsprovider på klientsidan används endast inom Blazor och är inte integrerad med ASP.NET Core-autentiseringssystemet. Under prerendering respekterar Blazor de metadata som definierats på sidan och använder ASP.NET Core-autentiseringssystemet för att avgöra om användaren autentiseras. När en användare navigerar från en sida till en annan används en autentiseringsprovider på klientsidan. När användaren uppdaterar sidan (fullsidesuppdatering) är autentiseringstillståndsprovidern på klientsidan inte inblandad i autentiseringsbeslutet på servern. Eftersom användarens tillstånd inte bevaras av servern går alla autentiseringstillstånd som underhålls på klientsidan förlorade.

För att åtgärda detta är den bästa metoden att utföra autentisering i ASP.NET Core-autentiseringssystemet. Autentiseringstillståndsprovidern på klientsidan tar bara hand om att återspegla användarens autentiseringstillstånd. Exempel på hur du gör detta med autentiseringstillståndsleverantörer demonstreras i Blazor Web App-projektmallen och beskrivs nedan.

I serverprojektets Program-fil anropar du AddAuthenticationStateSerialization, som serialiserar AuthenticationState som returneras av serversidan AuthenticationStateProvider med hjälp av tjänsten Persistent Component State (PersistentComponentState):

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

API:et serialiserar endast serversidans namn och rollanspråk för åtkomst i webbläsaren. Om du vill inkludera alla anspråk anger du SerializeAllClaims till true i anropet på serversidan till AddAuthenticationStateSerialization:

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

I projektets .Client-fil (Program) anropar du AddAuthenticationStateDeserialization, som lägger till en AuthenticationStateProvider där AuthenticationState deserialiseras från servern med hjälp av AuthenticationStateData och tjänsten Persistent Component State (PersistentComponentState). Det bör finnas ett motsvarande anrop till AddAuthenticationStateSerialization i serverprojektet.

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

• PersistingRevalidatingAuthenticationStateProvider (referenskälla): För Blazor Web Appsom använder interaktiv återgivning på serversidan (interaktiv SSR) och återgivning på klientsidan (CSR). Det här är en AuthenticationStateProvider på serversidan som omvaliderar säkerhetsstämpeln för den anslutna användaren var 30:e minut när en interaktiv session är ansluten. Den använder också tjänsten Persistent Component State för att överföra autentiseringstillståndet till klienten, vilket förblir konstant under CSR-livslängden.

• PersistingServerAuthenticationStateProvider (referenskälla): För Blazor Web Appsom endast använder CSR. Det här är en AuthenticationStateProvider på serversidan som använder tjänsten Persistent Component State för att överföra autentiseringstillståndet till klienten, vilket sedan fastställs för CSR:s livslängd.

• PersistentAuthenticationStateProvider (referenskälla): För Blazor Web Appsom använder CSR. Det här är en AuthenticationStateProvider på klientsidan som avgör användarens autentiseringstillstånd genom att söka efter data som sparats på sidan när de renderades på servern. Det här autentiseringstillståndet är fastställt för hela CSR:s livslängd. Om användaren behöver logga in eller ut krävs en fullsidesinläsning. Detta ger endast ett användarnamn och e-postmeddelande i visningssyfte. Det innehåller inte token som autentiserar till servern när efterföljande begäranden görs; processen hanteras separat med hjälp av en cookie som ingår i HttpClient-begäranden till servern.

Ställning Identity

Mer information om hur du scaffoldar Identity i en serverbaserad Blazor-app finns i Scaffold Identity i ASP.NET Core-projekt.

Scaffold Identity till en Blazor app på serversidan:

• Utan befintlig auktorisering.
• Med auktorisering.

I filen Program:

builder.Services.AddScoped<ExampleService>();

I Startup.ConfigureServices av 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);
    }
}

• Inaktivera prerendering: Ange återgivningsläget med parametern prerender inställd på false på den högsta komponenten i appens komponenthierarki som inte är en rotkomponent.

  Notera

  Det går inte att göra en rotkomponent interaktiv, till exempel komponenten App. Därför kan prerendering inte inaktiveras direkt av komponenten App.

  För appar som baseras på Blazor Web App-projektmallen inaktiveras prerendering vanligtvis där komponenten Routes används i komponenten App (Components/App.razor) :

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

  Inaktivera även prerendering för den HeadOutlet komponenten:

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

  Du kan också selektivt styra återgivningsläget som tillämpas på den Routes komponentinstansen. För exempel, se ASP.NET Core Blazor återgivningslägen.

• Inaktivera prerendering: Öppna filen _Host.cshtml och ändra attributet render-mode för -komponenttag-helpern till Server:

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

Giltighetsperiod för tillfällig omdirigerings-URL

Det här avsnittet gäller för Blazor Web Apps.

Använd alternativet RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration för att hämta eller ange giltighetstiden för ASP.NET Core Data Protection för tillfälliga omdirigerings-URL:er som genereras av server-side rendering Blazor. Dessa används endast tillfälligt, så livslängden behöver bara vara tillräckligt lång för att en klient ska kunna ta emot URL:en och börja navigera till den. Det bör dock också vara tillräckligt länge för att tillåta klocksnedvridning mellan servrar. Standardvärdet är fem minuter.

I följande exempel utökas värdet till sju minuter:

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

AuthenticationStateProvider är den underliggande tjänsten som används av AuthorizeView-komponenten och sammanhängande autentiseringstjänster för att hämta autentiseringstillståndet för en användare.

AuthenticationStateProvider är den underliggande tjänsten som används av komponenten AuthorizeView och CascadingAuthenticationState komponent för att hämta autentiseringstillståndet för en användare.

@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.";
        }
    }
}

I föregående exempel:

• ClaimsPrincipal.Claims returnerar användarens anspråk (claims) för visning i användargränssnittet.
• Raden som hämtar användarens efternamn (surname) anropar ClaimsPrincipal.FindAll med ett predikat för att filtrera användarens anspråk.

@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.";
            }
        }
    }
}

Konfigurera den Task<AuthenticationState>kaskaderande parametern med tjänsterna AuthorizeRouteView och kaskaderande autentiseringstillstånd.

När du skapar en Blazor app från någon av de Blazor projektmallarna med autentisering aktiverat, innehåller appen AuthorizeRouteView och anropet till AddCascadingAuthenticationState som visas i följande exempel. En Blazor app på klientsidan innehåller även de tjänstregistreringar som krävs. Ytterligare information presenteras i avsnittet Anpassa obehörigt innehåll med komponenten Router.

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

I filen Program registrerar du sammanhängande autentiseringstillståndstjänster:

builder.Services.AddCascadingAuthenticationState();

Konfigurera den Task<AuthenticationState>sammanhängande parametern med hjälp av komponenterna AuthorizeRouteView och CascadingAuthenticationState.

När du skapar en Blazor app från en av Blazor projektmallar med autentisering aktiverat innehåller appen de AuthorizeRouteView- och CascadingAuthenticationState komponenter som visas i följande exempel. En Blazor app på klientsidan innehåller även de tjänstregistreringar som krävs. Ytterligare information presenteras i avsnittet Anpassa obehörigt innehåll med komponenten Router.

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

Lägg till auktoriseringstjänster i Blazor-filen i en Program-app på klientsidan:

builder.Services.AddAuthorizationCore();

Lägg till alternativ och auktoriseringstjänster i Blazor-filen i en Program-app på klientsidan:

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

Razor-komponenter i Blazor Web Apps visar aldrig <NotAuthorized>-innehåll när auktoriseringen misslyckas på serversidan under statisk SSR. Serversidan ASP.NET Core-pipelinen bearbetar auktorisering på servern. Använd tekniker på serversidan för att hantera obehöriga begäranden. För mer information, se ASP.NET Core Blazor återgivningslägen.

Resursauktorisering

Om du vill auktorisera användare för resurser skickar du begärans routningsdata till parametern Resource för AuthorizeRouteView.

I innehållet för Router.Found för en begärd rutt:

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

Mer information om hur auktoriseringstillståndsdata skickas och används i procedurlogik finns i avsnittet Exponera autentiseringstillståndet som en sammanhängande parameter.

När AuthorizeRouteView tar emot routningsdata för resursen har auktoriseringsprinciper åtkomst till RouteData.PageType och RouteData.RouteValues som tillåter att anpassad logik fattar auktoriseringsbeslut.

I följande exempel skapas en EditUser princip i AuthorizationOptions för appens konfiguration av auktoriseringstjänsten (AddAuthorizationCore) med följande logik:

• Kontrollera om det finns ett routningsvärde med nyckeln id. Om nyckeln finns lagras vägvärdet i value.
• I en variabel med namnet idlagrar du value som en sträng eller anger ett tomt strängvärde (string.Empty).
• Om id inte är en tom sträng, kontrollera att principen är uppfylld (returnera true) om strängens värde börjar med EMP. Annars ska du slå fast att policyn misslyckas (returnera false).

I filen Program:

• Lägg till namnområden för Microsoft.AspNetCore.Components och System.Linq:

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

• Lägg till principen:

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

Föregående exempel är en översimplifierad auktoriseringsprincip som bara används för att demonstrera konceptet med ett fungerande exempel. Mer information om hur du skapar och konfigurerar auktoriseringsprinciper finns i Principbaserad auktorisering i ASP.NET Core.

I följande EditUser komponent har resursen på /users/{id}/edit en vägparameter för användarens identifierare ({id}). Komponenten använder föregående EditUser auktoriseringsprincip för att avgöra om vägvärdet för id börjar med EMP. Om id börjar med EMPlyckas principen och åtkomsten till komponenten är auktoriserad. Om id börjar med ett annat värde än EMP eller om id är en tom sträng misslyckas principen och komponenten läses inte in.

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>

Innehållet i Authorized och NotAuthorized kan innehålla godtyckliga objekt, till exempel andra interaktiva komponenter.

builder.Services.AddCascadingAuthenticationState();

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

Innehållet i NotFound, Authorizedoch NotAuthorized kan innehålla godtyckliga objekt, till exempel andra interaktiva komponenter.

@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)
                {
                    // ...
                }
            }
        }
    }
}

• Resurser för serversidan och Blazor Web App
  • Snabbstart: Lägga till inloggning med Microsoft i en ASP.NET Core-webbapp
  • snabbstart: Skydda ett ASP.NET Core-webb-API med Microsoft identity plattform
  • Konfigurera ASP.NET Core att fungera med proxyservrar och lastbalanserare: Innehåller vägledning om:
    • Använda vidarebefordrade huvudmellanprogram för att bevara HTTPS-schemainformation över proxyservrar och interna nätverk.
    • Ytterligare scenarier och användningsfall, inklusive manuell schemakonfiguration, begärandesökvägsändringar för korrekt routning av begäranden och vidarebefordran av begärandeschemat för Linux och icke-IIS omvända proxyservrar.
• Dokumentation om Microsoft identity-plattformen
  • Översikt
  • OAuth 2.0- och OpenID Connect-protokoll på Microsoft identity-plattformen
  • Microsoft identity-plattformen och OAuth 2.0-auktoriseringskodflödet
  • Microsoft identity plattforms-ID-token
  • Åtkomsttoken för Microsoft identity-plattformen
• ASP.NET Core-säkerhetsavsnitt
• Konfigurera Windows-autentisering i ASP.NET Core
• Skapa en anpassad version av JavaScript-biblioteket Authentication.MSAL
• Awesome Blazor: Exempellänkar för autentisering community
• ASP.NET Core Blazor Hybrid-autentisering och auktorisering

• Resurser på serversidan Blazor
  • Snabbstart: Lägga till inloggning med Microsoft i en ASP.NET Core-webbapp
  • snabbstart: Skydda ett ASP.NET Core-webb-API med Microsoft identity plattform
  • Konfigurera ASP.NET Core att fungera med proxyservrar och lastbalanserare: Innehåller vägledning om:
    • Använda vidarebefordrade huvudmellanprogram för att bevara HTTPS-schemainformation över proxyservrar och interna nätverk.
    • Ytterligare scenarier och användningsfall, inklusive manuell schemakonfiguration, begärandesökvägsändringar för korrekt routning av begäranden och vidarebefordran av begärandeschemat för Linux och icke-IIS omvända proxyservrar.
• Dokumentation om Microsoft identity-plattformen
  • Översikt
  • OAuth 2.0- och OpenID Connect-protokoll på Microsoft identity-plattformen
  • Microsoft identity-plattformen och OAuth 2.0-auktoriseringskodflödet
  • Microsoft identity plattforms-ID-token
  • Åtkomsttoken för Microsoft identity-plattformen
• ASP.NET Core-säkerhetsavsnitt
• Konfigurera Windows-autentisering i ASP.NET Core
• Skapa en anpassad version av JavaScript-biblioteket Authentication.MSAL
• Awesome Blazor: Exempellänkar för autentisering community