Używanie cookie uwierzytelniania bez ASP.NET Core Identity

Autor: Rick Anderson

ASP.NET Core Identity to kompletny, w pełni funkcjonalny dostawca uwierzytelniania do tworzenia i obsługi identyfikatorów logowania. Można jednak użyć dostawcy uwierzytelniania opartego cookiena ASP.NET Core Identity . Aby uzyskać więcej informacji, zobacz Wprowadzenie do Identity ASP.NET Core.

Wyświetl lub pobierz przykładowy kod (jak pobrać)

W celach demonstracyjnych w przykładowej aplikacji konto użytkownika hipotetycznego użytkownika Maria Rodriguez jest zakodowane w aplikacji. Użyj adresu maria.rodriguez@contoso.com e-mail i dowolnego hasła, aby zalogować się do użytkownika. Użytkownik jest uwierzytelniany w metodzie AuthenticateUser Pages/Account/Login.cshtml.cs w pliku . W rzeczywistym przykładzie użytkownik zostanie uwierzytelniony w magazynie danych.

Dodawanie cookie uwierzytelniania

• Dodaj usługi oprogramowania pośredniczącego uwierzytelniania za AddAuthentication pomocą metod i AddCookie .
• Wywołaj UseAuthentication metodę HttpContext.User iUseAuthorization, aby ustawić właściwość i uruchomić oprogramowanie pośredniczące autoryzacji dla żądań. UseAuthentication i UseAuthorization muszą być wywoływane przed Map metodami, takimi jak MapRazorPages i 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 przekazano do AddAuthentication ustawienia domyślnego schematu uwierzytelniania dla aplikacji. AuthenticationScheme jest przydatne, gdy istnieje wiele wystąpień uwierzytelniania, a aplikacja musi autoryzować cookie określony schemat. Ustawienie wartości AuthenticationScheme CookieAuthenticationDefaults.AuthenticationScheme zapewnia wartość "Cookies" dla schematu. Można użyć dowolnej wartości ciągu, która odróżnia schemat.

Schemat uwierzytelniania aplikacji różni się od schematu cookie uwierzytelniania aplikacji. cookie Jeśli schemat uwierzytelniania nie jest udostępniany w programie AddCookie, używa elementu CookieAuthenticationDefaults.AuthenticationScheme. Źródło CookieAuthenticationDefaults.AuthenticationScheme usługi GitHub pokazuje, że jest ono ustawione na "Cookies"wartość .

Właściwość uwierzytelniania cookiejest domyślnie ustawiona IsEssential na true wartość . Pliki cookie uwierzytelniania są dozwolone, gdy użytkownik witryny nie wyraził zgody na zbieranie danych. Aby uzyskać więcej informacji, zobacz Ogólne wsparcie dotyczące rozporządzenia o ochronie danych (RODO) w ASP.NET Core.

Klasa CookieAuthenticationOptions służy do konfigurowania opcji dostawcy uwierzytelniania.

Skonfiguruj CookieAuthenticationOptions w metodzie AddCookie :

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 Oprogramowanie pośredniczące zasad

Oprogramowanie Cookie pośredniczące zasad (źródło GitHub) UseCookiePolicy umożliwia cookie korzystanie z zasad. Oprogramowanie pośredniczące jest przetwarzane w kolejności dodawania:

app.UseCookiePolicy(cookiePolicyOptions);

Służy CookiePolicyOptions do oprogramowania pośredniczącego Cookie cookie zasad w celu kontrolowania globalnych cech przetwarzania i przypinania do cookie procedur obsługi przetwarzania, gdy pliki cookie są dołączane lub usuwane.

Wartością domyślną MinimumSameSitePolicy jest SameSiteMode.Lax zezwolenie na uwierzytelnianie OAuth2. Aby ściśle wymusić zasady tej samej lokacji SameSiteMode.Strictprogramu , ustaw wartość MinimumSameSitePolicy. Mimo że to ustawienie powoduje przerwanie uwierzytelniania OAuth2 i innych schematów uwierzytelniania między źródłami, zwiększa poziom cookie zabezpieczeń dla innych typów aplikacji, które nie korzystają z przetwarzania żądań między źródłami.

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

Cookie Ustawienie Oprogramowania pośredniczącego zasad dla programu może mieć wpływ na ustawienie MinimumSameSitePolicy Cookie.SameSite ustawień zgodnie CookieAuthenticationOptions z poniższą macierzą.

MinimumSameSitePolicy	Cookie. SameSite	Wynikowy Cookie. Ustawienie 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

Tworzenie uwierzytelniania cookie

Aby utworzyć informacje o użytkowniku cookie gospodarstwa, skonstruuj element ClaimsPrincipal. Informacje o użytkowniku są serializowane i przechowywane w pliku cookie.

Utwórz obiekt ClaimsIdentity z dowolnymi wymaganymi Claimelementami i wywołaj SignInAsync polecenie , aby zalogować użytkownika. Login.cshtml.cs w przykładowej aplikacji zawiera następujący kod:

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

Jeśli chcesz zobaczyć komentarze kodu przetłumaczone na języki inne niż angielski, poinformuj nas o tym w tym problemie z dyskusją w usłudze GitHub.

SignInAsync tworzy zaszyfrowany cookie kod i dodaje go do bieżącej odpowiedzi. Jeśli AuthenticationScheme nie zostanie określony, zostanie użyty schemat domyślny.

RedirectUri Jest używany tylko w kilku określonych ścieżkach domyślnie, na przykład ścieżki logowania i wylogowywanie ścieżek. Aby uzyskać więcej informacji, zobacz źródło programu CookieAuthenticationHandler.

System ochrony danych ASP.NET Core jest używany do szyfrowania. W przypadku aplikacji hostowanej na wielu maszynach równoważenie obciążenia w aplikacjach lub przy użyciu farmy internetowej skonfiguruj ochronę danych tak, aby korzystała z tego samego pierścienia kluczy i identyfikatora aplikacji.

Wyloguj się

Aby wylogować bieżącego użytkownika i usunąć go cookie, wywołaj metodę 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;
}

Jeśli CookieAuthenticationDefaults.AuthenticationScheme lub "Pliki cookie" nie są używane jako schemat, podaj schemat używany podczas konfigurowania dostawcy uwierzytelniania. W przeciwnym razie jest używany schemat domyślny. Jeśli na przykład "ContosoCookie" jest używany jako schemat, podaj schemat używany podczas konfigurowania dostawcy uwierzytelniania.

Po zamknięciu przeglądarki automatycznie usuwa pliki cookie oparte na sesji (nietrwałe pliki cookie), ale żadne pliki cookie nie są czyszczone po zamknięciu pojedynczej karty. Serwer nie jest powiadamiany o zdarzeniach zamknięcia karty lub przeglądarki.

Reagowanie na zmiany zaplecza

Po utworzeniu cookie obiektu cookie element jest pojedynczym źródłem identity. Jeśli konto użytkownika jest wyłączone w systemach zaplecza:

• System uwierzytelniania aplikacji cookie nadal przetwarza żądania na podstawie uwierzytelniania cookie.
• Użytkownik pozostaje zalogowany do aplikacji, o ile uwierzytelnianie cookie jest prawidłowe.

Zdarzenie ValidatePrincipal może służyć do przechwytywania i zastępowania weryfikacji obiektu cookieidentity. Weryfikowanie elementu na każdym żądaniu cookie zmniejsza ryzyko odwołanych użytkowników, którzy uzyskują dostęp do aplikacji.

Jednym z podejść do cookie walidacji jest śledzenie zmian bazy danych użytkownika. Jeśli baza danych nie została zmieniona od czasu wydania użytkownika, nie trzeba ponownie uwierzytelniać użytkownika cookie , jeśli jest cookie on nadal prawidłowy. W przykładowej aplikacji baza danych jest implementowana i IUserRepository przechowuje LastChanged wartość. Gdy użytkownik zostanie zaktualizowany w bazie danych, LastChanged wartość zostanie ustawiona na bieżący czas.

Aby unieważnić cookie element, gdy baza danych zmieni się na LastChanged podstawie wartości, utwórz element cookie z oświadczeniem zawierającym LastChanged bieżącą LastChanged wartość z bazy danych:

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

Aby zaimplementować przesłonięcia dla ValidatePrincipal zdarzenia, napisz metodę z następującym podpisem w klasie pochodzącej z CookieAuthenticationEventsklasy :

ValidatePrincipal(CookieValidatePrincipalContext)

Poniżej przedstawiono przykładową implementację elementu 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);
        }
    }
}

Zarejestruj wystąpienie zdarzeń podczas cookie rejestracji usługi. Podaj rejestrację usługi w zakresie dla klasyCustomCookieAuthenticationEvents:

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

Rozważ sytuację, w której nazwa użytkownika jest aktualizowana — decyzja, która nie ma wpływu na bezpieczeństwo w żaden sposób. Jeśli chcesz niedestrukcyjne zaktualizować nazwę główną użytkownika, wywołaj context.ReplacePrincipal i ustaw context.ShouldRenew właściwość na true.

Ostrzeżenie

Opisane tutaj podejście jest wyzwalane na każdym żądaniu. Weryfikowanie plików cookie uwierzytelniania dla wszystkich użytkowników na każdym żądaniu może spowodować dużą karę za wydajność aplikacji.

Trwałe pliki cookie

Możesz chcieć cookie zachować ustawienia między sesjami przeglądarki. Ta trwałość powinna być włączona tylko z jawną zgodą użytkownika z polem wyboru "Zapamiętaj mnie" przy logowaniu lub podobnym mechanizmie.

Poniższy fragment kodu tworzy element identity i odpowiadający cookie mu za pośrednictwem zamknięć przeglądarki. Wszystkie ustawienia wygasania przesuwanego wcześniej skonfigurowane są honorowane. cookie Jeśli wygaśnie po zamknięciu przeglądarki, przeglądarka wyczyści cookie ją po ponownym uruchomieniu.

Ustaw IsPersistent wartość na true w pliku AuthenticationProperties:

// using Microsoft.AspNetCore.Authentication;

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

Wygaśnięcie bezwzględne cookie

Można ustawić bezwzględny czas wygaśnięcia za pomocą polecenia ExpiresUtc. Aby utworzyć trwały cookieelement , IsPersistent należy również ustawić. cookie W przeciwnym razie element jest tworzony przy użyciu okresu istnienia opartego na sesji i może wygasnąć przed biletem uwierzytelniania lub po jego przechowywaniu. Po ExpiresUtc ustawieniu zastępuje wartość ExpireTimeSpan opcji CookieAuthenticationOptions, jeśli jest ustawiona.

Poniższy fragment kodu tworzy element identity i odpowiadający mu cookie przez 20 minut. Spowoduje to zignorowanie wszystkich wcześniej skonfigurowanych ustawień wygasania.

// using Microsoft.AspNetCore.Authentication;

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