Usar autenticação de cookie sem o ASP.NET Core IdentityUse cookie authentication without ASP.NET Core Identity

Por Rick Anderson e Luke LathamBy Rick Anderson and Luke Latham

Como você viu nos tópicos anteriores de autenticação, ASP.NET Core Identity é um provedor de autenticação completa e a versão completa para criar e manter os logons.As you've seen in the earlier authentication topics, ASP.NET Core Identity is a complete, full-featured authentication provider for creating and maintaining logins. No entanto, você talvez queira usar sua própria lógica de autenticação personalizada com autenticação baseada em cookie às vezes.However, you may want to use your own custom authentication logic with cookie-based authentication at times. Você pode usar a autenticação baseada em cookie como um provedor de autenticação autônomo sem o ASP.NET Core Identity.You can use cookie-based authentication as a standalone authentication provider without ASP.NET Core Identity.

Exibir ou baixar código de exemplo (como baixar)View or download sample code (how to download)

Para fins de demonstração no aplicativo de exemplo, a conta de usuário para o usuário hipotético, Maria Rodriguez, é codificados no aplicativo.For demonstration purposes in the sample app, the user account for the hypothetical user, Maria Rodriguez, is hardcoded into the app. Use o nome de usuário de Email "maria.rodriguez@contoso.com" e nenhuma senha para a entrada do usuário.Use the Email username "maria.rodriguez@contoso.com" and any password to sign in the user. O usuário é autenticado na AuthenticateUser método na Pages/Account/Login.cshtml.cs arquivo.The user is authenticated in the AuthenticateUser method in the Pages/Account/Login.cshtml.cs file. Em um exemplo do mundo real, o usuário deve ser autenticado em relação a um banco de dados.In a real-world example, the user would be authenticated against a database.

Para obter informações sobre a autenticação baseada em cookie Migrando do ASP.NET Core 1.x para 2.0, consulte migrar autenticação e identidade para o tópico do ASP.NET Core 2.0 (autenticação baseada em Cookie).For information on migrating cookie-based authentication from ASP.NET Core 1.x to 2.0, see Migrate Authentication and Identity to ASP.NET Core 2.0 topic (Cookie-based Authentication).

Para usar a identidade do ASP.NET Core, consulte o Introdução à identidade tópico.To use ASP.NET Core Identity, see the Introduction to Identity topic.

ConfiguraçãoConfiguration

Se o aplicativo não usa o metapacote do Microsoft, criar uma referência de pacote no arquivo de projeto para o Microsoft.AspNetCore.Authentication.Cookies pacote (versão 2.1.0 ou mais tarde).If the app doesn't use the Microsoft.AspNetCore.App metapackage, create a package reference in the project file for the Microsoft.AspNetCore.Authentication.Cookies package (version 2.1.0 or later).

No ConfigureServices método, crie o serviço de Middleware de autenticação com o AddAuthentication e AddCookie métodos:In the ConfigureServices method, create the Authentication Middleware service with the AddAuthentication and AddCookie methods:

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie();

AuthenticationScheme passado para AddAuthentication define o esquema de autenticação padrão para o aplicativo.AuthenticationScheme passed to AddAuthentication sets the default authentication scheme for the app. AuthenticationScheme é útil quando há várias instâncias de autenticação de cookie e você deseja autorizar com um esquema específico.AuthenticationScheme is useful when there are multiple instances of cookie authentication and you want to authorize with a specific scheme. Definindo o AuthenticationScheme para CookieAuthenticationDefaults.AuthenticationScheme fornece um valor de "Cookies" para o esquema.Setting the AuthenticationScheme to CookieAuthenticationDefaults.AuthenticationScheme provides a value of "Cookies" for the scheme. Você pode fornecer qualquer valor de cadeia de caracteres que diferencia o esquema.You can supply any string value that distinguishes the scheme.

Esquema de autenticação do aplicativo é diferente do esquema de autenticação de cookie do aplicativo.The app's authentication scheme is different from the app's cookie authentication scheme. Quando um esquema de autenticação de cookie não é fornecido para AddCookie, ele usa CookieAuthenticationDefaults.AuthenticationScheme ("Cookies").When a cookie authentication scheme isn't provided to AddCookie, it uses CookieAuthenticationDefaults.AuthenticationScheme ("Cookies").

No Configure método, use o UseAuthentication método para invocar o Middleware de autenticação define o HttpContext.User propriedade.In the Configure method, use the UseAuthentication method to invoke the Authentication Middleware that sets the HttpContext.User property. Chame o UseAuthentication método antes de chamar UseMvcWithDefaultRoute ou UseMvc:Call the UseAuthentication method before calling UseMvcWithDefaultRoute or UseMvc:

app.UseAuthentication();

Opções de AddCookieAddCookie Options

O CookieAuthenticationOptions classe é usada para configurar as opções de provedor de autenticação.The CookieAuthenticationOptions class is used to configure the authentication provider options.

OpçãoOption DescriçãoDescription
AccessDeniedPathAccessDeniedPath Fornece o caminho para fornecer a uma 302 não encontrado (redirecionamento de URL) quando disparado por HttpContext.ForbidAsync.Provides the path to supply with a 302 Found (URL redirect) when triggered by HttpContext.ForbidAsync. O valor padrão é /Account/AccessDenied.The default value is /Account/AccessDenied.
ClaimsIssuerClaimsIssuer O emissor a ser usado para o emissor propriedade em quaisquer declarações criadas pelo serviço de autenticação de cookie.The issuer to use for the Issuer property on any claims created by the cookie authentication service.
Cookie.DomainCookie.Domain O nome de domínio no qual o cookie é atendido.The domain name where the cookie is served. Por padrão, isso é o nome do host da solicitação.By default, this is the host name of the request. O navegador envia apenas o cookie em solicitações para um nome de host correspondente.The browser only sends the cookie in requests to a matching host name. Talvez você queira ajustar isso para ter cookies disponíveis para qualquer host no seu domínio.You may wish to adjust this to have cookies available to any host in your domain. Por exemplo, definir o domínio do cookie .contoso.com disponibiliza para contoso.com, www.contoso.com, e staging.www.contoso.com.For example, setting the cookie domain to .contoso.com makes it available to contoso.com, www.contoso.com, and staging.www.contoso.com.
Cookie.ExpirationCookie.Expiration Obtém ou define o tempo de vida de um cookie.Gets or sets the lifespan of a cookie. Atualmente, essa opção não funciona e se tornará obsoleta no ASP.NET Core 2.1 +.Currently, this option no-ops and will become obsolete in ASP.NET Core 2.1+. Use o ExpireTimeSpan opção para definir a expiração do cookie.Use the ExpireTimeSpan option to set cookie expiration. Para obter mais informações, consulte esclarecer o comportamento de CookieAuthenticationOptions.Cookie.Expiration.For more information, see Clarify behavior of CookieAuthenticationOptions.Cookie.Expiration.
Cookie.HttpOnlyCookie.HttpOnly Um sinalizador que indica se o cookie deve ser acessível somente aos servidores.A flag indicating if the cookie should be accessible only to servers. A alteração desse valor para false permite que os scripts do lado do cliente para acessar o cookie e pode abrir seu aplicativo ao roubo de cookie deve ter de seu aplicativo uma Cross-site scripting (XSS) vulnerabilidade.Changing this value to false permits client-side scripts to access the cookie and may open your app to cookie theft should your app have a Cross-site scripting (XSS) vulnerability. O valor padrão é true.The default value is true.
Cookie.NameCookie.Name Define o nome do cookie.Sets the name of the cookie.
Cookie.PathCookie.Path Usado para isolar aplicativos em execução no mesmo nome de host.Used to isolate apps running on the same host name. Se você tiver um aplicativo em execução no /app1 e para restringir os cookies para o aplicativo, defina a CookiePath propriedade /app1.If you have an app running at /app1 and want to restrict cookies to that app, set the CookiePath property to /app1. Ao fazer isso, o cookie só está disponível em solicitações para /app1 e qualquer aplicativo abaixo dela.By doing so, the cookie is only available on requests to /app1 and any app underneath it.
Cookie.SameSiteCookie.SameSite Indica se o navegador deve permitir que o cookie a ser anexado a somente solicitações do mesmo site (SameSiteMode.Strict) ou solicitações entre sites usando métodos seguros de HTTP e as solicitações do mesmo site (SameSiteMode.Lax).Indicates whether the browser should allow the cookie to be attached to same-site requests only (SameSiteMode.Strict) or cross-site requests using safe HTTP methods and same-site requests (SameSiteMode.Lax). Quando definido como SameSiteMode.None, o valor do cabeçalho de cookie não está definido.When set to SameSiteMode.None, the cookie header value isn't set. Observe que Middleware do Cookie política pode substituir o valor fornecido por você.Note that Cookie Policy Middleware might overwrite the value that you provide. Para dar suporte à autenticação OAuth, o valor padrão é SameSiteMode.Lax.To support OAuth authentication, the default value is SameSiteMode.Lax. Para obter mais informações, consulte autenticação OAuth interrompida devido à política de cookies SameSite.For more information, see OAuth authentication broken due to SameSite cookie policy.
Cookie.SecurePolicyCookie.SecurePolicy Um sinalizador que indica se o cookie criado deve ser limitado a HTTPS (CookieSecurePolicy.Always), HTTP ou HTTPS (CookieSecurePolicy.None), ou o mesmo protocolo usado na solicitação (CookieSecurePolicy.SameAsRequest).A flag indicating if the cookie created should be limited to HTTPS (CookieSecurePolicy.Always), HTTP or HTTPS (CookieSecurePolicy.None), or the same protocol as the request (CookieSecurePolicy.SameAsRequest). O valor padrão é CookieSecurePolicy.SameAsRequest.The default value is CookieSecurePolicy.SameAsRequest.
DataProtectionProviderDataProtectionProvider Define o DataProtectionProvider que é usado para criar o padrão TicketDataFormat.Sets the DataProtectionProvider that's used to create the default TicketDataFormat. Se o TicketDataFormat propriedade for definida, o DataProtectionProvider opção não é usada.If the TicketDataFormat property is set, the DataProtectionProvider option isn't used. Se não for fornecido, o provedor de proteção de dados do aplicativo padrão é usado.If not provided, the app's default data protection provider is used.
EventosEvents O manipulador chama métodos no provedor que fornecem o controle de aplicativo em determinados pontos de processamento.The handler calls methods on the provider that give the app control at certain processing points. Se Events não são fornecidas, uma instância padrão é fornecida que não faz nada quando os métodos são chamados.If Events aren't provided, a default instance is supplied that does nothing when the methods are called.
EventsTypeEventsType Usado como o tipo de serviço para obter o Events instância em vez da propriedade.Used as the service type to get the Events instance instead of the property.
ExpireTimeSpanExpireTimeSpan O TimeSpan depois que o tíquete de autenticação armazenado dentro do cookie expira.The TimeSpan after which the authentication ticket stored inside the cookie expires. ExpireTimeSpan é adicionado à hora atual para criar o tempo de expiração para o tíquete.ExpireTimeSpan is added to the current time to create the expiration time for the ticket. O ExpiredTimeSpan valor sempre entra no AuthTicket criptografado verificado pelo servidor.The ExpiredTimeSpan value always goes into the encrypted AuthTicket verified by the server. Isso também pode acontecer na Set-Cookie cabeçalho, mas somente se IsPersistent está definido.It may also go into the Set-Cookie header, but only if IsPersistent is set. Para definir IsPersistent à true, configure o AuthenticationProperties passado para SignInAsync.To set IsPersistent to true, configure the AuthenticationProperties passed to SignInAsync. O valor padrão de ExpireTimeSpan é de 14 dias.The default value of ExpireTimeSpan is 14 days.
LoginPathLoginPath Fornece o caminho para fornecer a uma 302 não encontrado (redirecionamento de URL) quando disparado por HttpContext.ChallengeAsync.Provides the path to supply with a 302 Found (URL redirect) when triggered by HttpContext.ChallengeAsync. A URL atual que gerou o 401 é adicionada para o LoginPath como um parâmetro de cadeia de caracteres de consulta nomeado pelo ReturnUrlParameter.The current URL that generated the 401 is added to the LoginPath as a query string parameter named by the ReturnUrlParameter. Uma vez uma solicitação para o LoginPath concede uma nova entrada identidade, o ReturnUrlParameter valor é usado para redirecionar o navegador para a URL que causou o código de status não autorizado original.Once a request to the LoginPath grants a new sign-in identity, the ReturnUrlParameter value is used to redirect the browser back to the URL that caused the original unauthorized status code. O valor padrão é /Account/Login.The default value is /Account/Login.
LogoutPathLogoutPath Se o LogoutPath é fornecido para o manipulador, em seguida, redireciona uma solicitação para o caminho com base no valor da ReturnUrlParameter.If the LogoutPath is provided to the handler, then a request to that path redirects based on the value of the ReturnUrlParameter. O valor padrão é /Account/Logout.The default value is /Account/Logout.
ReturnUrlParameterReturnUrlParameter Determina o nome do parâmetro de cadeia de consulta que é acrescentado pelo manipulador para uma resposta 302 do encontrado (redirecionamento de URL).Determines the name of the query string parameter that's appended by the handler for a 302 Found (URL redirect) response. ReturnUrlParameter é usado quando uma solicitação chega na LoginPath ou LogoutPath para retornar o navegador a URL original depois que a ação de logon ou logoff é executada.ReturnUrlParameter is used when a request arrives on the LoginPath or LogoutPath to return the browser to the original URL after the login or logout action is performed. O valor padrão é ReturnUrl.The default value is ReturnUrl.
SessionStoreSessionStore Um contêiner opcional usado para armazenar a identidade entre solicitações.An optional container used to store identity across requests. Quando usado, somente um identificador de sessão é enviado ao cliente.When used, only a session identifier is sent to the client. SessionStore pode ser usado para atenuar problemas potenciais com identidades grandes.SessionStore can be used to mitigate potential problems with large identities.
slidingExpirationSlidingExpiration Um sinalizador que indica se um novo cookie com um tempo de expiração atualizados deve ser emitido dinamicamente.A flag indicating if a new cookie with an updated expiration time should be issued dynamically. Isso pode acontecer em qualquer solicitação em que o período de expiração do cookie atual mais de 50% expirou.This can happen on any request where the current cookie expiration period is more than 50% expired. A nova data de expiração é movida para frente até ser a data atual mais o ExpireTimespan.The new expiration date is moved forward to be the current date plus the ExpireTimespan. Uma tempo de expiração do cookie absoluto pode ser definida usando o AuthenticationProperties classe ao chamar SignInAsync.An absolute cookie expiration time can be set by using the AuthenticationProperties class when calling SignInAsync. Um tempo de expiração absoluto pode melhorar a segurança do seu aplicativo, limitando a quantidade de tempo que o cookie de autenticação é válido.An absolute expiration time can improve the security of your app by limiting the amount of time that the authentication cookie is valid. O valor padrão é true.The default value is true.
TicketDataFormatTicketDataFormat O TicketDataFormat é usado para proteger e desproteger a identidade e outras propriedades que são armazenadas no valor do cookie.The TicketDataFormat is used to protect and unprotect the identity and other properties that are stored in the cookie value. Se não for fornecido, um TicketDataFormat é criado usando o DataProtectionProvider.If not provided, a TicketDataFormat is created using the DataProtectionProvider.
ValidarValidate Método que verifica que as opções são válidas.Method that checks that the options are valid.

Definir CookieAuthenticationOptions na configuração do serviço para autenticação no ConfigureServices método:Set CookieAuthenticationOptions in the service configuration for authentication in the ConfigureServices method:

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        ...
    });

ASP.NET Core 1.x usa cookie middleware que serializa uma entidade de usuário em um cookie criptografado.ASP.NET Core 1.x uses cookie middleware that serializes a user principal into an encrypted cookie. Em solicitações subsequentes, o cookie é validado, e a entidade de segurança é recriada e atribuída ao HttpContext.User propriedade.On subsequent requests, the cookie is validated, and the principal is recreated and assigned to the HttpContext.User property.

Instalar o Microsoft.AspNetCore.Authentication.Cookies pacote do NuGet em seu projeto.Install the Microsoft.AspNetCore.Authentication.Cookies NuGet package in your project. Este pacote contém o cookie de middleware.This package contains the cookie middleware.

Use o UseCookieAuthentication método no Configure método na sua Startup.cs antes do arquivo UseMvc ou UseMvcWithDefaultRoute:Use the UseCookieAuthentication method in the Configure method in your Startup.cs file before UseMvc or UseMvcWithDefaultRoute:

app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
    AccessDeniedPath = "/Account/Forbidden/",
    AuthenticationScheme = CookieAuthenticationDefaults.AuthenticationScheme,
    AutomaticAuthenticate = true,
    AutomaticChallenge = true,
    LoginPath = "/Account/Unauthorized/"
});

Opções de CookieAuthenticationOptionsCookieAuthenticationOptions Options

O CookieAuthenticationOptions classe é usada para configurar as opções de provedor de autenticação.The CookieAuthenticationOptions class is used to configure the authentication provider options.

OpçãoOption DescriçãoDescription
AuthenticationSchemeAuthenticationScheme Define o esquema de autenticação.Sets the authentication scheme. AuthenticationScheme é útil quando há várias instâncias de autenticação e você deseja autorizar com um esquema específico.AuthenticationScheme is useful when there are multiple instances of authentication and you want to authorize with a specific scheme. Definindo o AuthenticationScheme para CookieAuthenticationDefaults.AuthenticationScheme fornece um valor de "Cookies" para o esquema.Setting the AuthenticationScheme to CookieAuthenticationDefaults.AuthenticationScheme provides a value of "Cookies" for the scheme. Você pode fornecer qualquer valor de cadeia de caracteres que diferencia o esquema.You can supply any string value that distinguishes the scheme.
AutomaticAuthenticateAutomaticAuthenticate Define um valor para indicar que a autenticação de cookie deve executar em cada solicitação e tente validar e reconstrua qualquer entidade de segurança serializada criado por ele.Sets a value to indicate that the cookie authentication should run on every request and attempt to validate and reconstruct any serialized principal it created.
AutomaticChallengeAutomaticChallenge Se for true, o middleware de autenticação lida com desafios automática.If true, the authentication middleware handles automatic challenges. Se false, o middleware de autenticação altera somente as respostas quando explicitamente indicado pelo AuthenticationScheme.If false, the authentication middleware only alters responses when explicitly indicated by the AuthenticationScheme.
ClaimsIssuerClaimsIssuer O emissor a ser usado para o emissor propriedade em quaisquer declarações criado pelo middleware de autenticação de cookie.The issuer to use for the Issuer property on any claims created by the cookie authentication middleware.
CookieDomainCookieDomain O nome de domínio no qual o cookie é atendido.The domain name where the cookie is served. Por padrão, isso é o nome do host da solicitação.By default, this is the host name of the request. O navegador só serve o cookie para um nome de host correspondente.The browser only serves the cookie to a matching host name. Talvez você queira ajustar isso para ter cookies disponíveis para qualquer host no seu domínio.You may wish to adjust this to have cookies available to any host in your domain. Por exemplo, definir o domínio do cookie .contoso.com disponibiliza para contoso.com, www.contoso.com, e staging.www.contoso.com.For example, setting the cookie domain to .contoso.com makes it available to contoso.com, www.contoso.com, and staging.www.contoso.com.
CookieHttpOnlyCookieHttpOnly Um sinalizador que indica se o cookie deve ser acessível somente aos servidores.A flag indicating if the cookie should be accessible only to servers. A alteração desse valor para false permite que os scripts do lado do cliente para acessar o cookie e pode abrir seu aplicativo ao roubo de cookie deve ter de seu aplicativo uma Cross-site scripting (XSS) vulnerabilidade.Changing this value to false permits client-side scripts to access the cookie and may open your app to cookie theft should your app have a Cross-site scripting (XSS) vulnerability. O valor padrão é true.The default value is true.
CookiePathCookiePath Usado para isolar aplicativos em execução no mesmo nome de host.Used to isolate apps running on the same host name. Se você tiver um aplicativo em execução no /app1 e para restringir os cookies para o aplicativo, defina a CookiePath propriedade /app1.If you have an app running at /app1 and want to restrict cookies to that app, set the CookiePath property to /app1. Ao fazer isso, o cookie só está disponível em solicitações para /app1 e qualquer aplicativo abaixo dela.By doing so, the cookie is only available on requests to /app1 and any app underneath it.
CookieSecureCookieSecure Um sinalizador que indica se o cookie criado deve ser limitado a HTTPS (CookieSecurePolicy.Always), HTTP ou HTTPS (CookieSecurePolicy.None), ou o mesmo protocolo usado na solicitação (CookieSecurePolicy.SameAsRequest).A flag indicating if the cookie created should be limited to HTTPS (CookieSecurePolicy.Always), HTTP or HTTPS (CookieSecurePolicy.None), or the same protocol as the request (CookieSecurePolicy.SameAsRequest). O valor padrão é CookieSecurePolicy.SameAsRequest.The default value is CookieSecurePolicy.SameAsRequest.
DescriçãoDescription Informações adicionais sobre o tipo de autenticação que será disponibilizado para o aplicativo.Additional information about the authentication type which is made available to the app.
ExpireTimeSpanExpireTimeSpan O TimeSpan depois que o tíquete de autenticação expira.The TimeSpan after which the authentication ticket expires. Ele é adicionado à hora atual para criar o tempo de expiração para o tíquete.It's added to the current time to create the expiration time for the ticket. Para usar ExpireTimeSpan, você deve definir IsPersistent ao true no AuthenticationProperties passado para SignInAsync.To use ExpireTimeSpan, you must set IsPersistent to true in the AuthenticationProperties passed to SignInAsync. O valor padrão é 14 dias.The default value is 14 days.
slidingExpirationSlidingExpiration Um sinalizador que indica se a data de expiração do cookie redefine quando houver mais de metade do ExpireTimeSpan intervalo tenha decorrido.A flag indicating whether the cookie expiration date resets when more than half of the ExpireTimeSpan interval has passed. A nova hora exipiration é movida para frente até ser a data atual mais o ExpireTimespan.The new exipiration time is moved forward to be the current date plus the ExpireTimespan. Uma tempo de expiração do cookie absoluto pode ser definida usando o AuthenticationProperties classe ao chamar SignInAsync.An absolute cookie expiration time can be set by using the AuthenticationProperties class when calling SignInAsync. Um tempo de expiração absoluto pode melhorar a segurança do seu aplicativo, limitando a quantidade de tempo que o cookie de autenticação é válido.An absolute expiration time can improve the security of your app by limiting the amount of time that the authentication cookie is valid. O valor padrão é true.The default value is true.

Definir CookieAuthenticationOptions para o Middleware de autenticação de Cookie no Configure método:Set CookieAuthenticationOptions for the Cookie Authentication Middleware in the Configure method:

app.UseCookieAuthentication(new CookieAuthenticationOptions
{
    ...
});

Middleware do cookie política habilita recursos de política de cookie em um aplicativo.Cookie Policy Middleware enables cookie policy capabilities in an app. Adicionar o middleware ao pipeline de processamento de aplicativos é a ordem de minúsculas; ela afeta apenas os componentes registrados depois no pipeline.Adding the middleware to the app processing pipeline is order sensitive; it only affects components registered after it in the pipeline.

app.UseCookiePolicy(cookiePolicyOptions);

O CookiePolicyOptions fornecido para o Cookie de Middleware de política permitem controlar características globais do processamento de cookie e gancho em manipuladores de processamento do cookie quando os cookies são acrescentados ou excluídos.The CookiePolicyOptions provided to the Cookie Policy Middleware allow you to control global characteristics of cookie processing and hook into cookie processing handlers when cookies are appended or deleted.

PropriedadeProperty DescriçãoDescription
HttpOnlyHttpOnly Afeta se os cookies devem ser HttpOnly, que é um sinalizador que indica se o cookie deve ser acessível somente aos servidores.Affects whether cookies must be HttpOnly, which is a flag indicating if the cookie should be accessible only to servers. O valor padrão é HttpOnlyPolicy.None.The default value is HttpOnlyPolicy.None.
MinimumSameSitePolicyMinimumSameSitePolicy Afeta o atributo de mesmo site do cookie (veja abaixo).Affects the cookie's same-site attribute (see below). O valor padrão é SameSiteMode.Lax.The default value is SameSiteMode.Lax. Essa opção está disponível para o ASP.NET Core 2.0 +.This option is available for ASP.NET Core 2.0+.
OnAppendCookieOnAppendCookie Chamado quando um cookie será acrescentado.Called when a cookie is appended.
OnDeleteCookieOnDeleteCookie Chamado quando um cookie é excluído.Called when a cookie is deleted.
ProtegerSecure Afeta se os cookies devem ser seguro.Affects whether cookies must be Secure. O valor padrão é CookieSecurePolicy.None.The default value is CookieSecurePolicy.None.

MinimumSameSitePolicy (ASP.NET Core 2.0 ou posterior somente)MinimumSameSitePolicy (ASP.NET Core 2.0+ only)

O padrão MinimumSameSitePolicy valor é SameSiteMode.Lax para permitir a autenticação OAuth2.The default MinimumSameSitePolicy value is SameSiteMode.Lax to permit OAuth2 authentication. Estritamente impor uma política do mesmo site do SameSiteMode.Strict, defina o MinimumSameSitePolicy.To strictly enforce a same-site policy of SameSiteMode.Strict, set the MinimumSameSitePolicy. Embora essa configuração interrompe OAuth2 e outras esquemas de autenticação entre origens, ela eleva o nível de segurança do cookie para outros tipos de aplicativos que não dependem de processamento de solicitação entre origens.Although this setting breaks OAuth2 and other cross-origin authentication schemes, it elevates the level of cookie security for other types of apps that don't rely on cross-origin request processing.

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

A configuração de Middleware de política de Cookie para MinimumSameSitePolicy pode afetar sua configuração de Cookie.SameSite em CookieAuthenticationOptions configurações de acordo com a matriz a seguir.The Cookie Policy Middleware setting for MinimumSameSitePolicy can affect your setting of Cookie.SameSite in CookieAuthenticationOptions settings according to the matrix below.

MinimumSameSitePolicyMinimumSameSitePolicy Cookie.SameSiteCookie.SameSite Configuração de Cookie.SameSite resultanteResultant Cookie.SameSite setting
SameSiteMode.NoneSameSiteMode.None SameSiteMode.NoneSameSiteMode.None
SameSiteMode.LaxSameSiteMode.Lax
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.NoneSameSiteMode.None
SameSiteMode.LaxSameSiteMode.Lax
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.LaxSameSiteMode.Lax SameSiteMode.NoneSameSiteMode.None
SameSiteMode.LaxSameSiteMode.Lax
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.LaxSameSiteMode.Lax
SameSiteMode.LaxSameSiteMode.Lax
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.StrictSameSiteMode.Strict SameSiteMode.NoneSameSiteMode.None
SameSiteMode.LaxSameSiteMode.Lax
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.StrictSameSiteMode.Strict
SameSiteMode.StrictSameSiteMode.Strict

Para criar um cookie contendo informações de usuário, você precisa construir uma ClaimsPrincipal.To create a cookie holding user information, you must construct a ClaimsPrincipal. As informações do usuário são serializadas e armazenadas no cookie.The user information is serialized and stored in the cookie.

Criar uma ClaimsIdentity com qualquer necessárias declaraçãos e chame SignInAsync para a entrada do usuário:Create a ClaimsIdentity with any required Claims and call SignInAsync to sign in the user:

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. Required when setting the 
    // ExpireTimeSpan option of CookieAuthenticationOptions 
    // set with AddCookie. Also required when setting 
    // ExpiresUtc.

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

Chame SignInAsync para a entrada do usuário:Call SignInAsync to sign in the user:

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

SignInAsync cria um cookie criptografado e o adiciona à resposta atual.SignInAsync creates an encrypted cookie and adds it to the current response. Se você não especificar um AuthenticationScheme, o esquema padrão é usado.If you don't specify an AuthenticationScheme, the default scheme is used.

Nos bastidores, a criptografia usada é ASP.NET Core proteção de dados sistema.Under the covers, the encryption used is ASP.NET Core's Data Protection system. Se você estiver hospedando o aplicativo em várias máquinas, balanceamento de carga entre aplicativos ou usar uma web farm, você deve configurar a proteção de dados para usar o mesmo anel de chave e o identificador do aplicativo.If you're hosting app on multiple machines, load balancing across apps, or using a web farm, then you must configure data protection to use the same key ring and app identifier.

SairSign out

Para desconectar o usuário atual e excluir seus cookies, chame SignOutAsync:To sign out the current user and delete their cookie, call SignOutAsync:

await HttpContext.SignOutAsync(
    CookieAuthenticationDefaults.AuthenticationScheme);

Para desconectar o usuário atual e excluir seus cookies, chame SignOutAsync:To sign out the current user and delete their cookie, call SignOutAsync:

await HttpContext.Authentication.SignOutAsync(
    CookieAuthenticationDefaults.AuthenticationScheme);

Se você não estiver usando CookieAuthenticationDefaults.AuthenticationScheme (ou "Cookies") como o esquema (por exemplo, "ContosoCookie"), forneça o esquema usado ao configurar o provedor de autenticação.If you aren't using CookieAuthenticationDefaults.AuthenticationScheme (or "Cookies") as the scheme (for example, "ContosoCookie"), supply the scheme you used when configuring the authentication provider. Caso contrário, o esquema padrão é usado.Otherwise, the default scheme is used.

Reagir às alterações de back-endReact to back-end changes

Depois que um cookie é criado, ele se torna a única fonte de identidade.Once a cookie is created, it becomes the single source of identity. Mesmo se você desabilitar um usuário em seus sistemas de back-end, o sistema de autenticação de cookie não tem conhecimento disso, e um usuário permaneça conectado enquanto seu cookie é válido.Even if you disable a user in your back-end systems, the cookie authentication system has no knowledge of this, and a user stays logged in as long as their cookie is valid.

O ValidatePrincipal evento no ASP.NET Core 2.x ou o ValidateAsync método no ASP.NET Core 1.x pode ser usado para interceptar e substituir a validação da identidade do cookie.The ValidatePrincipal event in ASP.NET Core 2.x or the ValidateAsync method in ASP.NET Core 1.x can be used to intercept and override validation of the cookie identity. Essa abordagem minimiza o risco de usuários revogados acessando o aplicativo.This approach mitigates the risk of revoked users accessing the app.

Uma abordagem de validação de cookie baseia-se em manter o controle de quando o banco de dados do usuário foi alterado.One approach to cookie validation is based on keeping track of when the user database has been changed. Se o banco de dados não foi alterado desde que o cookie do usuário foi emitido, não é necessário para autenticar o usuário novamente se o cookie ainda é válido.If the database hasn't been changed since the user's cookie was issued, there's no need to re-authenticate the user if their cookie is still valid. Para implementar este cenário, o banco de dados, que é implementado no IUserRepository para este exemplo armazena um LastChanged valor.To implement this scenario, the database, which is implemented in IUserRepository for this example, stores a LastChanged value. Quando nenhum usuário é atualizado no banco de dados, o LastChanged valor é definido como a hora atual.When any user is updated in the database, the LastChanged value is set to the current time.

Para invalidar um cookie, quando as alterações de banco de dados com base nas LastChanged o valor, criar o cookie com um LastChanged contendo atual de declaração LastChanged valor do banco de dados:In order to invalidate a cookie when the database changes based on the LastChanged value, create the cookie with a LastChanged claim containing the current LastChanged value from the database:

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

Para implementar uma substituição para o ValidatePrincipal eventos, escreva um método com a assinatura a seguir em uma classe que você deriva CookieAuthenticationEvents:To implement an override for the ValidatePrincipal event, write a method with the following signature in a class that you derive from CookieAuthenticationEvents:

ValidatePrincipal(CookieValidatePrincipalContext)

Um exemplo é semelhante ao seguinte:An example looks like the following:

using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;

public class CustomCookieAuthenticationEvents : CookieAuthenticationEvents
{
    private readonly IUserRepository _userRepository;

    public CustomCookieAuthenticationEvents(IUserRepository userRepository)
    {
        // Get the database from registered DI services.
        _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);
        }
    }
}

Registrar a instância de eventos durante o registro do serviço de cookie no ConfigureServices método.Register the events instance during cookie service registration in the ConfigureServices method. Fornecer um registro de serviço com escopo para sua CustomCookieAuthenticationEvents classe:Provide a scoped service registration for your CustomCookieAuthenticationEvents class:

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

services.AddScoped<CustomCookieAuthenticationEvents>();

Para implementar uma substituição para o ValidateAsync eventos, escreva um método com a seguinte assinatura:To implement an override for the ValidateAsync event, write a method with the following signature:

ValidateAsync(CookieValidatePrincipalContext)

Identidade do ASP.NET Core implementa essa verificação como parte de sua SecurityStampValidator.ASP.NET Core Identity implements this check as part of its SecurityStampValidator. Um exemplo é semelhante ao seguinte:An example looks like the following:

public static class LastChangedValidator
{
    public static async Task ValidateAsync(CookieValidatePrincipalContext context)
    {
        // Pull database from registered DI services.
        var userRepository = 
            context.HttpContext.RequestServices
                .GetRequiredService<IUserRepository>();
        var userPrincipal = context.Principal;

        // Look for the last changed 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);
        }
    }
}

Registrar o evento durante a configuração de autenticação de cookie no Configure método:Register the event during cookie authentication configuration in the Configure method:

app.UseCookieAuthentication(new CookieAuthenticationOptions
{
    Events = new CookieAuthenticationEvents
    {
        OnValidatePrincipal = LastChangedValidator.ValidateAsync
    }
});

Considere uma situação em que o nome do usuário é atualizado — uma decisão que não afeta a segurança de qualquer forma.Consider a situation in which the user's name is updated — a decision that doesn't affect security in any way. Se você quiser atualizar forma não destrutiva a entidade de usuário, chame context.ReplacePrincipal e defina o context.ShouldRenew propriedade true.If you want to non-destructively update the user principal, call context.ReplacePrincipal and set the context.ShouldRenew property to true.

Aviso

A abordagem descrita aqui é disparada em cada solicitação.The approach described here is triggered on every request. Isso pode resultar em uma penalidade de desempenho grande para o aplicativo.This can result in a large performance penalty for the app.

Cookies persistentesPersistent cookies

Talvez você queira que o cookie para persistir entre as sessões do navegador.You may want the cookie to persist across browser sessions. Essa persistência deve ser habilitada apenas com o consentimento explícito do usuário com uma caixa de seleção "Lembrar-Me" no logon ou um mecanismo semelhante.This persistence should only be enabled with explicit user consent with a "Remember Me" check box on login or a similar mechanism.

O trecho de código a seguir cria uma identidade e o cookie correspondente que sobrevive a por meio de fechamentos de navegador.The following code snippet creates an identity and corresponding cookie that survives through browser closures. Quaisquer configurações de expiração deslizante configuradas anteriormente são consideradas.Any sliding expiration settings previously configured are honored. Se o cookie expirar enquanto o navegador é fechado, o navegador limpa o cookie depois que ele seja reiniciado.If the cookie expires while the browser is closed, the browser clears the cookie once it's restarted.

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

O AuthenticationProperties classe reside no Microsoft.AspNetCore.Authentication namespace.The AuthenticationProperties class resides in the Microsoft.AspNetCore.Authentication namespace.

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

O AuthenticationProperties classe reside no Microsoft.AspNetCore.Http.Authentication namespace.The AuthenticationProperties class resides in the Microsoft.AspNetCore.Http.Authentication namespace.

Você pode definir um tempo de expiração absoluto com ExpiresUtc.You can set an absolute expiration time with ExpiresUtc. Você também deve definir IsPersistent; caso contrário, ExpiresUtc será ignorado e um cookie de sessão único é criado.You must also set IsPersistent; otherwise, ExpiresUtc is ignored and a single-session cookie is created. Quando ExpiresUtc é definida em SignInAsync, ele substitui o valor da ExpireTimeSpan opção de CookieAuthenticationOptions, se definido.When ExpiresUtc is set on SignInAsync, it overrides the value of the ExpireTimeSpan option of CookieAuthenticationOptions, if set.

O trecho de código a seguir cria uma identidade e o cookie correspondente que dura por 20 minutos.The following code snippet creates an identity and corresponding cookie that lasts for 20 minutes. Isso ignora as configurações de expiração deslizante configuradas anteriormente.This ignores any sliding expiration settings previously configured.

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

Recursos adicionaisAdditional resources