Konfigurieren von ASP.NET Core Identity

ASP.NET Core Identity verwendet Standardwerte für Einstellungen wie Kennwortrichtlinie, Sperrung und cookie-Konfiguration. Diese Einstellungen können beim Anwendungsstart außer Kraft gesetzt werden.

Identity-Optionen

Die IdentityOptions-Klasse stellt die Optionen dar, die zum Konfigurieren des Identity-Systems verwendet werden können. IdentityOptions muss nach dem Aufrufen von AddIdentity oder AddDefaultIdentity festgelegt werden.

Ansprüche in Identity

IdentityOptions.ClaimsIdentity gibt die ClaimsIdentityOptions mit den in der folgenden Tabelle beschriebenen Eigenschaften an.

Eigenschaft	BESCHREIBUNG	Standard
RoleClaimType	Ruft den für einen Rollenanspruch verwendeten Anspruchstyp ab oder legt ihn fest	ClaimTypes.Role
SecurityStampClaimType	Ruft den für den Sicherheitsstempelanspruch verwendeten Anspruchstyp ab oder legt ihn fest	AspNet.Identity.SecurityStamp
UserIdClaimType	Ruft den für den Benutzer-ID-Anspruch verwendeten Anspruchstyp ab oder legt ihn fest	ClaimTypes.NameIdentifier
UserNameClaimType	Ruft den für den Benutzernamenanspruch verwendeten Anspruchstyp ab oder legt ihn fest	ClaimTypes.Name

Sperre

Eine Sperre wird in der PasswordSignInAsync-Methode festgelegt:

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

Der obige Code basiert auf der LoginIdentity-Vorlage.

Sperroptionen werden in Program.cs festgelegt:

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

Der obige Code legt die IdentityOptions LockoutOptions auf die Standardwerte fest.

Bei einer erfolgreichen Authentifizierung werden die Anzahl der fehlerhaften Zugriffsversuche und die Uhr zurückgesetzt.

IdentityOptions.Lockout gibt die LockoutOptions mit den in der Tabelle beschriebenen Eigenschaften an.

Eigenschaft	BESCHREIBUNG	Standard
AllowedForNewUsers	Bestimmt, ob neue Benutzer*innen gesperrt werden können	true
DefaultLockoutTimeSpan	Die Zeitspanne, die Benutzer*innen bei einer Sperrung gesperrt werden	5 Minuten
MaxFailedAccessAttempts	Die Anzahl fehlerhafter Zugriffsversuche, bevor Benutzer*innen gesperrt werden, wenn die Sperrung aktiviert ist	5

Kennwort

Identity erfordert standardmäßig, dass Kennwörter jeweils mindestens einen Großbuchstaben, einen Kleinbuchstaben, eine Ziffer und ein nicht alphanumerisches Zeichen enthalten. Kennwörter müssen mindestens sechs Zeichen lang sein.

Kennwörter werden wie folgt konfiguriert:

• PasswordOptions in Program.cs.
• [StringLength]-Attribute von Password-Eigenschaften, wenn Identityals Gerüst in der App erstellt wurde InputModel-Password-Eigenschaften finden Sie in den folgenden Dateien:
  • 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 gibt die PasswordOptions mit den in der Tabelle beschriebenen Eigenschaften an.

Eigenschaft	BESCHREIBUNG	Standard
RequireDigit	Erfordert eine Zahl zwischen 0 und 9 im Kennwort	true
RequiredLength	Die Mindestlänge des Kennworts	6
RequireLowercase	Erfordert einen Kleinbuchstaben im Kennwort	true
RequireNonAlphanumeric	Erfordert ein nicht alphanumerisches Zeichen im Kennwort	true
RequiredUniqueChars	Gilt nur für ASP.NET Core 2.0 und höher. Erfordert die angegebene Anzahl unterschiedlicher Zeichen im Kennwort	1
RequireUppercase	Erfordert einen Großbuchstaben im Kennwort	true

Anmelden

Der folgende Code legt SignIn-Einstellungen (auf Standardwerte) fest:

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

IdentityOptions.SignIn gibt die SignInOptions mit den in der Tabelle beschriebenen Eigenschaften an.

Eigenschaft	BESCHREIBUNG	Standard
RequireConfirmedEmail	Erfordert für die Anmeldung eine bestätigte E-Mail-Adresse	false
RequireConfirmedPhoneNumber	Erfordert für die Anmeldung eine bestätigte Telefonnummer	false

Token

IdentityOptions.Tokens gibt die TokenOptions mit den in der Tabelle beschriebenen Eigenschaften an.

Eigenschaft	Beschreibung
AuthenticatorTokenProvider	Ruft den AuthenticatorTokenProvider ab, der zum Überprüfen von zweistufigen Anmeldungen mit einem Authentifikator verwendet wird, oder legt ihn fest
ChangeEmailTokenProvider	Ruft den zum Generieren von Token, die in Bestätigungs-E-Mails bei Änderungen der E-Mail-Adresse verwendet werden, verwendeten ChangeEmailTokenProvider ab oder legt ihn fest
ChangePhoneNumberTokenProvider	Ruft den zum Generieren von Token, die bei Änderungen der Telefonnummer verwendet werden, verwendeten ChangePhoneNumberTokenProvider ab oder legt ihn fest
EmailConfirmationTokenProvider	Ruft den zum Generieren von Token, die in Bestätigungs-E-Mails für Konten verwendet werden, verwendeten Tokenanbieter ab oder legt ihn fest
PasswordResetTokenProvider	Ruft den zum Generieren von Token, die in E-Mails zur Kennwortzurücksetzung verwendet werden, verwendeten IUserTwoFactorTokenProvider<TUser> ab oder legt ihn fest
ProviderMap	Wird verwendet, um einen Benutzertokenanbieter zu erstellen, bei dem der Schlüssel als Anbietername verwendet wird.

Benutzer

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

});

IdentityOptions.User gibt die UserOptions mit den in der Tabelle beschriebenen Eigenschaften an.

Eigenschaft	BESCHREIBUNG	Standard
AllowedUserNameCharacters	Zulässige Zeichen im Benutzernamen.	abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 -._@+
RequireUniqueEmail	Erfordert, dass sämtliche Benutzer*innen eine eindeutige E-Mail haben.	false

Cookie -Einstellungen

Konfigurieren Sie das cookie der App in Program.cs. ConfigureApplication muss nach dem Aufruf von AddIdentity oder AddDefaultIdentity aufgerufen werden.

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

Weitere Informationen finden Sie unter CookieAuthenticationOptions.

Optionen für den Kennworthasher

PasswordHasherOptions ruft die Optionen für die Kennworthasherstellung ab und legt sie fest.

Option	Beschreibung
CompatibilityMode	Der Kompatibilitätsmodus, der bei der Hasherstellung für neue Kennwörter verwendet wird. Wird standardmäßig auf IdentityV3 festgelegt. Das erste Byte eines Hashkennworts wird als Formatmarkierung bezeichnet und gibt die Version des Hashalgorithmus an, der zum Erstellen des Hashwerts für das Kennwort verwendet wird. Beim Überprüfen eines Kennworts anhand eines Hashs wählt die VerifyHashedPassword-Methode den richtigen Algorithmus basierend auf dem ersten Byte aus. Ein Client kann sich unabhängig davon authentifizieren, welche Version des Algorithmus zum Erstellen des Kennworthashs verwendet wurde. Das Festlegen des Kompatibilitätsmodus wirkt sich auf das Erstellen von Hashwerten für neue Kennwörter aus.
IterationCount	Die Anzahl der Iterationen, die beim Erstellen von Kennworthashs mithilfe von PBKDF2 verwendet werden. Dieser Wert wird nur verwendet, wenn CompatibilityMode auf IdentityV3 festgelegt wird. Der Wert muss eine positive ganze Zahl sein und ist standardmäßig auf 100000 festgelegt.

Im folgenden Beispiel wird IterationCount in Program.cs auf 12000 festgelegt:

// using Microsoft.AspNetCore.Identity;

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

Globale Erzwingen der Authentifizierung aller Benutzer*innen

Informationen dazu, wie global die Authentifizierung aller Benutzer angefordert werden kann, finden Sie unter Authentifizierte Benutzer erforderlich.

ISecurityStampValidator und „Überall abmelden“

Apps müssen auf Ereignisse reagieren, die sicherheitsrelevante Aktionen beinhalten, indem sie den ClaimsPrincipal der Benutzer*innen neu generieren. Beispielsweise sollte der ClaimsPrincipal neu generiert werden, wenn sie einer Rolle beitreten, das Kennwort ändern oder andere sicherheitsrelevante Ereignisse eintreten. Identity verwendet die ISecurityStampValidator-Schnittstelle, um den ClaimsPrincipal neu zu generieren. Die Standardimplementierung von Identity registriert einen SecurityStampValidator beim Standard-cookie der Anwendung und beim cookie für die zweistufige Authentifizierung. Das Validierungssteuerelement wird in das OnValidatePrincipal-Ereignis der einzelnen cookie eingebunden, um bei einem Aufruf von Identity zu überprüfen, ob der Sicherheitsstempelanspruch der Benutzer*innen identisch mit dem in cookie gespeicherten Wert ist. Das Validierungssteuerelement führt in regelmäßigen Abständen Aufrufe durch. Das Aufrufintervall stellt einen Kompromiss zwischen zu häufigen und zu seltenen Aufrufen an den Datenspeicher dar. Eine Überprüfung mit einem zu langen Intervall führt zu veralteten Ansprüchen. Rufen Sie userManager.UpdateSecurityStampAsync(user) auf, um zu erzwingen, dass vorhandene s bei der nächsten Überprüfung ungültig werden. Die meisten Identity-Benutzeroberflächenkonten und Verwaltungsseiten rufen userManager.UpdateSecurityStampAsync(user) auf, nachdem sie das Kennwort geändert oder eine Anmeldung hinzugefügt haben. Apps können userManager.UpdateSecurityStampAsync(user) aufrufen, um eine Aktion zum überall Abmelden zu implementieren.

Das Ändern des Validierungsintervalls wird im folgenden hervorgehobenen Code gezeigt:

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