Proteggere un'app ASP.NET Core Blazor WebAssembly ospitata con Azure Active Directory B2C
Questo articolo illustra come creare una soluzione ospitata Blazor WebAssembly che usa Azure Active Directory (AAD) B2C per l'autenticazione.
Per altre informazioni sulla copertura dello scenario di sicurezza dopo la lettura di questo articolo, vedere ASP.NET Scenari di sicurezza aggiuntivi di baseBlazor WebAssembly.
scenario
Le sottosezioni della procedura dettagliata illustrano come:
- Creare un tenant in Azure
- Registrare un'app per le API server in Azure
- Registrare un'app client in Azure
- Creare l'app Blazor
- Modificare lo schema di ambito del token di accesso predefinito
- Eseguire l'app
Creare un tenant in Azure
Seguire le indicazioni riportate in Esercitazione: Creare un tenant di Azure Active Directory B2C per creare un tenant AAD B2C.
Prima di procedere con le indicazioni di questo articolo, verificare di aver selezionato la directory corretta per il tenant AAD B2C.
Registrare un'app per le API server in Azure
Registrare un'app AAD B2C per l'app per le API server:
- Passare ad Azure AD B2C nella portale di Azure. Selezionare Registrazioni app nella barra laterale. Selezionare il pulsante Nuova registrazione.
- Specificare un nome per l'app, Blazor Server ad esempio AAD B2C.
- Per Tipi di account supportati, selezionare l'opzione multi-tenant: Account in qualsiasi provider di identità o directory organizzativa (per autenticare gli utenti con flussi utente)
- L'app per le API server non richiede un URI di reindirizzamento in questo scenario, quindi lasciare deselezionata l'elenco a discesa Selezionare una piattaforma e non immettere un URI di reindirizzamento.
- Verificare che l'opzione Autorizzazioni>conceda il consenso dell'amministratore per openid e offline_access autorizzazioni sia selezionata.
- Selezionare Registra.
Registrare le informazioni seguenti:
- ID applicazione dell'app per le API server (client) (ad esempio,
41451fa7-82d9-4673-8fa5-69eff5a761fd
) - Istanza di AAD B2C ,
https://contoso.b2clogin.com/
ad esempio , che include la barra finale. L'istanza è lo schema e l'host di una registrazione dell'app Azure B2C, disponibile aprendo la finestra Endpoint dalla pagina Registrazioni app nella portale di Azure. - Dominio primario/server di pubblicazione/tenant ,ad esempio :
contoso.onmicrosoft.com
il dominio è disponibile come dominio del server di pubblicazione nel pannello Personalizzazione del portale di Azure per l'app registrata.
Selezionare Esporre un'API dalla barra laterale e seguire questa procedura:
- Seleziona Aggiungi un ambito.
- Selezionare Salva e continua.
- Specificare un nome ambito , ad esempio
API.Access
. - Specificare un nome visualizzato del consenso Amministrazione , ad esempio
Access API
. - Specificare una descrizione del consenso Amministrazione , ad esempio
Allows the app to access server app API endpoints.
. - Verificare che Lo stato sia impostato su Abilitato.
- Seleziona Aggiungi ambito.
Registrare le informazioni seguenti:
- GUID URI ID app (ad esempio, record
41451fa7-82d9-4673-8fa5-69eff5a761fd
dahttps://contoso.onmicrosoft.com/41451fa7-82d9-4673-8fa5-69eff5a761fd
) - Nome ambito (ad esempio,
API.Access
)
Registrare un'app client in Azure
Registrare un'app AAD B2C per l'app client:
- Passare ad Azure AD B2C nella portale di Azure. Selezionare Registrazioni app nella barra laterale. Selezionare il pulsante Nuova registrazione.
- Specificare un nome per l'app, Blazor ad esempio Client AAD B2C.
- Per Tipi di account supportati, selezionare l'opzione multi-tenant: Account in qualsiasi provider di identità o directory organizzativa (per autenticare gli utenti con flussi utente)
- Impostare l'elenco a discesa URI di reindirizzamento su Applicazione a pagina singola (SPA) e specificare un valore URI di reindirizzamento pari
https://localhost/authentication/login-callback
a . Se si conosce l'URI di reindirizzamento di produzione per l'host predefinito di Azure ( ad esempio ,azurewebsites.net
) o l'host di dominio personalizzato (ad esempio ,contoso.com
), è anche possibile aggiungere l'URI di reindirizzamento di produzione contemporaneamente all'URIlocalhost
di reindirizzamento specificato. Assicurarsi di includere il numero di porta per le porte non:443
in qualsiasi URI di reindirizzamento di produzione aggiunti. - Verificare che l'opzione Autorizzazioni>conceda il consenso dell'amministratore per openid e offline_access autorizzazioni sia selezionata.
- Selezionare Registra.
Nota
Non è necessario specificare il numero di porta per un localhost
URI di reindirizzamento AAD B2C. Per altre informazioni, vedere Restrizioni e limitazioni dell'URI di reindirizzamento (URL di risposta): eccezioni Localhost (documentazione di Entra).
Registrare l'ID applicazione client (client), ad esempio 4369008b-21fa-427c-abaa-9b53bf58e538
.
In Authentication Platform configurations single-page application (Configurazioni>della piattaforma di autenticazione>) applicazione a pagina singola:
- Verificare che l'URI di reindirizzamento di
https://localhost/authentication/login-callback
sia presente. - Nella sezione Concessione implicita verificare che le caselle di controllo per Token di accesso e token ID non siano selezionate. La concessione implicita non è consigliata per Blazor le app che usano MSAL v2.0 o versione successiva. Per altre informazioni, vedere Secure ASP.NET Core Blazor WebAssembly.
- Le impostazioni predefinite rimanenti per l'app sono accettabili per questa esperienza.
- Selezionare il pulsante Salva se sono state apportate modifiche.
In Autorizzazioni API dalla barra laterale:
- Selezionare Aggiungi un'autorizzazione seguita dalle API personali.
- Selezionare l'app per le API server dalla colonna Nome , Blazor Server ad esempio AAD B2C.
- Aprire l'elenco di API se non è già aperto.
- Abilitare l'accesso all'API (ad esempio,
API.Access
) con la casella di controllo . - Selezionare Aggiungi autorizzazioni.
- Selezionare il pulsante Concedi consenso amministratore per {NOME TENANT} . Seleziona Sì per confermare.
Importante
Se non si ha l'autorità per concedere il consenso amministratore al tenant nell'ultimo passaggio della configurazione delle autorizzazioni API perché il consenso per l'uso dell'app viene delegato agli utenti, è necessario eseguire i passaggi aggiuntivi seguenti:
- L'app deve usare un dominio di pubblicazione attendibile.
Server
Nella configurazione dell'app nella portale di Azure selezionare Esporre un'API. In Applicazioni client autorizzate selezionare il pulsante Aggiungi un'applicazione client. Aggiungere l'IDClient
applicazione (client) dell'app , ad esempio4369008b-21fa-427c-abaa-9b53bf58e538
.
Tornare ad Azure AD B2C nella portale di Azure. Selezionare Flussi utente e usare le indicazioni seguenti: Creare un flusso utente di iscrizione e accesso. Selezionare almeno Attestazioni applicazione per il flusso utente di iscrizione/accesso e quindi la casella di controllo Attributo utente Nome visualizzato per popolare context.User.Identity?.Name
context.User.Identity.Name
/nel LoginDisplay
componente ().Shared/LoginDisplay.razor
Registrare il nome del flusso utente di iscrizione e di accesso creato per l'app , ad esempio B2C_1_signupsignin1
.
Creare l'app Blazor
Sostituire i segnaposto nel comando seguente con le informazioni registrate in precedenza ed eseguire il comando in una shell dei comandi:
dotnet new blazorwasm -au IndividualB2C --aad-b2c-instance "{AAD B2C INSTANCE}" --api-client-id "{SERVER API APP CLIENT ID}" --app-id-uri "{SERVER API APP ID URI GUID}" --client-id "{CLIENT APP CLIENT ID}" --default-scope "{DEFAULT SCOPE}" --domain "{TENANT DOMAIN}" -ho -o {PROJECT NAME} -ssp "{SIGN UP OR SIGN IN POLICY}"
Avviso
Evitare di usare trattini (-
) nel nome {PROJECT NAME}
dell'app che interrompono la formazione dell'identificatore dell'app OIDC. La logica nel modello di Blazor WebAssembly progetto usa il nome del progetto per un identificatore di app OIDC nella configurazione della soluzione. Le maiuscole/minuscole Pascal (BlazorSample
) o caratteri di sottolineatura (Blazor_Sample
) sono alternative accettabili. Per altre informazioni, vedere Dashes in a hosted project name break OIDC security (dotnet/aspnetcore #35337).For more information, see Dashes in a hosted Blazor WebAssembly project name break OIDC security (dotnet/aspnetcore #35337).
Segnaposto | Nome portale di Azure | Esempio |
---|---|---|
{AAD B2C INSTANCE} |
Istanza | https://contoso.b2clogin.com/ (include la barra finale) |
{PROJECT NAME} |
— | BlazorSample |
{CLIENT APP CLIENT ID} |
ID applicazione (client) per l'app Client | 4369008b-21fa-427c-abaa-9b53bf58e538 |
{DEFAULT SCOPE} |
Nome ambito | API.Access |
{SERVER API APP CLIENT ID} |
ID applicazione (client) per l'app Server | 41451fa7-82d9-4673-8fa5-69eff5a761fd |
{SERVER API APP ID URI GUID} |
GUID URI ID applicazione | 41451fa7-82d9-4673-8fa5-69eff5a761fd (SOLO GUID, per impostazione predefinita corrisponde a {SERVER API APP CLIENT ID} ) |
{SIGN UP OR SIGN IN POLICY} |
Flusso utente di iscrizione/accesso | B2C_1_signupsignin1 |
{TENANT DOMAIN} |
Dominio primario/server di pubblicazione/tenant | contoso.onmicrosoft.com |
Il percorso di output specificato con l'opzione -o|--output
crea una cartella del progetto se non esiste e diventa parte del nome del progetto. Evitare di usare trattini (-
) nel nome dell'app che interrompono la formazione dell'identificatore dell'app OIDC (vedere l'avviso precedente).
Eseguire l'app
Eseguire l'app dal Server
progetto. Quando si usa Visual Studio, è possibile:
Selezionare la freccia a discesa accanto al pulsante Esegui . Aprire Configura progetti di avvio dall'elenco a discesa. Selezionare l'opzione Progetto di avvio singolo. Confermare o modificare il progetto per il progetto di avvio nel
Server
progetto.Verificare che il
Server
progetto sia evidenziato in Esplora soluzioni prima di avviare l'app con uno degli approcci seguenti:- Selezionare il pulsante Run (Esegui).
- Usare Debug>Avvia debug dal menu.
- Premere F5.
In una shell dei comandi passare alla
Server
cartella del progetto della soluzione. Eseguire il comandodotnet run
.
Criteri personalizzati
Microsoft Authentication Library (Microsoft.Authentication.WebAssembly.Msalpacchetto NuGet) non supporta i criteri personalizzati AAD B2C per impostazione predefinita.
ConfigurareUser.Identity.Name
Le indicazioni contenute in questa sezione illustrano facoltativamente il popolamento User.Identity.Name
con il valore dell'attestazione name
.
Per impostazione predefinita, l'API dell'app Server viene popolata con il valore del http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name
tipo di attestazione User.Identity.Name
, ad esempio 2d64b3da-d9d5-42c6-9352-53d8df33d770@contoso.onmicrosoft.com
.
Per configurare l'app per ricevere il valore dal name
tipo di attestazione:
Aggiungere uno spazio dei nomi per Microsoft.AspNetCore.Authentication.JwtBearer al
Program
file:using Microsoft.AspNetCore.Authentication.JwtBearer;
Configurare l'oggetto TokenValidationParameters.NameClaimTypeJwtBearerOptions di nel
Program
file:builder.Services.Configure<JwtBearerOptions>( JwtBearerDefaults.AuthenticationScheme, options => { options.TokenValidationParameters.NameClaimType = "name"; });
Parti della soluzione
Questa sezione descrive le parti di una soluzione generata dal Blazor WebAssembly modello di progetto e descrive come vengono configurati i progetti e Server la soluzione Client per riferimento. Non sono disponibili indicazioni specifiche da seguire in questa sezione per un'applicazione funzionante di base se è stata creata l'app usando le indicazioni nella sezione Procedura dettagliata . Le indicazioni contenute in questa sezione sono utili per aggiornare un'app per autenticare e autorizzare gli utenti. Tuttavia, un approccio alternativo all'aggiornamento di un'app consiste nel creare una nuova app dalle indicazioni nella sezione Procedura dettagliata e spostare i componenti, le classi e le risorse dell'app nella nuova app.
Configurazione appsettings.json
Questa sezione riguarda l'app della Server soluzione.
Il appsettings.json
file contiene le opzioni per configurare il gestore di connessione JWT usato per convalidare i token di accesso:
{
"AzureAdB2C": {
"Instance": "https://{TENANT}.b2clogin.com/",
"ClientId": "{SERVER API APP CLIENT ID}",
"Domain": "{TENANT DOMAIN}",
"Scopes": "{DEFAULT SCOPE}",
"SignUpSignInPolicyId": "{SIGN UP OR SIGN IN POLICY}"
}
}
Esempio:
{
"AzureAdB2C": {
"Instance": "https://contoso.b2clogin.com/",
"ClientId": "41451fa7-82d9-4673-8fa5-69eff5a761fd",
"Domain": "contoso.onmicrosoft.com",
"Scopes": "API.Access",
"SignUpSignInPolicyId": "B2C_1_signupsignin1",
}
}
Pacchetto di autenticazione
Questa sezione riguarda l'app della Server soluzione.
Il supporto per l'autenticazione e l'autorizzazione delle chiamate alle API Web di base di ASP.NET con la piattaforma Microsoft Identity viene fornito dal Microsoft.Identity.Web
pacchetto.
Nota
Per indicazioni sull'aggiunta di pacchetti alle app .NET, vedere gli articoli sotto Installare e gestire pacchetti in Flusso di lavoro dell'utilizzo di pacchetti (documentazione di NuGet). Confermare le versioni corrette del pacchetto all'indirizzo NuGet.org.
L'app Server di una soluzione ospitata Blazor creata dal Blazor WebAssembly modello include il Microsoft.Identity.Web.UI
pacchetto per impostazione predefinita. Il pacchetto aggiunge l'interfaccia utente per l'autenticazione utente nelle app Web e non viene usata dal Blazor framework. Se l'app Server non verrà usata per autenticare direttamente gli utenti, è possibile rimuovere il riferimento al pacchetto dal Server file di progetto dell'app.
Supporto del servizio di autenticazione
Questa sezione riguarda l'app della Server soluzione.
Il AddAuthentication
metodo configura i servizi di autenticazione all'interno dell'app e configura il gestore bearer JWT come metodo di autenticazione predefinito. Il AddMicrosoftIdentityWebApi metodo configura i servizi per proteggere l'API Web con Microsoft Identity Platform v2.0. Questo metodo prevede una AzureAdB2C
sezione della configurazione dell'app con le impostazioni necessarie per inizializzare le opzioni di autenticazione.
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApi(Configuration.GetSection("AzureAdB2C"));
Nota
Quando viene registrato un singolo schema di autenticazione, lo schema di autenticazione viene usato automaticamente come schema predefinito dell'app e non è necessario dichiarare lo schema a AddAuthentication o tramite AuthenticationOptions. Per altre informazioni, vedere Panoramica dell'autenticazione principale di ASP.NET e dell'annuncio di ASP.NET Core (aspnet/Announcements #490).
UseAuthentication e UseAuthorization assicurarsi che:
- L'app tenta di analizzare e convalidare i token nelle richieste in ingresso.
- Qualsiasi richiesta che tenta di accedere a una risorsa protetta senza credenziali appropriate non riesce.
app.UseAuthorization();
WeatherForecast Controller
Questa sezione riguarda l'app della Server soluzione.
Il WeatherForecast
controller (Controllers/WeatherForecastController.cs
) espone un'API protetta con l'attributo [Authorize]
applicato al controller. È importante comprendere che:
- L'attributo
[Authorize]
in questo controller API è l'unica cosa che protegge questa API dall'accesso non autorizzato. - L'attributo
[Authorize]
usato nell'app Blazor WebAssembly funge solo da suggerimento per l'app che l'utente deve essere autorizzato per il corretto funzionamento dell'app.
[Authorize]
[ApiController]
[Route("[controller]")]
[RequiredScope(RequiredScopesConfigurationKey = "AzureAdB2C:Scopes")]
public class WeatherForecastController : ControllerBase
{
[HttpGet]
public IEnumerable<WeatherForecast> Get()
{
...
}
}
Configurazione wwwroot/appsettings.json
Questa sezione riguarda l'app della Client soluzione.
La configurazione viene fornita dal wwwroot/appsettings.json
file :
{
"AzureAdB2C": {
"Authority": "{AAD B2C INSTANCE}{TENANT DOMAIN}/{SIGN UP OR SIGN IN POLICY}",
"ClientId": "{CLIENT APP CLIENT ID}",
"ValidateAuthority": false
}
}
Nella configurazione precedente, include {AAD B2C INSTANCE}
una barra finale.
Esempio:
{
"AzureAdB2C": {
"Authority": "https://contoso.b2clogin.com/contoso.onmicrosoft.com/B2C_1_signupsignin1",
"ClientId": "4369008b-21fa-427c-abaa-9b53bf58e538",
"ValidateAuthority": false
}
}
Pacchetto di autenticazione
Questa sezione riguarda l'app della Client soluzione.
Quando viene creata un'app per l'uso di un singolo account B2C (IndividualB2C
), l'app riceve automaticamente un riferimento al pacchetto per Microsoft Authentication Library (Microsoft.Authentication.WebAssembly.Msal
). Il pacchetto fornisce un set di primitive che consentono all'app di autenticare gli utenti e ottenere i token per chiamare le API protette.
Se si aggiunge l'autenticazione a un'app, aggiungere manualmente il Microsoft.Authentication.WebAssembly.Msal
pacchetto all'app.
Nota
Per indicazioni sull'aggiunta di pacchetti alle app .NET, vedere gli articoli sotto Installare e gestire pacchetti in Flusso di lavoro dell'utilizzo di pacchetti (documentazione di NuGet). Confermare le versioni corrette del pacchetto all'indirizzo NuGet.org.
Il Microsoft.Authentication.WebAssembly.Msal
pacchetto aggiunge in modo transitivo il Microsoft.AspNetCore.Components.WebAssembly.Authentication
pacchetto all'app.
Supporto del servizio di autenticazione
Questa sezione riguarda l'app della Client soluzione.
Viene aggiunto il supporto per HttpClient le istanze che includono i token di accesso durante l'esecuzione di richieste al progetto server.
Nel file Program
:
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"));
Il segnaposto {PROJECT NAME}
è il nome del progetto durante la creazione della soluzione. Ad esempio, specificando un nome di progetto di BlazorSample
produce un nome denominato HttpClient .BlazorSample.ServerAPI
Il supporto per l'autenticazione degli utenti viene registrato nel contenitore del servizio con il AddMsalAuthentication metodo di estensione fornito dal Microsoft.Authentication.WebAssembly.Msal
pacchetto. Questo metodo configura i servizi necessari per l'interazione dell'app con il Identity provider (IP).
Nel file Program
:
builder.Services.AddMsalAuthentication(options =>
{
builder.Configuration.Bind("AzureAdB2C", options.ProviderOptions.Authentication);
options.ProviderOptions.DefaultAccessTokenScopes.Add("{SCOPE URI}");
});
{SCOPE URI}
è l'ambito del token di accesso predefinito, https://contoso.onmicrosoft.com/41451fa7-82d9-4673-8fa5-69eff5a761fd/API.Access
ad esempio o l'URI personalizzato configurato nella portale di Azure.
Il AddMsalAuthentication metodo accetta un callback per configurare i parametri necessari per autenticare un'app. I valori necessari per configurare l'app possono essere ottenuti dalla configurazione di AAD del portale di Azure quando si registra l'app.
Ambiti del token di accesso
Questa sezione riguarda l'app della Client soluzione.
Gli ambiti predefiniti del token di accesso rappresentano l'elenco degli ambiti del token di accesso seguenti:
- Incluso per impostazione predefinita nella richiesta di accesso.
- Usato per effettuare il provisioning di un token di accesso immediatamente dopo l'autenticazione.
Tutti gli ambiti devono appartenere alla stessa app per le regole di Microsoft Entra ID. È possibile aggiungere ambiti aggiuntivi per altre app per le API in base alle esigenze:
builder.Services.AddMsalAuthentication(options =>
{
...
options.ProviderOptions.DefaultAccessTokenScopes.Add("{SCOPE URI}");
});
Specificare ambiti aggiuntivi con AdditionalScopesToConsent
:
options.ProviderOptions.AdditionalScopesToConsent.Add("{ADDITIONAL SCOPE URI}");
Nota
AdditionalScopesToConsent non è in grado di effettuare il provisioning delle autorizzazioni utente delegate per Microsoft Graph tramite l'interfaccia utente di consenso dell'ID di Microsoft Entra quando un utente usa per la prima volta un'app registrata in Microsoft Azure. Per altre informazioni, vedere Usare l'API Graph con ASP.NET Core Blazor WebAssembly.
Esempio di ambito del token di accesso predefinito:
options.ProviderOptions.DefaultAccessTokenScopes.Add(
"https://contoso.onmicrosoft.com/41451fa7-82d9-4673-8fa5-69eff5a761fd/API.Access");
Per altre informazioni, vedere le sezioni seguenti dell'articolo Scenari aggiuntivi :
Modalità di accesso
Questa sezione riguarda l'app della Client soluzione.
Il framework usa per impostazione predefinita la modalità di accesso popup e torna alla modalità di accesso di reindirizzamento se non è possibile aprire un popup. Configurare MSAL per l'uso della modalità di accesso di reindirizzamento impostando la LoginMode
proprietà di MsalProviderOptions su redirect
:
builder.Services.AddMsalAuthentication(options =>
{
...
options.ProviderOptions.LoginMode = "redirect";
});
L'impostazione predefinita è popup
e il valore stringa non fa distinzione tra maiuscole e minuscole.
Importa il file
Questa sezione riguarda l'app della Client soluzione.
Lo Microsoft.AspNetCore.Components.Authorization spazio dei nomi viene reso disponibile in tutta l'app tramite il _Imports.razor
file :
@using System.Net.Http
@using System.Net.Http.Json
@using Microsoft.AspNetCore.Components.Authorization
@using Microsoft.AspNetCore.Components.Forms
@using Microsoft.AspNetCore.Components.Routing
@using Microsoft.AspNetCore.Components.Web
@using Microsoft.AspNetCore.Components.Web.Virtualization
@using Microsoft.AspNetCore.Components.WebAssembly.Http
@using Microsoft.JSInterop
@using {APPLICATION ASSEMBLY}
@using {APPLICATION ASSEMBLY}.Shared
Pagina di indice
Questa sezione riguarda l'app della Client soluzione.
La pagina Indice (wwwroot/index.html
) include uno script che definisce in AuthenticationService
JavaScript. AuthenticationService
gestisce i dettagli di basso livello del protocollo OIDC. L'app chiama internamente i metodi definiti nello script per eseguire le operazioni di autenticazione.
<script src="_content/Microsoft.Authentication.WebAssembly.Msal/AuthenticationService.js"></script>
Componente dell'app
Questa sezione riguarda l'app della Client soluzione.
Il App
componente (App.razor
) è simile al App
componente presente nelle Blazor Server app:
- Il CascadingAuthenticationState componente gestisce l'esposizione dell'oggetto AuthenticationState al resto dell'app.
- Il AuthorizeRouteView componente garantisce che l'utente corrente sia autorizzato ad accedere a una determinata pagina o che esegua il rendering del
RedirectToLogin
componente. - Il componente gestisce il
RedirectToLogin
reindirizzamento di utenti non autorizzati alla pagina di accesso.
A causa delle modifiche apportate al framework tra le versioni di ASP.NET Core, Razor il markup per il App
componente (App.razor
) non viene visualizzato in questa sezione. Per esaminare il markup del componente per una determinata versione, usare uno degli approcci seguenti:
Creare un'app di cui è stato effettuato il provisioning per l'autenticazione dal modello di progetto predefinito Blazor WebAssembly per la versione di ASP.NET Core che si intende usare. Esaminare il
App
componente (App.razor
) nell'app generata.Esaminare il componente (
App.razor
) nell'origineApp
di riferimento. Selezionare la versione dal selettore di ramo e cercare il componente nellaProjectTemplates
cartella del repository perché è stato spostato nel corso degli anni.Nota
I collegamenti della documentazione all'origine del riferimento .NET in genere caricano il ramo predefinito del repository, che rappresenta lo sviluppo corrente per la versione successiva di .NET. Per selezionare un tag per una versione specifica, usare l'elenco a discesa Switch branches or tags. Per altre informazioni, vedere How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Come selezionare un tag di versione del codice sorgente di ASP.NET - dotnet/AspNetCore.Docs #26205).
Componente RedirectToLogin
Questa sezione riguarda l'app della Client soluzione.
Componente RedirectToLogin
(RedirectToLogin.razor
):
- Gestisce il reindirizzamento di utenti non autorizzati alla pagina di accesso.
- L'URL corrente a cui l'utente sta tentando di accedere viene mantenuto in modo che possa essere restituito a tale pagina se l'autenticazione ha esito positivo:
- Stato della cronologia di spostamento in ASP.NET Core in .NET 7 o versione successiva.
- Stringa di query in ASP.NET Core in .NET 6 o versioni precedenti.
Esaminare il componente nell'origine RedirectToLogin
di riferimento. La posizione del componente è cambiata nel tempo, quindi usare gli strumenti di ricerca gitHub per individuare il componente.
Nota
I collegamenti della documentazione all'origine del riferimento .NET in genere caricano il ramo predefinito del repository, che rappresenta lo sviluppo corrente per la versione successiva di .NET. Per selezionare un tag per una versione specifica, usare l'elenco a discesa Switch branches or tags. Per altre informazioni, vedere How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Come selezionare un tag di versione del codice sorgente di ASP.NET - dotnet/AspNetCore.Docs #26205).
Componente LoginDisplay
Questa sezione riguarda l'app della Client soluzione.
Il LoginDisplay
rendering del MainLayout
componente (LoginDisplay.razor
) viene eseguito nel componente (MainLayout.razor
) e gestisce i comportamenti seguenti:
- Per gli utenti autenticati:
- Visualizza il nome utente corrente.
- Offre un collegamento alla pagina del profilo utente in ASP.NET Core Identity.
- Offre un pulsante per disconnettersi dall'app.
- Per gli utenti anonimi:
- Offre la possibilità di registrarsi.
- Offre l'opzione di accesso.
A causa delle modifiche apportate al framework tra le versioni di ASP.NET Core, Razor il markup per il LoginDisplay
componente non viene visualizzato in questa sezione. Per esaminare il markup del componente per una determinata versione, usare uno degli approcci seguenti:
Creare un'app di cui è stato effettuato il provisioning per l'autenticazione dal modello di progetto predefinito Blazor WebAssembly per la versione di ASP.NET Core che si intende usare. Esaminare il
LoginDisplay
componente nell'app generata.Esaminare il componente nell'origine
LoginDisplay
di riferimento. La posizione del componente è cambiata nel tempo, quindi usare gli strumenti di ricerca gitHub per individuare il componente. Viene usato il contenuto basato su modelli perHosted
uguale atrue
.Nota
I collegamenti della documentazione all'origine del riferimento .NET in genere caricano il ramo predefinito del repository, che rappresenta lo sviluppo corrente per la versione successiva di .NET. Per selezionare un tag per una versione specifica, usare l'elenco a discesa Switch branches or tags. Per altre informazioni, vedere How to select a version tag of ASP.NET Core source code (dotnet/AspNetCore.Docs #26205) (Come selezionare un tag di versione del codice sorgente di ASP.NET - dotnet/AspNetCore.Docs #26205).
Componente di autenticazione
Questa sezione riguarda l'app della Client soluzione.
La pagina prodotta dal Authentication
componente (Pages/Authentication.razor
) definisce le route necessarie per la gestione di diverse fasi di autenticazione.
Componente RemoteAuthenticatorView :
- Viene fornito dal
Microsoft.AspNetCore.Components.WebAssembly.Authentication
pacchetto. - Gestisce l'esecuzione delle azioni appropriate in ogni fase di autenticazione.
@page "/authentication/{action}"
@using Microsoft.AspNetCore.Components.WebAssembly.Authentication
<RemoteAuthenticatorView Action="Action" />
@code {
[Parameter]
public string? Action { get; set; }
}
Nota
I tipi di riferimento nullable (NRT) e l'analisi statica dello stato null del compilatore .NET sono supportati in ASP.NET Core in .NET 6 o versione successiva. Prima del rilascio di ASP.NET Core in .NET 6, il string
tipo viene visualizzato senza la designazione di tipo Null (?
).
Componente FetchData
Questa sezione riguarda l'app della Client soluzione.
Il FetchData
componente mostra come:
- Effettuare il provisioning di un token di accesso.
- Usare il token di accesso per chiamare un'API risorsa protetta nell'app Server .
La @attribute [Authorize]
direttiva indica al Blazor WebAssembly sistema di autorizzazione che l'utente deve essere autorizzato per visitare questo componente. La presenza dell'attributo nell'app Client
non impedisce che l'API nel server venga chiamata senza credenziali appropriate. L'app Server
deve essere usata [Authorize]
anche negli endpoint appropriati per proteggerli correttamente.
IAccessTokenProvider.RequestAccessToken richiede un token di accesso che può essere aggiunto alla richiesta per chiamare l'API. Se il token viene memorizzato nella cache o il servizio è in grado di effettuare il provisioning di un nuovo token di accesso senza interazione dell'utente, la richiesta di token ha esito positivo. In caso contrario, la richiesta di token ha esito negativo con un AccessTokenNotAvailableExceptionoggetto , che viene intercettato in un'istruzione try-catch
.
Per ottenere il token effettivo da includere nella richiesta, l'app deve verificare che la richiesta sia riuscita chiamando tokenResult.TryGetToken(out var token)
.
Se la richiesta ha esito positivo, la variabile del token viene popolata con il token di accesso. La AccessToken.Value proprietà del token espone la stringa letterale da includere nell'intestazione della Authorization
richiesta.
Se la richiesta non è riuscita perché non è stato possibile effettuare il provisioning del token senza l'interazione dell'utente:
- ASP.NET Core in .NET 7 o versione successiva: l'app passa all'uso
AccessTokenResult.InteractiveRequestUrl
dell'oggetto specificatoAccessTokenResult.InteractionOptions
per consentire l'aggiornamento del token di accesso. - ASP.NET Core in .NET 6 o versioni precedenti: il risultato del token contiene un URL di reindirizzamento. Passando a questo URL, l'utente passa alla pagina di accesso e torna alla pagina corrente dopo l'autenticazione completata.
@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();
}
}
}
Risoluzione dei problemi
Registrazione
Per abilitare la registrazione di debug o traccia per Blazor WebAssembly l'autenticazione, vedere la sezione Registrazione dell'autenticazione lato client di ASP.NET Core Blazor con il selettore della versione dell'articolo impostato su ASP.NET Core 7.0 o versione successiva.
Errori comuni
Configurazione errata dell'app o Identity del provider (IP)
Gli errori più comuni sono causati da una configurazione errata. Di seguito sono riportati alcuni esempi:
- A seconda dei requisiti dello scenario, un'autorità mancante o non corretta, istanza, ID tenant, dominio tenant, ID client o URI di reindirizzamento impedisce a un'app di autenticare i client.
- Gli ambiti di richiesta non corretti impediscono ai client di accedere agli endpoint DELL'API Web del server.
- Autorizzazioni DELL'API server non corrette o mancanti impediscono ai client di accedere agli endpoint DELL'API Web del server.
- L'esecuzione dell'app in una porta diversa da quella configurata nell'URI di reindirizzamento della registrazione dell'app ip. Si noti che non è necessaria una porta per Microsoft Entra ID e un'app in esecuzione in un
localhost
indirizzo di test di sviluppo, ma la configurazione della porta dell'app e la porta in cui è in esecuzione l'app devono corrispondere per gli indirizzi nonlocalhost
.
Le sezioni di configurazione di questo articolo illustrano esempi della configurazione corretta. Controllare attentamente ogni sezione dell'articolo alla ricerca di errori di configurazione di app e IP.
Se la configurazione è corretta:
Analizzare i log delle applicazioni.
Esaminare il traffico di rete tra l'app client e l'app IP o server con gli strumenti di sviluppo del browser. Spesso, un messaggio di errore esatto o un messaggio con un indizio sulla causa del problema viene restituito al client dall'app IP o server dopo aver effettuato una richiesta. Strumenti di sviluppo materiale sussidiario sono disponibili negli articoli seguenti:
- Google Chrome (documentazione di Google)
- Microsoft Edge
- Mozilla Firefox (documentazione di Mozilla)
Per le versioni di Blazor in cui viene usato un JStoken JWT (ON Web Token), decodificare il contenuto del token usato per autenticare un client o accedere a un'API Web del server, a seconda della posizione in cui si verifica il problema. Per altre informazioni, vedere Esaminare il contenuto di un token Web ON (JWT).For more information, see Inspect the content of a JSON Web Token (JWT).
Il team della documentazione risponde al feedback e ai bug dei documenti negli articoli (aprire un problema dalla sezione Commenti e suggerimenti della pagina ), ma non è in grado di fornire supporto tecnico. Sono disponibili diversi forum di supporto pubblico per facilitare la risoluzione dei problemi di un'app. Consigliamo quanto segue:
I forum precedenti non sono di proprietà o controllati da Microsoft.
Per i report sui bug del framework non riservati, non sensibili e non riservati, aprire un problema con l'unità del prodotto ASP.NET Core. Non aprire un problema con l'unità di prodotto fino a quando non hai approfondito la causa di un problema e non puoi risolverlo autonomamente e con l'aiuto della community in un forum di supporto pubblico. L'unità prodotto non è in grado di risolvere i problemi relativi alle singole app interrotte a causa di semplici errori di configurazione o casi d'uso che coinvolgono servizi di terze parti. Se un report è sensibile o riservato in natura o descrive un potenziale difetto di sicurezza nel prodotto che gli utenti malintenzionati possono sfruttare, vedere Segnalazione di problemi di sicurezza e bug (
dotnet/aspnetcore
repository GitHub).Client non autorizzato per ME-ID
info: Microsoft.AspNetCore.Authorization.DefaultAuthorizationService[2] Autorizzazione non riuscita. Questi requisiti non sono stati soddisfatti: DenyAnonymousAuthorizationRequirement: richiede un utente autenticato.
Errore di callback di accesso da ME-ID:
- Errore:
unauthorized_client
- Description (Descrizione):
AADB2C90058: The provided application is not configured to allow public clients.
Per risolvere l'errore:
- Nella portale di Azure accedere al manifesto dell'app.
- Impostare l'attributo
allowPublicClient
sunull
o .true
- Errore:
Cookies e i dati del sito
Cookies e i dati del sito possono persistere tra gli aggiornamenti delle app e interferire con i test e la risoluzione dei problemi. Cancellare quanto segue quando si apportano modifiche al codice dell'app, modifiche all'account utente con il provider o modifiche alla configurazione dell'app del provider:
- Account di accesso cookieutente
- App cookies
- Dati del sito memorizzati nella cache e archiviati
Un approccio per evitare che i dati del sito e di s persistenti cookieinterferiscano con i test e la risoluzione dei problemi consiste nel:
- Configurare un browser
- Usare un browser per i test che è possibile configurare per eliminare tutti i cookie dati del sito e ogni volta che il browser viene chiuso.
- Assicurarsi che il browser venga chiuso manualmente o dall'IDE per qualsiasi modifica apportata alla configurazione dell'app, dell'utente di test o del provider.
- Usare un comando personalizzato per aprire un browser in modalità InPrivate o In incognito in Visual Studio:
- Aprire la finestra di dialogo Sfoglia con dal pulsante Esegui di Visual Studio.
- Seleziona il pulsante Aggiungi.
- Specificare il percorso del browser nel campo Programma . I percorsi eseguibili seguenti sono percorsi di installazione tipici per Windows 10. Se il browser è installato in un percorso diverso o non si usa Windows 10, specificare il percorso dell'eseguibile del browser.
- 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
- Microsoft Edge:
- Nel campo Argomenti specificare l'opzione della riga di comando usata dal browser per aprire in modalità InPrivate o Incognito. Alcuni browser richiedono l'URL dell'app.
- Microsoft Edge: usare
-inprivate
. - Google Chrome: usare
--incognito --new-window {URL}
, dove il segnaposto{URL}
è l'URL da aprire (ad esempio,https://localhost:5001
). - Mozilla Firefox: usare
-private -url {URL}
, dove il segnaposto{URL}
è l'URL da aprire (ad esempio,https://localhost:5001
).
- Microsoft Edge: usare
- Specificare un nome nel campo Nome descrittivo. Ad esempio:
Firefox Auth Testing
. - Selezionare il pulsante OK.
- Per evitare di dover selezionare il profilo del browser per ogni iterazione di test con un'app, impostare il profilo come predefinito con il pulsante Imposta come predefinito .
- Assicurarsi che il browser sia chiuso dall'IDE per qualsiasi modifica apportata all'app, all'utente di test o alla configurazione del provider.
Aggiornamenti di app
Un'app funzionante potrebbe non riuscire immediatamente dopo l'aggiornamento di .NET Core SDK nel computer di sviluppo o la modifica delle versioni dei pacchetti all'interno dell'app. In alcuni casi i pacchetti incoerenti possono interrompere un'app quando si eseguono aggiornamenti principali. La maggior parte di questi problemi può essere risolta attenendosi alle istruzioni seguenti:
- Cancellare le cache dei pacchetti NuGet del sistema locale eseguendo
dotnet nuget locals all --clear
da una shell dei comandi. - Eliminare le cartelle e
obj
delbin
progetto. - Ripristinare e ricompilare il progetto.
- Eliminare tutti i file nella cartella di distribuzione nel server prima di ridistribuire l'app.
Nota
L'uso di versioni del pacchetto incompatibili con il framework di destinazione dell'app non è supportato. Per informazioni su un pacchetto, usare La raccolta NuGet o Esplora pacchetti FuGet.
Eseguire l'app Server
Durante il test e la risoluzione dei problemi di una soluzione ospitataBlazor WebAssembly, assicurarsi di eseguire l'app dal Server
progetto.
Esaminare l'utente
Il componente seguente User
può essere usato direttamente nelle app o funge da base per un'ulteriore personalizzazione.
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));
}
}
Esaminare il contenuto di un JStoken WEB ON (JWT)
Per decodificare un JStoken JWT (ON Web Token), usare lo strumento di jwt.ms Microsoft. I valori nell'interfaccia utente non lasciano mai il browser.
JWT codificato di esempio (abbreviato per la visualizzazione):
eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImtpZCI6Ilg1ZVhrNHh5b2pORnVtMWtsMll0djhkbE5QNC1j ... bQdHBHGcQQRbW7Wmo6SWYG4V_bU55Ug_PW4pLPr20tTS8Ct7_uwy9DWrzCMzpD-EiwT5IjXwlGX3IXVjHIlX50IVIydBoPQtadvT7saKo1G5Jmutgq41o-dmz6-yBMKV2_nXA25Q
Esempio JWT decodificato dallo strumento per un'app che esegue l'autenticazione in Azure AAD B2C:
{
"typ": "JWT",
"alg": "RS256",
"kid": "X5eXk4xyojNFum1kl2Ytv8dlNP4-c57dO6QGTVBwaNk"
}.{
"exp": 1610059429,
"nbf": 1610055829,
"ver": "1.0",
"iss": "https://mysiteb2c.b2clogin.com/5cc15ea8-a296-4aa3-97e4-226dcc9ad298/v2.0/",
"sub": "5ee963fb-24d6-4d72-a1b6-889c6e2c7438",
"aud": "70bde375-fce3-4b82-984a-b247d823a03f",
"nonce": "b2641f54-8dc4-42ca-97ea-7f12ff4af871",
"iat": 1610055829,
"auth_time": 1610055822,
"idp": "idp.com",
"tfp": "B2C_1_signupsignin"
}.[Signature]
Risorse aggiuntive
- Configurare il dominio di pubblicazione di un'app
- Manifesto dell'app Microsoft Entra ID: attributo identifierUris
- Scenari di sicurezza aggiuntivi per ASP.NET Core Blazor WebAssembly
- Creare una versione personalizzata della libreria JavaScript Authentication.MSAL
- Richieste API Web non autenticate o non autorizzate in un'app con un client predefinito sicuro
- Autenticazione cloud con Azure Active Directory B2C in ASP.NET Core
- Esercitazione: Creare un tenant di Azure Active Directory B2C
- Esercitazione: Registrare un'applicazione in Azure Active Directory B2C
- Documentazione di Microsoft Identity Platform
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per