¡Claro que sí! Aquí tienes un “cheatsheet” completo y bien estructurado de la librería jwt-decode, optimizado para ser claro y conciso para una IA conversacional.
🔑 jwt-decode Cheatsheet Completo 🔑
jwt-decode es una librería ligera para decodificar JSON Web Tokens (JWTs) en el lado del cliente (navegador o Node.js). Es importante entender que esta librería SÓLO DECODIFICA el token; NO LO VALIDA. Esto significa que no verifica la firma, la expiración o cualquier otra afirmación de seguridad.
1. 🌟 Conceptos Clave
- JWT (JSON Web Token): Un formato compacto y autocontenido para transmitir información de forma segura entre partes como un objeto JSON. Consta de tres partes separadas por puntos (
.):- Header (Cabecera): Contiene el tipo de token (JWT) y el algoritmo de firma (ej. HS256, RS256).
- Payload (Carga Útil): Contiene las “claims” (afirmaciones) o datos sobre la entidad (normalmente el usuario) y metadatos adicionales (expiración, emisor, etc.).
- Signature (Firma): Se utiliza para verificar que el emisor del JWT es quien dice ser y que el mensaje no ha sido alterado.
- Decodificación: El proceso de tomar las partes codificadas en Base64url (Header y Payload) y convertirlas de nuevo en objetos JSON legibles.
jwt-decode: Una librería que realiza la decodificación del Header y Payload de un JWT.
2. 🛠️ Configuración Inicial
- Instalación:
npm install jwt-decode # o yarn add jwt-decode - Importación:
import { jwtDecode } from 'jwt-decode'; // Importación con nombre (desde v4.0.0) // O para versiones anteriores (v3.x.x): // import jwt_decode from 'jwt-decode';
3. 🚀 Uso Básico (jwtDecode())
La función principal es jwtDecode(), que toma un JWT como string y devuelve el objeto payload decodificado.
import { jwtDecode } from 'jwt-decode';
// Ejemplo de un JWT (SOLO PARA DEMOSTRACIÓN, NO USAR TOKENS REALES AQUÍ)
const myJwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjE2Nzg5NzE2MDAsInJvbGUiOiJ1c2VyIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c";
try {
const decodedPayload = jwtDecode(myJwt);
console.log('Payload decodificado:', decodedPayload);
/*
Salida esperada:
{
sub: "1234567890",
name: "John Doe",
iat: 1516239022,
exp: 1678971600, // Unix timestamp (segundos)
role: "user"
}
*/
// Acceder a propiedades específicas
console.log('Nombre de usuario:', decodedPayload.name);
console.log('Rol:', decodedPayload.role);
// Convertir timestamp de expiración a Date (si existe)
if (decodedPayload.exp) {
const expirationDate = new Date(decodedPayload.exp * 1000); // Multiplicar por 1000 para milisegundos
console.log('Token expira el:', expirationDate);
}
} catch (error) {
console.error('Error al decodificar el token:', error.message);
}
4. ❌ Manejo de Errores
jwt-decode lanzará un error si el token no es un JWT válido o está malformado. Es crucial envolver la llamada en un bloque try-catch.
import { jwtDecode } from 'jwt-decode';
const invalidJwt = "esto.no.es.un.jwt.valido";
const malformedJwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.INVALID_PAYLOAD.SIGNATURE";
try {
jwtDecode(invalidJwt);
} catch (error) {
console.error('Error con token inválido:', error.message); // Por ejemplo: "Invalid JWT specified"
}
try {
jwtDecode(malformedJwt);
} catch (error) {
console.error('Error con token malformado:', error.message); // Por ejemplo: "Invalid or malformed JWT"
}
5. 🟦 Inferencia de Tipos con TypeScript
Cuando usas jwt-decode con TypeScript, puedes inferir el tipo del payload para obtener autocompletado y seguridad de tipos.
import { jwtDecode } from 'jwt-decode';
// 1. Define la interfaz de tu Payload JWT (lo que esperas en el token)
interface MyTokenPayload {
sub: string;
name: string;
iat: number;
exp: number; // Expiración en segundos (Unix timestamp)
role: 'admin' | 'user';
// ... cualquier otra afirmación personalizada
}
const myJwt: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjE2Nzg5NzE2MDAsInJvbGUiOiJ1c2VyIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c";
try {
// 2. Especifica el tipo genérico al llamar a jwtDecode
const decodedPayload = jwtDecode<MyTokenPayload>(myJwt);
console.log('ID de usuario:', decodedPayload.sub); // TypeScript sabe que 'sub' existe y es string
console.log('Rol del usuario:', decodedPayload.role); // TypeScript sabe que 'role' es 'admin' | 'user'
// Esto daría un error de TypeScript porque 'nonExistentProperty' no está en MyTokenPayload
// console.log(decodedPayload.nonExistentProperty);
} catch (error: any) { // Es buena práctica tipar el error en el catch
console.error('Error al decodificar el token:', error.message);
}
6. ⚠️ CONSIDERACIONES DE SEGURIDAD CRÍTICAS ⚠️
¡ESTO ES LO MÁS IMPORTANTE QUE DEBES SABER SOBRE jwt-decode!
- NO VALIDA EL TOKEN:
jwt-decodesolo descifra la parte codificada en Base64url de un JWT. No realiza ninguna de las siguientes comprobaciones de seguridad cruciales:- Verificación de Firma: No comprueba si la firma es válida, lo que significa que un token podría haber sido manipulado o falsificado.
- Verificación de Expiración (
exp): Aunque puedes decodificar y ver el campoexp, la librería no te dirá automáticamente si el token ha expirado. Debes comprobarlo manualmente. - Verificación de Emisor (
iss) / Audiencia (aud): No comprueba si el token fue emitido por un servidor de confianza o si está destinado a tu aplicación. - Verificación de “Not Before” (
nbf): No comprueba si el token es válido a partir de una fecha determinada.
- Uso en el lado del Cliente (Frontend):
- NUNCA USES
jwt-decodePARA VALIDAR LA AUTENTICACIÓN O AUTORIZACIÓN CRÍTICA EN EL FRONTEND. - La validación real de un JWT (especialmente la verificación de la firma) SIEMPRE DEBE HACERSE EN EL SERVIDOR (Backend). El backend tiene acceso al secreto o a la clave pública necesaria para verificar la firma, lo que garantiza la integridad y autenticidad del token.
- NUNCA USES
- Casos de Uso Aceptables para
jwt-decode(Frontend):- Mostrar información al usuario: Mostrar el nombre del usuario, el rol, o el ID sin hacer otra llamada a la API.
- Verificar la expiración para UX: Mostrar un mensaje “Tu sesión expirará pronto” o redirigir al usuario al login antes de que expire para una mejor experiencia de usuario. (Pero la decisión de si el token es realmente válido para una acción sigue siendo del backend).
- Depuración: Inspeccionar el contenido de un token durante el desarrollo.
- Pasar información contextual: Si necesitas un dato del payload para una lógica de UI simple (ej. si el usuario es
adminpara mostrar/ocultar un botón) y ya has asumido que el token es válido porque tu backend lo validó al inicio de la sesión.
7. 💡 Buenas Prácticas y Consejos
- Complemento, no reemplazo: Considera
jwt-decodecomo una herramienta para leer el contenido de un JWT en el frontend, no como una solución de seguridad. - Siempre
try-catch: Como el token puede venir de una fuente externa y estar malformado o inválido, siempre envuelve la llamada ajwtDecodeen un bloquetry-catch. - Comprobación manual de expiración: Si usas
exppara lógica del lado del cliente, siempre comparadecodedPayload.exp * 1000conDate.now(). - Backend es el guardián: La seguridad de tu aplicación depende de la correcta validación del JWT en tu servidor para cada petición sensible.
Este cheatsheet te proporciona una comprensión profunda de jwt-decode, sus capacidades y, lo que es más importante, sus limitaciones de seguridad para que puedas usarla de manera responsable y efectiva.