Configurar o ASP.NET Core Identity

O ASP.NET Core Identity usa valores padrão para configurações como política de senha, bloqueio e configuração de cookie. Essas configurações podem ser substituídas na inicialização do aplicativo.

Identity options

A classe IdentityOptions representa as opções que podem ser usadas para configurar o sistema Identity. IdentityOptions deve ser definido após chamar AddIdentity ou AddDefaultIdentity.

Declarações Identity

IdentityOptions.ClaimsIdentity especifica o ClaimsIdentityOptions com as propriedades mostradas na tabela a seguir.

Propriedade	Descrição	Padrão
RoleClaimType	Obtém ou define o tipo de declaração usada para uma declaração da função.	ClaimTypes.Role
SecurityStampClaimType	Obtém ou define o tipo de declaração usado para a declaração do carimbo de segurança.	AspNet.Identity.SecurityStamp
UserIdClaimType	Obtém ou define o tipo de declaração usada para a declaração do identificador de usuário.	ClaimTypes.NameIdentifier
UserNameClaimType	Obtém ou define o tipo de declaração usado para a declaração de nome do usuário.	ClaimTypes.Name

Bloquear

O bloqueio é definido no 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();
}

O código anterior é baseado no modelo LoginIdentity.

As opções de bloqueio são definidas em 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();

O código anterior define IdentityOptions LockoutOptions com valores padrão.

Uma autenticação bem-sucedida redefine a contagem de tentativas de acesso com falha e redefine o relógio.

IdentityOptions.Lockout especifica o LockoutOptions com as propriedades mostradas na tabela.

Propriedade	Descrição	Padrão
AllowedForNewUsers	Determina se um novo usuário pode ser bloqueado.	true
DefaultLockoutTimeSpan	A quantidade de tempo pela qual usuário é bloqueado quando ocorre um bloqueio.	5 minutos
MaxFailedAccessAttempts	O número de tentativas de acesso com falha até que um usuário seja bloqueado, se o bloqueio estiver habilitado.	5

Senha

Por padrão, Identity exige que as senhas contenham um caractere maiúsculo, um caractere minúsculo, um dígito e um caractere não alfanumérico. As senhas devem ter pelo menos seis caracteres.

As senhas são configuradas com:

• PasswordOptions em Program.cs.
• [StringLength] atributos de Password propriedades se for realizado scaffolding de Identity no aplicativo. InputModel Password propriedades são encontradas nos seguintes arquivos:
  • 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 com as propriedades mostradas na tabela.

Propriedade	Descrição	Padrão
RequireDigit	Requer um número entre 0 e 9 na senha.	true
RequiredLength	O comprimento mínimo da senha.	6
RequireLowercase	Requer um caractere minúsculo na senha.	true
RequireNonAlphanumeric	Requer um caractere não alfanumérico na senha.	true
RequiredUniqueChars	Aplica-se somente ao ASP.NET Core versão 2.0 ou posterior. Requer o número de caracteres distintos na senha.	1
RequireUppercase	Requer um caractere maiúsculo na senha.	true

Conexão

O código a seguir define as configurações de SignIn (para valores padrão):

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

IdentityOptions.SignIn especifica o SignInOptions com as propriedades mostradas na tabela.

Propriedade	Descrição	Padrão
RequireConfirmedEmail	Requer um email confirmado para entrar.	false
RequireConfirmedPhoneNumber	Requer um número de telefone confirmado para entrar.	false

Tokens

IdentityOptions.Tokens especifica o TokenOptions com as propriedades mostradas na tabela.

Propriedade	Descrição
AuthenticatorTokenProvider	Obtém ou define o AuthenticatorTokenProvider usado para validar entradas de dois fatores com um autenticador.
ChangeEmailTokenProvider	Obtém ou define o ChangeEmailTokenProvider usado para gerar tokens usados em emails de confirmação de alteração de email.
ChangePhoneNumberTokenProvider	Obtém ou define o ChangePhoneNumberTokenProvider usado para gerar tokens usados ao alterar números de telefone.
EmailConfirmationTokenProvider	Obtém ou define o provedor de token usado para gerar tokens usados em emails de confirmação de conta.
PasswordResetTokenProvider	Obtém ou define o IUserTwoFactorTokenProvider<TUser> usado para gerar tokens usados em emails de redefinição de senha.
ProviderMap	Usado para construir um Provedor de Token de Usuário com a chave usada como o nome do provedor.

Usuário

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

});

IdentityOptions.User especifica UserOptions com as propriedades mostradas na tabela.

Propriedade	Descrição	Padrão
AllowedUserNameCharacters	Caracteres permitidos no nome de usuário.	abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 -._@+
RequireUniqueEmail	Exige que cada usuário tenha um email exclusivo.	false

Configurações doCookie

Configure o cookie do aplicativo em Program.cs. ConfigureApplicationCookie deve ser chamado depois de chamar AddIdentity ou 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 obter mais informações, consulte CookieAuthenticationOptions.

Opções de hasher de senha

PasswordHasherOptions obtém e define opções para hash de senha.

Opção	Descrição
CompatibilityMode	O modo de compatibilidade usado ao fazer hash de novas senhas. Assume o padrão de IdentityV3. O primeiro byte de uma senha com hash, chamado de marcador de formato, especifica a versão do algoritmo de hash usado para hash da senha. Ao verificar uma senha em relação a um hash, o método VerifyHashedPassword seleciona o algoritmo correto com base no primeiro byte. Um cliente é capaz de autenticar independentemente de qual versão do algoritmo foi usada para fazer hash da senha. Definir o modo de compatibilidade afeta o hash de novas senhas.
IterationCount	O número de iterações usadas ao fazer hash de senhas usando PBKDF2. Esse valor é usado apenas quando CompatibilityMode está definido como IdentityV3. O valor deve ser um inteiro positivo e o padrão é 100000.

No exemplo a seguir, IterationCount é definido como 12000 em Program.cs:

// using Microsoft.AspNetCore.Identity;

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

Exigir globalmente que todos os usuários sejam autenticados

Para obter informações sobre como exigir que todos os usuários sejam autenticados globalmente, confira Exigir usuários autenticados.

ISecurityStampValidator e SignOut em todos os lugares

Os aplicativos precisam reagir a eventos que envolvem ações confidenciais de segurança regenerando o ClaimsPrincipal dos usuários. Por exemplo, o ClaimsPrincipal deve ser regenerado ao ingressar em uma função, alterar a senha ou outros eventos confidenciais de segurança. Identity usa a interface ISecurityStampValidator para regenerar o ClaimsPrincipal. A implementação padrão de Identity registra um SecurityStampValidator com o aplicativo cookie principal e o cookie de dois fatores. O validador conecta-se ao evento OnValidatePrincipal de cada cookie para chamar Identity para verificar se a declaração de selo de segurança do usuário está inalterada em relação ao que está armazenado no cookie. O validador chama em intervalos regulares. O intervalo de chamadas é uma compensação entre atingir o armazenamento de dados com muita frequência e não com frequência suficiente. A verificação com um intervalo longo resulta em declarações obsoletas. Chame userManager.UpdateSecurityStampAsync(user) para forçar que os cookies existentes sejam inválidos na próxima vez que forem verificados. A maior parte da conta de interface do usuário e gerenciamento de páginas de Identity chama userManager.UpdateSecurityStampAsync(user) depois de alterar a senha ou adicionar um logon. Os aplicativos podem chamar userManager.UpdateSecurityStampAsync(user) para implementar uma ação de saída em todos os lugares.

A alteração do intervalo de validação é mostrada no seguinte código realçado:

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