Použití cookie ověřování bez ASP.NET Core Identity

Autor: Rick Anderson

ASP.NET Core Identity je kompletní plně funkční zprostředkovatel ověřování pro vytváření a údržbu přihlášení. cookieZprostředkovatele ověřování na základě identity bez ASP.NET Core Identity je však možné použít. Další informace najdete v tématu Úvod do Identity ASP.NET Core.

Zobrazení nebo stažení ukázkového kódu (postup stažení)

Pro demonstrační účely v ukázkové aplikaci je uživatelský účet hypotetického uživatele Maria Rodriguez pevně zakódovaný do aplikace. K přihlášení uživatele použijte e-mailovou adresu maria.rodriguez@contoso.com a jakékoli heslo. Uživatel se ověřuje v AuthenticateUser metodě v Pages/Account/Login.cshtml.cs souboru. V reálném příkladu by se uživatel ověřil vůči úložišti dat.

Přidání cookie ověřování

• Přidejte ověřovací middlewarové služby pomocí AddAuthentication metod a AddCookie metod.
• Zavolejte UseAuthentication a UseAuthorization nastavte HttpContext.User vlastnost a spusťte autorizační middleware pro požadavky. UseAuthentication a UseAuthorization musí být volána před Map metodami, jako MapRazorPages jsou MapDefaultControllerRoute

using Microsoft.AspNetCore.Authentication.Cookies;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie();

builder.Services.AddHttpContextAccessor();

var app = builder.Build();

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

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

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

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

AuthenticationScheme předané pro AddAuthentication nastavení výchozího schématu ověřování pro aplikaci. AuthenticationScheme je užitečné, když existuje více instancí cookie ověřování a aplikace musí autorizovat s konkrétním schématem. AuthenticationScheme Nastavení metody CookieAuthenticationDefaults.AuthenticationScheme poskytuje hodnotu "Cookies" schématu. Lze použít libovolnou řetězcovou hodnotu, která rozlišuje schéma.

Schéma ověřování aplikace se liší od schématu cookie ověřování aplikace. cookie Pokud schéma ověřování není k dispozici AddCookie, používá CookieAuthenticationDefaults.AuthenticationScheme. Zdroj CookieAuthenticationDefaults.AuthenticationScheme GitHubu zobrazuje, že je nastavený na "Cookies".

Vlastnost ověřování cookieIsEssential je ve výchozím nastavení nastavená na true hodnotu. Ověřování cookieje povoleno, když návštěvník webu neschyboval souhlas se shromažďováním dat. Další informace najdete v tématu Obecná podpora nařízení o ochraně osobních údajů (GDPR) v ASP.NET Core.

Třída CookieAuthenticationOptions se používá ke konfiguraci možností zprostředkovatele ověřování.

Konfigurace CookieAuthenticationOptions v AddCookie metodě:

using Microsoft.AspNetCore.Authentication.Cookies;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.ExpireTimeSpan = TimeSpan.FromMinutes(20);
        options.SlidingExpiration = true;
        options.AccessDeniedPath = "/Forbidden/";
    });

builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();

var app = builder.Build();

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

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

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

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

Cookie Middleware zásad

Middleware Cookie zásad (zdroj GitHubu)UseCookiePolicy umožňuje cookie možnosti zásad. Middleware se zpracovává v pořadí, ve které se přidává:

app.UseCookiePolicy(cookiePolicyOptions);

Cookie K řízení globálních cookie charakteristik zpracování a připojení k cookie obslužným rutinám cookiezpracování při připojení nebo odstranění se používá CookiePolicyOptions middleware zásad.

Výchozí MinimumSameSitePolicy hodnotou je SameSiteMode.Lax povolení ověřování OAuth2. Chcete-li striktně vynutit zásady SameSiteMode.Strictstejného webu , nastavte .MinimumSameSitePolicy I když toto nastavení přeruší ověřování OAuth2 a další schémata ověřování mezi zdroji, zvýší úroveň cookie zabezpečení pro jiné typy aplikací, které nespoléhá na zpracování požadavků mezi zdroji.

var cookiePolicyOptions = new CookiePolicyOptions
{
    MinimumSameSitePolicy = SameSiteMode.Strict,
};

Nastavení Middlewaru Cookie zásad pro MinimumSameSitePolicy může ovlivnit nastavení Cookie.SameSite v CookieAuthenticationOptions nastavení podle níže uvedené matice.

MinimumSameSitePolicy	Cookie. SameSite	Výsledná Cookie. Nastavení SameSite
SameSiteMode.None	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict
SameSiteMode.Lax	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.Lax SameSiteMode.Lax SameSiteMode.Strict
SameSiteMode.Strict	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.Strict SameSiteMode.Strict SameSiteMode.Strict

Vytvoření ověřování cookie

Chcete-li vytvořit cookie informace o uživateli, vytvořte ClaimsPrincipal. Informace o uživateli jsou serializovány a uloženy v souboru cookie.

Vytvořte s libovolným požadovaným ClaimsIdentityClaimvoláním a přihlaste SignInAsync se uživatele. Login.cshtml.cs v ukázkové aplikaci obsahuje následující kód:

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    ReturnUrl = returnUrl;

    if (ModelState.IsValid)
    {
        // Use Input.Email and Input.Password to authenticate the user
        // with your custom authentication logic.
        //
        // For demonstration purposes, the sample validates the user
        // on the email address maria.rodriguez@contoso.com with 
        // any password that passes model validation.

        var user = await AuthenticateUser(Input.Email, Input.Password);

        if (user == null)
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }

        var claims = new List<Claim>
        {
            new Claim(ClaimTypes.Name, user.Email),
            new Claim("FullName", user.FullName),
            new Claim(ClaimTypes.Role, "Administrator"),
        };

        var claimsIdentity = new ClaimsIdentity(
            claims, CookieAuthenticationDefaults.AuthenticationScheme);

        var authProperties = new AuthenticationProperties
        {
            //AllowRefresh = <bool>,
            // Refreshing the authentication session should be allowed.

            //ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(10),
            // The time at which the authentication ticket expires. A 
            // value set here overrides the ExpireTimeSpan option of 
            // CookieAuthenticationOptions set with AddCookie.

            //IsPersistent = true,
            // Whether the authentication session is persisted across 
            // multiple requests. When used with cookies, controls
            // whether the cookie's lifetime is absolute (matching the
            // lifetime of the authentication ticket) or session-based.

            //IssuedUtc = <DateTimeOffset>,
            // The time at which the authentication ticket was issued.

            //RedirectUri = <string>
            // The full path or absolute URI to be used as an http 
            // redirect response value.
        };

        await HttpContext.SignInAsync(
            CookieAuthenticationDefaults.AuthenticationScheme, 
            new ClaimsPrincipal(claimsIdentity), 
            authProperties);

        _logger.LogInformation("User {Email} logged in at {Time}.", 
            user.Email, DateTime.UtcNow);

        return LocalRedirect(Url.GetLocalUrl(returnUrl));
    }

    // Something failed. Redisplay the form.
    return Page();
}

Pokud chcete zobrazit komentáře ke kódu přeložené do jiných jazyků, než je angličtina, dejte nám vědět v této diskuzi na GitHubu.

SignInAsync vytvoří zašifrovaný cookie kód a přidá ho do aktuální odpovědi. Pokud AuthenticationScheme není zadané, použije se výchozí schéma.

RedirectUri se ve výchozím nastavení používá jenom na několika konkrétních cestách, například na cestě k přihlášení a cestě k odhlášení. Další informace naleznete ve zdroji CookieAuthenticationHandler.

systém ochrany dat ASP.NET Core se používá k šifrování. U aplikace hostované na více počítačích, vyrovnávání zatížení mezi aplikacemi nebo pomocí webové farmy nakonfigurujte ochranu dat tak, aby používala stejný okruh klíčů a identifikátor aplikace.

Odhlásit se

Pokud se chcete odhlásit aktuálního uživatele a odstranit ho cookie, zavolejte SignOutAsync:

public async Task OnGetAsync(string returnUrl = null)
{
    if (!string.IsNullOrEmpty(ErrorMessage))
    {
        ModelState.AddModelError(string.Empty, ErrorMessage);
    }

    // Clear the existing external cookie
    await HttpContext.SignOutAsync(
        CookieAuthenticationDefaults.AuthenticationScheme);

    ReturnUrl = returnUrl;
}

Pokud CookieAuthenticationDefaults.AuthenticationScheme nebo "Cookies" se nepoužívá jako schéma, zadejte schéma použité při konfiguraci zprostředkovatele ověřování. V opačném případě se použije výchozí schéma. Pokud se například jako schéma používá "ContosoCookie", zadejte schéma použité při konfiguraci zprostředkovatele ověřování.

Když se prohlížeč zavře, automaticky odstraní relace založené na cookierelacích (non-persistent cookies), ale při zavření jednotlivé karty se nevymaže žádné cookie. Server není upozorněn na události tabulátoru nebo zavření prohlížeče.

Reakce na změny back-endu

cookie Po vytvoření cookie se jedná o jediný zdroj identity. Pokud je uživatelský účet v back-endových systémech zakázaný:

• Ověřovací systém aplikace cookie nadále zpracovává požadavky na základě ověřování cookie.
• Uživatel zůstane přihlášený k aplikaci, pokud je ověřování cookie platné.

Událost ValidatePrincipal se dá použít k zachycení a přepsání ověření cookie identity. Ověřením cookie u každého požadavku se snižuje riziko odvolaných uživatelů přistupujících k aplikaci.

Jedním z přístupů k cookie ověřování je sledování, kdy se uživatelská databáze změní. Pokud se databáze od vydání uživatele cookie nezměnila, není potřeba uživatele znovu ověřit, pokud cookie je stále platný. V ukázkové aplikaci se databáze implementuje a IUserRepository ukládá LastChanged hodnotu. Při aktualizaci uživatele v databázi LastChanged je hodnota nastavena na aktuální čas.

Pokud chcete zneplatnit cookie platnost, když se databáze změní na LastChanged základě hodnoty, vytvořte cookie deklaraci identity obsahující LastChanged aktuální LastChanged hodnotu z databáze:

var claims = new List<Claim>
{
    new Claim(ClaimTypes.Name, user.Email),
    new Claim("LastChanged", {Database Value})
};

var claimsIdentity = new ClaimsIdentity(
    claims,
    CookieAuthenticationDefaults.AuthenticationScheme);

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme, 
    new ClaimsPrincipal(claimsIdentity));

Chcete-li implementovat přepsání události ValidatePrincipal , napište metodu s následujícím podpisem ve třídě, která je odvozena od CookieAuthenticationEvents:

ValidatePrincipal(CookieValidatePrincipalContext)

Následuje příklad implementace CookieAuthenticationEvents:

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;

public class CustomCookieAuthenticationEvents : CookieAuthenticationEvents
{
    private readonly IUserRepository _userRepository;

    public CustomCookieAuthenticationEvents(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public override async Task ValidatePrincipal(CookieValidatePrincipalContext context)
    {
        var userPrincipal = context.Principal;

        // Look for the LastChanged claim.
        var lastChanged = (from c in userPrincipal.Claims
                           where c.Type == "LastChanged"
                           select c.Value).FirstOrDefault();

        if (string.IsNullOrEmpty(lastChanged) ||
            !_userRepository.ValidateLastChanged(lastChanged))
        {
            context.RejectPrincipal();

            await context.HttpContext.SignOutAsync(
                CookieAuthenticationDefaults.AuthenticationScheme);
        }
    }
}

Během registrace služby zaregistrujte instanci cookie událostí. Zadejte pro svou CustomCookieAuthenticationEvents třídu registraci služby s vymezeným oborem:

using Microsoft.AspNetCore.Authentication.Cookies;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.EventsType = typeof(CustomCookieAuthenticationEvents);
    });

builder.Services.AddScoped<CustomCookieAuthenticationEvents>();

var app = builder.Build();

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

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

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

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

Představte si situaci, ve které se aktualizuje jméno uživatele – rozhodnutí, které nijak neovlivní zabezpečení. Pokud chcete nedestruktivní aktualizaci objektu zabezpečení uživatele, zavolejte context.ReplacePrincipal a nastavte context.ShouldRenew vlastnost na true.

Upozorňující

Zde popsaný přístup se aktivuje při každém požadavku. Ověření ověřování cookiepro všechny uživatele na každém požadavku může vést k velkému snížení výkonu aplikace.

Trvalé cookies

Možná budete chtít cookie , aby se zachovala napříč relacemi prohlížeče. Tato trvalost by měla být povolena pouze s explicitním souhlasem uživatele se zaškrtávacím políčkam Pamatovat si mě při přihlášení nebo podobném mechanismu.

Následující fragment kódu vytvoří identitu a odpovídající cookie , která přežije prostřednictvím uzavření prohlížeče. Jsou dodržena všechna dříve nakonfigurovaná nastavení vypršení platnosti. cookie Pokud vyprší platnost v době, kdy je prohlížeč zavřený, prohlížeč vymažecookie, jakmile se restartuje.

Nastavit IsPersistent na true :AuthenticationProperties

// using Microsoft.AspNetCore.Authentication;

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme,
    new ClaimsPrincipal(claimsIdentity),
    new AuthenticationProperties
    {
        IsPersistent = true
    });

Absolutní cookie vypršení platnosti

Absolutní čas vypršení platnosti lze nastavit pomocí ExpiresUtc. Chcete-li vytvořit trvalou , cookieIsPersistent musí být také nastavena. cookie Jinak se vytvoří s životností založenou na relaci a platnost může vypršet buď před nebo po ověřovacím lístku, který obsahuje. Když ExpiresUtc je nastavena, přepíše hodnotu možnosti ExpireTimeSpanCookieAuthenticationOptions, pokud je nastavena.

Následující fragment kódu vytvoří identitu a odpovídající cookie identitě, která trvá 20 minut. Tím se ignorují všechna dříve nakonfigurovaná nastavení klouzavého vypršení platnosti.

// using Microsoft.AspNetCore.Authentication;

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme,
    new ClaimsPrincipal(claimsIdentity),
    new AuthenticationProperties
    {
        IsPersistent = true,
        ExpiresUtc = DateTime.UtcNow.AddMinutes(20)
    });