Protección de aplicaciones de Blazor del lado servidor de ASP.NET Core

  • Artículo

Nota:

Esta no es la versión más reciente de este artículo. Para la versión actual, consulte la versión .NET 8 de este artículo.

Importante

Esta información hace referencia a un producto en versión preliminar, el cual puede sufrir importantes modificaciones antes de que se publique la versión comercial. Microsoft no proporciona ninguna garantía, expresa o implícita, con respecto a la información proporcionada aquí.

Para la versión actual, consulte la versión .NET 8 de este artículo.

En este artículo se explica cómo proteger las aplicaciones de Blazor del lado servidor como aplicaciones ASP.NET Core.

Las aplicaciones de Blazor del lado servidor están configuradas para la seguridad, de la misma manera que las aplicaciones ASP.NET Core. Para obtener más información, consulte los artículos disponibles en Temas de seguridad de ASP.NET Core.

El contexto de autenticación solo se establece cuando se inicia la aplicación, es decir, cuando la aplicación se conecta por primera vez a WebSocket. El contexto de la autenticación se mantiene durante la vigencia del circuito. Las aplicaciones vuelven a validar periódicamente el estado de autenticación del usuario. Actualmente, esto se realiza cada 30 minutos de forma predeterminada.

Si la aplicación debe capturar usuarios para servicios personalizados o reaccionar a las actualizaciones del usuario, consulte escenarios de seguridad adicionales del lado servidor de ASP.NET Core Blazor.

El Blazor difiere de una aplicación web representada por el servidor tradicional que realiza nuevas solicitudes HTTP con cookies en cada navegación de página. La autenticación se comprueba durante los eventos de navegación. Sin embargo, no se tienen en cuenta las cookies. Las Cookies solo se envían al realizar una solicitud HTTP a un servidor, lo cual no sucede cuando el usuario navega en una aplicación de Blazor. Durante la navegación, el estado de la autenticación del usuario se comprueba dentro del circuito de Blazor, que puede actualizar en cualquier momento en el servidor mediante la abstracción del RevalidatingAuthenticationStateProvider.

Importante

No se recomienda implementar un NavigationManager personalizado para lograr la validación de autenticación durante la navegación. Si la aplicación debe ejecutar la lógica de estado de autenticación personalizada durante la navegación, use un AuthenticationStateProvider personalizado.

Nota:

En los ejemplos de código de este artículo se adoptan tipos de referencia que admiten un valor NULL (NRT) y análisis estático de estado NULL del compilador de .NET, que se admiten en ASP.NET Core en .NET 6 o posterior. Al tener como destino ASP.NET Core 5.0 o versiones anteriores, quite la designación de tipo null (?) de los ejemplos del artículo.

Plantilla de proyectos

Cree una nueva aplicación de Blazor del lado servidor siguiendo las instrucciones de Herramienta para ASP.NET Core Blazor.

Después de elegir la plantilla de aplicación del lado servidor y configurar el proyecto, seleccione la autenticación de la aplicación en Tipo de autenticación:

  • Ninguno (predeterminado): no hay autenticación.
  • Cuentas individuales: las cuentas de usuario se almacenan en la aplicación mediante Identity en ASP.NET Core.
  • Ninguno (predeterminado): no hay autenticación.
  • Cuentas individuales: las cuentas de usuario se almacenan en la aplicación mediante Identity en ASP.NET Core.
  • Plataforma de identidad de Microsoft: para más información, consulte Autenticación y autorización de Blazor en ASP.NET Core.
  • Windows: use la autenticación de Windows.

BlazorIdentityUI (cuentas individuales)

Blazor admite la generación de una interfaz de usuario completa basada en BlazorIdentity al elegir la opción de autenticación para cuentas individuales.

La plantilla de aplicación web de Blazor sirve de andamiaje para el código de Identity para una base de datos de SQL Server. La versión de la línea de comandos usa SQLite de forma predeterminada e incluye una base de datos de SQLite para Identity.

La plantilla se ocupa de lo siguiente:

  • Agrega componentes IdentityRazor y lógica relacionada para tareas de autenticación rutinarias, como iniciar y cerrar usuarios.
  • Agrega los paquetes y dependencias relacionados con Identity.
  • Hace referencia a los paquetes de Identity en _Imports.razor.
  • Crea una clase de usuario Identity personalizada (ApplicationUser).
  • Crea y registra un contexto de base de datos EF Core (ApplicationDbContext).
  • Configura el enrutamiento para los puntos de conexión integrados Identity.
  • Incluye validación y lógica de negocios de Identity.

Para inspeccionar los componentes Identity del marco Blazor, acceda a ellos en las carpetas Pages y Shared de la carpeta Account de la plantilla de proyecto de Web App Blazor (origen de referencia).

Al elegir los modos de representación de WebAssembly interactivo o Automático interactivo, el servidor controla todas las solicitudes de autenticación y autorización, y los componentes de Identity se representan estáticamente en el servidor en el proyecto principal de Blazor Web Apps. La plantilla de proyecto incluye una clase PersistentAuthenticationStateProvider (origen de referencia) en el proyecto .Client para sincronizar el estado de autenticación del usuario entre el servidor y el explorador. La clase es una implementación personalizada de AuthenticationStateProvider. El proveedor usa la clase PersistentComponentState para representar previamente el estado de autenticación y conservarlo en la página.

BlazorIdentity depende de las instancias de DbContext no creadas por una fábrica, lo que es intencional porque DbContext es suficiente para que los componentes de Identity de la plantilla del proyecto se representen estáticamente sin admitir la interactividad.

En el proyecto principal de una aplicación web Blazor, el proveedor de estado de autenticación se denomina IdentityRevalidatingAuthenticationStateProvider (origen de referencia) (solo soluciones de interactividad de servidor) o PersistingRevalidatingAuthenticationStateProvider (origen de referencia) (Soluciones de interactividad de WebAssembly o Auto interactividad).

Para obtener una descripción de cómo se aplican los modos de representación interactiva global a los componentes que no son componentes Identity, mientras que al mismo tiempo se aplica SSR estático a los componentes Identity, consulte ASP.NET Core Blazor modos de representación.

Para obtener más información sobre cómo conservar el estado prerrepresentado, consulte Prerrepresentar componentes Razor ASP.NET Core.

Para obtener más información sobre la BlazorIdentity interfaz de usuario y orientación sobre cómo integrar inicios de sesión externos a través de sitios web sociales, consulte Novedades de la identidad en .NET 8.

Nota:

Los vínculos de la documentación al origen de referencia de .NET cargan normalmente la rama predeterminada del repositorio, que representa el desarrollo actual para la próxima versión de .NET. Para seleccionar una etiqueta de una versión específica, use la lista desplegable Cambiar ramas o etiquetas. Para obtener más información, vea Procedimientos para seleccionar una etiqueta de versión de código fuente de ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Administrar el estado de autenticación en Blazor aplicaciones web

Esta sección se aplica a las Blazor aplicaciones Web que adoptan:

  • Representación interactiva del lado del servidor (SSR interactivo) y CSR.
  • Representación del lado cliente (CSR).

Un proveedor de estado de autenticación del lado cliente solo se usa en Blazor y no está integrado con el sistema de autenticación ASP.NET Core. Durante la representación previa, Blazor respeta los metadatos definidos en la página y usa el sistema de autenticación ASP.NET Core para determinar si el usuario está autenticado. Cuando un usuario navega de una página a otra, se usa un proveedor de autenticación del lado cliente. Cuando el usuario actualiza la página (recarga de página completa), el proveedor de estado de autenticación del lado cliente no participa en la decisión de autenticación en el servidor. Dado que el servidor no conserva el estado del usuario, se pierde ningún estado de autenticación mantenido en el lado cliente.

Para solucionar esto, el mejor enfoque es realizar la autenticación en el sistema de autenticación ASP.NET Core. El proveedor de estado de autenticación del lado cliente solo se encarga de reflejar el estado de autenticación del usuario. Los ejemplos de cómo hacerlo con proveedores de estado de autenticación se muestran mediante la plantilla de proyecto de aplicación web Blazor:

Nota:

Los vínculos de la documentación al origen de referencia de .NET cargan normalmente la rama predeterminada del repositorio, que representa el desarrollo actual para la próxima versión de .NET. Para seleccionar una etiqueta de una versión específica, use la lista desplegable Cambiar ramas o etiquetas. Para obtener más información, vea Procedimientos para seleccionar una etiqueta de versión de código fuente de ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Scaffolding para Identity

Para obtener más información sobre scaffolding de Identity en un proyecto de aplicación Blazor del lado servidor, consulte Scaffolding de Identity en proyectos de ASP.NET Core.

Scaffolding de Identity a una aplicación de Blazor del lado servidor:

Notificaciones y tokens adicionales de proveedores externos

Para almacenar notificaciones adicionales de proveedores externos, consulte Conservar notificaciones y tokens adicionales en in ASP.NET Core.

Azure App Service en Linux con Identity Server

Al realizar una implementación en Azure App Service en Linux con Identity Server, especifique el emisor de forma explícita. Para más información, consulte Uso de Identity para proteger un back-end de API web para SPA.

Implementación de un elemento AuthenticationStateProvider personalizado

Si la aplicación requiere un proveedor personalizado, implemente un AuthenticationStateProvider e invalide el GetAuthenticationStateAsync.

En el siguiente ejemplo, todos los usuarios se autentican con el nombre de usuario 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));
    }
}

El servicio CustomAuthStateProvider se registra en el archivo Program:

using Microsoft.AspNetCore.Components.Authorization;

...

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

El servicio CustomAuthStateProvider se registra en el archivo Programdespués de la llamada a AddServerSideBlazor:

using Microsoft.AspNetCore.Components.Authorization;

...

builder.Services.AddServerSideBlazor();

...

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

El servicio CustomAuthStateProvider se registra en los Startup.ConfigureServices de Startup.csdespués de la llamada a AddServerSideBlazor:

using Microsoft.AspNetCore.Components.Authorization;

...

services.AddServerSideBlazor();

...

services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Confirme o agregue un elemento de AuthorizeRouteView al componente Router.

En el componente Routes (Components/Routes.razor):

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

Agregue servicios de estado de autenticación en cascada a la colección de servicios del archivo Program:

builder.Services.AddCascadingAuthenticationState();

Nota:

Al crear una aplicación de Blazor a partir de una de las plantillas de proyecto de Blazor con la autenticación habilitada, la aplicación incluye el componente AuthorizeRouteView y la llamada a AddCascadingAuthenticationState. Para obtener más información, consulte Autenticación y autorización de Blazor en ASP.NET Core con información adicional presentada en la sección Personalización de contenido no autorizado con el componente enrutador del artículo.

Confirme o agregue un elemento de AuthorizeRouteView y CascadingAuthenticationState al componente de Router.

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

Nota:

Al crear una aplicación de Blazor a partir de una de las plantillas de proyecto de Blazor con autenticación habilitada, la aplicación incluye los componentes AuthorizeRouteView y CascadingAuthenticationState que se muestran en el ejemplo anterior. Para obtener más información, consulte Autenticación y autorización de Blazor en ASP.NET Core con información adicional presentada en la sección Personalización de contenido no autorizado con el componente enrutador del artículo.

Una AuthorizeView muestra el nombre del usuario autenticado en cualquier componente:

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

Para obtener instrucciones sobre el uso de la AuthorizeView, consulte Autenticación y autorización de Blazor en ASP.NET Core.

Notificación sobre los cambios de estado de autenticación

Un AuthenticationStateProvider personalizado puede invocar a NotifyAuthenticationStateChanged en la clase base del AuthenticationStateProvider para notificar a los consumidores del cambio de estado de la autenticación para una nueva representación.

El ejemplo siguiente se basa en la implementación de un AuthenticationStateProvider personalizado mediante el seguimiento de las instrucciones de la sección Implementar un AuthenticationStateProvider personalizado.

La siguiente implementación del CustomAuthStateProvider expone un método personalizado, AuthenticateUser, para iniciar sesión con un usuario y notificar a los consumidores del cambio de estado de la autenticación.

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

En un componente:

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

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

El enfoque anterior se puede mejorar para desencadenar notificaciones de cambios de estado de autenticación a través de un servicio personalizado. El AuthenticationService siguiente mantiene la entidad de seguridad de notificaciones del usuario actual en un campo de respaldo (currentUser) con un evento (UserChanged) al que AuthenticationStateProvider se puede suscribir. En él, el evento invoca a NotifyAuthenticationStateChanged. Con la configuración adicional que se verá más adelante en esta sección, AuthenticationService se puede insertar en un componente con lógica que establece al CurrentUser para desencadenar el 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);
            }
        }
    }
}

En el archivo Program, registre el AuthenticationService en el contenedor de inserción de dependencias:

builder.Services.AddScoped<AuthenticationService>();

En los Startup.ConfigureServices de Startup.cs, registre el AuthenticationService en el contenedor de inserción de dependencias:

services.AddScoped<AuthenticationService>();

El siguiente CustomAuthStateProvider se suscribe al evento AuthenticationService.UserChanged. GetAuthenticationStateAsync devuelve el estado de autenticación del usuario. Inicialmente, el estado de autenticación se basa en el valor de AuthenticationService.CurrentUser. Cuando se produce un cambio en el usuario, se crea un nuevo estado de autenticación con el nuevo usuario (new AuthenticationState(newUser)) para las llamadas 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);
}

El método de SignIn del componente siguiente crea una entidad de seguridad de notificaciones para que el identificador del usuario lo establezca en el 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;
    }
}

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

Inserción del AuthenticationStateProvider para los servicios con ámbito en un componente

No intente resolver AuthenticationStateProvider dentro de un ámbito personalizado porque dará como resultado la creación de una nueva instancia del AuthenticationStateProvider que no se inicializa correctamente.

Para acceder al AuthenticationStateProvider dentro de un servicio con ámbito en un componente, inserte al AuthenticationStateProvider con la directiva @inject o el atributo [Inject] y páselo al servicio como parámetro. Este enfoque garantiza que la instancia correcta e inicializada del AuthenticationStateProvider se use para cada instancia de aplicación de usuario.

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

Registre el servicio como uno con ámbito. En una aplicación del lado servidor de Blazor, los servicios con ámbito tienen una vigencia igual a la duración del circuito de la conexión de cliente.

En el archivo Program:

builder.Services.AddScoped<ExampleService>();

En Startup.ConfigureServices de Startup.cs:

services.AddScoped<ExampleService>();

En el componente InjectAuthStateProvider siguiente:

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

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

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

<p>@message</p>

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

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

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

Para más información, consulte las instrucciones de OwningComponentBase en la Inserción de dependencias de Blazor en ASP.NET Core.

Presentación de contenido no autorizado durante la representación previa con un AuthenticationStateProviderpersonalizado

Para evitar mostrar contenido no autorizado, por ejemplo contenido en un componente AuthorizeView, mientras se representa previamente con un elemento AuthenticationStateProvider personalizado, adopte uno de los enfoques siguientes:

  • Deshabilite la representación previa: indique el modo de representación con el parámetro prerender establecido en false en el componente de nivel más alto de la jerarquía de componentes de la aplicación que no sea un componente raíz.

    Nota:

    No se admite la creación de un componente raíz interactivo, como el componente App. Por lo tanto, el componente App no puede deshabilitar la representación previa directamente.

    En el caso de las aplicaciones basadas en la plantilla de proyecto de Blazor Web Apps, la representación previa se deshabilita normalmente cuando se usa el componente Routes en el componente App (Components/App.razor):

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

    Además, deshabilite la representación previa para el componente de HeadOutlet:

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

    También puede deshabilitar de forma selectiva la representación previa con un control preciso del modo de representación aplicado a la instancia del componente Routes. Para obtener más información, vea Modos de representación de ASP.NET CoreBlazor.

  • Autenticar al usuario en el servidor antes de que se inicie la aplicación: para adoptar este enfoque, la aplicación debe responder a la solicitud inicial de un usuario con la página o vista de inicio de sesión basada en Identity y evitar las solicitudes a puntos de conexión Blazor hasta que se autentiquen. Para más información, consulte Creación de una aplicación ASP.NET Core con datos de usuario protegidos por autorización. Después de la autenticación, solo se muestra contenido no autorizado en componentes de Razor creados previamente cuando el usuario no está autorizado para ver el contenido.

Administración de Estados de usuario

A pesar de contener la palabra "state" (estado) en el nombre, AuthenticationStateProvider no se usa para almacenar el estado del usuario general. AuthenticationStateProvider indica únicamente el estado de autenticación del usuario a la aplicación, si ha iniciado sesión en ella y el nombre de usuario con el que ha iniciado sesión.

La autenticación usa la misma autenticación ASP.NET Core Identity que Razor Pages y las aplicaciones MVC. El estado de usuario almacenado en la Identity de ASP.NET Core se dirige a Blazor sin agregar código adicional a la aplicación. Siga las instrucciones de los artículos y tutoriales de la Identity de ASP.NET Core para que las características de Identity surtan efecto en los elementos Blazor de la aplicación.

Para obtener instrucciones sobre la administración de estado general fuera de la Identity de ASP.NET Core, consulte: Administración de estado de Blazor en ASP.NET Core.

Abstracciones de seguridad adicionales

Dos abstracciones adicionales participan en la administración del estado de autenticación:

Nota:

Los vínculos de la documentación al origen de referencia de .NET cargan normalmente la rama predeterminada del repositorio, que representa el desarrollo actual para la próxima versión de .NET. Para seleccionar una etiqueta de una versión específica, use la lista desplegable Cambiar ramas o etiquetas. Para obtener más información, vea Procedimientos para seleccionar una etiqueta de versión de código fuente de ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Duración de la validez de la dirección URL de redireccionamiento temporal

Esta sección se aplica a Blazor Web Apps.

Use la opción RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration para obtener o establecer la vigencia de la validez de la protección de datos para las direcciones URL de redirección temporales emitidas por la representación del lado servidor Blazor. Solo se usan transitoriamente, por lo que la duración debe simplemente ser lo suficientemente larga como para que un cliente reciba la dirección URL y comience la navegación a ella. Sin embargo, también debe ser lo suficientemente larga como para permitir la asimetría del reloj entre servidores. El valor predeterminado es cinco minutos.

En el ejemplo siguiente, el valor se extiende a siete minutos:

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

Recursos adicionales