fbpx
Invista no exterior sem taxas com a Nomad

Bearer Token e JWT em ASP.NET 5

416

Aprenda a implementar autenticação e autorização em aplicativos ASP.NET 5 com Bearer e JWT. Saiba como gerar tokens, autenticar e autorizar usuários.

A segurança é uma preocupação crítica na construção de aplicativos web. E, usando o padrão Bearer Token e o formato JWT, exploraremos como implementar a autenticação e autorização em ASP.NET 5.

O ASP.NET 5

É uma plataforma de desenvolvimento de aplicativos da Microsoft, projetada para criar aplicativos web modernos, seguros e escaláveis e, que fornece diversas opções de autenticação e autorização para proteger seus dados e recursos.

O que é Bearer Token?

O Bearer Token é um padrão usado para autenticação em aplicativos web, onde uma string representa a autorização de um usuário para acessar um recurso específico.

Este token é enviado na solicitação HTTP como um cabeçalho de autorização e é usado pelo servidor para autenticar o usuário e autorizar o acesso aos recursos protegidos.

O que é JWT?

O JWT, ou JSON Web Token, é um formato para representar as informações de autenticação e autorização em formato JSON, e transmiti-las entre as partes em uma requisição HTTP.

Os JWTs são assinados digitalmente para garantir a integridade dos dados e são facilmente decodificados para obter informações sobre o usuário autenticado.

Devido a sua segurança e eficiência, ele se tornou amplamente usado em aplicativos da web modernos.

Estrutura de um token JWT

Um token JWT (JSON Web Token) é um padrão aberto (RFC 7519) e consiste em três partes codificadas em Base64URL e separadas por pontos:

xxxxx.yyyyy.zzzzz

A primeira parte é o cabeçalho (header) do token, que contém informações sobre o tipo de token e o algoritmo usado para assinar o token.

A segunda parte é a carga útil (payload) do token, que contém informações adicionais, como o nome de usuário e as permissões do usuário.

A terceira parte é a assinatura (signature) do token, que é usada para verificar a integridade dele e garantir que o mesmo não tenha sido adulterado. A assinatura é criada usando a chave secreta do servidor e o algoritmo especificado no cabeçalho.

Aqui está um exemplo de token JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

No exemplo acima, a primeira parte (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9) é o cabeçalho, a segunda parte (eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) é a carga útil e a terceira parte (SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c) é a assinatura.

Ao decodificar o token JWT, o cabeçalho e a carga útil podem ser facilmente lidos como um objeto JSON. A assinatura é usada para verificar a integridade do token e garantir que ele não tenha sido adulterado.

Gerando um Token

Para gerar um token JWT, precisamos criar uma classe que represente as informações do usuário que serão incluídas no token.

Esta classe deve incluir as informações de autenticação, como o nome de usuário, o ID do usuário e a data de expiração do token. Aqui está um exemplo de uma classe User:

public class User
{
    public int Id { get; set; }
    public string UserName { get; set; }
    public DateTime Expiration { get; set; }
}

Em seguida, precisamos escrever o código para gerar o token JWT. Para isso, podemos usar uma biblioteca, como a System.IdentityModel.Tokens.Jwt, para codificar as informações do usuário em um token JWT.

Abaixo temos um código de exemplo para gerar um token:

var user = new User { Id = 1, UserName = "John Doe", Expiration = DateTime.UtcNow.AddMinutes(30) };

var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("mySecretKey1234567890"));

var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

var token = new JwtSecurityToken(
    issuer: "myIssuer",
    audience: "myAudience",
    claims: new List<Claim>
            {
                new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
                new Claim(ClaimTypes.Name, user.UserName)
            },
    expires: user.Expiration,
    signingCredentials: credentials
);

var jwtToken = new JwtSecurityTokenHandler().WriteToken(token);

Este código cria um objeto User que representa as informações do usuário que serão incluídas no token. Em seguida, cria um objeto SymmetricSecurityKey com uma chave secreta usada para assinar o token JWT.

Depois disso, cria um objeto SigningCredentials com a chave e o algoritmo de assinatura usado para assinar o token.

Por fim, cria um objeto JwtSecurityToken com as informações do usuário, data de expiração e credenciais de assinatura, e usa um JwtSecurityTokenHandler para codificar o token JWT como uma string.

Adicionando autenticação e autorização

Agora que temos um token JWT, podemos usá-lo para proteger nossos recursos. O ASP.NET 5 tem um middleware para autenticação e autorização que podemos usar para isso.

Para adicionar o middleware, precisamos incluí-lo na configuração do pipeline de middleware no arquivo Startup.cs. Aqui está um exemplo de código:

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "myIssuer",
            ValidAudience = "myAudience",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("mySecretKey1234567890"))
        };
    });
	
    services.AddAuthorization();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAuthentication();
    app.UseAuthorization();
}

Este código adiciona o middleware de autenticação e autorização, configurando o esquema de autenticação como JwtBearer e definindo os parâmetros de validação do token JWT. Também adiciona o middleware de autorização, que é usado para proteger os recursos.

Autenticando

Para autenticar um usuário, precisamos enviar o token JWT no cabeçalho de autorização da solicitação HTTP. O middleware de autenticação do ASP.NET 5 verifica se o token é válido e, se for, define o User atual para representar o usuário autenticado.

Aqui está um exemplo de código para autenticar um usuário usando o token JWT:

public async Task<IActionResult> Login(LoginRequest request)
{
    var user = await _userService.Authenticate(request.Username, request.Password);
	
    if (user == null)
        return BadRequest(new { message = "Usuário ou senha inválido" });

    var token = GenerateJwtToken(user);

    return Ok(new { token });
}

Este código recebe um objeto LoginRequest com as informações de autenticação do usuário, chama o serviço Authenticate para verificar se o usuário é válido e, se for, gera um token JWT usando o método GenerateJwtToken. O token é retornado como uma resposta HTTP.

Autorizando

A autorização é usada para proteger recursos específicos, permitindo ou negando o acesso com base nas permissões do usuário autenticado. O ASP.NET 5 tem um sistema de políticas de autorização que podemos usar para definir as permissões necessárias para acessar um recurso. Aqui está um exemplo de código para autorizar um usuário com base em uma política de autorização:

[Authorize(Policy = "AdminOnly")]
public async Task<IActionResult> GetAdminResource()
{
    var user = await _userService.GetUser(User);

    if (user == null)
        return NotFound();

    return Ok(user);
}

Este código usa a anotação Authorize para proteger um recurso e definir a política de autorização como AdminOnly. A política é definida na configuração do serviço, como mostrado abaixo:

public void ConfigureServices(IServiceCollection services)
{
    // ...

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AdminOnly", policy => policy.RequireClaim(ClaimTypes.Role, "admin"));
    });
}

Este código adiciona uma política de autorização chamada AdminOnly que requer que o usuário tenha uma reivindicação de ClaimTypes.Role com o valor admin. Isso garante que apenas usuários com a permissão de admin possam acessar o recurso protegido.

Recuperando o usuário logado

O ASP.NET 5 define uma propriedade User no contexto HTTP que representa o usuário autenticado atualmente. Podemos usá-lo para recuperar informações do usuário, como o nome de usuário, as reivindicações de segurança e muito mais. Aqui está um exemplo de código para recuperar o nome de usuário do usuário logado:

public async Task<IActionResult> GetCurrentUser()
{
    var user = await _userService.GetUser(User);

    if (user == null)
        return NotFound();

    return Ok(new { username = user.UserName });
}

Este código usa a propriedade User do contexto HTTP para obter informações do usuário autenticado, chama o serviço GetUser para recuperar as informações do usuário com base no User, e retorna o nome de usuário do usuário como uma resposta HTTP.

Prós e contras dos JWTs

Prós em utilizar um JWT:

  • Segurança: Os JWTs são assinados digitalmente usando uma chave secreta (HMAC) ou um par de chaves público/privado (RSA ou ECDSA) que os protege de serem modificados pelo cliente ou um invasor.
  • Armazenado somente no cliente: Você gera os JWTs no servidor e os envia para o cliente. O cliente, então, envia o JWT com cada solicitação. Isso economiza espaço no banco de dados.
  • Eficiente / Stateless: É rápido verificar um JWT, já que não requer uma consulta ao banco de dados. Isso é especialmente útil em sistemas distribuídos grandes.

No entanto, alguns dos contras são:

  • Não revogável: Devido à sua natureza autocontida e ao processo de verificação sem estado, pode ser difícil revogar um JWT antes de expirar naturalmente. Portanto, ações como banir um usuário imediatamente não podem ser implementadas facilmente. Dito isso, há uma maneira de manter a lista negra de JWTs e, através disso, podemos revogá-los imediatamente.
  • Dependente de uma chave secreta: A criação de um JWT depende de uma chave secreta e, se ela for comprometida, o invasor pode fabricar seu próprio JWT que a camada da API aceitará. Isso, por sua vez, implica que se a chave secreta for comprometida, o invasor pode falsificar a identidade de qualquer usuário. Podemos reduzir esse risco alterando a chave secreta de tempos em tempos.

Conclusão

O ASP.NET 5 oferece suporte completo à autenticação e autorização baseadas em token usando Bearer e JWT. Com os recursos fornecidos pelo framework, podemos facilmente implementar autenticação e autorização em nossos aplicativos.

Esperamos que este artigo tenha sido útil para entender como implementar autenticação e autorização em aplicativos ASP.NET 5 com Bearer e JWT.

Os comentários estão fechados, mas trackbacks E pingbacks estão abertos.

This website uses cookies to improve your experience. We'll assume you're ok with this, but you can opt-out if you wish. Accept Read More