---
title: "Decodificar no es hackear: qué protege la firma de un JWT"
description: "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."
canonical: "https://vtsecurity.com.ar/articulo/jwt-decodificar-no-es-hackear"
author: "Valentín Torassa"
lang: "es-AR"
datePublished: "2026-11-20T12:00:06.544Z"
dateModified: "2026-11-20T12:00:06.544Z"
---

# 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.

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](https://www.youtube.com/watch?v=EFhvG90WvPM\&ref=blog), con [jose](https://github.com/panva/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](https://www.rfc-editor.org/rfc/rfc7519)) 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:

```sh
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.

*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](https://www.rfc-editor.org/rfc/rfc7518#section-3.2) 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:

*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](https://www.rfc-editor.org/rfc/rfc8725#section-3.1) 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](https://owasp.org/API-Security/editions/2023/en/0xa1-broken-object-level-authorization/).

## 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](https://www.youtube.com/watch?v=EFhvG90WvPM\&ref=blog), el [cheat sheet de JWT de OWASP](https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_Cheat_Sheet.html) y la [RFC 8725](https://www.rfc-editor.org/rfc/rfc8725).
