ASP.NET Core Blazor hitelesítése és engedélyezése

Ha az engedélyezési szabály érvényesítését garantálni kell, ne hajtsa végre az engedélyezési ellenőrzéseket az ügyféloldali kódban. Hozzon létre egy Blazor Web App, amely csak a kiszolgálóoldali renderelésre (SSR) támaszkodik az engedélyezési ellenőrzésekhez és a szabályérvényesítéshez.

Ha az engedélyezési szabályok betartatását, valamint az adatok és kódok biztonságát garantálni kell, ne dolgozzon ki ügyféloldali alkalmazást. Blazor Server-alkalmazás létrehozása.

ASP.NET Core Identity a HTTP kérés- és válaszkommunikáció kontextusában működik, amely általában nem az Blazor alkalmazás ügyfél-kiszolgáló kommunikációs modellje. ASP.NET Core alkalmazások, amelyek az ASP.NET Core Identity-t használják felhasználókezeléshez, a Razor-hoz kapcsolódó felhasználói felülethez használjanak Razor lapokat a Identity összetevők helyett, például a felhasználói regisztráció, bejelentkezés, kijelentkezés és egyéb felhasználókezelési feladatok esetén. A Razor feladatokat közvetlenül kezelő Identity összetevők létrehozása több forgatókönyv esetében is lehetséges, de a Microsoft nem javasolja vagy támogatja.

ASP.NET alapvető absztrakciók, például SignInManager<TUser> és UserManager<TUser>nem támogatottak Razor összetevőkben. Az ASP.NET Core IdentityBlazorhasználatával kapcsolatos további információkért lásd: Scaffold ASP.NET Core Identity kiszolgálóoldali Blazor alkalmazásba.

Hamisítás elleni támogatás

A Blazor sablon:

• Az antiforgery szolgáltatásokat automatikusan hozzáadja, amikor a AddRazorComponents meg van hívva a Program fájlban.
• Hozzáadja az Antiforgery Middleware-t úgy, hogy meghívja UseAntiforgery a kérésfeldolgozó folyamatában a Program fájlban, és végponti antiforgery védelmi igényel a helyek közötti kérelemhamisítás (CSRF/XSRF) veszélyeinek enyhítéséhez. UseAntiforgery UseHttpsRedirectionután kerül meghívásra. A UseAntiforgery hívását a UseAuthentication és UseAuthorizationhívása után kell kezdeményezni, amennyiben azok megtörténtek.

A AntiforgeryToken összetevő rejtett mezőként jeleníti meg az antiforgery tokent, és ezt az összetevőt automatikusan hozzáadják a form (EditForm) példányaihoz. További információért lásd: ASP.NET Core Blazor űrlapok áttekintése.

A AntiforgeryStateProvider szolgáltatás hozzáférést biztosít az aktuális munkamenethez társított antiforgery tokenhez. Injektálja a szolgáltatást, és hívja meg a GetAntiforgeryToken() metódust az aktuális AntiforgeryRequestTokenmegszerzéséhez. További információ: Webes API meghívása egy ASP.NET Core Blazor-alkalmazásból.

Blazor a kéréstokeneket az összetevő állapotban tárolja, ami garantálja, hogy a hamisítás elleni tokenek elérhetők legyenek az interaktív összetevők számára, még akkor is, ha nincs hozzáférésük a kéréshez.

További információ:

• Helyek közötti hamisítás (XSRF/CSRF) támadások megakadályozása ASP.NET Core: Ez a cikk az elsődleges ASP.NET Core-cikk, amely a kiszolgálóoldali Blazor Server, a Blazor Web Apps kiszolgálóprojektje és Blazor MVC/Razor Pages-integrációra vonatkozik.
• ASP.NET Alapvető Blazor űrlapok áttekintése: A cikk Antiforgery támogatási szakasza Blazor űrlapok antiforgery támogatására vonatkozik.

Blazor Identity felhasználói felület (egyéni fiókok)

Blazor támogatja a teljes Blazoralapú Identity felhasználói felület létrehozását, amikor a egyéni fiókokhitelesítési lehetőséget választja.

A Blazor Web App sablon egy SQL Server-adatbázis Identity kódját tartalmazza. A parancssori verzió SQLite-t használ, és tartalmaz egy SQLite-adatbázist a(z) Identityszámára.

A sablon:

• Támogatja az interaktív kiszolgálóoldali renderelést (interaktív SSR) és ügyféloldali renderelési (CSR) forgatókönyveket hitelesített felhasználókkal.
• Hozzáadja IdentityRazor összetevőket és a kapcsolódó logikát a rutinhitelesítési feladatokhoz, például a felhasználók be- és kijelentkeztetéséhez. A Identity összetevők olyan speciális Identity funkciókat is támogatnak, mint például a fiók megerősítése és a jelszó-helyreállítási, valamint többtényezős hitelesítés külső alkalmazással. Vegye figyelembe, hogy maguk a Identity összetevők nem támogatják az interaktivitást.
• Hozzáadja a Identitykapcsolódó csomagokat és függőségeket.
• A Identity_Imports.razor csomagjaira hivatkozik.
• Létrehoz egy egyéni felhasználói Identity osztályt (ApplicationUser).
• Létrehoz és regisztrál egy EF Core adatbázis-környezetet (ApplicationDbContext).
• A beépített Identity végpontok útválasztását konfigurálja.
• Identity érvényesítési és üzleti logikát tartalmaz.

A keretrendszer összetevőinek vizsgálatához a projektsablon (referenciaforrás) mappájának és mappájában érheti el őket.

Amikor az Interaktív WebAssembly vagy az Interaktív automatikus renderelési módot választja, a kiszolgáló kezeli az összes hitelesítési és engedélyezési kérést, és a Identity összetevők statikusan jelennek meg a kiszolgálón a Blazor Web Appfő projektjében.

A keretrendszer egy egyéni AuthenticationStateProvider-t biztosít mind a kiszolgáló-, mind az ügyfélprojektekben (.Client), hogy továbbítja a felhasználó hitelesítési állapotát a böngészőbe. A kiszolgálóprojekt meghívja AddAuthenticationStateSerialization, míg az ügyfélprojekt AddAuthenticationStateDeserialization. Az ügyfél helyett a kiszolgálón történő hitelesítés lehetővé teszi az alkalmazás számára a hitelesítési állapot elérését az előrendelés során és a .NET WebAssembly futtatókörnyezet inicializálása előtt. Az egyéni AuthenticationStateProvider-implementációk az Állandó összetevő állapota szolgáltatás (PersistentComponentState) használatával szerializálják a hitelesítési állapotot HTML-megjegyzésekbe, majd a WebAssemblyből olvassák vissza egy új AuthenticationState-példány létrehozásához. További információ: Hitelesítési állapot kezelése Blazor Web App szakaszában.

Csak interaktív kiszolgálói megoldások esetén IdentityRevalidatingAuthenticationStateProvider (referenciaforrás) egy kiszolgálóoldali AuthenticationStateProvider, amely 30 percenként újraellenőrzi a csatlakoztatott felhasználó biztonsági pecsétjét, amikor egy interaktív kapcsolat van létrehozva.

Amikor az Interaktív WebAssembly vagy az Interaktív automatikus renderelési módot választja, a kiszolgáló kezeli az összes hitelesítési és engedélyezési kérést, és a Identity összetevők statikusan jelennek meg a kiszolgálón a Blazor Web Appfő projektjében. A projektsablon tartalmaz egy PersistentAuthenticationStateProvider osztályt (referenciaforrást) a .Client projektben a felhasználó hitelesítési állapotának szinkronizálásához a kiszolgáló és a böngésző között. Az osztály a AuthenticationStateProvideregyéni implementációja. A szolgáltató az Állandó összetevő állapota szolgáltatás (PersistentComponentState) használatával előrerendeli a hitelesítési állapotot, és megőrzi azt a lapon.

Egy Blazor Web Appfő projektjében a hitelesítési állapotszolgáltató neve IdentityRevalidatingAuthenticationStateProvider (referenciaforrás) (csak kiszolgáló interaktivitási megoldásai) vagy PersistingRevalidatingAuthenticationStateProvider (referenciaforrás) (WebAssembly vagy Automatikus interaktivitási megoldások).

az olyan példányoktól függ, amelyek nem a(z)gyártó által lettek létrehozva, ami szándékos, mert elegendő ahhoz, hogy a projektsablon összetevői statikusan, interaktivitás támogatása nélkül renderelődjenek.

A globális interaktív renderelési módok nemIdentity összetevőkre való alkalmazásáról, valamint a statikus SSR kényszerítéséről az Identity-összetevőkhöz, lásd ASP.NET Core Blazor renderelési módokat.

Az előrerendelt állapot megőrzéséről további információt Prerender ASP.NET Core Razor-összetevőkcímű cikkben talál.

Hitelesítési állapot kezelése Blazor Web Apps-ben

Ez a szakasz a következő Blazor Web App-re vonatkozik:

• Egyéni fiókok
• ügyféloldali renderelés (CSR, WebAssembly-alapú interaktivitás).

Az ügyféloldali hitelesítési állapotszolgáltató csak a Blazor belül használható, és nem integrálva van a ASP.NET Core hitelesítési rendszerrel. Az előrendelés során Blazor tiszteletben tartja a lapon definiált metaadatokat, és a ASP.NET Core hitelesítési rendszer használatával állapítja meg, hogy a felhasználó hitelesítése megtörtént-e. Amikor egy felhasználó egyik oldalról a másikra navigál, a rendszer ügyféloldali hitelesítésszolgáltatót használ. Amikor a felhasználó frissíti a lapot (teljes oldal újrabetöltése), az ügyféloldali hitelesítési állapotszolgáltató nem vesz részt a kiszolgáló hitelesítési döntésében. Mivel a kiszolgáló nem őrzi meg a felhasználó állapotát, az ügyféloldalon tárolt hitelesítési állapot elveszik.

Ennek megoldásához a legjobb módszer a hitelesítés végrehajtása a ASP.NET Core hitelesítési rendszeren belül. Az ügyféloldali hitelesítési állapotszolgáltató csak a felhasználó hitelesítési állapotát tükrözi. A hitelesítési állapotszolgáltatókkal való végrehajtására vonatkozó példákat a Blazor Web App projektsablon szemlélteti, és az alábbiakban ismertetjük.

A kiszolgálóprojekt Program fájljában hívja meg a AddAuthenticationStateSerialization-t, amely szerializálja a kiszolgálóoldali AuthenticationState által visszaadott AuthenticationStateProvider-t az Állandó Összetevő Állapota szolgáltatás (PersistentComponentState) segítségével:

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

Az API csak a kiszolgálóoldali nevet és a szerepkör-jogcímeket szerializálja a böngészőben való hozzáféréshez. Az összes jogcím belefoglalásához állítsa SerializeAllClaims értékét true-re a AddAuthenticationStateSerializationkiszolgálóoldali hívásában.

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

Az ügyfél (.Client) projektjének Program fájljában hívja meg a AddAuthenticationStateDeserialization-t, amely hozzáad egy AuthenticationStateProvider-at, ahol a AuthenticationState deszerializálódik a szerverről a AuthenticationStateData használatával és a Komponens Állapot Szolgáltatással (PersistentComponentState). A kiszolgálóprojektben megfelelő hívás van AddAuthenticationStateSerialization-ra.

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

• PersistingRevalidatingAuthenticationStateProvider (referenciaforrás): Az interaktív kiszolgálóoldali renderelést (interaktív SSR) és ügyféloldali renderelést (CSR) alkalmazó Blazor Web Appesetében. Ez egy szerveroldali AuthenticationStateProvider, amely 30 percenként újraellenőrzi a csatlakoztatott felhasználó biztonsági pecsétjét, amikor egy interaktív áramkör csatlakoztatva van. Emellett az Állandó összetevő állapota szolgáltatás használatával továbbítja a hitelesítési állapotot az ügyfélhez, amely aztán a CSR élettartama alatt rögzített marad.

• PersistingServerAuthenticationStateProvider (referenciaforrás): Olyan Blazor Web Appesetében, amelyek csak CSR-t fogadnak el. Ez egy szerveroldali AuthenticationStateProvider, amely az Állandó összetevő állapot szolgáltatás-t használja a hitelesítési állapot átadására az ügyfélnek, és amelyet a CSR élettartama alatt rögzítenek.

• PersistentAuthenticationStateProvider (referenciaforrás): CSR-t alkalmazó Blazor Web Appesetén. Ez egy ügyféloldali AuthenticationStateProvider, amely meghatározza a felhasználó hitelesítési állapotát úgy, hogy a kiszolgálón való megjelenítéskor a lapon tárolt adatokat keresi. Ez a hitelesítési állapot a CSR élettartamára van rögzítve. Ha a felhasználónak be kell jelentkeznie vagy ki kell jelentkeznie, teljes oldalú újrabetöltésre van szükség. Ez csak megjelenítendő felhasználónevet és e-mail-címet biztosít. Nem tartalmaz olyan tokeneket, amelyek a kiszolgálóhoz történő hitelesítésre szolgálnak a későbbi kérésekhez; ezeket külön kezelik, amikor a cookie részeként benne foglaltatnak a szervernek címzett HttpClient kérésekben.

Állványzat Identity

További információért arról, hogyan alapozható meg a Identity egy kiszolgálóoldali Blazor alkalmazásban, lásd: Állománygenerálás az ASP.NET Core-projektekben Identity.

Állványzat Identity kiszolgálóoldali Blazor alkalmazásba:

• Meglévő engedélynélkül.
• Engedéllyel.

A Program fájlban:

builder.Services.AddScoped<ExampleService>();

A(z) Startup.ConfigureServicesStartup.cs-ben:

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

• A renderelés előzetes letiltása: A renderelési módot a prerender paraméter false-re állításával jelezze az alkalmazás összetevőhierarchiájának legfelső szintű összetevőjénél, amely nem gyökérösszetevő.

  Jegyzet

  A gyökérösszetevő interaktívvá tétele, például a App összetevő nem támogatott. Ezért a App összetevő nem tilthatja le közvetlenül az előzetes rendezést.

  A Blazor Web App projektsablonon alapuló alkalmazások esetében az előrendelés általában le van tiltva, ha a Routes összetevőt a App összetevőben (Components/App.razor) használják:

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

  Emellett tiltsa le az előbetöltést a HeadOutlet összetevőnél:

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

  A Routes összetevőpéldányra alkalmazott renderelési módot is szelektíven szabályozhatja. Lásd például ASP.NET Core Blazor renderelési módokat.

• A prerendelés letiltása: Nyissa meg a _Host.cshtml fájlt, és módosítsa a render-mode attribútumát Server-re:

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

Ideiglenes átirányítási URL-cím érvényességi időtartama

Ez a szakasz Blazor Web Apps.

A RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration opció segítségével lekérheti vagy beállíthatja az ASP.NET Core Data Protection érvényességi időtartamát a Blazor kiszolgálóoldali renderelés által kibocsátott ideiglenes átirányító URL-címekhez. Ezeket csak átmenetien használják, így az élettartamnak csak elég hosszúnak kell lennie ahhoz, hogy egy ügyfél megkapja az URL-címet, és navigálást kezdjen rajta. Azonban elég hosszúnak kell lennie ahhoz is, hogy az óraeltérés engedélyezhető legyen a kiszolgálók között. Az alapértelmezett érték öt perc.

Az alábbi példában az érték hét percre van kiterjesztve:

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

AuthenticationStateProvider a AuthorizeView összetevő és a kaszkádolt hitelesítési szolgáltatások által a felhasználó hitelesítési állapotának lekéréséhez használt mögöttes szolgáltatás.

AuthenticationStateProvider az AuthorizeView összetevő és CascadingAuthenticationState összetevő által a felhasználó hitelesítési állapotának lekéréséhez használt mögöttes szolgáltatás.

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

Az előző példában:

• ClaimsPrincipal.Claims visszaadja a felhasználó igényeit (claims) a felhasználói felületen való megjelenítés céljából.
• A felhasználó vezetéknevét (surname) beolvasó sor meghívja a ClaimsPrincipal.FindAll-et egy predikátum használatával a felhasználó követeléseinek szűrésére.

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

Állítsa be a Task<AuthenticationState>kaszkádolt paramétert a AuthorizeRouteView és a kaszkádolt hitelesítési állapotszolgáltatások használatával.

Amikor egy Blazor alkalmazást hoz létre az egyik Blazor-projektsablonból, ahol a hitelesítés engedélyezve van, az alkalmazás az alábbi példában bemutatott AuthorizeRouteView-t és AddCascadingAuthenticationState hívását tartalmazza. Az ügyféloldali Blazor-alkalmazások tartalmazzák a szükséges szolgáltatásregisztrációkat is. További információt a Jogosulatlan tartalom testreszabása a Router összetevő szakaszában talál.

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

A Program fájlban regisztrálja a kaszkádolt hitelesítési állapotszolgáltatásokat:

builder.Services.AddCascadingAuthenticationState();

Állítsa be a Task<AuthenticationState>kaszkádolt paramétert a AuthorizeRouteView és CascadingAuthenticationState összetevők használatával.

Amikor Blazor alkalmazást hoz létre az egyik Blazor projektsablonból, amelyen engedélyezve van a hitelesítés, az alkalmazás tartalmazza az alábbi példában látható AuthorizeRouteView és CascadingAuthenticationState összetevőket. Az ügyféloldali Blazor-alkalmazások tartalmazzák a szükséges szolgáltatásregisztrációkat is. További információt a Jogosulatlan tartalom testreszabása a Router összetevő szakaszában talál.

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

Ügyféloldali Blazor alkalmazásban adja hozzá az engedélyezési szolgáltatásokat a Program fájlhoz:

builder.Services.AddAuthorizationCore();

Ügyféloldali Blazor alkalmazásban adja hozzá a beállításokat és az engedélyezési szolgáltatásokat a Program fájlhoz:

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

Razor Blazor Web Appösszetevői soha nem jelenítik meg <NotAuthorized> tartalmat, ha az engedélyezés kiszolgálóoldalon meghiúsul a statikus kiszolgálóoldali renderelés (statikus SSR) során. A kiszolgálóoldali ASP.NET Core-folyamat a kiszolgálón dolgozza fel az engedélyezést. Használjon kiszolgálóoldali technikákat a jogosulatlan kérések kezeléséhez. További információ: ASP.NET Core Blazor renderelési módok.

Erőforrás-engedélyezés

Ha engedélyezni szeretné a felhasználók számára az erőforrásokat, adja át a kérés útvonaladatait a ResourceAuthorizeRouteView paraméterének.

A kért útvonal Router.Found tartalma:

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

Az engedélyezési állapot adatainak átadásáról és a folyamatlogikában való használatáról a A hitelesítési állapot kaszkádolt paraméterként való felfedése szakaszban talál további információt.

Amikor a AuthorizeRouteView megkapja az erőforrás útvonaladatait, az autorizációs szabályzatok hozzáférhetnek RouteData.PageType-hez és RouteData.RouteValues-höz, ami lehetővé teszi az egyéni logika számára az engedélyezési döntések meghozatalát.

Az alábbi példában egy EditUser szabályzatot hoznak létre AuthorizationOptions az alkalmazás engedélyezési szolgáltatásának konfigurációjához (AddAuthorizationCore) a következő logikával:

• Állapítsa meg, hogy létezik-e útvonalérték idkulccsal. Ha a kulcs létezik, az útvonalnak az értékét a valuetárolja.
• Egy idnevű változóban tárolja a value sztringként, vagy állítson be egy üres sztringértéket (string.Empty).
• Ha id nem üres karakterlánc, győződjünk meg arról, hogy a szabályzat teljesül, ha a karakterlánc értéke true-vel kezdődik (EMPvisszaadása). Ellenkező esetben érvényesítse, hogy a szabályzat meghiúsul (falsevisszaadása).

A Program fájlban:

• Adja hozzá a névtereket: Microsoft.AspNetCore.Components és System.Linq.

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

• Adja hozzá a szabályzatot:

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

Az előző példa egy túlsimított engedélyezési szabályzat, amely csupán egy működő példával szemlélteti a koncepciót. Az engedélyezési szabályzatok létrehozásával és konfigurálásával kapcsolatos további információkért lásd szabályzatalapú engedélyezést ASP.NET Core.

Az alábbi EditUser összetevőben az erőforrás /users/{id}/edit rendelkezik egy útvonalparaméterrel a felhasználó azonosítójára ({id}). Az összetevő az előzetes EditUser engedélyezési szabályzattal határozza meg, ha a id útvonalértéke a EMP-vel kezdődik. Ha idEMPkezdődik, a szabályzat sikeres lesz, és az összetevőhöz való hozzáférés engedélyezve van. Ha id nem EMP értékkel kezdődik, vagy ha id üres sztring, a szabályzat meghiúsul, és az összetevő nem töltődik be.

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>

A Authorized és NotAuthorized tartalma tetszőleges elemeket tartalmazhat, például más interaktív összetevőket.

builder.Services.AddCascadingAuthenticationState();

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

A NotFound, Authorizedés NotAuthorized tartalma tetszőleges elemeket tartalmazhat, például más interaktív összetevőket.

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

• Kiszolgálóoldali és Blazor Web App-erőforrások
  • Rövid útmutató: Bejelentkezés hozzáadása Microsoft-fiókkal egy ASP.NET Core-webalkalmazáshoz
  • Gyors kezdés: ASP.NET Core webes API védelme a Microsoft identitásplatformmal
  • ASP.NET Core konfigurálása proxykiszolgálókkal és terheléselosztókkal való együttműködésre: Útmutatást tartalmaz a következőhöz:
    • A Továbbított fejlécek köztes szoftver használata a HTTPS-séma információinak megőrzéséhez proxykiszolgálókon és belső hálózatokon.
    • További forgatókönyvek és használati esetek, beleértve a manuális sémakonfigurációt, a kérelem útvonalának változásait a megfelelő kérés-útválasztáshoz, valamint a kérelemséma továbbítása Linux és nem IIS fordított proxyk esetében.
• A Microsoft identitásplatform dokumentációja
  • Áttekintés
  • OAuth 2.0 és OpenID Connect protokollokat a Microsoft identitásplatformján
  • Microsoft identity platform és az OAuth 2.0 engedélyezési kódfolyamat
  • Microsoft identitásplatform ID-tokenjei
  • Microsoft identitásplatform hozzáférési jogkivonatai
• ASP.NET alapvető biztonsági témakörök
• Windows-hitelesítés konfigurálása ASP.NET Core
• IHttpContextAccessor/HttpContext ASP.NET Core Blazor-alkalmazásokban
• Authentication.MSAL JavaScript-kódtár egyéni verziójának létrehozása
• Nagyszerű Blazor: Hitelesítési közösségi mintalinkek
• ASP.NET Core Blazor Hybrid hitelesítési és engedélyezési

• Kiszolgálóoldali Blazor erőforrások
  • Rövid útmutató: Bejelentkezés hozzáadása Microsoft-fiókkal egy ASP.NET Core-webalkalmazáshoz
  • Gyors kezdés: ASP.NET Core webes API védelme a Microsoft identitásplatformmal
  • ASP.NET Core konfigurálása proxykiszolgálókkal és terheléselosztókkal való együttműködésre: Útmutatást tartalmaz a következőhöz:
    • A Továbbított fejlécek köztes szoftver használata a HTTPS-séma információinak megőrzéséhez proxykiszolgálókon és belső hálózatokon.
    • További forgatókönyvek és használati esetek, beleértve a manuális sémakonfigurációt, a kérelem útvonalának változásait a megfelelő kérés-útválasztáshoz, valamint a kérelemséma továbbítása Linux és nem IIS fordított proxyk esetében.
• A Microsoft identitásplatform dokumentációja
  • Áttekintés
  • OAuth 2.0 és OpenID Connect protokollokat a Microsoft identitásplatformján
  • Microsoft identity platform és az OAuth 2.0 engedélyezési kódfolyamat
  • Microsoft identitásplatform ID-tokenjei
  • Microsoft identitásplatform hozzáférési jogkivonatai
• ASP.NET alapvető biztonsági témakörök
• IHttpContextAccessor/HttpContext ASP.NET Core Blazor-alkalmazásokban
• Windows-hitelesítés konfigurálása ASP.NET Core
• Authentication.MSAL JavaScript-kódtár egyéni verziójának létrehozása
• Nagyszerű Blazor: Hitelesítési közösségi mintalinkek