Configuración de ASP.NET Core Identity

ASP.NET Core Identity utiliza valores predeterminados para ajustes como la directiva de contraseñas, el bloqueo y la configuración de cookie. Esta configuración se puede invalidar en el inicio de la aplicación.

Opciones de Identity

La clase IdentityOptions representa las opciones que se pueden utilizar para configurar el sistema Identity. IdentityOptions debe establecerse después de llamar a AddIdentity o AddDefaultIdentity.

Identity de notificaciones

IdentityOptions.ClaimsIdentity especifica ClaimsIdentityOptions con las propiedades que se muestran en la siguiente tabla.

Propiedad	Descripción	Valor predeterminado
RoleClaimType	Obtiene o establece el tipo de notificación utilizado para las notificaciones de rol.	ClaimTypes.Role
SecurityStampClaimType	Obtiene o establece el tipo de notificación utilizado para la notificación del sello de seguridad.	AspNet.Identity.SecurityStamp
UserIdClaimType	Obtiene o establece el tipo de notificación usado para la notificación del identificador de usuario.	ClaimTypes.NameIdentifier
UserNameClaimType	Obtiene o establece el tipo de notificación usado para la notificación del nombre de usuario.	ClaimTypes.Name

Bloqueo

El bloqueo se establece en el método PasswordSignInAsync:

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl ??= Url.Content("~/");

    ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();

    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(Input.Email,
             Input.Password, Input.RememberMe,
             lockoutOnFailure: false);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in.");
            return LocalRedirect(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("User account locked out.");
            return RedirectToPage("./Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

El código anterior se basa en la plantilla de LoginIdentity.

Las opciones de bloqueo se establecen en Program.cs:

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using RPauth.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

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

builder.Services.Configure<IdentityOptions>(options =>
{
    // Default Lockout settings.
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
    options.Lockout.MaxFailedAccessAttempts = 5;
    options.Lockout.AllowedForNewUsers = true;
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();

app.Run();

El código anterior establece IdentityOptionsLockoutOptions con valores predeterminados.

Una autenticación correcta restablece el recuento de intentos de accesos fallidos y restablece el reloj.

IdentityOptions.Lockout especifica LockoutOptions con las propiedades que se muestran en la tabla.

Propiedad	Descripción	Valor predeterminado
AllowedForNewUsers	Determina si se puede bloquear un nuevo usuario.	true
DefaultLockoutTimeSpan	La cantidad de tiempo que un usuario se bloquea cuando se produce un bloqueo.	5 minutos
MaxFailedAccessAttempts	Número de intentos de acceso erróneos hasta que un usuario está bloqueado, si está habilitado el bloqueo.	5

Contraseña

De forma predeterminada, Identity requiere que las contraseñas contengan un carácter en mayúsculas, un carácter en minúsculas, un dígito y un carácter no alfanumérico. Las contraseñas deben tener al menos seis caracteres.

Las contraseñas se configuran con:

• PasswordOptions en Program.cs.
• Atributos [StringLength] de propiedades Password si Identity se aplica con scaffolding a la aplicación. Las propiedades de InputModelPassword se encuentran en los archivos siguientes:
  • Areas/Identity/Pages/Account/Register.cshtml.cs
  • Areas/Identity/Pages/Account/ResetPassword.cshtml.cs

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using RPauth.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

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

builder.Services.Configure<IdentityOptions>(options =>
{
    // Default Password settings.
    options.Password.RequireDigit = true;
    options.Password.RequireLowercase = true;
    options.Password.RequireNonAlphanumeric = true;
    options.Password.RequireUppercase = true;
    options.Password.RequiredLength = 6;
    options.Password.RequiredUniqueChars = 1;
});

var app = builder.Build();

// Remaining code removed for brevity.

IdentityOptions.Password especifica PasswordOptions con las propiedades que se muestran en la tabla.

Propiedad	Descripción	Valor predeterminado
RequireDigit	Requiere un número entre 0 y 9 en la contraseña.	true
RequiredLength	La longitud mínima de la contraseña.	6
RequireLowercase	Requiere un carácter en minúsculas en la contraseña.	true
RequireNonAlphanumeric	Requiere un carácter no alfanumérico en la contraseña.	true
RequiredUniqueChars	Solo se aplica a ASP.NET Core 2.0 o posterior. Requiere el número de caracteres distintos en la contraseña.	1
RequireUppercase	Requiere un carácter en mayúsculas en la contraseña.	true

Inicio de sesión

El siguiente código establece la configuración de SignIn (a valores predeterminados):

builder.Services.Configure<IdentityOptions>(options =>
{
    // Default SignIn settings.
    options.SignIn.RequireConfirmedEmail = false;
    options.SignIn.RequireConfirmedPhoneNumber = false;
});

IdentityOptions.SignIn especifica SignInOptions con las propiedades que se muestran en la tabla.

Propiedad	Descripción	Valor predeterminado
RequireConfirmedEmail	Requiere un correo electrónico confirmado para iniciar sesión.	false
RequireConfirmedPhoneNumber	Requiere un número de teléfono confirmado para iniciar sesión.	false

Tokens

IdentityOptions.Tokens especifica TokenOptions con las propiedades que se muestran en la tabla.

Propiedad	Descripción
AuthenticatorTokenProvider	Obtiene o establece el AuthenticatorTokenProvider utilizado para validar los inicios de sesión en dos fases con un autenticador.
ChangeEmailTokenProvider	Obtiene o establece el ChangeEmailTokenProvider utilizado para generar tokens usados en los correos electrónicos de confirmación de cambios de correo electrónico.
ChangePhoneNumberTokenProvider	Obtiene o establece el ChangePhoneNumberTokenProvider utilizado para generar tokens usados al cambiar los números de teléfono.
EmailConfirmationTokenProvider	Obtiene o establece el proveedor de tokens usado para generar tokens usados en los correos electrónicos de confirmación de la cuenta.
PasswordResetTokenProvider	Obtiene o establece el IUserTwoFactorTokenProvider<TUser> utilizado para generar tokens usados en los correos electrónicos de restablecimiento de contraseña.
ProviderMap	Se usa para construir un proveedor de tokens de usuario con la clave usada como nombre del proveedor.

Usuario

builder.Services.Configure<IdentityOptions>(options =>
{
    // Default User settings.
    options.User.AllowedUserNameCharacters =
            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
    options.User.RequireUniqueEmail = false;

});

IdentityOptions.User especifica UserOptions con las propiedades que se muestran en la tabla.

Propiedad	Descripción	Valor predeterminado
AllowedUserNameCharacters	Caracteres permitidos en el nombre de usuario.	abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 -._@+
RequireUniqueEmail	Requiere que cada usuario tenga un correo electrónico único.	false

Configuración deCookie

Configure la cookie de la aplicación en Program.cs. Se debe llamar a ConfigureApplicationCookiedespués de llamar a AddIdentity o AddDefaultIdentity.

builder.Services.ConfigureApplicationCookie(options =>
{
    options.AccessDeniedPath = "/Identity/Account/AccessDenied";
    options.Cookie.Name = "YourAppCookieName";
    options.Cookie.HttpOnly = true;
    options.ExpireTimeSpan = TimeSpan.FromMinutes(60);
    options.LoginPath = "/Identity/Account/Login";
    // ReturnUrlParameter requires 
    //using Microsoft.AspNetCore.Authentication.Cookies;
    options.ReturnUrlParameter = CookieAuthenticationDefaults.ReturnUrlParameter;
    options.SlidingExpiration = true;
});

Para obtener más información, vea CookieAuthenticationOptions.

Opciones de Hasher de contraseña

PasswordHasherOptions obtiene y establece las opciones para el hash de contraseñas.

Opción	Descripción
CompatibilityMode	Modo de compatibilidad que se usa al aplicar hash a nuevas contraseñas. Tiene como valor predeterminado IdentityV3. El primer byte de una contraseña con hash, denominado marcador de formato, especifica la versión del algoritmo hash utilizado para aplicar un hash a la contraseña. Al comprobar una contraseña con un hash, el método VerifyHashedPassword selecciona el algoritmo correcto en función del primer byte. Un cliente puede autenticarse independientemente de la versión del algoritmo que se usó para aplicar un algoritmo hash a la contraseña. Establecer el modo de compatibilidad afecta al hash de las nuevas contraseñas.
IterationCount	Número de iteraciones usadas al aplicar hash a contraseñas mediante PBKDF2. Este valor solo se usa cuando se establece CompatibilityMode en IdentityV3. El valor debe ser un entero positivo y el valor predeterminado es 100000.

En el siguiente ejemplo, IterationCount se establece en 12000 en Program.cs:

// using Microsoft.AspNetCore.Identity;

builder.Services.Configure<PasswordHasherOptions>(option =>
{
    option.IterationCount = 12000;
});

Requerir globalmente que todos los usuarios se autentiquen

Para obtener información sobre cómo requerir globalmente la autenticación de todos los usuarios, vea Requerir usuarios autenticados.

ISecurityStampValidator y SignOut en todas partes

Las aplicaciones deben reaccionar a eventos que implican acciones confidenciales de seguridad mediante la regeneración de los usuarios ClaimsPrincipal. Por ejemplo, ClaimsPrincipal se debe volver a generar al unir un rol, cambiar la contraseña u otros eventos confidenciales de seguridad. Identity usa la interfaz ISecurityStampValidator para regenerar ClaimsPrincipal. La implementación predeterminada de Identity registra un SecurityStampValidator con la cookiede aplicación principal y la cookie de dos factores. El validador se enlaza con el evento OnValidatePrincipal de cada cookie para llamar a Identity y verificar que la notificación de sello de seguridad del usuario no ha cambiado con respecto a lo almacenado en la cookie. El validador llama en intervalos regulares. El intervalo de llamada es un equilibrio entre alcanzar el almacén de datos con demasiada frecuencia y no hacerlo con la suficiente. La comprobación con un intervalo largo da como resultado notificaciones obsoletas. Llame a userManager.UpdateSecurityStampAsync(user) para forzar que las cookies existentes no se invaliden la próxima vez que se comprueben. La mayoría de las páginas de administración y la cuenta de la interfaz de usuario de Identity llaman a userManager.UpdateSecurityStampAsync(user) después de cambiar la contraseña o añadir un inicio de sesión. Las aplicaciones pueden llamar a userManager.UpdateSecurityStampAsync(user) para implementar una acción de cierre de sesión en todas partes.

El cambio del intervalo de validación se muestra en el código resaltado siguiente:

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebClaimsPrincipal.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") 
    ?? throw new InvalidOperationException("'DefaultConnection' not found.");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

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

// Force Identity's security stamp to be validated every minute.
builder.Services.Configure<SecurityStampValidatorOptions>(o => 
                   o.ValidationInterval = TimeSpan.FromMinutes(1));

builder.Services.AddRazorPages();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();