Üzemeltetett ASP.NET Core Blazor WebAssembly-alkalmazás védelme Identity Serverrel

Important

Az üzemeltetett Blazor WebAssembly projektsablon a .NET 8 kiadásával (2023. november) el lett távolítva a keretrendszerből. A cikkben szereplő útmutatás csak a .NET 7-hez vagy korábbi verziókhoz támogatott. Az egyes kiadásokra frissített üzemeltetett Blazor WebAssembly alkalmazások továbbra is terméktámogatást kapnak. Másik lehetőségként alakítsa át az alkalmazást önálló Blazor WebAssembly alkalmazássá vagy egy Blazor Web App-es alkalmazássá.

Ez a cikk bemutatja, hogyan hozhat létre egy üzemeltetett Blazor WebAssembly megoldás, amely Duende Identity Server használatával hitelesíti a felhasználókat és az API-hívásokat.

Important

Lehetséges, hogy a Duende Software licencdíjat kér a Duende Identity Server éles használatáért. További információ: Migrálás ASP.NET Core-ból .NET 5-ről .NET 6-ra.

Note

Ha önálló vagy üzemeltetett Blazor WebAssembly-alkalmazást szeretne konfigurálni egy meglévő, külső Identity-kiszolgálópéldány használatára, kövesse az Az ASP.NET Core Blazor WebAssembly önálló alkalmazás biztonságossá tétele a Hitelesítési kódtárcímű témakörben található útmutatást.

A cikk elolvasása után további biztonsági forgatókönyvekkel kapcsolatban lásd ASP.NET Core Blazor WebAssembly további biztonsági forgatókönyveket.

Walkthrough

Az útmutató alszakaszai az alábbiakat ismertetik:

Az Blazor alkalmazás létrehozása
Az alkalmazás futtatása

Új Blazor WebAssembly projekt létrehozása hitelesítési mechanizmussal:

Hozzon létre egy új projektet.
Válassza ki az Blazor WebAssembly alkalmazás sablont. Válassza a Következőlehetőséget.
Adjon meg egy projektnevet kötőjelek használata nélkül. Győződjön meg arról, hogy a hely helyes. Válassza a Következőlehetőséget.

Kerülje a kötőjelek (-) használatát a projekt nevében, amely megszakítja az OIDC-alkalmazásazonosító létrehozását. A Blazor WebAssembly projektsablon logikája egy OIDC-alkalmazásazonosító projektnevét használja a megoldás konfigurációjában, és a kötőjelek nem engedélyezettek az OIDC-alkalmazásazonosítóban. A Pascal-eset (BlazorSample) vagy aláhúzás (Blazor_Sample) elfogadható alternatívát jelentenek.
A További információk párbeszédpanelen válassza Egyéni fiókokHitelesítési típus lehetőséget a felhasználók ASP.NET Core Identity rendszerével való tárolásához.
Jelölje be a ASP.NET Core Hosted jelölőnégyzetet.
Válassza a létrehozása gombot az alkalmazás létrehozásához.

Ha új Blazor WebAssembly projektet szeretne létrehozni egy üres mappában lévő hitelesítési mechanizmussal, adja meg a Individual hitelesítési mechanizmust az -au|--auth beállítással, amellyel a felhasználókat az alkalmazáson belül tárolhatja ASP.NET Core Identity rendszerével:

dotnet new blazorwasm -au Individual -ho -o {PROJECT NAME}

Placeholder	Example
`{PROJECT NAME}`	`BlazorSample`

Az opcionális -o|--output beállítással megadott kimeneti hely létrehoz egy projektmappát, ha az nem létezik, és a projekt nevének részévé válik.

Kerülje a kötőjelek (-) használatát a projekt nevében, amely megszakítja az OIDC-alkalmazásazonosító létrehozását. A Blazor WebAssembly projektsablon logikája egy OIDC-alkalmazásazonosító projektnevét használja a megoldás konfigurációjában, és a kötőjelek nem engedélyezettek az OIDC-alkalmazásazonosítóban. A Pascal-eset (BlazorSample) vagy aláhúzás (Blazor_Sample) elfogadható alternatívát jelentenek.

További információkért tekintse meg a dotnet new parancsot a .NET-útmutatóban.

Az alkalmazás futtatása

Futtassa az alkalmazást a Server projekt keretében. A Visual Studio használata esetén az alábbi lehetőségek közül választhat:

Válassza ki a legördülő nyilat a Futtatás gomb mellett. Nyissa meg Indítási projektek konfigurálása legördülő listából. Válassza az Egyszeri indítású projekt lehetőséget. Erősítse meg vagy módosítsa az indítási projektet az Server projektre.
Győződjön meg arról, hogy a Server projekt ki van emelve a Solution Explorerben, mielőtt elindítja az alkalmazást az alábbi megközelítések bármelyikével:
- Válassza a Futtatás gombot.
- Használja Hibakeresés>Hibakeresés indítása a menüből.
- Nyomja le az F5 billentyűt.
A parancshéjban keresse meg a megoldás Server projektmappáját. Hajtsa végre a dotnet watch (vagy dotnet run) parancsot.

A megoldás részei

Ez a szakasz a Blazor WebAssembly projektsablonból létrehozott megoldás részeit ismerteti, és ismerteti, hogy a megoldás Client és Server projektjei hogyan vannak konfigurálva referenciaként. Ebben a szakaszban nem talál konkrét útmutatást egy alapszintű munkaalkalmazáshoz, ha az alkalmazást az útmutató szakaszban található útmutatással hozta létre. Az ebben a szakaszban található útmutató segítséget nyújt egy alkalmazás frissítéséhez a felhasználók hitelesítéséhez és engedélyezéséhez. Az alkalmazások frissítésének alternatív módszere azonban az, ha az útmutató szakasz útmutatásából új alkalmazást hoz létre, és áthelyezi az alkalmazás összetevőit, osztályait és erőforrásait az új alkalmazásba.

Server appszolgáltatások

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A rendszer az alábbi szolgáltatásokat regisztrálja.

A Program fájlban:

Entity Framework Core és ASP.NET Core Identity:

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlite( ... ));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<ApplicationUser>(options => 
        options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();

Identity kiszolgáló egy további AddApiAuthorization segédmetódussal, amely beállítja az alapértelmezett ASP.NET Core-konvenciókat a Identity kiszolgálón:
```
builder.Services.AddIdentityServer()
    .AddApiAuthorization<ApplicationUser, ApplicationDbContext>();
```
Hitelesítés egy további AddIdentityServerJwt segédmetódussal, amely konfigurálja az alkalmazást a Identity Server által előállított JWT-jogkivonatok ellenőrzésére:
```
builder.Services.AddAuthentication()
    .AddIdentityServerJwt();
```

A Startup.ConfigureServicesStartup.cs-ban:
- Entity Framework Core és ASP.NET Core Identity:
```
services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlite(
        Configuration.GetConnectionString("DefaultConnection")));

services.AddDefaultIdentity<ApplicationUser>(options => 
        options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();
```
  Warning
  
  Ne tárolja az alkalmazás titkos kulcsait, kapcsolati sztringeket, hitelesítő adatokat, jelszavakat, személyes azonosítószámokat (PIN-eket), titkos C#/.NET-kódot vagy titkos kulcsokat/jogkivonatokat az ügyféloldali kódban, amely mindig nem biztonságos. Tesztelési/előkészítési és éles környezetekben a kiszolgálóoldali Blazor kód- és webes API-knak biztonságos hitelesítési folyamatokat kell használniuk, amelyek nem őrzik meg a hitelesítő adatokat a projektkódban vagy a konfigurációs fájlokban. A helyi fejlesztési tesztelésen kívül javasoljuk, hogy kerülje a környezeti változók bizalmas adatok tárolására való használatát, mivel a környezeti változók nem a legbiztonságosabb megközelítések. A helyi fejlesztési teszteléshez a Secret Manager eszköz ajánlott bizalmas adatok védelméhez. További információ: Bizalmas adatok és hitelesítő adatok biztonságos karbantartása.
- Identity kiszolgáló egy további AddApiAuthorization segédmetódussal, amely beállítja az alapértelmezett ASP.NET Core-konvenciókat a Identity kiszolgálón:
```
services.AddIdentityServer()
    .AddApiAuthorization<ApplicationUser, ApplicationDbContext>();
```
- Hitelesítés egy további AddIdentityServerJwt segédmetódussal, amely konfigurálja az alkalmazást a Identity Server által előállított JWT-jogkivonatok ellenőrzésére:
```
services.AddAuthentication()
    .AddIdentityServerJwt();
```

Note

Ha egyetlen hitelesítési sémát regisztrál, a rendszer automatikusan az alkalmazás alapértelmezett sémájaként használja a hitelesítési sémát, és nem szükséges a sémát AddAuthentication vagy AuthenticationOptionskeresztül állapotba tenni. További információkért lásd: ASP.NET Core Authentication áttekintése és az ASP.NET Core-közleményt (aspnet/Announcements #490).

A Program fájlban:

A Startup.ConfigureStartup.cs-ban:

A Identity kiszolgálóközvetítő az OpenID Connect (OIDC) végpontokat teszi elérhetővé:
```
app.UseIdentityServer();
```

A hitelesítési köztes szoftver felelős a kérés hitelesítő adatainak érvényesítéséért és a felhasználó kérési környezethez való beállításáért:
```
app.UseAuthentication();
```

Az engedélyezési köztes szoftver engedélyezi az engedélyezési képességeket:
```
app.UseAuthorization();
```

API-engedélyezés

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A AddApiAuthorization segédmetódus Identity Server konfigurálja ASP.NET Core-forgatókönyvekhez. Identity Kiszolgáló hatékony és bővíthető keretrendszer az alkalmazásbiztonsági problémák kezelésére. Identity kiszolgáló a leggyakoribb forgatókönyvek szükségtelen összetettségét teszi elérhetővé. Következésképpen számos konvenció és konfigurációs lehetőség áll rendelkezésre, amelyek alapján jó kiindulópontot tekintünk. Miután a hitelesítést módosítani kell, a Identity-kiszolgáló teljes ereje elérhető az alkalmazás igényeinek megfelelő hitelesítés testreszabásához.

Hitelesítési kezelő hozzáadása olyan API-hoz, amely Identity-kiszolgálóval együtt létezik

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A AddIdentityServerJwt segédmetódus alapértelmezett hitelesítési kezelőként konfigurálja az alkalmazás szabályzatsémát. A szabályzat úgy van konfigurálva, hogy lehetővé tegye Identity számára az Identityalatti /Identity URL-terület bármely alútjára irányított kérések kezelését. A JwtBearerHandler kezeli az összes többi kérést. Emellett ez a módszer:

Regisztrál egy API-erőforrást a Identity-kiszolgálóval, amelynek alapértelmezett hatóköre {PROJECT NAME}API, ahol a {PROJECT NAME} helyőrző a projekt neve az alkalmazás létrehozásakor.
Konfigurálja a JWT Bearer Token Middleware-t az alkalmazáshoz Identity Server által kibocsátott jogkivonatok érvényesítéséhez.

Időjárás-előrejelzés vezérlő

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A WeatherForecastController (Controllers/WeatherForecastController.cs) esetén a [Authorize] attribútum alkalmazódik az osztályra. Az attribútum azt jelzi, hogy a felhasználónak az alapértelmezett szabályzat alapján kell engedélyeznie az erőforrás elérését. Az alapértelmezett engedélyezési szabályzat az alapértelmezett hitelesítési séma használatára van konfigurálva, amelyet a AddIdentityServerJwtállít be. A segédmetódus az alkalmazás kéréseinek alapértelmezett kezelőjeként konfigurálja a JwtBearerHandler.

Alkalmazás-adatbázis környezete

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A ApplicationDbContext (Data/ApplicationDbContext.cs) esetében a DbContext kibővíti a ApiAuthorizationDbContext<TUser>-at, hogy tartalmazza a Identity kiszolgáló sémáját. ApiAuthorizationDbContext<TUser> IdentityDbContextszármazik.

Az adatbázisséma teljes körű vezérléséhez örökölje az egyik elérhető IdentityDbContext osztályt, és konfigurálja a környezetet úgy, hogy az Identity sémát is tartalmazza, ha meghívja builder.ConfigurePersistedGrantContext(_operationalStoreOptions.Value) a OnModelCreating metódusba.

OIDC konfigurációvezérlő

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A OidcConfigurationController (Controllers/OidcConfigurationController.cs) az ügyfélvégpont ki van építve az OIDC-paraméterek kiszolgálására.

Alkalmazásbeállítások

Ez a szakasz a megoldás Server alkalmazására vonatkozik.

A projekt gyökérkönyvtárában található alkalmazásbeállítások fájlban (appsettings.json) a IdentityServer szakasz ismerteti a konfigurált ügyfelek listáját. Az alábbi példában egyetlen ügyfél található. Az ügyfélnév az Client alkalmazás szerelvénynevének felel meg, és konvenció szerint megfelel az OAuth ClientId paraméternek. A profil a konfigurált alkalmazástípust jelzi. A profil belsőleg arra szolgál, hogy olyan konvenciókhoz vezessen, amelyek leegyszerűsítik a kiszolgáló konfigurációs folyamatát.

"IdentityServer": {
  "Clients": {
    "{ASSEMBLY NAME}": {
      "Profile": "IdentityServerSPA"
    }
  }
}

A {ASSEMBLY NAME} helyőrző az Client alkalmazás szerelvényének neve (például BlazorSample.Client).

Hitelesítési csomag

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

Amikor egy alkalmazás egyéni fiókok használatára jön létre (Individual), az alkalmazás automatikusan megkapja a csomagra vonatkozó csomaghivatkozást Microsoft.AspNetCore.Components.WebAssembly.Authentication . A csomag primitívek készletét biztosítja, amelyek segítenek az alkalmazásnak hitelesíteni a felhasználókat, és jogkivonatokat szerezni a védett API-k meghívásához.

Ha hitelesítést ad hozzá egy alkalmazáshoz, manuálisan adja hozzá a Microsoft.AspNetCore.Components.WebAssembly.Authentication csomagot az alkalmazáshoz.

Note

A csomagok .NET-alkalmazásokhoz való hozzáadásáról a Csomagok telepítése és kezeléseCsomaghasználati munkafolyamat (NuGet-dokumentáció)című cikkben talál útmutatást. Ellenőrizze a megfelelő csomagverziókat a NuGet.org.

`HttpClient` konfigurációja

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A Program fájlban egy elnevezett HttpClient úgy van konfigurálva, hogy HttpClient olyan példányokat adjon meg, amelyek hozzáférési tokeneket tartalmaznak, amikor kéréseket küld a kiszolgáló API-nak. A megoldás létrehozásakor a megnevezett HttpClient a {PROJECT NAME}.ServerAPI, ahol a {PROJECT NAME} helyőrző a projekt nevét jelenti.

builder.Services.AddHttpClient("{PROJECT NAME}.ServerAPI", 
        client => client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress))
    .AddHttpMessageHandler<BaseAddressAuthorizationMessageHandler>();

builder.Services.AddScoped(sp => sp.GetRequiredService<IHttpClientFactory>()
    .CreateClient("{PROJECT NAME}.ServerAPI"));

A {PROJECT NAME} helyőrző a projekt neve a megoldás létrehozásakor. Ha például megad egy BlazorSample projektnevet, az HttpClientegy nevesített BlazorSample.ServerAPI-et eredményez.

Note

Ha egy Blazor WebAssembly-alkalmazást úgy konfigurál, hogy olyan meglévő Identity kiszolgálópéldányt használjon, amely nem része egy üzemeltetett Blazor megoldásnak, módosítsa az HttpClient alapcímregisztrációt a IWebAssemblyHostEnvironment.BaseAddress (builder.HostEnvironment.BaseAddress) helyett a kiszolgálóalkalmazás API-engedélyezési végpontjának URL-címére.

API-engedélyezési támogatás

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A felhasználók hitelesítésének támogatását a Microsoft.AspNetCore.Components.WebAssembly.Authentication csomagban megadott bővítménymetódus csatlakoztatja a szolgáltatástárolóhoz. Ez a módszer beállítja az alkalmazás által a meglévő engedélyezési rendszerrel való interakcióhoz szükséges szolgáltatásokat.

builder.Services.AddApiAuthorization();

Az alkalmazás konfigurációja konvenció alapján töltődik be a _configuration/{client-id}-ból. Megállapodás szerint az ügyfélazonosító az alkalmazás szerelvényének nevére van beállítva. Ez az URL-cím módosítható úgy, hogy egy külön végpontra mutasson a megfelelő opciókkal rendelkező túlterhelt függvény meghívásával.

`Imports` fájl

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A Microsoft.AspNetCore.Components.Authorization névtér az alkalmazás teljes területén elérhetővé válik a _Imports.razor fájlon keresztül:

...
@using Microsoft.AspNetCore.Components.Authorization
...

`Index` lap

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

Az Indexlap (wwwroot/index.html) oldal tartalmaz egy szkriptet, amely meghatározza a JavaScriptben található AuthenticationService. AuthenticationService kezeli az OIDC protokoll alacsony szintű részleteit. Az alkalmazás belsőleg meghívja a szkriptben meghatározott metódusokat a hitelesítési műveletek végrehajtásához.

<script src="_content/Microsoft.AspNetCore.Components.WebAssembly.Authentication/AuthenticationService.js"></script>

`App` összetevő

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A App összetevő (App.razor) hasonló az App alkalmazásokban található Blazor Server összetevőhöz:

A CascadingAuthenticationState összetevő felel a AuthenticationState alkalmazás többi része számára történő feltárásáért.
A AuthorizeRouteView összetevő gondoskodik arról, hogy az aktuális felhasználó hozzáférhessen egy adott laphoz, vagy más módon renderelje a RedirectToLogin összetevőt.
A RedirectToLogin összetevő kezeli a jogosulatlan felhasználók bejelentkezési lapra való átirányítását.

Az ASP.NET Core kiadásaiban bekövetkezett változások miatt a Razor összetevő (App) App.razor jelölése nem jelenik meg ebben a szakaszban. A komponens egy adott kiadásra vonatkozó jelölésének vizsgálatához használja az alábbi megközelítések egyikét:

Hozzon létre egy hitelesítéshez kiépített alkalmazást a használni kívánt ASP.NET Core alapértelmezett Blazor WebAssembly projektsablonjából. Vizsgálja meg a App összetevőt (App.razor) a létrehozott alkalmazásban.
Vizsgálja meg a App összetevőt (App.razor) a referenciaforrás-ban. Válassza ki a verziót az ágválasztóból, és keresse meg az összetevőt az adattár ProjectTemplates mappájában, mert az App összetevő helye az évek során megváltozott.

Note

A .NET referenciaforrásra mutató dokumentációs hivatkozások általában betöltik az adattár alapértelmezett ágát, amely a .NET következő kiadásának aktuális fejlesztését jelöli. Egy adott kiadás címkéjének kiválasztásához használja az Ágak vagy címkék váltása legördülő listát. További információ: A ASP.NET Core-forráskód (dotnet/AspNetCore.Docs #26205) verziócímkéjének kiválasztása.

`RedirectToLogin` összetevő

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A RedirectToLogin összetevő (RedirectToLogin.razor):

Kezeli a jogosulatlan felhasználók bejelentkezési lapra való átirányítását.
A felhasználó által elérni kívánt aktuális URL-címet a rendszer úgy tartja karban, hogy vissza lehessen adni őket az adott oldalra, ha a hitelesítés sikeres:
- navigációs előzmények állapota ASP.NET Core-ban a .NET 7 vagy újabb verzióiban.
- Lekérdezési karakterlánc a .NET 6-os vagy korábbi ASP.NET Core-ban.

Vizsgálja meg a RedirectToLogin összetevőt a -es referenciaforrásban. Az összetevő helye idővel megváltozott, ezért a GitHub keresőeszközei segítségével keresse meg az összetevőt.

A bejelentkezési útvonalat az alkalmazás testre szabhatja (RemoteAuthenticationApplicationPathsOptions.LogInPath a keretrendszer alapértelmezései (dotnet/aspnetcorereferenciaforrás)). A projektsablon RedirectToLogin összetevője az alapértelmezett bejelentkezési útvonalat authentication/loginhasználja.

Note

A .NET referenciaforrásra mutató dokumentációs hivatkozások általában betöltik az adattár alapértelmezett ágát, amely a .NET következő kiadásának aktuális fejlesztését jelöli. Egy adott kiadás címkéjének kiválasztásához használja az Ágak vagy címkék váltása legördülő listát. További információ: A ASP.NET Core-forráskód (dotnet/AspNetCore.Docs #26205) verziócímkéjének kiválasztása.

Ha egy alkalmazás testre szabja a bejelentkezési útvonalat, kövesse az alábbi módszerek egyikét:

Egyezzen az összetevőben lévő, rögzített sztring elérési útjára RedirectToLogin .
Injektáljuk RemoteAuthenticationOptions a konfigurált érték beolvasásához. Ezt a megközelítést például akkor érdemes alkalmazni, ha az elérési utat a következővel AddApiAuthorizationszabja testre: Adja hozzá a következő irányelveket az RedirectToLogin összetevő tetején:
```
@using Microsoft.Extensions.Options
@inject IOptionsSnapshot<RemoteAuthenticationOptions<ApiAuthorizationProviderOptions>> RemoteOptions
```
Módosítsa az összetevő átirányítását a OnInitialized metódusban:
```
- Navigation.NavigateToLogin("authentication/login");
+ Navigation.NavigateToLogin(RemoteOptions.Get(Options.DefaultName)
+     .AuthenticationPaths.LogInPath);
```
Note

Ha más útvonalak eltérnek a projektsablon vagy a keretrendszer alapértelmezett elérési útjaitól, azokat ugyanúgy kell kezelni.

`LoginDisplay` összetevő

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A LoginDisplay összetevő (LoginDisplay.razor) a MainLayout összetevőben (MainLayout.razor) jelenik meg, és a következő viselkedéseket kezeli:

Hitelesített felhasználók esetén:
- Megjeleníti az aktuális felhasználónevet.
- A ASP.NET Core Identityfelhasználói profillapjára mutató hivatkozást kínál.
- Egy gombot kínál az alkalmazásból való kijelentkezéshez.
Névtelen felhasználók számára:
- Lehetőséget kínál a regisztrációra.
- Lehetőséget kínál a bejelentkezésre.

A keretrendszerben a ASP.NET Core kiadásaiban bekövetkezett változások miatt ebben a szakaszban nem jelenik meg az Razor összetevőre vonatkozó LoginDisplay korrektúra. A komponens egy adott kiadásra vonatkozó jelölésének vizsgálatához használja az alábbi megközelítések egyikét:

Hozzon létre egy hitelesítéshez kiépített alkalmazást a használni kívánt ASP.NET Core alapértelmezett Blazor WebAssembly projektsablonjából. Vizsgálja meg a létrehozott alkalmazás LoginDisplay összetevőjét.
Vizsgálja meg a LoginDisplay összetevőt a -es referenciaforrásban. Az összetevő helye idővel megváltozott, ezért a GitHub keresőeszközei segítségével keresse meg az összetevőt. A Hosted egyenlő true sablonalapú tartalmát használják.

Note

A .NET referenciaforrásra mutató dokumentációs hivatkozások általában betöltik az adattár alapértelmezett ágát, amely a .NET következő kiadásának aktuális fejlesztését jelöli. Egy adott kiadás címkéjének kiválasztásához használja az Ágak vagy címkék váltása legördülő listát. További információ: A ASP.NET Core-forráskód (dotnet/AspNetCore.Docs #26205) verziócímkéjének kiválasztása.

`Authentication` összetevő

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A Authentication összetevő (Pages/Authentication.razor) által létrehozott oldal határozza meg a különböző hitelesítési szakaszok kezeléséhez szükséges útvonalakat.

A RemoteAuthenticatorView összetevő:

A Microsoft.AspNetCore.Components.WebAssembly.Authentication csomag biztosítja.
Kezeli a megfelelő műveletek végrehajtását a hitelesítés minden szakaszában.

@page "/authentication/{action}"
@using Microsoft.AspNetCore.Components.WebAssembly.Authentication

<RemoteAuthenticatorView Action="@Action" />

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

Note

Null értékű referenciatípusok (NRT-k) és a .NET-fordító nullállapot statikus elemzése támogatott az ASP.NET Core-ban a .NET 6-os vagy újabb verzióval. A .NET 6-ban a ASP.NET Core kiadása előtt a string típus null típusú megjelölés (?) nélkül jelenik meg.

`FetchData` összetevő

Ez a szakasz a megoldás Client alkalmazására vonatkozik.

A FetchData összetevő a következő lépéseket mutatja be:

Hozzáférési token biztosítása.
A hozzáférési jogkivonat használatával meghívhat egy védett erőforrás API-t a Server alkalmazásban.

A @attribute [Authorize] irányelv azt jelzi a Blazor WebAssembly engedélyezési rendszernek, hogy a felhasználónak engedélyezettnek kell lennie ahhoz, hogy meglátogathassa ezt a komponenst. Az attribútum jelenléte az Client alkalmazásban nem akadályozza meg, hogy a kiszolgáló API-ja megfelelő hitelesítő adatok nélkül legyen meghívva. Az Server alkalmazásnak [Authorize] kell használnia a megfelelő végpontokon a megfelelő védelem érdekében.

IAccessTokenProvider.RequestAccessToken gondoskodik egy hozzáférési jogkivonat kéréséről, amely hozzáadható az API meghívására irányuló kéréshez. Ha a jogkivonat gyorsítótárazva van, vagy a szolgáltatás felhasználói beavatkozás nélkül tud kiépíteni egy új hozzáférési jogkivonatot, a jogkivonat-kérés sikeres lesz. Ellenkező esetben a jogkivonat-kérés sikertelen lesz egy AccessTokenNotAvailableExceptionmiatt, amelyet egy try-catch utasítás fog le.

Ahhoz, hogy beszerezze a kérésbe belefoglalandó tényleges jogkivonatot, az alkalmazásnak ellenőriznie kell, hogy a kérés sikeres volt-e a tokenResult.TryGetToken(out var token) meghívásával.

Ha a kérés sikeres volt, a jogkivonat változója fel lesz töltve a hozzáférési jogkivonattal. A token AccessToken.Value tulajdonsága megjeleníti a literális sztringet, amely szerepel a Authorization kérelem fejlécében.

Ha a token nem biztosítható felhasználói beavatkozás nélkül, ami sikertelen kérést eredményez:

ASP.NET Core a .NET 7-ben vagy újabb verziókban: Az alkalmazás a megadott AccessTokenResult.InteractiveRequestUrl használatával navigál a AccessTokenResult.InteractionOptions-hoz a hozzáférési jogkivonat frissítésének engedélyezése érdekében.
ASP.NET Core a .NET 6 vagy annál korábbi verziókban: A token eredménye egy átirányítási URL-t tartalmaz. Az URL-címre lépve a felhasználó a bejelentkezési oldalra kerül, és a sikeres hitelesítés után visszaáll az aktuális lapra.

@page "/fetchdata"
@using Microsoft.AspNetCore.Authorization
@using Microsoft.AspNetCore.Components.WebAssembly.Authentication
@using {APP NAMESPACE}.Shared
@attribute [Authorize]
@inject HttpClient Http

...

@code {
    private WeatherForecast[] forecasts;

    protected override async Task OnInitializedAsync()
    {
        try
        {
            forecasts = await Http.GetFromJsonAsync<WeatherForecast[]>("WeatherForecast");
        }
        catch (AccessTokenNotAvailableException exception)
        {
            exception.Redirect();
        }
    }
}

Azure App Service on Linux

Explicit módon adja meg a kiállítót, amikor az Azure App Service-t Linuxra telepíti. További információkért lásd: Az Identity használata webes API háttérrendszer védelmére SPA-k esetén.

Név és szerepkör igény az API engedélyezése során

Egyéni felhasználói generátor

Az Client alkalmazásban hozzon létre egy egyéni felhasználói gyárat. Identity kiszolgáló több szerepkört küld JSON-tömbként egyetlen role jogcímben. A rendszer egyetlen szerepkört küld sztringértékként a jogcímben. A gyár létrehoz egy egyéni role jogcímet az egyes felhasználók szerepköreihez.

CustomUserFactory.cs:

using System.Security.Claims;
using System.Text.Json;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication;
using Microsoft.AspNetCore.Components.WebAssembly.Authentication.Internal;

public class CustomUserFactory(IAccessTokenProviderAccessor accessor)
    : AccountClaimsPrincipalFactory<RemoteUserAccount>(accessor)
{
    public override async ValueTask<ClaimsPrincipal> CreateUserAsync(
        RemoteUserAccount account,
        RemoteAuthenticationUserOptions options)
    {
        var user = await base.CreateUserAsync(account, options);

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            var identity = (ClaimsIdentity)user.Identity;
            var roleClaims = identity.FindAll(identity.RoleClaimType).ToArray();

            if (roleClaims.Any())
            {
                foreach (var existingClaim in roleClaims)
                {
                    identity.RemoveClaim(existingClaim);
                }

                var rolesElem = 
                    account.AdditionalProperties[identity.RoleClaimType];

                if (options.RoleClaim is not null && rolesElem is JsonElement roles)
                {
                    if (roles.ValueKind == JsonValueKind.Array)
                    {
                        foreach (var role in roles.EnumerateArray())
                        {
                            var roleValue = role.GetString();

                            if (!string.IsNullOrEmpty(roleValue))
                            {
                                identity.AddClaim(
                                  new Claim(options.RoleClaim, roleValue));
                            }
        
                        }
                    }
                    else
                    {
                        var roleValue = roles.GetString();

                        if (!string.IsNullOrEmpty(roleValue))
                        {
                            identity.AddClaim(
                              new Claim(options.RoleClaim, roleValue));
                        }
                    }
                }
            }
        }

        return user;
    }
}

Az Client alkalmazásban regisztrálja a gyárat a Program fájlban:

builder.Services.AddApiAuthorization()
    .AddAccountClaimsPrincipalFactory<CustomUserFactory>();

Az Server alkalmazásban hívja meg a AddRoles-et a Identity építőn, amely szerepkörhöz kapcsolódó szolgáltatásokat ad hozzá.

A Program fájlban:

using Microsoft.AspNetCore.Identity;

...

builder.Services.AddDefaultIdentity<ApplicationUser>(options => 
    options.SignIn.RequireConfirmedAccount = true)
    .AddRoles<IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>();

A Startup.cs:

using Microsoft.AspNetCore.Identity;

...

services.AddDefaultIdentity<ApplicationUser>(options => 
    options.SignIn.RequireConfirmedAccount = true)
    .AddRoles<IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>();

Identity-kiszolgáló konfigurálása

Használja az alábbi módszerek közül az egyik:

API engedélyezési beállításai
Profilszolgáltatás

API-engedélyezési beállítások

Az Server alkalmazásban:

Konfigurálja a Identity-kiszolgálót úgy, hogy a name és role jogcímeket az azonosító jogkivonatba és a hozzáférési jogkivonatba helyezze.
A JWT-jogkivonat-kezelő szerepköreinek alapértelmezett leképezésének megakadályozása.

A Program fájlban:

using System.IdentityModel.Tokens.Jwt;

...

builder.Services.AddIdentityServer()
    .AddApiAuthorization<ApplicationUser, ApplicationDbContext>(options => {
        options.IdentityResources["openid"].UserClaims.Add("name");
        options.ApiResources.Single().UserClaims.Add("name");
        options.IdentityResources["openid"].UserClaims.Add("role");
        options.ApiResources.Single().UserClaims.Add("role");
    });

JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Remove("role");

A Startup.cs:

using System.IdentityModel.Tokens.Jwt;
using System.Linq;

...

services.AddIdentityServer()
    .AddApiAuthorization<ApplicationUser, ApplicationDbContext>(options => {
        options.IdentityResources["openid"].UserClaims.Add("name");
        options.ApiResources.Single().UserClaims.Add("name");
        options.IdentityResources["openid"].UserClaims.Add("role");
        options.ApiResources.Single().UserClaims.Add("role");
    });

JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Remove("role");

Profilszolgáltatás

Az Server alkalmazásban hozzon létre egy ProfileService implementációt.

ProfileService.cs:

using IdentityModel;
using Duende.IdentityServer.Models;
using Duende.IdentityServer.Services;

public class ProfileService : IProfileService
{
    public ProfileService()
    {
    }

    public async Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        var nameClaim = context.Subject.FindAll(JwtClaimTypes.Name);
        context.IssuedClaims.AddRange(nameClaim);

        var roleClaims = context.Subject.FindAll(JwtClaimTypes.Role);
        context.IssuedClaims.AddRange(roleClaims);

        await Task.CompletedTask;
    }

    public async Task IsActiveAsync(IsActiveContext context)
    {
        await Task.CompletedTask;
    }
}

Az Server alkalmazásban regisztrálja a Profilszolgáltatást a Program fájlban:

using Duende.IdentityServer.Services;

...

builder.Services.AddTransient<IProfileService, ProfileService>();

JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Remove("role");

Az Server alkalmazásban regisztrálja a Profilszolgáltatást a Startup.ConfigureServicesrész Startup.cs-ben.

using IdentityServer4.Services;

...

services.AddTransient<IProfileService, ProfileService>();

JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Remove("role");

Engedélyezési mechanizmusok használata

Az Client alkalmazásban jelenleg az összetevők engedélyezési megközelítései működnek. Az összetevők bármelyik engedélyezési mechanizmusa szerepkörrel engedélyezheti a felhasználót:

AuthorizeView összetevő (Példa: <AuthorizeView Roles="Admin">)
[Authorize] irányelv az attribútumhoz (AuthorizeAttribute) (Példa: @attribute [Authorize(Roles = "Admin")])
Eljárási logika (Példa: if (user.IsInRole("Admin")) { ... })

Több szerepkörteszt is támogatott:
```
if (user.IsInRole("Admin") && user.IsInRole("Developer"))
{
    ...
}
```

A User.Identity.Name mező a Client alkalmazásban a felhasználó felhasználónevével van kitöltve, ami általában a bejelentkezési e-mail címük.

`UserManager` és `SignInManager`

Állítsa be a felhasználói azonosító jogcímtípusát, ha egy kiszolgálóalkalmazáshoz a következőre van szükség:

UserManager<TUser> vagy SignInManager<TUser> API-végpontban.
IdentityUser adatokat, például a felhasználó nevét, e-mail-címét vagy a zárolás befejezési idejét.

A .NET 6-os vagy újabb ASP.NET Core Program.cs esetén:

using System.Security.Claims;

...

builder.Services.Configure<IdentityOptions>(options => 
    options.ClaimsIdentity.UserIdClaimType = ClaimTypes.NameIdentifier);

A Startup.ConfigureServices .NET 5-ös vagy korábbi verziójában:

using System.Security.Claims;

...

services.Configure<IdentityOptions>(options => 
    options.ClaimsIdentity.UserIdClaimType = ClaimTypes.NameIdentifier);

Az alábbi WeatherForecastController naplózza a UserName-et a Get metódus meghívásakor.

Note

A következő példa a következőket használja:

Egy fájlhatókörű névtér, amely egy C# 10 vagy újabb (.NET 6 vagy újabb) funkció.
Egy elsődleges konstruktor, amely a C# 12 vagy újabb (.NET 8 vagy újabb) verziók funkciója.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Logging;
using BlazorSample.Server.Models;
using BlazorSample.Shared;

namespace BlazorSample.Server.Controllers;

[Authorize]
[ApiController]
[Route("[controller]")]
public class WeatherForecastController(ILogger<WeatherForecastController> logger, 
        UserManager<ApplicationUser> userManager) : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", 
        "Balmy", "Hot", "Sweltering", "Scorching"
    };

    [HttpGet]
    public async Task<IEnumerable<WeatherForecast>> Get()
    {
        var rng = new Random();

        var user = await userManager.GetUserAsync(User);

        if (user != null)
        {
            logger.LogInformation("User.Identity.Name: {UserIdentityName}", user.UserName);
        }

        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

Az előző példában:

A Server projekt névtere BlazorSample.Server.
A Shared projekt névtere BlazorSample.Shared.

Azure App Service üzemeltetése egyéni tartománnyal és SSL tanúsítvánnyal

Az alábbi útmutató a következőket ismerteti:

Hogyan helyezzünk üzembe egy üzemeltetett Blazor WebAssembly alkalmazást Identity Serverrel az Azure App Service-re egyéni tartománnyal.
TLS-tanúsítvány létrehozása és használata HTTPS protokollal való kommunikációhoz böngészőkkel. Bár az útmutató a tanúsítvány egyéni tartománnyal való használatára összpontosít, az útmutató ugyanúgy alkalmazható az alapértelmezett Azure Apps-tartomány használatára, például contoso.azurewebsites.net.

Ebben az üzemeltetési forgatókönyvben ne használja ugyanazt a tanúsítványt Duende Identity Server jogkivonat-aláíró kulcsához és a weboldal HTTPS-alapú biztonságos kommunikációjának biztosítására a böngészőkkel.

A két követelményhez különböző tanúsítványok használata jó biztonsági gyakorlat, mivel minden célra elkülöníti a titkos kulcsokat.
A böngészőkkel való kommunikáció TLS-tanúsítványait a rendszer függetlenül kezeli anélkül, hogy befolyásolná Identity kiszolgáló jogkivonatának aláírását.
Amikor Azure Key Vault egy tanúsítványt biztosít egy App Service-alkalmazásnak egyéni tartománykötéshez, Identity Server nem tudja beszerezni ugyanazt a tanúsítványt az Azure Key Vaultból a jogkivonat-aláíráshoz. Bár a Identity kiszolgáló konfigurálása ugyanahhoz a TLS-tanúsítványhoz fizikai útvonalról lehetséges, a biztonsági tanúsítványok forráskonfigurációba helyezése helytelen gyakorlat, és a legtöbb forgatókönyvben el kell kerülni.

Az alábbi útmutatóban egy önaláírt tanúsítvány jön létre az Azure Key Vaultban kizárólag Identity kiszolgálói jogkivonat-aláíráshoz. A Identity kiszolgáló konfigurációja a Key Vault-tanúsítványt használja az alkalmazás CurrentUser>My tanúsítványtárolóján keresztül. Az egyéni tartományokkal rendelkező HTTPS-forgalomhoz használt egyéb tanúsítványok a Identity kiszolgáló aláíró tanúsítványától külön jönnek létre és konfigurálhatók.

Egy alkalmazás, az Azure App Service és az Azure Key Vault konfigurálása egyéni tartománnyal és HTTPS-lel, gazdagépként való használathoz:

Hozzon létre egy App Service-csomagotBasic B1 vagy magasabb csomagszinttel. Az App Service Basic B1 vagy magasabb szolgáltatási szintet igényel az egyéni tartományok használatához.
Hozzon létre egy PFX-tanúsítványt a webhely biztonságos böngésző kommunikációjához (HTTPS protokoll) a webhely teljes tartománynevének (FQDN) közös nevével, amelyet a szervezet szabályoz (például www.contoso.com). Hozza létre a tanúsítványt a következőkkel:
- Kulcshasználatok
  - Digitális aláírás ellenőrzése (digitalSignature)
  - Kulcsfelfedés (keyEncipherment)
- Javított/kiterjesztett kulcshasználatok
  - Ügyfél-hitelesítés (1.3.6.1.5.5.7.3.2)
  - Kiszolgálói hitelesítés (1.3.6.1.5.5.7.3.1)
A tanúsítvány létrehozásához használja az alábbi módszerek vagy bármely más megfelelő eszköz vagy online szolgáltatás egyikét:
Jegyezze fel a jelszót, amelyet később használnak a tanúsítvány Azure Key Vaultba való importálásához.

További információ az Azure Key Vault-tanúsítványokról: Azure Key Vault: Tanúsítványok.
Hozzon létre egy új Azure Key Vaultot, vagy használjon egy meglévő kulcstartót az Azure-előfizetésében.
A kulcstár tanúsítványok területére importálja a PFX-tanúsítványt. Jegyezze fel a tanúsítvány ujjlenyomatát, amelyet később az alkalmazás konfigurációjában használnak.
Az Azure Key Vaultban hozzon létre egy új önaláírt tanúsítványt Identity szerver token aláírásához. Adjon meg egy tanúsítványnevet és tárgyat. A AlanyCN={COMMON NAME}meg van határozva, ahol a {COMMON NAME} helyőrző a tanúsítvány közismert neve. Az általános név bármilyen alfanumerikus karaktersor lehet. A CN=IdentityServerSigning például érvényes tanúsítvány, Tárgy. A Kiállítási szabályzat>Haladó szabályzatkonfigurációesetében az alapértelmezett beállításokat kell használni. Jegyezze fel a tanúsítvány ujjlenyomatát, amelyet később az alkalmazás konfigurációjában használnak.
Lépjen az Azure App Service-be az Azure Portalon, és hozzon létre egy új App Service-t az alábbi konfigurációval:
- Közzététel beállítása Code.
- A futtatókörnyezet vereme az alkalmazás futási környezetére van állítva.
- A termékváltozat ésméret esetében ellenőrizze, hogy az App Service szintje Basic B1 vagy magasabb. Az App Service Basic B1 vagy magasabb szolgáltatási szintet igényel az egyéni tartományok használatához.
Miután az Azure létrehozta az App Service-t, nyissa meg az alkalmazás konfigurációs, és adjon hozzá egy új alkalmazásbeállítást, amely megadja a korábban rögzített tanúsítvány ujjlenyomatait. Az alkalmazásbeállítási kulcs WEBSITE_LOAD_CERTIFICATES. Az alkalmazásbeállítási érték tanúsítvány-ujjlenyomatait vesszővel kell elválasztania, ahogy az alábbi példa mutatja:
- Kulcs: WEBSITE_LOAD_CERTIFICATES
- Érték: 57443A552A46DB...D55E28D412B943565,29F43A772CB6AF...1D04F0C67F85FB0B1
Az Azure Portalon az alkalmazásbeállítások mentése két lépésből áll: Mentse a WEBSITE_LOAD_CERTIFICATES kulcs-érték beállítást, majd válassza a Mentés gombot a panel tetején.
Válassza ki az alkalmazás TLS/SSL-beállításait. Válassza a privátkulcs-tanúsítványok (.pfx) lehetőséget. Használja a Key Vault-tanúsítvány importálásának folyamatát. Használja a folyamatot kétszer a webhely HTTPS-kommunikációhoz szükséges tanúsítványának és a webhely önaláírt Identity kiszolgálói jogkivonat-aláíró tanúsítványának importálásához.
Lépjen az Egyéni tartomány ablakra. A tartományregisztráló webhelyén a tartomány konfigurálásához használja a IP-címet és egyéni tartomány-ellenőrzési azonosítót. Egy tipikus tartománykonfiguráció a következőket tartalmazza:
- Egy A rekord egy fogadó@, valamint az Azure portálról származó IP-cím értékkel.
- Egy TXT rekord, amelynek a gazdagépeasuid, és az Azure által generált, az Azure Portal által megadott ellenőrzési azonosító értéke.
Győződjön meg arról, hogy a módosításokat helyesen menti a domain név regisztrátor honlapján. Egyes regisztráló webhelyeken kétlépéses folyamat szükséges a tartományrekordok mentéséhez: Egy vagy több rekordot külön-külön ment a rendszer, majd egy külön gombbal frissíti a tartomány regisztrációját.
Térjen vissza a Egyéni tartományok lapra az Azure portálon. Válassza a Egyéni tartomány hozzáadását. Válassza a rekord lehetőséget. Adja meg a tartományt, majd válassza az lehetőséget aEllenőrzése céljából. Amennyiben a domainrekordok helyesek és az Interneten propagálva vannak, a portálon kiválaszthatja az Egyéni domain hozzáadása gombot.

A tartományregisztrációs módosítások az internetes tartománynév-kiszolgálókon (DNS) való propagálásuk néhány napig is eltarthat, miután a tartományregisztráló feldolgozta őket. Ha a tartományrekordok három munkanapon belül nem frissülnek, ellenőrizze, hogy a rekordok megfelelően vannak-e beállítva a tartományregisztrálónál, és forduljon az ügyfélszolgálathoz.
Az Egyéni tartományok panelen a tartományhoz tartozó SSL állapotNot Securevan megjelölve. Válassza a Kötés hozzáadása hivatkozást. Válassza ki a webhely HTTPS-tanúsítványát az egyéni tartománykötés kulcstartójából.
A Visual Studióban nyissa meg a Server projekt alkalmazásbeállítási fájlját (appsettings.json vagy appsettings.Production.json). A Identity kiszolgáló konfigurációjában adja hozzá a következő Key szakaszt. Adja meg a kulcshoz tartozó Name. A következő példában a kulcstárolóhoz rendelt tanúsítvány általános neve IdentityServerSigning, amely a CN=IdentityServerSigning eredményezi:
```
"IdentityServer": {

  ...

  "Key": {
    "Type": "Store",
    "StoreName": "My",
    "StoreLocation": "CurrentUser",
    "Name": "CN=IdentityServerSigning"
  }
},
```
A Visual Studióban hozzon létre egy Azure App Service-közzétételi profilt a Server projekthez. A menüsávon válassza a következőt: Build>Publish>New>Azure>Azure App Service (Windows vagy Linux). Ha a Visual Studio csatlakozik egy Azure-előfizetéshez, az Azure-erőforrásokat erőforrástípus szerinttekintheti meg. A webalkalmazás listájában keresse meg az alkalmazáshoz tartozó App Service-t, és jelölje ki. Válassza ki a Befejezésopciót.
Amikor a Visual Studio visszatér a Közzététel ablakba, a kulcstár és az SQL Server adatbázis-szolgáltatás függőségei automatikusan észlelésre kerülnek.

A Key Vault szolgáltatáshoz nincs szükség az alapértelmezett beállítások konfigurációs módosítására.

Tesztelési célokra az alkalmazás helyi SQLite-adatbázisa, amelyet a Blazor sablon konfigurál, további konfiguráció nélkül üzembe helyezhető az alkalmazással. Egy másik adatbázis konfigurálása az éles Identity kiszolgálóhoz túlmutat a jelen cikk keretein. További információkért tekintse meg az adatbázis erőforrásait a következő dokumentációs csoportokban:
- App Service
- Duende Identity Szerver
Válassza a Szerkesztés hivatkozást az ablak tetején található üzembehelyezési profil neve alatt. Módosítsa a cél URL-címét a webhely egyéni domain URL-címére (például https://www.contoso.com). Mentse a beállításokat.
Tegye közzé az alkalmazást. A Visual Studio megnyit egy böngészőablakot, és az egyéni tartományában kéri a webhelyet.

Az Azure dokumentációja további részleteket tartalmaz az Azure-szolgáltatások és az egyéni tartományok TLS-kötéssel való használatáról az App Service-ben, beleértve az A rekordok helyett a CNAME rekordok használatával kapcsolatos információkat. További információ:

Javasoljuk, hogy minden egyes alkalmazásteszthez használjon egy új privát módú böngészőablakot (például Microsoft Edge InPrivate mód vagy Google Chrome Inkognitó mód) az azure portalon az alkalmazás, az alkalmazáskonfiguráció vagy az Azure-szolgáltatások módosítása után. Az előző tesztfuttatásból származó megmaradt cookie-k sikertelen hitelesítést vagy engedélyezést okozhatnak a webhely tesztelése során, még akkor is, ha a webhely konfigurációja helyes. További információ arról, hogyan konfigurálhatja a Visual Studiót egy új privát böngészőablak megnyitására az egyes tesztfuttatásokhoz, olvassa el a Cookie-k és webhelyadatok című szakaszt.

Ha az App Service konfigurációja módosul az Azure Portalon, a frissítések általában gyorsan érvénybe lépnek, de nem azonnal. Előfordulhat, hogy egy konfigurációs módosítás érvénybe lépéséhez rövid ideig kell várnia, amíg az App Service újraindul.

Ha Identity kiszolgáló kulcs aláíró tanúsítványa betöltésével van probléma, hajtsa végre a következő parancsot az Azure portálon lévő Kudu PowerShell-parancshéjban. A parancs felsorolja azokat a tanúsítványokat, amelyeket az alkalmazás a CurrentUser>My tanúsítványtárolóból érhet el. A kimenet tartalmazza az alkalmazás hibakeresésekor hasznos tanúsítványokat és ujjlenyomatokat.

Get-ChildItem -path Cert:\CurrentUser\My -Recurse | Format-List DnsNameList, Subject, Thumbprint, EnhancedKeyUsageList

Troubleshoot

Logging

Ha engedélyezni szeretné a hibakeresést vagy a nyomkövetési naplózást a hitelesítéshezBlazor WebAssembly, tekintse meg a Blazor szakaszát, amelyben a cikk verzióválasztója ASP.NET Core a .NET 7-es vagy újabb verziójában.

Gyakori hibák

Az alkalmazás vagy Identity szolgáltató (IP) helytelen konfigurálása

A leggyakoribb hibákat a helytelen konfiguráció okozza. Az alábbiakban néhány példát láthat:
- A forgatókönyv követelményeitől függően egy hiányzó vagy helytelen szolgáltató, példány, bérlőazonosító, bérlői tartomány, ügyfélazonosító vagy átirányítási URI megakadályozza, hogy egy alkalmazás hitelesítse az ügyfeleket.
- A helytelen kérelemtartományok megakadályozzák, hogy az ügyfelek hozzáférjenek a kiszolgáló webes API-végpontjaihoz.
- Helytelen vagy hiányzó kiszolgálói API-engedélyek megakadályozzák, hogy az ügyfelek hozzáférjenek a kiszolgáló webes API-végpontjaihoz.
- Más porton futtatom az alkalmazást, mint ahogyan az IP-cím alkalmazásregisztrációjának átirányítási URI-jában van konfigurálva. Vegye figyelembe, hogy a Microsoft Entra-azonosítóhoz és egy localhost fejlesztési tesztelési címen futó alkalmazáshoz nincs szükség portra, de az alkalmazás portkonfigurációjának és a portnak, amelyen az alkalmazás fut, meg kell egyeznie a nemlocalhost címekhez.
A cikk útmutatójának konfigurációs szakaszai példákat mutatnak a helyes konfigurációra. Gondosan ellenőrizze a cikk egyes szakaszait, hogy az alkalmazás és az IP-cím helytelenül van-e konfigurálva.

Ha a konfiguráció helyesnek tűnik:
- Alkalmazásnaplók elemzése.
- Vizsgálja meg az ügyfélalkalmazás és az IP- vagy kiszolgálóalkalmazás közötti hálózati forgalmat a böngésző fejlesztői eszközeivel. Gyakran előfordul, hogy az IP vagy a szerver alkalmazás egy pontos hibaüzenetet vagy egy olyan üzenetet küld vissza az ügyfélnek, amelyből kiderül, mi okozza a problémát. A fejlesztői eszközökkel kapcsolatos útmutatást a következő cikkekben találja:
  - Google Chrome (Google-dokumentáció)
  - Microsoft Edge
  - Mozilla Firefox (Mozilla-dokumentáció)
- Azoknál a Blazor kiadásoknál, ahol JSON Web Token (JWT) kerül felhasználásra, dekódolja a hitelesítéshez vagy a kiszolgáló webes API-hozzáféréshez használt jogkivonat tartalmát, attól függően, hol jelentkezik a probléma. További információ: JSON-webjogkivonat (JWT) tartalmának vizsgálata.
A dokumentációs csapat válaszol a cikkekben szereplő dokumentumokkal kapcsolatos visszajelzésekre és hibákra (nyisson meg egy hibát a Ezen az oldalon visszajelzési szakaszból), de nem tud terméktámogatást nyújtani. Számos nyilvános támogatási fórum áll rendelkezésre az alkalmazások hibaelhárításához. A következőket javasoljuk:
Az előző fórumok nem a Microsoft tulajdonában vagy ellenőrzése alatt állnak.

A nem biztonsági, nem érzékeny és nem bizalmas, reprodukálható keretrendszer hibajelentései esetén nyisson meg egy témát az ASP.NET Core termékcsoportszámára. Ne nyisson meg egy problémát a termékegységben, amíg nem vizsgálja meg alaposan a probléma okát, és nem tudja önállóan és a közösség segítségével megoldani a problémát egy nyilvános támogatási fórumon. A termékegység nem tudja elhárítani a külső szolgáltatásokat érintő egyszerű helytelen konfiguráció vagy használati esetek miatt hibásan működő egyes alkalmazásokat. Ha egy jelentés bizalmas jellegű, vagy a kiberbűnözők által kihasználható termék biztonsági hibáját írja le, tekintse meg Biztonsági problémák és hibák jelentésével (dotnet/aspnetcore GitHub-adattár).
ME-ID jogosulatlan ügyfél

info: Microsoft.AspNetCore.Authorization.DefaultAuthorizationService[2] Az engedélyezés nem sikerült. Ezek a követelmények nem teljesültek: DenyAnonymousAuthorizationRequirement: Hitelesített felhasználót igényel.

Bejelentkezési visszahívási hiba a ME-ID-ből:
- Hiba: unauthorized_client
- Leírás: AADB2C90058: The provided application is not configured to allow public clients.
A hiba megoldása:
1. Az Azure Portalon érheti el a alkalmazás jegyzékfájlját.
2. Állítsa a allowPublicClient attribútumotnull vagy trueértékre.

Cookie-k és webhelyadatok

A cookie-k és a webhelyadatok az alkalmazásfrissítések során is megmaradhatnak, és zavarhatják a tesztelést és a hibaelhárítást. Az alábbi elemeket törölje, amikor alkalmazáskódot módosít, változtat a szolgáltatónál vezetett felhasználói fiók beállításain vagy a szolgáltatói alkalmazás konfigurációján.

Felhasználói bejelentkezési cookie-k
Alkalmazás cookie-k
Gyorsítótárazott és tárolt webhelyadatok

Az egyik módszer annak megakadályozására, hogy a cookie-k és a webhelyadatok zavarják a tesztelést és a hibaelhárítást:

Böngésző konfigurálása
- Használjon egy böngészőt a teszteléshez, amely konfigurálható az összes cookie és webhelyadatok törlésére minden alkalommal, amikor a böngésző bezárul.
- Győződjön meg arról, hogy a böngésző manuálisan vagy az IDE által bezárva van az alkalmazás, a tesztfelhasználó vagy a szolgáltató konfigurációjának bármilyen módosításához.
Egyéni paranccsal nyisson meg egy böngészőt InPrivate vagy Inkognitó módban a Visual Studióban:
- Nyissa meg a Tallózás párbeszédpanelt a Visual Studio Futtatás gomb segítségével.
- Válassza a Hozzáadás gombot.
- Adja meg a böngésző elérési útját a Program mezőben. A következő végrehajtható elérési utak a Windows 10 tipikus telepítési helyei. Ha a böngésző más helyen van telepítve, vagy nem Windows 10-et használ, adja meg a böngésző végrehajtható fájljának elérési útját.
  - Microsoft Edge: C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe
  - Google Chrome: C:\Program Files (x86)\Google\Chrome\Application\chrome.exe
  - Mozilla Firefox: C:\Program Files\Mozilla Firefox\firefox.exe
- Az Argumentumok mezőben adja meg azt a parancssori beállítást, amelyet a böngésző inPrivate vagy Inkognitó módban való megnyitáshoz használ. Egyes böngészőkben az alkalmazás URL-címe szükséges.
  - Microsoft Edge: A -inprivatehasználata.
  - Google Chrome: Használja a --incognito --new-window {URL}, ahol a {URL} helyőrző a megnyitni kívánt URL-cím (például https://localhost:5001).
  - Mozilla Firefox: Használja a -private -url {URL}, ahol a {URL} helyőrző a megnyitni kívánt URL-cím (például https://localhost:5001).
- Adjon meg egy nevet a Felhasználóbarát név mezőben. Például Firefox Auth Testing.
- Válassza az OK gombot.
- Ha el szeretné kerülni, hogy az alkalmazással végzett tesztelés minden iterációja esetében ki kell választania a böngészőprofilt, állítsa be a profilt alapértelmezettként az Alapértelmezett gombbal.
- Győződjön meg arról, hogy az IDE bezárja a böngészőt az alkalmazás, a tesztfelhasználó vagy a szolgáltató konfigurációjának bármilyen módosításához.

Alkalmazásfrissítések

A működő alkalmazások a .NET SDK fejlesztői gépen való frissítése vagy az alkalmazás csomagverzióinak módosítása után azonnal meghiúsulhatnak. Bizonyos esetekben az inkognitó csomagok megszakíthatják az alkalmazásokat a nagyobb frissítések végrehajtásakor. A legtöbb ilyen probléma az alábbi utasítások követésével javítható:

Törölje a helyi rendszer NuGet-csomaggyorsítótárait a dotnet nuget locals all --clear parancs végrehajtásával a parancshéjban.
Törölje a projekt bin és obj mappáit.
Állítsa vissza és építse újra a projektet.
Az alkalmazás ismételt üzembe helyezése előtt törölje a kiszolgáló üzembehelyezési mappájában lévő összes fájlt.

Note

Az alkalmazás cél-keretrendszerével nem kompatibilis csomagverziók használata nem támogatott. A csomaggal kapcsolatos információkért használja a NuGet Gallery-t.

Az `Server` alkalmazás futtatása

Egy üzemeltetett Blazor WebAssemblymegoldástesztelése és hibaelhárítása során győződjön meg arról, hogy az alkalmazást a Server projektből futtatja.

A felhasználó vizsgálata

A következő User összetevő közvetlenül az alkalmazásokban használható, vagy a további testreszabás alapjául szolgál.

User.razor:

@page "/user"
@attribute [Authorize]
@using System.Text.Json
@using System.Security.Claims
@inject IAccessTokenProvider AuthorizationService

<h1>@AuthenticatedUser?.Identity?.Name</h1>

<h2>Claims</h2>

@foreach (var claim in AuthenticatedUser?.Claims ?? Array.Empty<Claim>())
{
    <p class="claim">@(claim.Type): @claim.Value</p>
}

<h2>Access token</h2>

<p id="access-token">@AccessToken?.Value</p>

<h2>Access token claims</h2>

@foreach (var claim in GetAccessTokenClaims())
{
    <p>@(claim.Key): @claim.Value.ToString()</p>
}

@if (AccessToken != null)
{
    <h2>Access token expires</h2>

    <p>Current time: <span id="current-time">@DateTimeOffset.Now</span></p>
    <p id="access-token-expires">@AccessToken.Expires</p>

    <h2>Access token granted scopes (as reported by the API)</h2>

    @foreach (var scope in AccessToken.GrantedScopes)
    {
        <p>Scope: @scope</p>
    }
}

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

    public ClaimsPrincipal AuthenticatedUser { get; set; }
    public AccessToken AccessToken { get; set; }

    protected override async Task OnInitializedAsync()
    {
        await base.OnInitializedAsync();
        var state = await AuthenticationState;
        var accessTokenResult = await AuthorizationService.RequestAccessToken();

        if (!accessTokenResult.TryGetToken(out var token))
        {
            throw new InvalidOperationException(
                "Failed to provision the access token.");
        }

        AccessToken = token;

        AuthenticatedUser = state.User;
    }

    protected IDictionary<string, object> GetAccessTokenClaims()
    {
        if (AccessToken == null)
        {
            return new Dictionary<string, object>();
        }

        // header.payload.signature
        var payload = AccessToken.Value.Split(".")[1];
        var base64Payload = payload.Replace('-', '+').Replace('_', '/')
            .PadRight(payload.Length + (4 - payload.Length % 4) % 4, '=');

        return JsonSerializer.Deserialize<IDictionary<string, object>>(
            Convert.FromBase64String(base64Payload));
    }
}

JSON-webjogkivonat (JWT) tartalmának vizsgálata

JSON-webjogkivonat (JWT) dekódolásához használja a Microsoft jwt.ms eszközét. A felhasználói felületen lévő értékek soha nem hagyják el a böngészőt.

Példa kódolt JWT -ra (a megjelenítéshez rövidítve):

eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImtpZCI6Ilg1ZVhrNHh5b2pORnVtMWtsMll0djhkbE5QNC1j ... bQdHBHGcQQRbW7Wmo6SWYG4V_bU55Ug_PW4pLPr20tTS8Ct7_uwy9DWrzCMzpD-EiwT5IjXwlGX3IXVjHIlX50IVIydBoPQtadvT7saKo1G5Jmutgq41o-dmz6-yBMKV2_nXA25Q

Az eszköz által dekódolt JWT-példa egy Azure AAD B2C-vel hitelesítő alkalmazáshoz:

{
  "typ": "JWT",
  "alg": "RS256",
  "kid": "X5eXk4xyojNFum1kl2Ytv8dlNP4-c57dO6QGTVBwaNk"
}.{
  "exp": 1610059429,
  "nbf": 1610055829,
  "ver": "1.0",
  "iss": "https://mysiteb2c.b2clogin.com/11112222-bbbb-3333-cccc-4444dddd5555/v2.0/",
  "sub": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
  "aud": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "nonce": "bbbb0000-cccc-1111-dddd-2222eeee3333",
  "iat": 1610055829,
  "auth_time": 1610055822,
  "idp": "idp.com",
  "tfp": "B2C_1_signupsignin"
}.[Signature]

További erőforrások

Üzembe helyezés az Azure App Service-ben
Tanúsítvány importálása a Key Vaultból (Azure-dokumentáció)
ASP.NET Core Blazor WebAssembly további biztonsági forgatókönyvek
Nem hitelesített vagy jogosulatlan webes API-kérések egy biztonságos alapértelmezett ügyféllel rendelkező alkalmazásban,
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.
Duende Identity Szerver

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-11

Megosztás a következőn keresztül:

Üzemeltetett ASP.NET Core Blazor WebAssembly-alkalmazás védelme Identity Serverrel

Walkthrough

Blazor-alkalmazás létrehozása

Az alkalmazás futtatása

A megoldás részei

Server appszolgáltatások

API-engedélyezés

Hitelesítési kezelő hozzáadása olyan API-hoz, amely Identity-kiszolgálóval együtt létezik

Időjárás-előrejelzés vezérlő

Alkalmazás-adatbázis környezete

OIDC konfigurációvezérlő

Alkalmazásbeállítások

Hitelesítési csomag

HttpClient konfigurációja

API-engedélyezési támogatás

Imports fájl

Index lap

App összetevő

RedirectToLogin összetevő

LoginDisplay összetevő

Authentication összetevő

FetchData összetevő

Azure App Service on Linux

Név és szerepkör igény az API engedélyezése során

Egyéni felhasználói generátor

Identity-kiszolgáló konfigurálása

API-engedélyezési beállítások

Profilszolgáltatás

Engedélyezési mechanizmusok használata

UserManager és SignInManager

Azure App Service üzemeltetése egyéni tartománnyal és SSL tanúsítvánnyal

Troubleshoot

Logging

Gyakori hibák

Cookie-k és webhelyadatok

Alkalmazásfrissítések

Az Server alkalmazás futtatása

A felhasználó vizsgálata

JSON-webjogkivonat (JWT) tartalmának vizsgálata

További erőforrások

Visszajelzés

További források

`HttpClient` konfigurációja

`Imports` fájl

`Index` lap

`App` összetevő

`RedirectToLogin` összetevő

`LoginDisplay` összetevő

`Authentication` összetevő

`FetchData` összetevő

`UserManager` és `SignInManager`

Az `Server` alkalmazás futtatása