Integrar JWT en ASP.NET Core 6

JWT (JSON Web Token) es una forma segura y eficiente de transmitir información entre diferentes sistemas en forma de objetos JSON. En el contexto de las API web, JWT se utiliza a menudo como un mecanismo de autenticación y autorización, permitiendo a los usuarios autenticarse en una aplicación web y luego autorizar las solicitudes de la API en función de su nivel de acceso.

En este artículo, te enseñaré cómo implementar JWT en una aplicación Web API utilizando ASP.NET Core 6. Con la autenticación JWT, podemos asegurar una Web API siguiendo estos pasos:

Crear un proyecto ASP.NET Core Web API en Visual Studio 2022.

Para comenzar, abre Visual Studio 2022 e inicia un nuevo proyecto. Haz clic en "Crear nuevo proyecto" y selecciona "ASP.NET Core Web API".

A continuación, especifica el nombre y la ubicación del nuevo proyecto en la ventana "Configura tu nuevo proyecto" y haz clic en "Siguiente". Luego en la ventana de "Información adicional" deja todo predeterminado y haz clic en "Crear".

Instale el paquete JwtBearer NuGet

Para habilitar la autenticación JWT, necesitamos instalar el paquete Microsoft.AspNetCore.Authentication.JwtBearer en nuestro proyecto. Puedes hacer esto seleccionando Tools > NuGet Package Manager > Manage NuGet Packages for Solutions. en Visual Studio y buscando el paquete Microsoft.AspNetCore.Authentication.JwtBearer e instálelo.

También puedes instalar el paquete desde la consola de NuGet o .NET CLI ejecutando el siguiente comando:

NuGet\Install-Package Microsoft.AspNetCore.Authentication.JwtBearer -Version 6.0.15

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer --version 6.0.15

Especifica la clave secreta en el archivo appsettings.json

A continuación, debemos crear una sección en el archivo appsettings.json para la información del emisor, la audiencia y la clave secreta que se utilizará para crear un JSON Web Token.

Agrega la siguiente información en el archivo appsettings.json:

// appsettings.json

{
  "Jwt": {
    "Issuer": "https://alckor.dev/",
    "Audience": "https://alckor.dev/",
    "Key": "This is a sample secret key"
  }
}

Asegúrate de definir una clave secreta y mantenerla en un lugar seguro.

Especifica la configuración de autenticación en el archivo Program.cs

Para configurar la autenticación JWT en el momento en que se inicia la aplicación, se utiliza el método AddAuthenication en el archivo Program.cs. Este método especifica el esquema de autenticación como JwtBearer y configura los parámetros del token mediante la llamada al método AddJwtBearer.

Los valores de Emisor, Audiencia y Clave se leen del archivo de configuración appsettings.json. Para validar la información del emisor, la audiencia, la clave y la vida útil, se utiliza la instancia de TokenValidationParameters.

Para configurar la autenticación JWT en su aplicación, agregue el siguiente código en el archivo Program.cs:

// Program.cs

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

builder.Services.AddAuthentication(x =>
{
    x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(x =>
{
    x.TokenValidationParameters = new TokenValidationParameters
    {
        ValidIssuer = builder.Configuration["Jwt:Issuer"],
        ValidAudience = builder.Configuration["Jwt:Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"])),
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
    };
});

builder.Services.AddAuthorization();

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

Esto configurará la autenticación JWT en su aplicación ASP.NET Core 6, habilitará la capacidad de autorización y agregará la capacidad de autenticación y autorización en la aplicación.

Crear un modelo para el usuario en ASP.NET Core 6

Para almacenar las credenciales del inicio de sesión, debe crear una clase User.cs en la carpeta Entities.

// Entities/User.cs

namespace ApiJWT.Entities
{
    public class User
    {
        public string Username { get; set; } = null!;
        public string Password { get; set; } = null!;
    }
}

Con esta clase, podrá almacenar y validar las credenciales del usuario en su aplicación ASP.NET Core 6.

Crear los endpoints

Para probar el funcionamiento de nuestra aplicación, vamos a crear los siguientes controladores:

El AuthController se encargará de crear y retornar el JWT:

// Controllers/AuthController.cs

using ApiJWT.Entities;
using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace ApiJWT.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class AuthController : ControllerBase
    {
        private readonly IConfiguration _config;

        public AuthController(IConfiguration config)
        {
            _config = config;
        }

        [HttpPost]
        public ActionResult PostAuth(User user)
        {
            if (user.Username == "alckordev" && user.Password == "zxcvbnm")
            {
                var issuer = _config["Jwt:Issuer"];
                var audience = _config["Jwt:Audience"];
                var key = Encoding.UTF8.GetBytes(_config["Jwt:Key"]);

                var tokenDescriptor = new SecurityTokenDescriptor
                {
                    Subject = new ClaimsIdentity(new[]
                    {
                        new Claim("Id", Guid.NewGuid().ToString()),
                        new Claim("Username", user.Username),
                        new Claim(JwtRegisteredClaimNames.Sub, user.Username),
                        new Claim(JwtRegisteredClaimNames.Email, user.Username),
                        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
                    }),
                    Expires = DateTime.UtcNow.AddMinutes(5),
                    Issuer = issuer,
                    Audience = audience,
                    SigningCredentials = new SigningCredentials(
                        new SymmetricSecurityKey(key),
                        SecurityAlgorithms.HmacSha256Signature
                    )
                };

                var tokenHandler = new JwtSecurityTokenHandler();
                var jwtToken = tokenHandler.CreateToken(tokenDescriptor);
                var stringToken = tokenHandler.WriteToken(jwtToken);

                return Ok(new
                {
                    token = stringToken
                });
            }

            return Unauthorized();
        }
    }
}

A continuación, creamos un controlador llamado PublicController con el siguiente contenido:

// Controllers/PublicController.cs

using Microsoft.AspNetCore.Mvc;

namespace ApiJWT.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class PublicController : ControllerBase
    {
        [HttpGet("GetWelcomeMessage")]
        public ActionResult GetWelcomeMessage()
        {
            return Ok(new
            {
                Title = "Welcome!",
                message = "I'm a public endpoint."
            });
        }
    }
}

Este es un controlador simple que no necesita autorización para acceder. Aquí se pueden presentar algunos endpoints públicos que no necesitan autenticación previa.

Finalmente, creamos un controlador llamado PrivateController con el siguiente contenido:

// Controllers/PrivateController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace ApiJWT.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PrivateController : ControllerBase
    {
        [HttpGet("GetWelcomeMessage")]
        public ActionResult GetWelcomeMessage()
        {
            return Ok(new
            {
                Title = "Welcome!",
                message = "I'm a private endpoint."
            });
        }
    }
}

Como se puede observar, la única diferencia con el controlador público es que en nuestro controlador privado le hemos agregado una etiqueta [Authorize], la cual indica que el recurso controlado por el controlador está protegido y solo es accesible para usuarios autenticados y autorizados.

Si intentamos acceder al recurso sin enviar el token en la cabecera, recibiremos un status code 401 como se muestra en la imagen:

Para poder acceder al contenido protegido, necesitamos enviar el token en la cabecera de la solicitud como se muestra en la imagen:

Ahora bien, si necesitamos obtener los datos del usuario autenticado, podemos agregar las siguientes modificaciones en nuestro PrivateController.cs:

// Controllers/PrivateController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;

namespace ApiJWT.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class PrivateController : ControllerBase
    {
        [HttpGet("GetWelcomeMessage")]
        public ActionResult GetWelcomeMessage()
        {
            var username = HttpContext.User.FindFirstValue("Username");

            return Ok(new
            {
                Title = $"Welcome {username}!",
                message = "I'm a private endpoint."
            });
        }
    }
}

Como se puede observar, hemos declarado la variable username y la utilizamos para buscar el nombre del usuario autenticado. De la misma forma, podemos obtener el id, recordando que en la creación del JWT, agregamos está información.

La librería Microsoft.AspNetCore.Authentication.JwtBearer es la encargada de realizar la decodificación y validación del token de forma automática. Esta librería está diseñada para manejar la mayoría de los casos comunes de autenticación JWT y tiene una gran cantidad de características de seguridad integradas.

Finalmente, si enviamos la solicitud correctamente, recibiremos una respuesta como se muestra en la imagen:

Conclusión

En este tutorial aprendimos cómo agregar autenticación JWT a una API RESTful construida con ASP.NET Core 6. Comenzamos configurando nuestra aplicación ASP.NET Core 6 para utilizar el esquema de autenticación JWT. Luego, generamos tokens JWT utilizando un método personalizado, y utilizamos estos tokens para proteger los endpoints de nuestra API.

También aprendimos cómo decodificar y validar un token JWT utilizando la librería Microsoft.AspNetCore.Authentication.JwtBearer. Finalmente, demostramos cómo podemos obtener los datos del usuario autenticado desde el token.

La autenticación JWT es una excelente opción para proteger una API RESTful, ya que los tokens son autocontenidos y no requieren almacenamiento en el servidor. Además, los tokens pueden ser enviados en la cabecera de una solicitud HTTP, lo que los hace fáciles de integrar con otros sistemas.

Espero que este tutorial haya sido útil para ti y te haya brindado una buena introducción a la autenticación JWT en ASP.NET Core 6. Si tienes alguna pregunta o comentario, no dudes en dejarlos a continuación. ¡Gracias por leer!