¿Qué es JWT?

JWT significa json web token, su uso estándar abierto para transmitir información entre partes como un objeto JSON. Es compacto, seguro para URL y se utiliza ampliamente en aplicaciones web para autenticación e intercambio de información.

Los JWT se firman digitalmente mediante claves y secretos. Verificamos el JWT con estas claves y la firma para autenticar al usuario. La mayoría de los sistemas web utilizan JWT para autorizar a los usuarios a acceder a ciertos recursos.

Componentes del token

Un JWT tiene tres componentes principales: el encabezado, la carga útil y la firma. Cuando creamos un token, pasamos el encabezado y la carga útil, y luego el token genera la firma.

Headre: el encabezado de un JWT contiene metadatos sobre el token. Incluye tres valores: alg, typ y kid. El alg especifica el algoritmo utilizado para firmar el token, typ indica el tipo de token y kid es un parámetro opcional utilizado para identificar la clave. La inclusión de un niño depende de su caso de uso.

{
  "alg": "RS256", // allow [HS256,RS256,ES256]
  "typ": "JWT", // Specific Type Of token
  "kid": "12345" // Used to indicate which key was used to sign 
the JWT. This is particularly useful when multiple keys are in use
}

Carga útil: en la carga útil especificamos algunos datos personalizados, principalmente agregamos datos específicos del usuario a la carga útil, como la identificación del usuario y la función.

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Firma: la firma se genera codificando el encabezado y la carga útil con una clave secreta (para HS256) o firmándolos con una clave privada (para RSA) y luego aplicando hash al resultado. Esta firma se utiliza para verificar el token.

Cómo se crea el token

Como comentamos, un JWT tiene tres componentes: el encabezado, la carga útil y la firma. Proporcionamos el encabezado y la carga útil, y a partir de ellos se genera la firma. Después de combinar todos estos componentes, creamos el token.

// Header Encoding
Base64Url Encode({
  "alg": "RS256",
  "typ": "JWT"
}) → eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9


// Payload Encoding
Base64Url Encode({
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}) → eyJzdWIiOiAiMTIzNDU2Nzg5MCIsICJuYW1lIjogIkpvaG4gRG9lIiwgImlhdCI6IDE1MTYyMzkwMjJ9


// Concatenate Encoded header and payload
ConcatenatedHash =  Base64Url Encode(Header)   "."   Base64Url Encode(Payload)

//Create Signature
Hash = SHA-256(ConcatenatedHash)
Signature = RSA Sign(Hash with Private Key) or HS256 Sign(Hash with secrate)

// Create Token
Token = Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload)  "."  Signature

Entonces, el proceso para crear un JWT es el siguiente: codificamos la carga útil y los encabezados, luego generamos la firma a partir de ellos.

Verificación de tokens JWT

Anteriormente, discutimos cómo crear un JWT. Ahora, analicemos cómo verificar un JWT. El proceso de verificación es esencialmente lo contrario de la creación de tokens. Primero, desciframos el token usando una clave pública o secreta. Luego, concatenamos el encabezado y la carga útil para generar una firma. Si el hash generado coincide con la firma, el token es válido; de lo contrario, no es válido.

// Token we recive in this formate
Token = Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload)  "."  Signature

// Decrypt Signature
TokenHash = RSA Decrypt(Hash with Public Key) or HS256 Sign(Hash with secrate)

// Generate Hash From Encoded Header and Payload
Hash = SHA-256(Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload))

// Compare Hash
if(TokenHash == Hash) "Valid"
else "Not Valid"

Beneficios de usar JWT

1. Seguridad: Los JWT están firmados digitalmente, lo que garantiza la integridad y autenticidad de los datos
2. Compacto: Los JWT son de tamaño pequeño, lo que los hace eficientes para transmitir a través de la red.
3. Autocontenido: Los JWT contienen toda la información necesaria sobre el usuario, lo que reduce la necesidad de consultar la base de datos varias veces.

JWT proporciona todos los beneficios anteriores, lo que lo convierte en una opción popular para la mayoría de los mecanismos de autenticación para autorizar a los usuarios. Además, JWT se puede utilizar con varias técnicas de autenticación, como DPoP y otras.

Cómo utilizar JWT en su código

Para usar JWT en el código, utilizamos el paquete npm jsonwebtoken. Hay dos métodos para trabajar con JWT: el método sencillo que utiliza una clave secreta y el método del par de claves (que utiliza claves públicas y privadas).

Usando secreto

import jwt from 'jsonwebtoken';

// Define the type for the payload
interface Payload {
  userId: number;
  username: string;
}

// Secret key for signing the JWT
const secretKey: string = 'your-very-secure-secret';

// Payload to be included in the JWT
const payload: Payload = {
  userId: 123,
  username: 'exampleUser'
};

// Sign the JWT
const token: string = jwt.sign(payload, secretKey, { expiresIn: '1h' });
console.log('Generated Token:', token);

import jwt from 'jsonwebtoken';

// Secret key for signing the JWT
const secretKey: string = 'your-very-secure-secret';

// Verify the JWT
try {
  const decoded = jwt.verify(token, secretKey) as Payload;
  console.log('Decoded Payload:', decoded);
} catch (err) {
  console.error('Token verification failed:', (err as Error).message);
}

Usando el método de par de claves

import * as jwt from 'jsonwebtoken';
import { readFileSync } from 'fs';

// Load your RSA private key
const privateKey = readFileSync('private_key.pem', 'utf8');

// Define your payload
const payload = {
  sub: '1234567890',
  name: 'John Doe',
  iat: Math.floor(Date.now() / 1000) // Issued at
};

// Define JWT sign options
const signOptions: jwt.SignOptions = {
  algorithm: 'RS256',
  expiresIn: '1h' // Token expiration time
};

// Generate the JWT
const token = jwt.sign(payload, privateKey, signOptions);
console.log('Generated JWT:', token);

import * as jwt from 'jsonwebtoken';
import { readFileSync } from 'fs';

// Load your RSA public key
const publicKey = readFileSync('public_key.pem', 'utf8');

// Define JWT verify options
const verifyOptions: jwt.VerifyOptions = {
  algorithms: ['RS256'] // Specify the algorithm used
};

try {
  // Verify the JWT
  const decoded = jwt.verify(token, publicKey, verifyOptions) as jwt.JwtPayload;

  console.log('Decoded Payload:', decoded);
} catch (error) {
  console.error('Error verifying token:', error);
}

Conclusión

En resumen, los tokens web JSON (JWT) transmiten información de forma segura entre partes utilizando un formato compacto. La firma y verificación RSA implican el uso de una clave privada para la firma y una clave pública para la verificación. Los ejemplos de TypeScript ilustran la generación de un JWT con una clave RSA privada y su verificación con una clave RSA pública, lo que garantiza una autenticación segura basada en tokens y la integridad de los datos.