Seguridad 8 min de lectura

Lo que un token no te deja hacer: arrepentirte

¿Qué pasa si necesitas retirar un acceso antes de que caduque el JWT? La firma detecta cambios, pero no te saca de ahí: tienes que decidir dónde se comprueba que el permiso sigue vigente.

En este artículo 6 secciones
  1. Una postal lacrada
  2. ¿Puedo hacer que deje de valer ahora mismo?
  3. Mi panel no usa JWT
  4. ¿Quién más puede firmar esto?
  5. ¿Lo está comprobando alguien?
  6. Entonces, ¿cuándo sí?

Este mes leí en LinkedIn a Nicolás Bernal, que estudia en la Universidad de La Salle y acababa de implementar tokens JWT en Mercado Páramo, un proyecto de curso. Contaba lo aprendido con una honestidad que no abunda: en su primera versión había metido en el token el objeto entero del usuario, hash de la contraseña incluido, y fue la revisión de código la que lo paró antes de llegar a main. Y lo cerraba con una frase que me apunté:

Un JWT no es secreto, es a prueba de alteraciones.

Es la mejor definición corta que he leído de un JWT firmado. También se detiene justo antes de la parte que da problemas en producción. Es normal: esa parte no se aprende implementándolo, se aprende el día que necesitas echar a alguien.

Una postal lacrada

El JWT firmado de este ejemplo tiene tres trozos de texto separados por puntos:

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJhbmFAZWplbXBsby5jb20iLCJyb2wiOiJBRE1JTiIsImV4cCI6MTc5NTAwMDAwMH0.xgMC1RHjZzGOc0eyHAHwyUS2HdhfRQ5pIbtSF4m1p-c

Los dos primeros, decodificados, dicen esto:

{ "alg": "HS256" }
{ "sub": "ana@ejemplo.com", "rol": "ADMIN", "exp": 1795000000 }

El tercero es una firma calculada sobre los otros dos con una clave que solo tiene el servidor.

Piensa en una postal con un sello de lacre. Cualquiera que la tenga en la mano la lee; lo que no puede es cambiar una palabra sin que se note. El contenido va en Base64url, que es una forma de escribir datos, no de esconderlos.

Eso vale para lo que lleva escrito. El token entero es otra cosa: quien lo consiga puede presentarlo tal cual mientras el servidor lo acepte, así que se guarda como una llave.

Por eso una contraseña no pinta nada ahí, ni siquiera su hash: con él en la mano, cualquiera puede probar contraseñas candidatas en su propia máquina. Y fíjate en el ejemplo, que es el habitual: un email también es un dato personal, y los tokens acaban en logs, en herramientas de errores, en capturas de soporte y en decodificadores web donde alguien pega uno de producción para ver qué lleva. Si basta con un identificador interno, mejor un identificador interno.

Hasta aquí la frase se sostiene. Lo que no contesta son tres preguntas.

¿Puedo hacer que deje de valer ahora mismo?

Esta es la que más duele.

El atractivo de JWT es que el servidor puede aceptarlo sin consultar nada: mira la firma, mira la fecha y se fía del rol que trae escrito. Si valida así, no tiene dónde apuntar que ha cambiado de opinión. Y si el token dura veinticuatro horas y a la primera hora pasa algo de esto, tienes veintitrés por delante:

  • Despides a alguien. Su token sigue abriendo la puerta hasta que caduque.
  • Le quitas el rol de administrador. El rol que va dentro es una foto del momento en que se emitió.
  • Le roban el token. No hay nada que borrar, porque no hay nada guardado.
  • Pulsa «Cerrar sesión». Normalmente eso borra el token de su navegador. Cualquier copia sigue siendo válida.

Hay dos arreglos, y conviene mirar bien en qué consisten.

Caducidad corta y token de renovación. El token dura quince minutos y otro, guardado en base de datos, sirve para pedir uno nuevo. Revocar ese segundo impide pedir más, pero el que ya está emitido sigue valiendo hasta que caduque. Reduce la ventana, no la cierra, y ya tienes una tabla.

Lista de revocados. Cada token lleva un identificador (jti) y en cada petición compruebas si está en la lista. Funciona. Y en cada petición estás consultando un almacén en el servidor, que es lo que hace una sesión y lo que JWT venía a ahorrarte.

Ninguno de los dos es mala solución. Pero conviene llegar a ellos sabiendo que has dado la vuelta completa: la firma te dice si alguien ha cambiado el token, y si quieres retirar un permiso antes de que caduque, tienes que decidir dónde se comprueba que sigue vigente.

Mi panel no usa JWT

El panel desde el que se publica este blog funciona con una sesión de PHP de toda la vida. Tiene además una casilla de «Recordarme» durante treinta días, que es una cookie con dos valores aleatorios: uno para encontrar la fila y otro para demostrar que es tuya. En la base de datos solo se guarda el SHA-256 del segundo, de modo que quien lea esa tabla no saca de ella una cookie que funcione.

Cerrar sesión destruye la sesión y borra esa fila. Si esa cookie acaba en otras manos, borro la fila y ya no abre ninguna sesión nueva. Una que ya estuviera abierta con ella se corta aparte: no tengo un botón para eso, pero está en mi servidor, y vaciar la carpeta de sesiones las corta todas.

Lo pago leyendo la sesión en cada petición, un coste que un solo servidor con un solo panel no nota.

Con las máquinas hago lo mismo. Las herramientas que consultan este servidor entran con llaves aleatorias, guardo su hash y cada una tiene un botón de revocar. Tener una API no obliga a usar JWT.

¿Quién más puede firmar esto?

En HS256, la misma clave firma y comprueba. De ahí salen dos problemas.

La firma vale lo que vale la clave. Hacer que la aplicación no arranque si falta la variable de entorno es una buena costumbre, pero garantiza que hay clave, no que sea buena. Y quien tenga un solo token tiene con qué probar claves candidatas en su propia máquina: sin límite de intentos, sin logs y sin que te enteres. Si acierta, ya no lee tokens: los fabrica. Hashcat trae un modo específico para eso. La RFC 8725, que recoge las buenas prácticas de JWT, prohíbe usar como clave una contraseña memorizable, y la RFC 7518 exige al menos 256 bits para HS256. Aquí no aplica lo de la frase fácil de recordar, porque nadie tiene que recordarla: 32 bytes de un generador aleatorio y a la variable de entorno.

Todo el que comprueba puede fabricar. Si cinco servicios verifican tokens con HS256, los cinco tienen la clave, y basta con comprometer uno para emitir un token de administrador que los otros cuatro aceptarán encantados. Para eso existe la firma asimétrica (RS256, ES256): uno firma con la clave privada y los demás comprueban con la pública.

¿Lo está comprobando alguien?

«Si lo modifican, la firma deja de coincidir» da por hecho que alguien compara bien. Y aquí está la trampa: la cabecera dice qué algoritmo se usó, y la cabecera la escribe quien te manda el token.

En 2015, Tim McLean publicó lo que pasaba por hacerle caso. Algunas librerías aceptaban "alg": "none", es decir, un token sin firma que se declaraba válido a sí mismo. El otro caso era más retorcido: si el servidor esperaba RS256 y el atacante escribía HS256 en la cabecera, algunas usaban la clave pública como secreto para comprobar la firma. La clave pública, por definición, la tiene cualquiera. Esa confusión es el CVE-2015-9235, que el paquete jsonwebtoken de Node corrigió en la versión 4.2.2.

El remedio no ha cambiado en once años: el servidor decide qué algoritmo acepta y no se lo pregunta al token. Y luego comprueba lo demás que hace válido ese token para esa API: la caducidad y, cuando corresponda, el emisor y la audiencia.

El otro fallo clásico es más tonto. Muchas librerías tienen una función para decodificar y otra para verificar, y la primera no comprueba nada. El código que usa la que no toca pasa todas las pruebas hechas con tokens buenos.

Por eso me gustó otro detalle de aquel post: Nicolás cuenta que tiene una prueba que altera un carácter del token y exige que lo rechace. Esa es la idea. Yo la haría más explícita: cambia el rol de COMPRADOR a ADMIN en el JSON, vuelve a codificarlo, conserva la firma original y exige que falle. Así el rechazo no se puede explicar por haber roto el JSON.

Y si alteras caracteres, no toques el último de la firma. En HS256 son 43 caracteres para 32 bytes, y a ese último le sobran dos bits. Lo he probado: de las 63 sustituciones posibles, 3 decodifican exactamente a los mismos bytes. Si tu decodificador las admite, de vez en cuando el token seguirá valiendo y el test fallará sin motivo, que es la peor forma de fallar que tiene un test.

Entonces, ¿cuándo sí?

Sesión o token opaco con estado JWT firmado con validación local
Retirarlo al momento Se borra y ya está Hace falta añadir estado
Un cambio de rol En la siguiente petición, si el rol se lee del almacén Al renovar el token, si el emisor lo vuelve a consultar
Qué ve quien lo tiene Un valor aleatorio Todo el contenido
Quién puede validarlo Quien consulte el almacén Quien tenga la clave, sin consultar a nadie
Lo que te cuesta Una consulta por petición Claves, caducidades y renovación

JWT tiene sentido cuando esa penúltima fila es la que te importa: varios servicios independientes que validan sin llamar a uno central, tokens de vida corta entre máquinas o inicio de sesión con terceros, donde el ID token de OpenID Connect es un JWT.

Para una web o una aplicación con su propio backend, una sesión suele ser mejor elección, y es la opción aburrida. Si además el token va a vivir en un navegador, la cookie HttpOnly tiene una ventaja que localStorage no puede igualar: el JavaScript de la página no la lee, así que un script inyectado no se la lleva, aunque mientras siga ahí pueda hacer peticiones desde la página. A cambio hay que ocuparse del CSRF: SameSite ayuda, y según la aplicación hará falta algo más.

Antes de elegir, yo haría una sola pregunta: si mañana necesito que esto deje de valer ahora mismo, ¿qué hago?

Si la respuesta es «esperar a que caduque», puede ser una decisión perfectamente razonable. Pero que sea una decisión.

La ilustración de la cabecera y la de la vista previa al compartir este artículo están generadas con IA.

Preguntas frecuentes

¿El contenido de un JWT está cifrado?

En un JWT firmado, que es el caso habitual, no. El contenido va codificado en Base64url y cualquiera que tenga el token puede leerlo. La firma impide modificarlo sin que se note, pero no impide leerlo. Por eso no debe llevar contraseñas ni sus hashes, y conviene limitar también los datos personales.

¿Se puede invalidar un JWT antes de que caduque?

No por sí solo, porque el servidor lo acepta comprobando la firma y la fecha sin consultar nada. Una lista de identificadores revocados, guardada en el servidor, permite rechazarlo antes de que caduque. Una caducidad corta, con un token de renovación en base de datos, solo reduce el tiempo durante el que puede seguir usándose.

¿Qué longitud debe tener la clave de un JWT con HS256?

Al menos 256 bits, según la RFC 7518, generados por una fuente aleatoria. Una contraseña memorizable no sirve: quien consiga un token puede probar claves candidatas en su propia máquina sin límite de intentos y sin dejar rastro en el servidor.

¿Qué es el ataque alg none?

La cabecera de un JWT indica con qué algoritmo se firmó, y la escribe quien envía el token. Algunas librerías aceptaban el valor none, que significa sin firma, y daban por válido un token que nadie había firmado. La defensa es que el servidor fije qué algoritmos acepta en lugar de hacer caso a la cabecera.

¿Cuándo conviene usar JWT en lugar de sesiones?

Cuando varios servicios independientes tienen que validar la identidad sin llamar a uno central, en tokens de vida corta entre máquinas o en inicios de sesión con terceros mediante OpenID Connect. Para una web o aplicación con su propio backend, una sesión suele ser más sencilla y permite retirar el acceso al momento.

Sigue leyendo

¿Te ha resultado útil o quieres comentar algo?

Hablemos →