Konfigurera ASP.NET Core Identity

ASP.NET Core Identity använder standardvärden för inställningar som lösenordsprincip, utelåsning och cookie konfiguration. De här inställningarna kan åsidosättas vid programstart.

Identity Alternativ

Klassen IdentityOptions representerar de alternativ som kan användas för att konfigurera Identity systemet. IdentityOptions måste anges efter att ha anropat AddIdentity eller AddDefaultIdentity.

Anspråk Identity

IdentityOptions.ClaimsIdentity specificerar ClaimsIdentityOptions med de egenskaper som visas i följande tabell.

Fastighet	Description	Förinställning
RoleClaimType	Hämtar eller anger den anspråkstyp som används för ett rollanspråk.	ClaimTypes.Role
SecurityStampClaimType	Hämtar eller anger anspråkstypen som används för säkerhetsstämpelanspråket.	AspNet.Identity.SecurityStamp
UserIdClaimType	Hämtar eller anger anspråkstypen som används för anspråket för användaridentifierare.	ClaimTypes.NameIdentifier
UserNameClaimType	Hämtar eller anger anspråkstypen som används för användarnamnsanspråket.	ClaimTypes.Name

Låsning

Utelåsning anges i metoden 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();
}

Föregående kod baseras på mallenLoginIdentity.

Alternativ för utelåsning anges i 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();

Föregående kod anger IdentityOptionsLockoutOptions med standardvärden.

En lyckad autentisering återställer antalet misslyckade åtkomstförsök och återställer klockan.

IdentityOptions.Lockout anger LockoutOptions med de egenskaper som visas i tabellen.

Fastighet	Description	Förinställning
AllowedForNewUsers	Avgör om en ny användare kan låsas.	true
DefaultLockoutTimeSpan	Hur lång tid en användare är utelåst när en utelåsning sker.	5 minuter
MaxFailedAccessAttempts	Antalet misslyckade åtkomstförsök tills en användare är utelåst, om utelåsning är aktiverat.	5

Lösenord

Som standard Identity kräver att lösenord innehåller versaler, gemener, en siffra och ett icke-alfanumeriskt tecken. Lösenord måste vara minst sex tecken långa.

Lösenord konfigureras med:

• PasswordOptions i Program.cs.
• [StringLength] attribut förPassword egenskaper om Identity som är upptagna i appen. InputModel Password egenskaper finns i följande filer:
  • 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 specificerar PasswordOptions med de egenskaper som visas i tabellen.

Fastighet	Description	Förinställning
RequireDigit	Kräver ett tal mellan 0 och 9 i lösenordet.	true
RequiredLength	Minsta längd på lösenordet.	6
RequireLowercase	Kräver en gemen bokstav i lösenordet.	true
RequireNonAlphanumeric	Kräver ett icke-alfanumeriskt tecken i lösenordet.	true
RequiredUniqueChars	Gäller endast för ASP.NET Core 2.0 eller senare. Kräver antalet distinkta tecken i lösenordet.	1
RequireUppercase	Kräver en stor bokstav i lösenordet.	true

Logga in

Följande kod anger SignIn inställningar (till standardvärden):

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

IdentityOptions.SignIn anger SignInOptions med de egenskaper som visas i tabellen.

Fastighet	Description	Förinställning
RequireConfirmedEmail	Kräver ett bekräftat e-postmeddelande för att logga in.	false
RequireConfirmedPhoneNumber	Kräver ett bekräftat telefonnummer för att logga in.	false

Tokener

IdentityOptions.Tokens anger TokenOptions med de egenskaper som visas i tabellen.

Fastighet	Description
AuthenticatorTokenProvider	Hämtar eller anger den AuthenticatorTokenProvider som används för att verifiera tvåfaktorsautentiseringar med en autentiserare.
ChangeEmailTokenProvider	Hämtar eller anger den ChangeEmailTokenProvider som används för att generera tokens som används i e-poständringsbekräftelsemeddelanden.
ChangePhoneNumberTokenProvider	Hämtar eller anger den ChangePhoneNumberTokenProvider som används för att generera token som används vid ändring av telefonnummer.
EmailConfirmationTokenProvider	Hämtar eller anger den tokenprovider som används för att generera token som används i e-postmeddelanden för kontobekräftelse.
PasswordResetTokenProvider	Hämtar eller anger den IUserTwoFactorTokenProvider<TUser> som används för att generera tokens som används i e-postmeddelanden för återställning av lösenord.
ProviderMap	Används för att konstruera en Användartoken Provider med nyckeln som används som providerns namn.

User

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

});

IdentityOptions.User specificerar UserOptions med de egenskaper som visas i tabellen.

Fastighet	Description	Förinställning
AllowedUserNameCharacters	Tillåtna tecken i användarnamnet.	abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 -._@+
RequireUniqueEmail	Kräver att varje användare har ett unikt e-postmeddelande.	false

Cookie inställningar

Konfigurera appens cookie i Program.cs. ConfigureApplicationCookie måste anropas efter att ha anropat AddIdentity eller 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;
});

Mer information finns i CookieAuthenticationOptions.

Alternativ för lösenordshash-funktion

PasswordHasherOptions hämtar och anger alternativ för hashning av lösenord.

Option	Description
CompatibilityMode	Kompatibilitetsläget som används vid hashning av nya lösenord. Standardinställningen är IdentityV3. Den första byten av ett hashat lösenord, kallat en formatmarkör, anger versionen av hashalgoritmen som används för att hashat lösenordet. När du verifierar ett lösenord mot en hash VerifyHashedPassword väljer metoden rätt algoritm baserat på den första byteen. En klient kan autentisera oavsett vilken version av algoritmen som användes för att hash-lösenordet. Om du ställer in kompatibilitetsläget påverkas hasheringen av nya lösenord.
IterationCount	Antalet iterationer som används vid hashning av lösenord med PBKDF2. Det här värdet används bara när CompatibilityMode är inställt på IdentityV3. Värdet måste vara ett positivt heltal och standardvärdet är 100000.

I följande exempel anges IterationCount till 12000 i Program.cs:

// using Microsoft.AspNetCore.Identity;

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

Globalt kräver alla användare att autentiseras

Information om hur du globalt kräver att alla användare autentiseras finns i Kräv autentiserade användare.

ISecurityStampValidator och SignOut överallt

Appar måste reagera på händelser som involverar säkerhetskänsliga åtgärder genom att återskapa användarna ClaimsPrincipal. Till exempel ClaimsPrincipal bör återskapas när du ansluter en roll, ändrar lösenordet eller andra säkerhetskänsliga händelser. Identity använder ISecurityStampValidator-gränssnittet för att återskapa ClaimsPrincipal. Standardimplementeringen av Identity registrerar en SecurityStampValidator med huvudprogrammet för cookie och tvåfaktorsautentiseringen cookie. Validatorn ansluter till händelsen OnValidatePrincipal för varje cookie, där den anropar Identity för att verifiera att säkerhetsstämpeln i användarens anspråk är oförändrad från det som lagras i cookie. Validatorn anropar med jämna mellanrum. Samtalsintervallet är en kompromiss mellan att anropa datalagret för ofta och för sällan. Kontroll över ett långt intervall resulterar i inaktuella påståenden. Anropa userManager.UpdateSecurityStampAsync(user)för att tvinga befintliga cookies att ogiltigförklaras nästa gång de kontrolleras. De flesta Identity UI-kontohanteringssidorna anropar userManager.UpdateSecurityStampAsync(user) efter att lösenordet har ändrats eller en inloggning har lagts till. Appar kan anropa userManager.UpdateSecurityStampAsync(user) för att implementera en utloggningsåtgärd överallt.

Om du ändrar valideringsintervallet visas följande markerade kod:

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