Decodificar no es hackear: qué protege la firma de un JWT
Un JWT se lee con un comando y no se puede cambiar sin la clave. Qué garantiza la firma, qué no, y qué tiene que verificar tu backend, con una demo local.
En este artículo
Pegás un token en un decoder y aparecen tu id, tu nombre y "role": "user". Parece que rompiste algo, y hace unos años yo tenía la misma duda. No rompiste nada: un JWT firmado está codificado, no cifrado, y cualquiera que lo tenga lo puede leer.
La pregunta que importa es otra: si cambio user por admin, ¿el servidor se da cuenta? Para contestarla armé una demo chica en Node, la misma idea del video de JWT, con jose para verificar. Los usuarios y los secretos son inventados. Las salidas de abajo son de ahí.
Se lee con un comando #
Un JWT (RFC 7519) son tres tramos en base64url unidos por puntos: header.payload.signature. El header dice con qué algoritmo se firmó y el payload trae los claims: quién es (sub) y cuándo vence (exp). Para leerlo no hace falta ninguna página web. Cargá el token con read -rs TOKEN, así no queda en el historial, y:
python3 -c 'import sys, json, base64; p = sys.argv[1].split(".")[1]; print(json.dumps(json.loads(base64.urlsafe_b64decode(p + "=" * (-len(p) % 4))), indent=2))' "$TOKEN"{
"sub": "user-123",
"name": "Ana",
"role": "user",
"iat": 1795176000,
"exp": 1795176900
}Leerlo no te da nada que no viajara ya en cada request. El error está del otro lado: poner en el payload una contraseña, una clave o un dato que el usuario no tiene por qué ver. Y si el token es real, no lo pegues en un depurador online: mientras no vence, sirve como tu sesión.
Lo que protege la firma #
La firma es un HMAC de header.payload calculado con un secreto que solo tiene el servidor. Cambiá el rol en la figura: el payload cambia, la firma no, y la que calcula el servidor deja de coincidir.
El token viaja en el header Authorization. Cualquiera que lo tenga lee el payload sin ninguna clave: está en base64url, no cifrado.
La firma no impide leer el payload. Impide cambiarlo sin que el servidor se dé cuenta.
Todo depende de que el secreto no se pueda adivinar. Con 123, quien tenga un token lo prueba en su máquina, sin tocar tu servidor, y después firma lo que quiera: en la demo alcanzó una lista de ocho contraseñas comunes. La RFC 7518 pide para HS256 una clave de al menos 256 bits. Que sea aleatoria (openssl rand -base64 32) y viva fuera del repo.
Lo que el backend tiene que verificar #
La firma es el primer control, no el único. Con jose:
const { payload } = await jwtVerify(token, secret, {
algorithms: ["HS256"],
issuer: "api.ejemplo",
audience: "app.ejemplo",
requiredClaims: ["exp", "sub"],
});Por esa verificación pasan seis tokens de la demo. Apagá un control y mirá cuál entra:
Rol cambiado: la firma no coincide con el payload. jose: signature verification failed.
algorithms: el algoritmo lo decidís vos, no el header. Un token con"alg": "none"declara que no tiene firma, y la RFC 8725 pide verificarlo.expobligatorio y corto: un token robado sirve hasta que vence.issueryaudience: que lo haya emitido quien esperás y para esta app.
Hay algo que ninguna librería verifica por vos: que el usuario pueda tocar ese recurso. "role": "user" no dice si la factura 1041 es suya. Esa pregunta va en cada endpoint, y cuando falta es la primera del OWASP API Security Top 10.
Una firma válida no sabe que cerraste sesión #
El servidor valida la firma y confía. Si el logout solo borra el token del navegador, una copia que alguien se llevó sirve hasta el exp. Las salidas, de menos a más estado en el servidor: access tokens cortos con un refresh token revocable, una lista de jti revocados o sesiones del lado del servidor. Y si la autenticación no es el centro de tu producto, como digo en el video, delegala en un proveedor.
Qué no cubre esta demo #
Solo firma con un secreto compartido (HS256). Con claves asimétricas (RS256 o ES256) aparecen otros problemas, como de dónde sale la clave pública y cuándo se rota. Tampoco dice dónde guardar el token en el navegador: eso depende de cómo te protegés del XSS, y es otra nota.
Qué revisar en tu API #
- ¿El payload tiene algo que no querrías que lea el usuario?
- ¿El secreto tiene al menos 256 bits aleatorios y vive fuera del repo?
- ¿Fijás el algoritmo al verificar, o le creés al header?
- ¿Exigís
exp,issyaud? - ¿Cada endpoint comprueba que el recurso es del usuario?
- ¿Qué pasa con un token robado después del logout?
Si alguna respuesta es «no sé», empezá por la 3 y la 5. Para seguir: el video, el cheat sheet de JWT de OWASP y la RFC 8725.
Practicalo en el lab: JWT no es autorización
Lo próximo llega también por mail. Cada dos semanas, en Apuntes.
Comentarios
Pasan por moderación antes de aparecer.