VT Security blog

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
  1. Se lee con un comando
  2. Lo que protege la firma
  3. Lo que el backend tiene que verificar
  4. Una firma válida no sabe que cerraste sesión
  5. Qué no cubre esta demo
  6. Qué revisar en tu API

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:

terminal
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"
json
{
  "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.

tokencomo lo emitió el servidorheader · payload · firmaeyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyLTEyMyIsIm5hbWUiOiJBbmEiLCJyb2xlIjoidXNlciIsImlhdCI6MTc5NTE3NjAwMCwiZXhwIjoxNzk1MTc2OTAwfQ.80Q9bkyc1RjJtz6ASXU1ouyEZTpQ2yhhMhPU83gJS9Q↑ la calculó el servidor al emitirlo, con su clave↑ la firma no cambiópayload decodificado, sin ninguna clave"sub": "user-123","name": "Ana","role": "user","iat": 1795176000,"exp": 1795176900servidorclave••••••••HMAC-SHA256(header.payload, clave)firma del token80Q9bkyc1R…firma calculadaesperandocomparandoaceptadorechazado: la firma no coincideBearer eyJ…tokencomo lo emitió el servidorheader · payload · firmaeyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyLTEyMyIsIm5hbWUiOiJBbmEiLCJyb2xlIjoidXNlciIsImlhdCI6MTc5NTE3NjAwMCwiZXhwIjoxNzk1MTc2OTAwfQ.80Q9bkyc1RjJtz6ASXU1ouyEZTpQ2yhhMhPU83gJS9Q↑ la calculó el servidor al emitirlo, con su clave↑ la firma no cambiópayload decodificado, sin ninguna clave"sub": "user-123","name": "Ana","role": "user","iat": 1795176000,"exp": 1795176900servidorclave••••••••HMAC-SHA256(header.payload, clave)firma del token80Q9bkyc1R…firma calculadaesperandocomparandoaceptadorechazado: la firma no coincideBearer eyJ…

El token viaja en el header Authorization. Cualquiera que lo tenga lee el payload sin ninguna clave: está en base64url, no cifrado.

Las firmas son reales: HMAC-SHA256 con una clave de ejemplo de 256 bits.

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:

js
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:

token correctorol cambiadovencido (16 min después)emitido para otra appalg "none"sin expalgorithmsapagadofirmaapagadoexpapagadoissuer /audienceapagadoERR_JWS_SIGNATURE_VERIFICATION_FAILEDhandlertu APIcorrectotoken correctorol cambiadovencido (16 min después)emitido para otra appalg "none"sin expalgorithmsapagadofirmaapagadoexpapagadoissuer / audienceapagadoERR_JWS_SIGNATURE_VERIFICATION_FAILEDhandlertu APIcorrecto

Rol cambiado: la firma no coincide con el payload. jose: signature verification failed.

Los códigos son los que devolvió jose 6.1.0 en la demo. Con un control apagado, la figura muestra una verificación que no hace ese chequeo.
  • 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.
  • exp obligatorio y corto: un token robado sirve hasta que vence.
  • issuer y audience: 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 #

  1. ¿El payload tiene algo que no querrías que lea el usuario?
  2. ¿El secreto tiene al menos 256 bits aleatorios y vive fuera del repo?
  3. ¿Fijás el algoritmo al verificar, o le creés al header?
  4. ¿Exigís exp, iss y aud?
  5. ¿Cada endpoint comprueba que el recurso es del usuario?
  6. ¿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

Valentín Torassa. Hago videos de ciberseguridad en YouTube. Si encontraste un error, avisame en los comentarios y lo corrijo con una nota al pie.

Comentarios

Pasan por moderación antes de aparecer.

Lo próximo llega también por mail. Cada dos semanas, en Apuntes.