Cómo crear un sistema de autenticación con JWT en ASP.NET Core

La autenticación es uno de los pilares fundamentales de cualquier aplicación moderna. Cuando desarrollamos APIs con ASP.NET Core, una de las soluciones más utilizadas es JWT (JSON Web Token), un estándar que permite autenticar usuarios de forma segura, escalable y sin necesidad de mantener sesiones en el servidor.

En este artículo aprenderás cómo funciona JWT y cómo implementar un sistema de autenticación en ASP.NET Core paso a paso.

¿Qué es JWT?

JWT (JSON Web Token) es un estándar abierto que permite transmitir información entre dos partes de forma segura mediante un token firmado digitalmente.

Un token JWT está compuesto por tres partes:

• Header: Contiene información sobre el algoritmo utilizado para firmar el token.
• Payload: Incluye los datos del usuario y los claims (permisos o información adicional).
• Signature: Garantiza que el token no ha sido modificado.

Su estructura tiene el siguiente formato:

xxxxx.yyyyy.zzzzz

Cada sección está codificada en Base64 y separada por puntos.

¿Por qué usar JWT?

Las ventajas principales de JWT son:

• No requiere almacenar sesiones en el servidor.
• Es ideal para arquitecturas REST.
• Permite escalar aplicaciones fácilmente.
• Funciona perfectamente con aplicaciones web, móviles y microservicios.
• Reduce la carga sobre la base de datos.

Gracias a estas características, JWT se ha convertido en el estándar de autenticación para APIs modernas.

Crear el proyecto ASP.NET Core

Para comenzar, crea una nueva Web API:

dotnet new webapi -n JwtAuthApi

Ingresa al proyecto:

cd JwtAuthApi

Luego instala el paquete necesario:

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer

Este paquete permite validar y procesar tokens JWT dentro de ASP.NET Core.

Configurar JWT en appsettings.json

Agrega una sección para almacenar la configuración del token:

{
  "Jwt": {
    "Key": "MiClaveSuperSegura123456789",
    "Issuer": "MiApi",
    "Audience": "MiApiUsuarios",
    "DurationInMinutes": 60
  }
}

La clave debe ser larga y segura. En producción es recomendable almacenarla en Azure Key Vault, variables de entorno o servicios de secretos.

Configurar Authentication

En Program.cs agrega la configuración:

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

var builder = WebApplication.CreateBuilder(args);

var jwtSettings = builder.Configuration.GetSection("Jwt");

builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme =
        JwtBearerDefaults.AuthenticationScheme;

    options.DefaultChallengeScheme =
        JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters =
        new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,

            ValidIssuer = jwtSettings["Issuer"],
            ValidAudience = jwtSettings["Audience"],

            IssuerSigningKey =
                new SymmetricSecurityKey(
                    Encoding.UTF8.GetBytes(jwtSettings["Key"]))
        };
});

builder.Services.AddAuthorization();

var app = builder.Build();

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

app.MapControllers();

app.Run();

Con esta configuración, la API podrá validar automáticamente cualquier token recibido.

Crear un servicio para generar tokens

Crea una clase llamada JwtService:

using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

public class JwtService
{
private readonly IConfiguration _configuration;

public JwtService(IConfiguration configuration)
{
    _configuration = configuration;
}

public string GenerateToken(string username)
{
    var claims = new[]
    {
        new Claim(ClaimTypes.Name, username)
    };

    var key = new SymmetricSecurityKey(
        Encoding.UTF8.GetBytes(
            _configuration["Jwt:Key"]));

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

    var token = new JwtSecurityToken(
        issuer: _configuration["Jwt:Issuer"],
        audience: _configuration["Jwt:Audience"],
        claims: claims,
        expires: DateTime.Now.AddHours(1),
        signingCredentials: credentials);

    return new JwtSecurityTokenHandler()
        .WriteToken(token);
}

}

Este servicio será responsable de crear los tokens que recibirán los usuarios autenticados.

Registrar el servicio

En Program.cs:

builder.Services.AddScoped<JwtService>();

Crear el endpoint de login

Ahora crea un controlador para autenticar usuarios:

[ApiController]
[Route("api/auth")]
public class AuthController : ControllerBase
{
    private readonly JwtService _jwtService;

    public AuthController(JwtService jwtService)
    {
        _jwtService = jwtService;
    }

    [HttpPost("login")]
    public IActionResult Login(LoginRequest request)
    {
        if (request.Username == "admin" &&
            request.Password == "123456")
        {
            var token =
                _jwtService.GenerateToken(
                    request.Username);

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

        return Unauthorized();
    }
}

Modelo:

public class LoginRequest
{
    public string Username { get; set; }
    public string Password { get; set; }
}

En un proyecto real, las credenciales deben validarse contra una base de datos y las contraseñas deben almacenarse utilizando hashing con herramientas como BCrypt o ASP.NET Identity.

Proteger endpoints

Una vez generado el token, podemos proteger cualquier endpoint utilizando el atributo [Authorize].

[Authorize]
[HttpGet("perfil")]
public IActionResult Perfil()
{
    return Ok("Acceso autorizado");
}

Cuando un usuario intente acceder sin un token válido, ASP.NET Core responderá automáticamente con un error 401 Unauthorized.

Consumir la API

Después del login, el cliente recibirá un token similar a este:

eyJhbGciOiJIUzI1NiIs...

En las solicitudes posteriores deberá enviarlo en el encabezado:

Authorization: Bearer eyJhbGciOiJIUzI1NiIs...

ASP.NET Core validará el token antes de ejecutar el controlador.

JWT es una de las mejores opciones para implementar autenticación en APIs ASP.NET Core gracias a su simplicidad, seguridad y capacidad de escalar en entornos modernos. Con una correcta configuración de autenticación, generación de tokens y protección de endpoints mediante atributos de autorización, es posible construir sistemas robustos que funcionen perfectamente con aplicaciones web, móviles y arquitecturas basadas en microservicios. Dominar JWT es una habilidad esencial para cualquier desarrollador .NET que desee crear aplicaciones empresariales seguras y preparadas para producción.