Proteger microsserviços .NET e aplicativos WebMake secure .NET Microservices and Web Applications

Há muitos aspectos sobre segurança em microsserviços e aplicativos Web que o tópico poderia ter facilmente vários livros como este. Portanto, nesta seção, vamos nos concentrar na autenticação, na autorização e nos segredos do aplicativo.There are so many aspects about security in microservices and web applications that the topic could easy take several books like this one so, in this section, we'll focus on authentication, authorization, and application secrets.

Implementar a autenticação em microsserviços .NET e aplicativos WebImplement authentication in .NET microservices and web applications

Geralmente é necessário que os recursos e as APIs publicados por um serviço sejam limitados a determinados usuários ou clientes confiáveis.It's often necessary for resources and APIs published by a service to be limited to certain trusted users or clients. A primeira etapa para tomar esses tipos de decisões de confiança no nível da API é a autenticação.The first step to making these sorts of API-level trust decisions is authentication. Autenticação é o processo de confirmar a identidade do usuário de forma confiável.Authentication is the process of reliably verify a user’s identity.

Em cenários de microsserviço, normalmente a autenticação é manipulada centralmente.In microservice scenarios, authentication is typically handled centrally. Se você estiver usando um Gateway de API, o gateway será um bom lugar para fazer a autenticação, conforme é mostrado na Figura 9-1.If you're using an API Gateway, the gateway is a good place to authenticate, as shown in Figure 9-1. Se você usar esta abordagem, verifique se os microsserviços individuais não podem ser acessados diretamente (sem o Gateway de API), a não ser que haja uma segurança adicional em vigor para autenticar mensagens que entram ou não pelo gateway.If you use this approach, make sure that the individual microservices cannot be reached directly (without the API Gateway) unless additional security is in place to authenticate messages whether they come from the gateway or not.

Quando o Gateway de API centraliza a autenticação, ele adiciona informações do usuário ao encaminhar solicitações para os microsserviços.

Figura 9-1.Figure 9-1. Autenticação centralizada com um Gateway de APICentralized authentication with an API Gateway

Se os serviços puderem ser acessados diretamente, um serviço de autenticação como o Azure Active Directory ou um microsserviço de autenticação dedicado agindo como um STS (serviço de token de segurança) poderá ser usado para autenticar os usuários.If services can be accessed directly, an authentication service like Azure Active Directory or a dedicated authentication microservice acting as a security token service (STS) can be used to authenticate users. As decisões de confiança são compartilhadas entre os serviços com tokens de segurança ou cookies.Trust decisions are shared between services with security tokens or cookies. Esses tokens podem ser compartilhados entre aplicativos do ASP.NET Core, se necessário, ao implementar o compartilhamento de cookies. Esse padrão é ilustrado na Figura 9-2.(These tokens can be shared between ASP.NET Core applications, if needed, by implementing cookie sharing.) This pattern is illustrated in Figure 9-2.

Quando os microsserviços são acessados diretamente, a confiança, que inclui autenticação e autorização, é tratada por um token de segurança emitido por um microsserviço dedicado, compartilhado entre os microsserviços.

Figura 9-2.Figure 9-2. Autenticação por microsserviço de identidade; a confiança é compartilhada usando um token de autorizaçãoAuthentication by identity microservice; trust is shared using an authorization token

Autenticar usando o ASP.NET Core IdentityAuthenticate with ASP.NET Core Identity

O mecanismo primário no ASP.NET Core para identificar os usuários de um aplicativo é sistema de associação ASP.NET Core Identity.The primary mechanism in ASP.NET Core for identifying an application’s users is the ASP.NET Core Identity membership system. O ASP.NET Core Identity armazena as informações do usuário (incluindo informações de logon, funções e declarações) em um armazenamento de dados configurado pelo desenvolvedor.ASP.NET Core Identity stores user information (including sign-in information, roles, and claims) in a data store configured by the developer. Normalmente, o armazenamento de dados do ASP.NET Core Identity é um repositório do Entity Framework fornecido no pacote Microsoft.AspNetCore.Identity.EntityFrameworkCore.Typically, the ASP.NET Core Identity data store is an Entity Framework store provided in the Microsoft.AspNetCore.Identity.EntityFrameworkCore package. No entanto, os repositórios personalizados ou outros pacotes de terceiros podem ser usados para armazenar informações de identidade no Armazenamento de Tabelas do Azure, no CosmosDB ou em outros locais.However, custom stores or other third-party packages can be used to store identity information in Azure Table Storage, CosmosDB, or other locations.

O código a seguir foi obtido no modelo de projeto de aplicativo Web do ASP.NET Core com a autenticação de conta de usuário individual selecionada.The following code is taken from the ASP.NET Core Web Application project template with individual user account authentication selected. Ele mostra como configurar o ASP.NET Core Identity usando o EntityFramework.Core no método Startup.ConfigureServices.It shows how to configure ASP.NET Core Identity using EntityFramework.Core in the Startup.ConfigureServices method.

services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

Após configurar o ASP.NET Core Identity, você pode habilitá-lo chamando app.UseIdentity no método Startup.Configure do serviço.Once ASP.NET Core Identity is configured, you enable it by calling app.UseIdentity in the service’s Startup.Configure method.

Usar o ASP.NET Core Identity permite vários cenários:Using ASP.NET Core Identity enables several scenarios:

  • Criar informações de novo usuário usando o tipo UserManager (userManager.CreateAsync).Create new user information using the UserManager type (userManager.CreateAsync).

  • Autenticar usuários usando o tipo SignInManager.Authenticate users using the SignInManager type. Você pode usar signInManager.SignInAsync para entrar diretamente ou signInManager.PasswordSignInAsync para confirmar se a senha do usuário está correta e, em seguida, assiná-las.You can use signInManager.SignInAsync to sign in directly, or signInManager.PasswordSignInAsync to confirm the user’s password is correct and then sign them in.

  • Identificar um usuário com base nas informações armazenadas em um cookie (que são lidas pelo middleware do ASP.NET Core Identity) para que as próximas solicitações de um navegador incluam a identidade e as declarações do usuário conectado.Identify a user based on information stored in a cookie (which is read by ASP.NET Core Identity middleware) so that subsequent requests from a browser will include a signed-in user’s identity and claims.

O ASP.NET Core Identity também dá suporte à autenticação de dois fatores.ASP.NET Core Identity also supports two-factor authentication.

Para cenários de autenticação que usam um armazenamento de dados de usuário local e que persistem a identidade entre solicitações usando cookies (como é comum para aplicativos Web MVC), o ASP.NET Core Identity é uma solução recomendada.For authentication scenarios that make use of a local user data store and that persist identity between requests using cookies (as is typical for MVC web applications), ASP.NET Core Identity is a recommended solution.

Autenticar com provedores externosAuthenticate with external providers

O ASP.NET Core também dá suporte ao uso de provedores de autenticação externos para permitir que os usuários entrem por meio de fluxos OAuth 2.0.ASP.NET Core also supports using external authentication providers to let users sign in via OAuth 2.0 flows. Isso significa que os usuários podem entrar usando os processos de autenticação existentes de provedores como Microsoft, Google, Facebook ou Twitter e associar essas identidades a um ASP.NET Core Identity no seu aplicativo.This means that users can sign in using existing authentication processes from providers like Microsoft, Google, Facebook, or Twitter and associate those identities with an ASP.NET Core identity in your application.

Para usar a autenticação externa, você pode incluir o middleware de autenticação apropriado no pipeline de processamento de solicitação HTTP do aplicativo.To use external authentication, you include the appropriate authentication middleware in your application’s HTTP request processing pipeline. Este middleware é responsável por manipular solicitações para retornar as rotas de URI do provedor de autenticação, capturando informações de identidade e disponibilizando-as por meio do método SignInManager.GetExternalLoginInfo.This middleware is responsible for handling requests to return URI routes from the authentication provider, capturing identity information, and making it available via the SignInManager.GetExternalLoginInfo method.

Os provedores de autenticação externos populares e seus pacotes NuGet associados são mostrados na tabela a seguir:Popular external authentication providers and their associated NuGet packages are shown in the following table:

ProvedorProvider PacotePackage
MicrosoftMicrosoft Microsoft.AspNetCore.Authentication.MicrosoftAccountMicrosoft.AspNetCore.Authentication.MicrosoftAccount
GoogleGoogle Microsoft.AspNetCore.Authentication.GoogleMicrosoft.AspNetCore.Authentication.Google
FacebookFacebook Microsoft.AspNetCore.Authentication.FacebookMicrosoft.AspNetCore.Authentication.Facebook
TwitterTwitter Microsoft.AspNetCore.Authentication.TwitterMicrosoft.AspNetCore.Authentication.Twitter

Em todos os casos, o middleware é registrado com uma chamada para um método de registro semelhante a app.Use{ExternalProvider}Authentication em Startup.Configure.In all cases, the middleware is registered with a call to a registration method similar to app.Use{ExternalProvider}Authentication in Startup.Configure. Esses métodos de registro usam um objeto de opções que contém uma ID do aplicativo e informações secretas (uma senha, por exemplo), conforme o provedor exigir.These registration methods take an options object that contains an application ID and secret information (a password, for instance), as needed by the provider. Os provedores de autenticação externos requerem que o aplicativo seja registrado [conforme é explicado em ASP.NET Documentation (documentação do ASP.NET Core)] para que eles possam informar ao usuário qual aplicativo está solicitando acesso à sua identidade.External authentication providers require the application to be registered (as explained in ASP.NET Core documentation) so that they can inform the user what application is requesting access to their identity.

Depois que o middleware é registrado em Startup.Configure, você pode solicitar que os usuários entrem usando qualquer ação do controlador.Once the middleware is registered in Startup.Configure, you can prompt users to sign in from any controller action. Para isso, crie um objeto AuthenticationProperties que inclui o nome do provedor de autenticação e uma URL de redirecionamento.To do this, you create an AuthenticationProperties object that includes the authentication provider’s name and a redirect URL. Em seguida, você retorna uma resposta de desafio que passa o objeto AuthenticationProperties.You then return a Challenge response that passes the AuthenticationProperties object. O código a seguir mostra um exemplo disso.The following code shows an example of this.

var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider,
    redirectUrl);
return Challenge(properties, provider);

O parâmetro redirectUrl inclui a URL para a qual o provedor externo deverá ser redirecionado quando o usuário for autenticado.The redirectUrl parameter includes the URL that the external provider should redirect to once the user has authenticated. A URL deve representar uma ação que conectará o usuário com base nas informações de identidade externas, como no seguinte exemplo simplificado:The URL should represent an action that will sign the user in based on external identity information, as in the following simplified example:

// Sign in the user with this external login provider if the user
// already has a login.
var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false);

if (result.Succeeded)
{
    return RedirectToLocal(returnUrl);
}
else
{
    ApplicationUser newUser = new ApplicationUser
    {
        // The user object can be constructed with claims from the
        // external authentication provider, combined with information
        // supplied by the user after they have authenticated with
        // the external provider.
        UserName = info.Principal.FindFirstValue(ClaimTypes.Name),
        Email = info.Principal.FindFirstValue(ClaimTypes.Email)
    };
    var identityResult = await _userManager.CreateAsync(newUser);
    if (identityResult.Succeeded)
    {
        identityResult = await _userManager.AddLoginAsync(newUser, info);
        if (identityResult.Succeeded)
        {
            await _signInManager.SignInAsync(newUser, isPersistent: false);
        }
        return RedirectToLocal(returnUrl);
    }
}

Se você escolher a opção de autenticação Conta de Usuário Individual ao criar o projeto de aplicativo Web do ASP.NET Code no Visual Studio, todo o código necessário para entrar com um provedor externo já estará no projeto, conforme mostrado na Figura 9-3.If you choose the Individual User Account authentication option when you create the ASP.NET Code web application project in Visual Studio, all the code necessary to sign in with an external provider is already in the project, as shown in Figure 9-3.

Caixa de diálogo para o novo aplicativo Web do ASP.NET Core, realçando o botão para alterar a autenticação.

Figura 9-3.Figure 9-3. Selecionando uma opção para usar a autenticação externa ao criar um projeto de aplicativo WebSelecting an option for using external authentication when creating a web application project

Além dos provedores de autenticação externos listados anteriormente, estão disponíveis pacotes de terceiros que fornecem middleware para o uso de vários outros provedores de autenticação externos.In addition to the external authentication providers listed previously, third-party packages are available that provide middleware for using many more external authentication providers. Para obter uma lista, consulte o repositório AspNet.Security.OAuth.Providers no GitHub.For a list, see the AspNet.Security.OAuth.Providers repo on GitHub.

Você também pode criar seu próprio middleware de autenticação externa para resolver alguma necessidade especial.You can also create your own external authentication middleware to solve some special need.

Autenticar com tokens de portadorAuthenticate with bearer tokens

Autenticar com o ASP.NET Core Identity (ou com Identity e também com provedores de autenticação externos) funciona bem para vários cenários de aplicativo Web nos quais é apropriado armazenar informações do usuário em um cookie.Authenticating with ASP.NET Core Identity (or Identity plus external authentication providers) works well for many web application scenarios in which storing user information in a cookie is appropriate. Em outros cenários, no entanto, os cookies não são uma maneira natural de persistir e transmitir dados.In other scenarios, though, cookies are not a natural means of persisting and transmitting data.

Por exemplo, em uma API Web do ASP.NET Core que expõe pontos de extremidade RESTful que podem ser acessados por SPAs (Aplicativos de Única Página), por clientes nativos ou até mesmo por outras APIs Web, geralmente é melhor usar a autenticação de token de portador.For example, in an ASP.NET Core Web API that exposes RESTful endpoints that might be accessed by Single Page Applications (SPAs), by native clients, or even by other Web APIs, you typically want to use bearer token authentication instead. Esses tipos de aplicativos não funcionam com cookies, mas podem facilmente recuperar um token de portador e incluí-lo no cabeçalho de autorização das próximas solicitações.These types of applications do not work with cookies, but can easily retrieve a bearer token and include it in the authorization header of subsequent requests. Para habilitar a autenticação de token, o ASP.NET Core dá suporte a várias opções para usar OAuth 2.0 e OpenID Connect.To enable token authentication, ASP.NET Core supports several options for using OAuth 2.0 and OpenID Connect.

Autenticar com um provedor de identidade OAuth 2.0 ou OpenID ConnectAuthenticate with an OpenID Connect or OAuth 2.0 Identity provider

Se as informações de usuário estiverem armazenadas no Azure Active Directory ou em outra solução de identidade que dê suporte a OpenID Connect ou OAuth 2.0, você poderá usar o pacote Microsoft.AspNetCore.Authentication.OpenIdConnect para autenticar usando o fluxo de trabalho do OpenID Connect.If user information is stored in Azure Active Directory or another identity solution that supports OpenID Connect or OAuth 2.0, you can use the Microsoft.AspNetCore.Authentication.OpenIdConnect package to authenticate using the OpenID Connect workflow. Por exemplo, para autenticar no microsserviço Identity.Api em eShopOnContainers, um aplicativo Web do ASP.NET Core pode usar o middleware desse pacote, conforme mostrado no seguinte exemplo simplificado em Startup.cs:For example, to authenticate to the Identity.Api microservice in eShopOnContainers, an ASP.NET Core web application can use middleware from that package as shown in the following simplified example in Startup.cs:

// Startup.cs

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    //…
    // Configure the pipeline to use authentication
    app.UseAuthentication();
    //…
    app.UseMvc();
}

public void ConfigureServices(IServiceCollection services)
{
    var identityUrl = Configuration.GetValue<string>("IdentityUrl");
    var callBackUrl = Configuration.GetValue<string>("CallBackUrl");

    // Add Authentication services

    services.AddAuthentication(options =>
    {
        options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
    })
    .AddCookie()
    .AddOpenIdConnect(options =>
    {
        options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        options.Authority = identityUrl;
        options.SignedOutRedirectUri = callBackUrl;
        options.ClientSecret = "secret";
        options.SaveTokens = true;
        options.GetClaimsFromUserInfoEndpoint = true;
        options.RequireHttpsMetadata = false;
        options.Scope.Add("openid");
        options.Scope.Add("profile");
        options.Scope.Add("orders");
        options.Scope.Add("basket");
        options.Scope.Add("marketing");
        options.Scope.Add("locations");
        options.Scope.Add("webshoppingagg");
        options.Scope.Add("orders.signalrhub");
    });
}

Observe que quando você usa este fluxo de trabalho, o middleware do ASP.NET Core Identity não é necessário, porque todo o armazenamento de informações de usuário e toda a autenticação são manipulados pelo serviço de identidade.Note that when you use this workflow, the ASP.NET Core Identity middleware is not needed, because all user information storage and authentication is handled by the Identity service.

Emitir tokens de segurança de um serviço do ASP.NET CoreIssue security tokens from an ASP.NET Core service

Se preferir emitir tokens de segurança para usuários do ASP.NET Core Identity local em vez de usar um provedor de identidade externo, você poderá usufruir de algumas boas bibliotecas de terceiros.If you prefer to issue security tokens for local ASP.NET Core Identity users rather than using an external identity provider, you can take advantage of some good third-party libraries.

IdentityServer4 e OpenIddict são provedores do OpenID Connect que se integram facilmente ao ASP.NET Core Identity para permitir que você emita tokens de segurança de um serviço do ASP.NET Core.IdentityServer4 and OpenIddict are OpenID Connect providers that integrate easily with ASP.NET Core Identity to let you issue security tokens from an ASP.NET Core service. A IdentityServer4 documentation (Documentação do IdentityServer4) tem instruções detalhadas para usar a biblioteca.The IdentityServer4 documentation has in-depth instructions for using the library. No entanto, as etapas básicas para usar o IdentityServer4 para emitir tokens são as seguintes.However, the basic steps to using IdentityServer4 to issue tokens are as follows.

  1. Chame app.UseIdentityServer no método Startup.Configure para adicionar o IdentityServer4 ao pipeline de processamento de solicitação HTTP do aplicativo.You call app.UseIdentityServer in the Startup.Configure method to add IdentityServer4 to the application’s HTTP request processing pipeline. Isso permite que a biblioteca atenda solicitações dos pontos de extremidade do OpenID Connect e do OAuth2 como /connect/token.This lets the library serve requests to OpenID Connect and OAuth2 endpoints like /connect/token.

  2. Você pode configurar o IdentityServer4 no Startup.ConfigureServices fazendo uma chamada para services.AddIdentityServer.You configure IdentityServer4 in Startup.ConfigureServices by making a call to services.AddIdentityServer.

  3. Configure o servidor de identidade definindo os seguintes dados:You configure identity server by setting the following data:

    • As credenciais a serem usadas para assinar.The credentials to use for signing.

    • Os recursos de identidade e da API aos quais os usuários podem solicitar acesso:The Identity and API resources that users might request access to:

      • Os recursos da API representam dados ou funcionalidades protegidos que o usuário pode acessar com um token de acesso.API resources represent protected data or functionality that a user can access with an access token. Um exemplo de um recurso da API seria uma API Web (ou conjunto de APIs) que exige autorização.An example of an API resource would be a web API (or set of APIs) that requires authorization.

      • Os recursos de identidade representam informações (declarações) que são concedidas a um cliente para identificar um usuário.Identity resources represent information (claims) that are given to a client to identify a user. As declarações podem incluir o nome de usuário, o endereço de email e assim por diante.The claims might include the user name, email address, and so on.

    • Os clientes que se conectarão para solicitar tokens.The clients that will be connecting in order to request tokens.

    • O mecanismo de armazenamento de informações do usuário, como o ASP.NET Core Identity ou um outro.The storage mechanism for user information, such as ASP.NET Core Identity or an alternative.

Ao especificar os clientes e os recursos para o IdentityServer4 usar, você pode passar uma coleção IEnumerable<T> do tipo apropriado aos métodos que usam os repositórios de clientes ou de recursos na memória.When you specify clients and resources for IdentityServer4 to use, you can pass an IEnumerable<T> collection of the appropriate type to methods that take in-memory client or resource stores. Ou, para cenários mais complexos, você pode fornecer os tipos de provedor de clientes ou de recursos por meio de injeção de dependência.Or for more complex scenarios, you can provide client or resource provider types via Dependency Injection.

Um exemplo de configuração para o IdentityServer4 usar recursos e clientes na memória fornecidos por um tipo IClientStore personalizado pode ser semelhante ao exemplo a seguir:A sample configuration for IdentityServer4 to use in-memory resources and clients provided by a custom IClientStore type might look like the following example:

// Add IdentityServer services
services.AddSingleton<IClientStore, CustomClientStore>();
services.AddIdentityServer()
    .AddSigningCredential("CN=sts")
    .AddInMemoryApiResources(MyApiResourceProvider.GetAllResources())
    .AddAspNetIdentity<ApplicationUser>();

Consumir tokens de segurançaConsume security tokens

Autenticar em relação a um ponto de extremidade do OpenID Connect ou emitir seus próprios tokens de segurança cobre alguns cenários.Authenticating against an OpenID Connect endpoint or issuing your own security tokens covers some scenarios. Mas, e um serviço que apenas precisa limitar o acesso a esses usuários que têm tokens de segurança válidos que foram fornecidos por um serviço diferente?But what about a service that simply needs to limit access to those users who have valid security tokens that were provided by a different service?

Para esse cenário, o middleware de autenticação que manipula os tokens JWT está disponível no pacote Microsoft.AspNetCore.Authentication.JwtBearer.For that scenario, authentication middleware that handles JWT tokens is available in the Microsoft.AspNetCore.Authentication.JwtBearer package. JWT representa "Token Web JSON" e é um formato de token de segurança comum (definido pelo RFC 7519) para comunicação de declarações de segurança.JWT stands for "JSON Web Token" and is a common security token format (defined by RFC 7519) for communicating security claims. Um exemplo simplificado de como usar o middleware para consumir esses tokens pode parecer com este fragmento de código, tirado do microsserviço Ordering.API de eShopOnContainers.A simplified example of how to use middleware to consume such tokens might look like this code fragment, taken from the Ordering.Api microservice of eShopOnContainers.

// Startup.cs

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    //…
    // Configure the pipeline to use authentication
    app.UseAuthentication();
    //…
    app.UseMvc();
}

public void ConfigureServices(IServiceCollection services)
{
    var identityUrl = Configuration.GetValue<string>("IdentityUrl");

    // Add Authentication services

    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;

    }).AddJwtBearer(options =>
    {
        options.Authority = identityUrl;
        options.RequireHttpsMetadata = false;
        options.Audience = "orders";
    });
}

Os parâmetros nesse tipo de uso são:The parameters in this usage are:

  • Audience representa o receptor do token ou do recurso de entrada ao qual o token concede acesso.Audience represents the receiver of the incoming token or the resource that the token grants access to. Se o valor especificado nesse parâmetro não corresponder ao parâmetro no token, o token será rejeitado.If the value specified in this parameter does not match the parameter in the token, the token will be rejected.

  • Authority é o endereço do servidor de autenticação que emite o token.Authority is the address of the token-issuing authentication server. O middleware de portador do JWT usa esse URI para obter a chave pública que pode ser usada para validar a assinatura do token.The JWT bearer authentication middleware uses this URI to get the public key that can be used to validate the token's signature. O middleware também confirma se o parâmetro iss no token corresponde a esse URI.The middleware also confirms that the iss parameter in the token matches this URI.

Outro parâmetro, RequireHttpsMetadata, é útil para testes. Defina esse parâmetro como false para poder testar em ambientes nos quais você não tenha certificados.Another parameter, RequireHttpsMetadata, is useful for testing purposes; you set this parameter to false so you can test in environments where you don't have certificates. Em implantações reais, os tokens de portador do JWT sempre devem ser passados apenas por HTTPS.In real-world deployments, JWT bearer tokens should always be passed only over HTTPS.

Com este middleware em vigor, os tokens JWT são extraídos automaticamente dos cabeçalhos de autorização.With this middleware in place, JWT tokens are automatically extracted from authorization headers. Eles são desserializados, validados (usando os valores nos parâmetros Audience e Authority) e armazenados como informações de usuário a serem referenciadas posteriormente por ações de MVC ou filtros de autorização.They are then deserialized, validated (using the values in the Audience and Authority parameters), and stored as user information to be referenced later by MVC actions or authorization filters.

O middleware de autenticação de portador do JWT também pode dar suporte a cenários mais avançados, como o uso de um certificado local para validar um token se a autoridade não estiver disponível.The JWT bearer authentication middleware can also support more advanced scenarios, such as using a local certificate to validate a token if the authority is not available. Para este cenário, você pode especificar um objeto TokenValidationParameters no objeto JwtBearerOptions.For this scenario, you can specify a TokenValidationParameters object in the JwtBearerOptions object.

Recursos adicionaisAdditional resources