Cómo generar tokens web JSON (JWT) para la autenticación de API de red

¿Qué es un token web JSON (JWT)?

A JWT (JSON Web Token) es un estándar abierto (RFC 7519) para transmitir información de forma segura entre las partes como un objeto JSON. El objeto podría estar cifrado y firmado con una clave privada/pública, y se utiliza habitualmente para la autenticación y autorización en aplicaciones web.

Puedes pensar en JWT como una tarjeta de identificación digital utilizada en aplicaciones web para confirmar quién eres sin necesidad de iniciar sesión cada vez que interactúas con esa aplicación.

Es importante saber cómo generar un token JWT, ya que las API de red las utilizan para realizar la autorización. Existen varias maneras de generar un nuevo token JWT al consumir las API de Vonage:

• Usando el Generador JWT en línea. Necesitará su ID de aplicación y la clave privada generada por la aplicación en su panel de control. Las API de red no requieren ninguna propiedad ACL adicional.

• Uso de la Herramienta CLI de Vonage. Al igual que con el generador en línea, se debe proporcionar una clave privada y un ID de aplicación: vonage jwt --key_file=ruta/a/privada.key --app_id=<id_aplicación>

• Si utiliza uno de nuestros SDKsno tienes que preocuparte por JWT porque todos los SDKs soportan la generación de tokens JWT.

¿Y si quiero generar los tokens JWT sin depender de ninguna herramienta o librería externa? Si ese es el caso, ¡sigue leyendo!

Estructura JWT

Antes de implementar JWT, es importante entender su estructura.

Un JWT se compone de encabezado, carga útil y firma. Estas partes se codifican por separado utilizando el método Base64url y se concatenan mediante puntos:

jwt = base64url(header) + '.' + base64url(payload) + '.' + base64url(signature)

Sumerjámonos.

Cabecera

Especifica qué algoritmo se utiliza para generar la firma. Para las API de Vonage, la cabecera tendrá este aspecto:

{ 
  alg: "RS256",
  typ: "JWT"
};

Carga útil

Incluye información sobre el usuario y sus solicitudes, como el ID de la solicitud, la hora de emisión, la hora de vencimiento, etc. La siguiente lista contiene las claves necesarias al usar las API de Vonage:

• application_id. Corresponde al ID de la aplicación con capacidades de registro de redcreado en el panel del usuario.

• iat. Hora a la que se emitió la ficha.

• nbf. Hora a la que debe ser válido el token.

• exp. Hora a la que debe caducar el token.

• acl. Una lista de permisos que tendrá este token. Para las API de red, utilizaremos un valor vacío, ya que las API no necesitan permisos adicionales.

• jti. Un identificador único para el JWT.

Firma

Funciona como un sello para validar el token. Se calcula codificando la cabecera y la carga útil mediante el algoritmo de codificación Base64url, y se firma utilizando una clave secreta. La clave privada de la aplicación se utiliza para firmar el token. La clave pública correspondiente se utiliza para verificarlo. Las claves se encuentran en la configuración de la aplicación en el panel de control del usuario.

Cómo generar un JWT en JavaScript

El primer paso sería crear la cabecera:

const header = {
  alg: "RS256",
  typ: "JWT",
};

A continuación, cree la carga útil. En este ejemplo, establecemos un tiempo de caducidad de una hora:

const currentTime = Math.floor(Date.now() / 1000);

const payload = {
  application_id: "123-456-789",
  iat: currentTime,
  nbf: currentTime,
  exp: currentTime + (60 * 60),
  acl: {},                 
  jti: crypto.randomUUID()
};

JavaScript no incluye una implementación del algoritmo Base64URL, por lo que debemos implementar nuestra propia versión:

function base64url(str) {
  let encodedSource = Buffer.from(str).toString('base64');

  // remove padding and replace characters
  return encodedSource
       .replace(/\+/g, '-')
       .replace(/\//g, '_')
       .replace(/=+$/, '');
}

A continuación, vamos a crear la firma:

const crypto = require("crypto");
const fs = require("fs");

// Load your private key generated for the Vonage Application
const privateKey = fs.readFileSync("path/to/private.key", "utf8");

const encodedHeader = base64url(JSON.stringify(header));
const encodedPayload = base64url(JSON.stringify(payload));

const signingInput = `${encodedHeader}.${encodedPayload}`;

// Create RS256 signature (RSA-SHA256)
const signature = crypto.sign("RSA-SHA256", Buffer.from(signingInput), {
  key: privateKey,
});

const encodedSignature = base64url(signature);

Por último, nuestro JWT está listo para ser utilizado:

const jwt = `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
console.log(jwt);

Cómo generar un JWT en Python

El código para implementar un JWT es muy similar a la versión JavaScript. Empecemos por implementar el algoritmo Base64URL:

import base64
import json
import time
import uuid

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding

def base64url(data: bytes) -> str:
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("utf-8")

A continuación, definiremos el encabezado y la carga útil:

current_time = int(time.time())

header = {"alg": "RS256", "typ": "JWT"}

payload = {
    "application_id": "123-456-789",
    "iat": current_time,
    "nbf": current_time,
    "exp": current_time + 3600,
    "acl": {},
    "jti": str(uuid.uuid4()),
}

El siguiente paso es codificar tanto la cabecera como la carga útil:

encoded_header = base64url(json.dumps(header, separators=(",", ":")).encode("utf-8"))
encoded_payload = base64url(json.dumps(payload, separators=(",", ":")).encode("utf-8"))

Estamos listos para crear la firma:

app_id = "1234-4567-8901-abcd"
private_key = "/path/to/your/private/key"

with open(private_key, "rb") as f:
    private_key = serialization.load_pem_private_key(f.read(), password=None)

signature = private_key.sign(
    signing_input,
    padding.PKCS1v15(),
    hashes.SHA256(),
)

encoded_signature = base64url(signature)

Nuestro JWT está listo para ser utilizado:

jwt_token = f"{encoded_header}.{encoded_payload}.{encoded_signature}"
print(jwt_token)

Cómo utilizar JWT con API de red

Las APIs de red utilizan JWT durante el paso de autorización antes de realizar cualquier llamada a la API. Dado que los tokens son credenciales, debemos tener en cuenta algunas medidas de seguridad para evitar problemas de seguridad:

• La generación del JWT debe realizarse en el backend.

• No prolongue el plazo de caducidad de los tokens más de lo necesario.

Una vez generado, los usuarios deben poder utilizar el token para acceder a los extremos protegidos. Esto se suele hacer mediante la cabecera Authorization utilizando el esquema Bearer:

Authorization: Bearer <token>

La documentación de autorización de las API de red contiene una descripción detallada de cómo utilizar los tokens JWT en front-end y back-end front-end y back-end.

Ponte en contacto

¿Has implementado JWT en tu lenguaje favorito? ¡Nos encantaría ver tu código! Únete a nosotros en Slack de la comunidad de desarrolladores de Vonage o envíanos un mensaje en Xy nos pondremos en contacto contigo.

Gracias por leerme.