Proteggere ASP.NET app sul lato Blazor server Core

Questo articolo illustra come proteggere le app lato Blazor server come applicazioni principali ASP.NET.

Le app lato Blazor server vengono configurate per la sicurezza nello stesso modo delle app core ASP.NET. Per altre informazioni, vedere gli articoli negli argomenti dedicati alla sicurezza di ASP.NET Core.

Il contesto di autenticazione viene stabilito solo all'avvio dell'app, ovvero quando l'app si connette per la prima volta al WebSocket. Il contesto di autenticazione viene mantenuto per la durata del circuito. Le app riconvalidano periodicamente lo stato di autenticazione dell'utente, attualmente ogni 30 minuti per impostazione predefinita.

Se l'app deve acquisire utenti per servizi personalizzati o reagire agli aggiornamenti all'utente, vedere Scenari di sicurezza aggiuntivi sul lato server ASP.NET CoreBlazor.

Blazor differisce da un'app Web con rendering server tradizionale che effettua nuove richieste HTTP con cookies in ogni spostamento di pagina. L'autenticazione viene verificata durante gli eventi di spostamento. Tuttavia, cookienon sono coinvolti. Cookies viene inviato solo quando si effettua una richiesta HTTP a un server, che non avviene quando l'utente si sposta in un'app Blazor . Durante la navigazione, lo stato di autenticazione dell'utente viene controllato all'interno del Blazor circuito, che è possibile aggiornare in qualsiasi momento sul server usando l'astrazioneRevalidatingAuthenticationStateProvider.

Importante

L'implementazione di un personalizzato NavigationManager per ottenere la convalida dell'autenticazione durante la navigazione non è consigliata. Se l'app deve eseguire la logica dello stato di autenticazione personalizzata durante la navigazione, usare un oggetto personalizzato AuthenticationStateProvider.

Nota

Gli esempi di codice in questo articolo adottano tipi di riferimento nullable (NRT) e l'analisi statica dello stato null del compilatore .NET, supportati in ASP.NET Core in .NET 6 o versione successiva. Quando la destinazione è ASP.NET Core 5.0 o versioni precedenti, rimuovere la designazione di tipo Null (?) dagli esempi in questo articolo.

Modello di progetto

Creare una nuova app lato Blazor server seguendo le indicazioni riportate in Strumenti per ASP.NET Core Blazor.

Visual Studio

Dopo aver scelto il modello di app sul lato server e aver configurato il progetto, selezionare l'autenticazione dell'app in Tipo di autenticazione:

• Nessuno (impostazione predefinita): nessuna autenticazione.
• Account singoli: gli account utente vengono archiviati all'interno dell'app usando ASP.NET Core Identity.

Visual Studio Code

Quando si esegue il comando dell'interfaccia della riga di comando di .NET per creare e configurare l'app sul lato Blazor server, indicare il meccanismo di autenticazione con l'opzione -au|--auth :

-au {AUTHENTICATION}

Nota

Per il comando completo, vedere Strumenti per ASP.NET Core Blazor.

I valori di autenticazione consentiti per il {AUTHENTICATION} segnaposto sono illustrati nella tabella seguente.

Meccanismo di autenticazione	Descrizione
None (predefinito)	Nessuna autenticazione
Individual	Utenti archiviati nell'app con ASP.NET Core Identity

Per altre informazioni, vedere il comando dotnet new nella guida per .NET Core.

Interfaccia della riga di comando di .NET Core

Quando si esegue il comando dell'interfaccia della riga di comando di .NET per creare e configurare l'app sul lato Blazor server, indicare il meccanismo di autenticazione con l'opzione -au|--auth :

-au {AUTHENTICATION}

Nota

Per il comando completo, vedere Strumenti per ASP.NET Core Blazor.

I valori di autenticazione consentiti per il {AUTHENTICATION} segnaposto sono illustrati nella tabella seguente.

Meccanismo di autenticazione	Descrizione
None (predefinito)	Nessuna autenticazione
Individual	Utenti archiviati nell'app con ASP.NET Core Identity

Per altre informazioni:

• Vedere il comando dotnet new nella guida per .NET Core.

• Eseguire il comando della Guida per il modello in una shell dei comandi:

  dotnet new {PROJECT TEMPLATE} --help
  

  Nel comando precedente il {PROJECT TEMPLATE} segnaposto è il modello di progetto.

BlazorIdentity Interfaccia utente (singoli account)

Blazor supporta la generazione di un'interfaccia utente completa Blazorbasata su Identity quando si sceglie l'opzione di autenticazione per singoli account.

Il Blazor modello app Web esegue lo scaffolding del Identity codice per un database di SQL Server. La versione della riga di comando usa SQLite per impostazione predefinita e include un database SQLite per Identity.

Il modello gestisce quanto segue:

• Aggiunge IdentityRazor componenti e logica correlata per le attività di autenticazione di routine, ad esempio l'accesso e l'uscita degli utenti.
  • I Identity componenti supportano anche funzionalità avanzate Identity , ad esempio la conferma dell'account e il ripristino delle password e l'autenticazione a più fattori usando un'app di terze parti.
  • Sono supportati gli scenari di rendering lato server interattivo (SSR interattivo) e csr (Client-Side Rendering).
• Aggiunge i Identitypacchetti e le dipendenze correlati a .
• Fa riferimento ai Identity pacchetti in _Imports.razor.
• Crea una classe utente Identity personalizzata (ApplicationUser).
• Crea e registra un EF Core contesto di database (ApplicationDbContext).
• Configura il routing per gli endpoint predefiniti Identity .
• Include Identity la convalida e la logica di business.

Per esaminare i Blazor componenti del Identity framework, accedervi nelle Pages cartelle e Shared della Account cartella nel Blazor modello di progetto app Web (origine di riferimento).

Quando si scelgono le modalità di rendering Interattivo WebAssembly o Interactive Auto, il server gestisce tutte le richieste di autenticazione e autorizzazione e i Identity componenti vengono visualizzati in modo statico sul server nel Blazor progetto principale dell'app Web. Il modello di progetto include una PersistentAuthenticationStateProvider classe (origine di riferimento) nel .Client progetto per sincronizzare lo stato di autenticazione dell'utente tra il server e il browser. La classe è un'implementazione personalizzata di AuthenticationStateProvider. Il provider usa la PersistentComponentState classe per anteporre lo stato di autenticazione e renderla persistente nella pagina.

BlazorIdentity dipende dalle DbContext istanze non create da una factory, che è intenzionale perché DbContext è sufficiente per il rendering statico dei componenti del modello di Identity progetto senza supportare l'interattività.

Nel progetto principale di un'app Blazor Web, il provider di stato di autenticazione è denominatoIdentityRevalidatingAuthenticationStateProvider(origine di riferimento) (solo soluzioni di interattività server) o PersistingRevalidatingAuthenticationStateProvider (origine riferimento) (WebAssembly o soluzioni di interattività automatica).

Per una descrizione del modo in cui le modalità di rendering interattive globali vengono applicate aIdentity componenti diversi dall'applicazione contemporaneamente di SSR statico per i Identity componenti, vedere ASP.NET modalità di rendering coreBlazor.

Per altre informazioni sulla persistenza dello stato prerenderato, vedere Prerender ASP.NET Componenti principaliRazor.

Per altre informazioni sull'interfaccia utente e indicazioni sull'integrazione BlazorIdentity di account di accesso esterni tramite siti Web di social networking, vedere Novità dell'identità in .NET 8.

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).

Gestire lo stato di autenticazione in Blazor App Web

Questa sezione si applica alle Blazor App Web che adottano:

• Rendering interattivo lato server (SSR interattivo) e CSR.
• Rendering lato client (CSR).

Un provider di stato di autenticazione lato client viene usato solo all'interno Blazor di e non è integrato con il sistema di autenticazione ASP.NET Core. Durante la pre-esecuzione, Blazor rispetta i metadati definiti nella pagina e usa il sistema di autenticazione ASP.NET Core per determinare se l'utente è autenticato. Quando un utente passa da una pagina a un'altra, viene usato un provider di autenticazione lato client. Quando l'utente aggiorna la pagina (ricaricamento a pagina intera), il provider di stato di autenticazione lato client non è coinvolto nella decisione di autenticazione sul server. Poiché lo stato dell'utente non è persistente dal server, qualsiasi stato di autenticazione gestito sul lato client viene perso.

Per risolvere questo problema, l'approccio migliore consiste nell'eseguire l'autenticazione all'interno del sistema di autenticazione principale ASP.NET. Il provider di stato di autenticazione lato client si occupa solo di riflettere lo stato di autenticazione dell'utente. Gli esempi di come eseguire questa operazione con i provider di stato di autenticazione sono illustrati dal Blazor modello di progetto App Web:

• PersistingRevalidatingAuthenticationStateProvider(origine di riferimento): per Blazor App Web che adottano il rendering lato server interattivo (SSR interattivo) e il rendering lato client (CSR). Si tratta di un lato AuthenticationStateProvider server che riconvalida il timbro di sicurezza per l'utente connesso ogni 30 minuti che un circuito interattivo è connesso. Usa anche il servizio Stato componente persistente per eseguire il flusso dello stato di autenticazione al client, che viene quindi corretto per la durata della richiesta di firma del certificato.

• PersistingServerAuthenticationStateProvider(origine di riferimento): per Blazor App Web che adottano solo csr. Si tratta di un lato AuthenticationStateProvider server che usa il servizio Stato componente persistente per trasferire lo stato di autenticazione al client, che viene quindi risolto per la durata della richiesta di firma del certificato.

• PersistentAuthenticationStateProvider(origine di riferimento): per Blazor App Web che adottano csr. Si tratta di un lato AuthenticationStateProvider client che determina lo stato di autenticazione dell'utente cercando i dati salvati in modo permanente nella pagina quando è stato eseguito il rendering nel server. Questo stato di autenticazione è fisso per la durata della richiesta di firma del certificato. Se l'utente deve accedere o disconnettersi, è necessario ricaricare a pagina intera. Questo fornisce solo un nome utente e un messaggio di posta elettronica a scopo di visualizzazione. Non include token che eseguono l'autenticazione al server quando effettuano richieste successive, che vengono gestite separatamente usando un cookie oggetto incluso nelle HttpClient richieste al server.

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).

Attestazioni e token aggiuntivi da provider esterni

Per archiviare attestazioni aggiuntive da provider esterni, vedere Rendere persistenti attestazioni e token aggiuntivi da provider esterni in ASP.NET Core.

Servizio app di Azure in Linux con Identity Server

Specificare l'autorità emittente in modo esplicito durante la distribuzione in Servizio app di Azure in Linux con Identity Server. Per altre informazioni, vedere Usare Identity per proteggere un back-end dell'API Web per le applicazioni a pagina singola.

Implementare un AuthenticationStateProvider personalizzato

Se l'app richiede un provider personalizzato, implementare ed eseguire AuthenticationStateProvider l'override GetAuthenticationStateAsyncdi .

Nell'esempio seguente tutti gli utenti vengono autenticati con il nome utente mrfibuli.

CustomAuthStateProvider.cs:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    public override Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var identity = new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.Name, "mrfibuli"),
        }, "Custom Authentication");

        var user = new ClaimsPrincipal(identity);

        return Task.FromResult(new AuthenticationState(user));
    }
}

Il CustomAuthStateProvider servizio viene registrato nel Program file :

using Microsoft.AspNetCore.Components.Authorization;

...

builder.Services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Confermare o aggiungere un oggetto AuthorizeRouteView al Router componente.

Nel componente Routes (Components/Routes.razor):

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

Aggiungere servizi di stato di autenticazione a catena alla raccolta di servizi nel Program file:

builder.Services.AddCascadingAuthenticationState();

Nota

Quando si crea un'app Blazor da uno dei Blazor modelli di progetto con l'autenticazione abilitata, l'app include e AuthorizeRouteView la chiamata a AddCascadingAuthenticationState. Per altre informazioni, vedere ASP.NET'autenticazione e autorizzazione core Blazor con informazioni aggiuntive presentate nella sezione Personalizzare il contenuto non autorizzato con il componente Router.

Un AuthorizeView oggetto illustra il nome dell'utente autenticato in qualsiasi componente:

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

Per indicazioni sull'uso di AuthorizeView, vedere ASP.NET Autenticazione e autorizzazione di baseBlazor.

Notifica per le modifiche dello stato di autenticazione

Un oggetto personalizzato AuthenticationStateProvider può richiamare NotifyAuthenticationStateChanged sulla AuthenticationStateProvider classe di base per notificare ai consumer la modifica dello stato di autenticazione per il rerender.

L'esempio seguente si basa sull'implementazione di un oggetto personalizzato AuthenticationStateProvider seguendo le indicazioni riportate nella sezione Implementare una personalizzata AuthenticationStateProvider .

L'implementazione seguente CustomAuthStateProvider espone un metodo personalizzato, AuthenticateUser, per accedere a un utente e notificare ai consumer la modifica dello stato di autenticazione.

CustomAuthStateProvider.cs:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    public override Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var identity = new ClaimsIdentity();
        var user = new ClaimsPrincipal(identity);

        return Task.FromResult(new AuthenticationState(user));
    }

    public void AuthenticateUser(string userIdentifier)
    {
        var identity = new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.Name, userIdentifier),
        }, "Custom Authentication");

        var user = new ClaimsPrincipal(identity);

        NotifyAuthenticationStateChanged(
            Task.FromResult(new AuthenticationState(user)));
    }
}

In un componente:

• Inserimento di AuthenticationStateProvider.
• Aggiungere un campo per contenere l'identificatore dell'utente.
• Aggiungere un pulsante e un metodo a cui eseguire il AuthenticationStateProviderCustomAuthStateProvider cast e chiamare AuthenticateUser con l'identificatore dell'utente.

@inject AuthenticationStateProvider AuthenticationStateProvider

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        ((CustomAuthStateProvider)AuthenticationStateProvider)
            .AuthenticateUser(userIdentifier);
    }
}

L'approccio precedente può essere migliorato per attivare le notifiche delle modifiche dello stato di autenticazione tramite un servizio personalizzato. Di seguito AuthenticationService viene mantenuta l'entità attestazioni dell'utente corrente in un campo sottostante () con un evento (currentUserUserChanged) a cui l'oggetto AuthenticationStateProvider può sottoscrivere, in cui l'evento richiama NotifyAuthenticationStateChanged. Con la configurazione aggiuntiva più avanti in questa sezione, AuthenticationService è possibile inserire in un componente con logica che imposta l'oggetto CurrentUser per attivare l'evento UserChanged .

using System.Security.Claims;

public class AuthenticationService
{
    public event Action<ClaimsPrincipal>? UserChanged;
    private ClaimsPrincipal? currentUser;

    public ClaimsPrincipal CurrentUser
    {
        get { return currentUser ?? new(); }
        set
        {
            currentUser = value;

            if (UserChanged is not null)
            {
                UserChanged(currentUser);
            }
        }
    }
}

Program Nel file registrare AuthenticationService nel contenitore di inserimento delle dipendenze:

builder.Services.AddScoped<AuthenticationService>();

Il codice seguente CustomAuthStateProvider sottoscrive l'evento AuthenticationService.UserChanged . GetAuthenticationStateAsync restituisce lo stato di autenticazione dell'utente. Inizialmente, lo stato di autenticazione è basato sul valore di AuthenticationService.CurrentUser. Quando si verifica una modifica all'utente, viene creato un nuovo stato di autenticazione con il nuovo utente (new AuthenticationState(newUser)) per le chiamate a GetAuthenticationStateAsync:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    private AuthenticationState authenticationState;

    public CustomAuthStateProvider(AuthenticationService service)
    {
        authenticationState = new AuthenticationState(service.CurrentUser);

        service.UserChanged += (newUser) =>
        {
            authenticationState = new AuthenticationState(newUser);

            NotifyAuthenticationStateChanged(
                Task.FromResult(new AuthenticationState(newUser)));
        };
    }

    public override Task<AuthenticationState> GetAuthenticationStateAsync() =>
        Task.FromResult(authenticationState);
}

Il metodo del SignIn componente seguente crea un'entità attestazioni per l'identificatore dell'utente da impostare su AuthenticationService.CurrentUser:

@inject AuthenticationService AuthenticationService

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        var currentUser = AuthenticationService.CurrentUser;

        var identity = new ClaimsIdentity(
            new[]
            {
                new Claim(ClaimTypes.Name, userIdentifier),
            },
            "Custom Authentication");

        var newUser = new ClaimsPrincipal(identity);

        AuthenticationService.CurrentUser = newUser;
    }
}

AuthenticationStateProvider Inserimento per i servizi con ambito a un componente

Non tentare di risolvere AuthenticationStateProvider all'interno di un ambito personalizzato perché comporta la creazione di una nuova istanza di AuthenticationStateProvider che non è inizializzata correttamente.

Per accedere all'oggetto AuthenticationStateProvider all'interno di un servizio con ambito a un componente, inserire AuthenticationStateProvider con la@injectdirettiva o l'attributo [Inject] e passarlo al servizio come parametro. Questo approccio garantisce che venga usata l'istanza corretta e inizializzata di per ogni istanza dell'app AuthenticationStateProvider utente.

ExampleService.cs:

public class ExampleService
{
    public async Task<string> ExampleMethod(AuthenticationStateProvider authStateProvider)
    {
        var authState = await authStateProvider.GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            return $"{user.Identity.Name} is authenticated.";
        }
        else
        {
            return "The user is NOT authenticated.";
        }
    }
}

Registrare il servizio come ambito. In un'app lato Blazor server, i servizi con ambito hanno una durata uguale alla durata del circuito di connessione client.

Nel file Program:

builder.Services.AddScoped<ExampleService>();

Nel componente InjectAuthStateProvider seguente:

• Il componente eredita OwningComponentBase.
• L'oggetto AuthenticationStateProvider viene inserito e passato a ExampleService.ExampleMethod.
• ExampleService viene risolto con OwningComponentBase.ScopedServices e GetRequiredService, che restituisce l'istanza inizializzata corretta di ExampleService che esiste per la durata del circuito dell'utente.

InjectAuthStateProvider.razor:

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

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

<p>@message</p>

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

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

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

Per altre informazioni, vedere le indicazioni su OwningComponentBase in ASP.NET Blazor core dependency injection.

Visualizzazione di contenuto non autorizzato durante la pre-gestione con un oggetto personalizzato AuthenticationStateProvider

Per evitare di visualizzare contenuto non autorizzato, ad esempio contenuto in un componente, durante la pre-gestione con un oggetto personalizzatoAuthenticationStateProvider, adottare uno degli approcci seguenti:AuthorizeView

• Implementare IHostEnvironmentAuthenticationStateProvider per l'oggetto personalizzato AuthenticationStateProvider per supportare la prerendering: per un'implementazione di esempio di IHostEnvironmentAuthenticationStateProvider, vedere l'implementazione Blazor del ServerAuthenticationStateProvider framework in ServerAuthenticationStateProvider.cs (origine di riferimento).

  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).

• Disabilita prerendering: indicare la modalità di rendering con il prerender parametro impostato su false al componente di livello più alto nella gerarchia dei componenti dell'app che non è un componente radice.

  Nota

  Rendere interattivo un componente radice, ad esempio il App componente, non è supportato. Di conseguenza, il prerendering non può essere disabilitato direttamente dal App componente.

  Per le app basate sul modello di Blazor progetto app Web, il prerendering viene in genere disabilitato in cui il Routes componente viene usato nel App componente (Components/App.razor):

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

  Disabilitare anche la prerendering per il HeadOutlet componente:

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

  È anche possibile disabilitare in modo selettivo la prerendering con un controllo fine della modalità di rendering applicata all'istanza del Routes componente. Per altre informazioni, vedere ASP.NET Modalità di rendering coreBlazor.

• Autenticare l'utente nel server prima dell'avvio dell'app: per adottare questo approccio, l'app deve rispondere alla richiesta iniziale di un utente con la pagina o la Identityvisualizzazione di accesso basata su e impedire le richieste agli endpoint fino a Blazor quando non vengono autenticate. Per altre informazioni, vedere Creare un'app ASP.NET Core con i dati utente protetti dall'autorizzazione. Dopo l'autenticazione, il contenuto non autorizzato nei componenti prerenderati Razor viene visualizzato solo quando l'utente non è realmente autorizzato a visualizzare il contenuto.

Gestione dello stato utente

Nonostante la parola "state" nel nome, AuthenticationStateProvider non è per l'archiviazione dello stato utente generale. AuthenticationStateProvider indica solo lo stato di autenticazione dell'utente all'app, se hanno eseguito l'accesso all'app e chi ha eseguito l'accesso.

L'autenticazione usa la stessa autenticazione ASP.NET Core Identity delle Razor app Pages e MVC. Lo stato utente archiviato per i flussi ASP.NET Core Identity a Blazor senza aggiungere codice aggiuntivo all'app. Seguire le indicazioni riportate negli articoli e nelle esercitazioni di base di ASP.NET Identity per rendere effettive le Identity funzionalità nelle Blazor parti dell'app.

Per indicazioni sulla gestione generale dello stato all'esterno di ASP.NET CoreIdentity, vedere ASP.NET Gestione dello stato coreBlazor.

Astrazioni di sicurezza aggiuntive

Due astrazioni aggiuntive partecipano alla gestione dello stato di autenticazione:

• ServerAuthenticationStateProvider (origine di riferimento): usato AuthenticationStateProvider dal Blazor framework per ottenere lo stato di autenticazione dal server.

• RevalidatingServerAuthenticationStateProvider (origine di riferimento): classe base per AuthenticationStateProvider i servizi usati dal Blazor framework per ricevere uno stato di autenticazione dall'ambiente host e riconvalidarla a intervalli regolari.

  L'intervallo di riconvalida di 30 minuti predefinito può essere regolato in RevalidatingIdentityAuthenticationStateProvider (Areas/Identity/RevalidatingIdentityAuthenticationStateProvider.cs). L'esempio seguente riduce l'intervallo a 20 minuti:

  protected override TimeSpan RevalidationInterval => TimeSpan.FromMinutes(20);
  

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).

Durata della validità dell'URL di reindirizzamento temporaneo

Questa sezione si applica a Blazor App Web.

Usare l'opzione RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration per ottenere o impostare la durata della validità della protezione dei dati per gli URL di reindirizzamento temporanei generati dal Blazor rendering lato server. Questi vengono usati solo temporaneamente, quindi la durata deve essere sufficiente per consentire a un client di ricevere l'URL e iniziare a spostarsi. Tuttavia, dovrebbe anche essere abbastanza lungo per consentire l'asimmetria dell'orologio tra i server. Il valore predefinito è cinque minuti.

Nell'esempio seguente il valore viene esteso a sette minuti:

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

Risorse aggiuntive

• Guida introduttiva: Aggiungere l'accesso con Microsoft a un'app Web ASP.NET Core
• Guida introduttiva: Proteggere un'API Web ASP.NET Core con Microsoft Identity Platform
• Configurare ASP.NET Core per l'uso con server proxy e servizi di bilanciamento del carico: include indicazioni su:
  • Uso del middleware delle intestazioni inoltrate per mantenere le informazioni sullo schema HTTPS tra server proxy e reti interne.
  • Altri scenari e casi d'uso, tra cui la configurazione manuale dello schema, le modifiche del percorso della richiesta per il routing corretto delle richieste e l'inoltro dello schema delle richieste per i proxy inversi Linux e non IIS.