Firmado de JSON Web Tokens con Librería JWT en Node.js

Clase 9 de 25 • Curso de OAuth 2.0 y OpenID Connect: Flujos de Autenticación y Casos de Estudio

Resumen

¿Cómo firmar un JSON Web Token?

La firma de un JSON Web Token (JWT) es un proceso esencial para garantizar la autenticidad y la integridad de los datos que se transfieren en aplicaciones web. Utilizando la librería jsonwebtoken, podemos implementar un sistema de firmado en tres pasos fundamentales: definir el payload, elegir el algoritmo adecuado y firmar el token con un secret o clave privada. Esta implementación es crucial para proteger tus endpoints y garantizar la seguridad en la comunicación de datos.

¿Qué necesitamos para firmar un JWT?

Payload: Es el objeto JSON que contiene los Claim Names, como sub, name y exp. Utilizar la información del usuario verificado es vital para su correcta creación.
Secret o Private Key: Dependiendo del algoritmo de firmado:
- Simétrico (HS256): Usa un secret.
- Asimétrico (RS256): Usa una clave privada.
Opciones o callback function: Puede incluir configuraciones adicionales para el JWT.

Implementación práctica en Node.js

Construcción del payload

Antes de proceder al firmado, es vital estructurar correctamente el payload. A continuación, un ejemplo de cómo podría hacerse:

const user = /* Suponemos que el usuario está previamente definido y verificado */;
const payload = {
  sub: user.id, // Subject suele ser el ID del usuario
  name: user.full_name, // Usamos el nombre completo ya que no tenemos un campo 'name'
  exp: Math.floor(Date.now() / 1000) + (60 * 1) // Expiración en 1 minuto
};

Firmado del token

Para firmar el token, primero importamos la librería jsonwebtoken y luego utilizamos el método sign:

const jwt = require('jsonwebtoken');
const secret = process.env.SECRET_KEY; // Una buena práctica es utilizar variables de entorno

const token = jwt.sign(payload, secret);

Recomendaciones para el manejo del secret

Asegúrate de que el secret sea un string aleatorio y largo.
Usa variables de entorno para almacenar el secret y otros datos sensibles.
Nunca expongas tu secret ni tu clave privada en el repositorio.

Prueba y verificación en Postman

Para comprobar que el servidor y los endpoint funcionan correctamente, primero verifica el acceso al endpoint público:

Realiza un request a public para confirmar que el servidor está funcionando.
Solicita al endpoint token para obtener el JWT firmado.
Evalúa el token recibido accediendo al endpoint privado.

Desafío para el lector: Implementa en otro lenguaje

Un gran ejercicio sería realizar esta misma implementación de firmado de un JWT en otro lenguaje de programación diferente a Node.js. Esto no solo te ayudará a ampliar tus habilidades, sino también a entender las diferencias entre las implementaciones en distintos entornos.

¡Anímate a poner en práctica tus conocimientos, explora nuevos lenguajes y sigue mejorando tus habilidades en la programación y seguridad de aplicaciones web!

Mauricio Combariza

student•

Adjunto los codigos que uso en python para la creación de los tokens en FastAPI.


# Esta función firma los tokens


def signJWT(email: str, perfil: int):
    payload = {
        "userID": email,
        "perfilID": perfil,
        "expiry": time.time() + 600
    }
    token = jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)

    return token_response(token)

Carlos Andreimy

student•

//Using C# Net7
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace PlayOauth
{
    public class JwtHandler
    {
        private readonly string secretKey;

        public JwtHandler(string secretKey)
        {
            this.secretKey = secretKey;
        }

        public string GenerateToken(string username, int expirationMinutes = 60)
        {
            var key = Encoding.ASCII.GetBytes(secretKey);
            var tokenHandler = new JwtSecurityTokenHandler();
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[]
                {
                    new Claim(ClaimTypes.Name, username),
                }),
                Expires = DateTime.UtcNow.AddMinutes(expirationMinutes),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };

            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }
    }
}

Santiago Vizcaino

student•

private async Task<Tuple<string, string>> GenerateToken(IdentityUser user)
        {
            var jwtTokenHandler = new JwtSecurityTokenHandler();

            var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_jwtSettings.Key));

            var userClaims = await _userManager.GetClaimsAsync(user);

            var roles = await _userManager.GetRolesAsync(user);

            var roleClaims = new List<Claim>();

            foreach (var item in roles)
            {
                roleClaims.Add(new Claim(ClaimTypes.Role, item));
            }

            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[]
                    {
                        new Claim("Id",user.Id),
                        new Claim(JwtRegisteredClaimNames.Email,user.Email),
                        new Claim(JwtRegisteredClaimNames.Sub,user.UserName),
                        new Claim(JwtRegisteredClaimNames.Jti,Guid.NewGuid().ToString()),
                    }.Union(userClaims)
                     .Union(roleClaims)
                    ),
                Expires = DateTime.UtcNow.Add(_jwtSettings.ExpireTime),
                SigningCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256Signature)
            };
            var token = jwtTokenHandler.CreateToken(tokenDescriptor);
            var jwtToken = jwtTokenHandler.WriteToken(token);

            var refreshToken = new RefreshToken
            {
                JwtId = token.Id,
                IsUsed = false,
                IsRevoked = false,
                UserId = user.Id,
                CreatedDate = DateTime.UtcNow,
                ExpireDate = DateTime.UtcNow.AddMonths(6),
                Token = $"{GenerateRandomTokenCharacters(35)}{Guid.NewGuid()}"
            };

            await _cleanArchitectureIdentityDbContext.RefreshTokens!.AddAsync(refreshToken);
            await _cleanArchitectureIdentityDbContext.SaveChangesAsync();

            return new Tuple<string, string>(jwtToken, refreshToken.Token);


        }

Alvaro Jose Vanegas Vidal

student•

¿cuando es mas practico utilizar cada uno de los firmados?

Guillermo Rodas

teacher•

Si no estoy mal lo explicamos en clase o más adelante, pero basicamente lo ideal es irse siempre con el firmado asimetrico ya que de esa forma siempre se puede otorgar una llave publica a terceros y es más fácil de rotar.

Si la comunicación siempre es entre sistemas seguros, el firmado simetrico esta bien.

Angel Javier Sanchez Tenjo

student•

Firmar el JWT (Auth Server)

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.security.PrivateKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JwtSigner {

    private final PrivateKey privateKey;

    public JwtSigner(PrivateKey privateKey) {
        this.privateKey = privateKey;
    }

    public String generateToken(String userId, String role) {

        Map<String, Object> claims = new HashMap<>();
        claims.put("role", role);

        return Jwts.builder()
                .setSubject(userId)
                .setIssuer("xolit-auth-server")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 3600_000)) // 1h
                .addClaims(claims)
                .signWith(privateKey, SignatureAlgorithm.RS256)
                .compact();
    }
}

Alvaro Salinas Dockar

student•

Alguien sabe que plugin está usando para cubrir las variables de entorno?

Damián Valenzuela Negrete

student•

creo que es: Dotenv Official +Vault

Steve Anthony Luzquiños Agama

student•

Una que te recomiendo es Cloak:

Sergio Andrés Bolaños Penagos

student•

Qué clase tan increible

# Esta función firma los tokens


def signJWT(email: str, perfil: int):
    payload = {
        "userID": email,
        "perfilID": perfil,
        "expiry": time.time() + 600
    }
    token = jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)

    return token_response(token)

//Using C# Net7
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace PlayOauth
{
    public class JwtHandler
    {
        private readonly string secretKey;

        public JwtHandler(string secretKey)
        {
            this.secretKey = secretKey;
        }

        public string GenerateToken(string username, int expirationMinutes = 60)
        {
            var key = Encoding.ASCII.GetBytes(secretKey);
            var tokenHandler = new JwtSecurityTokenHandler();
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[]
                {
                    new Claim(ClaimTypes.Name, username),
                }),
                Expires = DateTime.UtcNow.AddMinutes(expirationMinutes),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };

            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }
    }
}

private async Task<Tuple<string, string>> GenerateToken(IdentityUser user)
        {
            var jwtTokenHandler = new JwtSecurityTokenHandler();

            var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_jwtSettings.Key));

            var userClaims = await _userManager.GetClaimsAsync(user);

            var roles = await _userManager.GetRolesAsync(user);

            var roleClaims = new List<Claim>();

            foreach (var item in roles)
            {
                roleClaims.Add(new Claim(ClaimTypes.Role, item));
            }

            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[]
                    {
                        new Claim("Id",user.Id),
                        new Claim(JwtRegisteredClaimNames.Email,user.Email),
                        new Claim(JwtRegisteredClaimNames.Sub,user.UserName),
                        new Claim(JwtRegisteredClaimNames.Jti,Guid.NewGuid().ToString()),
                    }.Union(userClaims)
                     .Union(roleClaims)
                    ),
                Expires = DateTime.UtcNow.Add(_jwtSettings.ExpireTime),
                SigningCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256Signature)
            };
            var token = jwtTokenHandler.CreateToken(tokenDescriptor);
            var jwtToken = jwtTokenHandler.WriteToken(token);

            var refreshToken = new RefreshToken
            {
                JwtId = token.Id,
                IsUsed = false,
                IsRevoked = false,
                UserId = user.Id,
                CreatedDate = DateTime.UtcNow,
                ExpireDate = DateTime.UtcNow.AddMonths(6),
                Token = $"{GenerateRandomTokenCharacters(35)}{Guid.NewGuid()}"
            };

            await _cleanArchitectureIdentityDbContext.RefreshTokens!.AddAsync(refreshToken);
            await _cleanArchitectureIdentityDbContext.SaveChangesAsync();

            return new Tuple<string, string>(jwtToken, refreshToken.Token);


        }

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.security.PrivateKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JwtSigner {

    private final PrivateKey privateKey;

    public JwtSigner(PrivateKey privateKey) {
        this.privateKey = privateKey;
    }

    public String generateToken(String userId, String role) {

        Map<String, Object> claims = new HashMap<>();
        claims.put("role", role);

        return Jwts.builder()
                .setSubject(userId)
                .setIssuer("xolit-auth-server")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 3600_000)) // 1h
                .addClaims(claims)
                .signWith(privateKey, SignatureAlgorithm.RS256)
                .compact();
    }
}

Firmado de JSON Web Tokens con Librería JWT en Node.js

Introducción a OAuth 2.0 y OIDC

OAuth y OpenID Connect: Autenticación y Autorización Básica

¿Qué es la autenticación?

Autorización y Control de Acceso Basado en Roles

Protocolos Open Authorization y OpenID Connect: Alternativas y Comparación

Protección de Endpoints con Autenticación y Autorización Básica

Flujo de Open Authorization y Open ID con Discord

JSON Web Tokens

JSON Web Tokens: Conceptos, Ventajas y Algoritmos de Firma

Comparación de Sesiones y JSON Web Tokens en Autenticación

Firmado de JSON Web Tokens con Librería JWT en Node.js

Verificación de JSON Web Tokens en Node.js

Open Authorization 2.0

Implementación de flujos OAuth 2.0 con APIs populares

Flujos de Autorización en OAuth 2.0: Conceptos y Funcionamiento

Elección del Flujo Oauth 2.0 según Roles del Cliente y Servidor

Implementación de Authorization Code Flow con Spotify y React

Implementación de Authorization CodeFlow con Proofkit en Twitter API

Implementación de Implicit Flow con Twitch en React

Implementación de Client Credentials Flow en Discord

Implementación de Resource Owner Password Flow con Auth0

Open ID Connect

OpenID Connect: Autenticación sobre OAuth paso a paso

Implementación de Implicit Flow con For Post usando Auth0

Implementación del Hybrid Flow en Autenticación de Aplicaciones

OAuth y OIDC en producción

Buenas prácticas y riesgos de los JSON Web Tokens (JWT)

Implementación Segura de Open Authorization (OAuth)

Autenticación Rápida con NextAlt y GitHub en Next.js

Curso Práctico de Autenticación con Outh Zero