GHSA-5WR4-942J-H43M
JWT Customizer: la ejecución con node:vm no tiene un timeout efectivo, lo que permite una DoS de todo el proceso o de todo el tenant
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-5WR4-942J-H43M divulgada | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
VULN-005 — El timeout del VM local de JWT Customizer es ineficaz, lo que permite DoS dentro del tenant y entre tenants
## Estado
CONFIRMADO
## Clasificación
- Vulnerabilidad: Consumo de recursos no controlado / Falta de aplicación de timeout en la ejecución de scripts no confiables
- CWE: CWE-400 — Consumo de recursos no controlado (contribuyente: CWE-834 — Iteración excesiva; CWE-1088 no aplicable)
- Severidad: Alta
- CVSS (estimado): 8.2 — CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:N/A:H
## Ubicación
- Archivo: `packages/core/src/utils/local-vm/index.ts` (`runScriptFunctionInLocalVm`, líneas 12-41)
- Línea 20: primera llamada a `runInNewContext(script + `;${functionName};`, globalContext)` — compila el script y ejecuta todas sus sentencias de nivel superior, sin ninguna opción `timeout`.
- Líneas 33-38: segunda llamada a `runInNewContext('(async () => customFunction(payload))();', ..., { timeout: 3000 })` — el `timeout` solo limita la evaluación *síncrona* de esa sentencia (que devuelve una `Promise` casi de inmediato); no limita la ejecución asíncrona real de `customFunction(payload)` que ocurre después.
- Archivo: `packages/core/src/oidc/extra-token-claims.ts` (línea 337) y `packages/core/src/routes/logto-config/jwt-customizer.ts` (línea 244) — ambos hacen `await` del resultado sin ningún timeout externo adicional.
- Función / Ruta / Endpoint: emisión de tokens OIDC (`getExtraTokenClaimsForJwtCustomization`, en cada concesión de access token o client-credentials una vez configurado un JWT customizer) y `POST /configs/jwt-customizer/test` de la Management API.
Código vulnerable
// packages/core/src/utils/local-vm/index.ts:12-41
export const runScriptFunctionInLocalVm = async (
script: string,
functionName: string,
payload: unknown
) => {
const globalContext = Object.freeze({
fetch: async (...args: Parameters<typeof fetch>) => fetch(...args),
});
// (1) NO timeout option here -- any top-level busy loop in `script` blocks
// the single-threaded Node event loop for as long as it runs.
const customFunction: unknown = runInNewContext(script + `;${functionName};`, globalContext);
if (typeof customFunction !== 'function') {
throw new TypeError(`The script does not have a function named \\`${functionName}\\``);
}
// (2) `timeout: 3000` only bounds the synchronous statement
// `(async () => customFunction(payload))();`, i.e. the creation of the
// Promise -- NOT the asynchronous continuation of `customFunction`
// (e.g. an unresolved `fetch()` or an intentionally-never-resolving Promise).
const result: unknown = await runInNewContext(
'(async () => customFunction(payload))();',
Object.freeze({ customFunction, payload }),
{ timeout: 3000 }
);
return result;
};## Por qué es vulnerable
El comentario del código afirma *"Limit the execution time to 3 seconds, throws error if the script takes too long to execute"*, pero esta garantía no se cumple por dos razones independientes, cada una suficiente por sí sola para causar denegación de servicio:
- No hay timeout en la llamada de compilación o ejecución de nivel superior. `runInNewContext(script + ';functionName;', globalContext)` se invoca sin un tercer argumento `options`, por lo que la protección `timeout` de `node:vm` no se aplica a esta llamada. Cualquier código que el script coloque *fuera* del cuerpo de la función `getCustomJwtClaims` (por ejemplo, un `while (true) {}` de nivel superior, o un cálculo síncrono grande) se ejecuta de forma síncrona e incondicional, bloqueando el event loop de Node, que es de un solo hilo, durante todo el tiempo que dure. Con un bucle infinito real, el bloqueo es permanente y solo se recupera reiniciando el proceso.
- El `timeout: 3000` de la segunda llamada no limita la ejecución real del script. La opción `timeout` de `node:vm` solo limita la parte *síncrona* de la cadena de código ejecutada. La cadena aquí, `(async () => customFunction(payload))();`, es una IIFE que retorna de inmediato con una `Promise` (invocar una función `async` solo ejecuta el código de forma síncrona hasta su primer `await` o `return`). El *cuerpo* de `customFunction`, incluido cualquier `await fetch(...)` a un host lento o no disponible, o un `return new Promise(() => {})` intencionalmente nunca resuelto, se ejecuta como una microtarea o continuación posterior, totalmente fuera de la ventana que vigila la opción `timeout`. Por lo tanto, `await runInNewContext(...)` en el llamador queda colgado durante todo el tiempo que tarde la promesa en resolverse, potencialmente para siempre.
Logto core atiende a múltiples tenants desde una única instancia de proceso de Node.js mediante un `TenantPool` compartido (`packages/core/src/tenants/index.ts`). Además, el script JWT customizer de un tipo de token se ejecuta en cada emisión de ese tipo de token para cada solicitante del tenant, no solo para el autor del script. Por ello, ambos fallos convierten un único script mal configurado o malicioso en una denegación de servicio que va más allá de la sesión del atacante:
- Caso 1 (bucle infinito de nivel superior): congela todo el event loop, es decir, toda la instancia de proceso de Logto core, todos los tenants que atiende y todas las solicitudes en curso, hasta que el proceso se detiene y se reinicia.
- Caso 2 (cuerpo asíncrono que nunca resuelve): cuelga cada solicitud posterior de emisión de tokens de ese tipo en el tenant (todos los usuarios que soliciten un access token o client-credentials de ese tipo), acumulando conexiones y handles abiertos con el tiempo.
## Flujo de datos (fuente -> sumidero)
- Fuente: el campo `script` de un JWT customizer (controlado por el atacante o por el autor), enviado mediante `PUT /configs/jwt-customizer/:tokenTypePath` (persistido y ejecutado en cada emisión de token posterior) o mediante `POST /configs/jwt-customizer/test` (ejecutado de inmediato).
- Ruta: `script` → `JwtCustomizerLibrary.runScriptInLocalVm` → `runScriptFunctionInLocalVm(script, 'getCustomJwtClaims', payload)` → dos llamadas a `runInNewContext`, ninguna de las cuales impone un límite real de tiempo de pared de extremo a extremo sobre el trabajo real del script.
- Sumidero: el event loop compartido de un solo hilo de Node (llamada 1, bloque síncrono de nivel superior) o la expresión `await runInNewContext(...)` dentro de `runScriptFunctionInLocalVm` (llamada 2, bloqueo por promesa sin resolver).
- Sanitización: ninguna. No hay análisis estático del script en busca de bucles o recursión, no hay cuota de CPU basada en worker threads o isolates, y no hay un `Promise.race` externo con un plazo máximo que envuelva toda la llamada a `runScriptFunctionInLocalVm`.
## Escenario de ataque
Caso A — congelamiento completo del proceso:
1. Un principal con permiso para probar JWT customizers invoca `POST /configs/jwt-customizer/test` (o persiste mediante `PUT`) con:
```js
function getCustomJwtClaims(payload) { return {}; }
while (true) {}
```
2. `runInNewContext(script + ';getCustomJwtClaims;', globalContext)` (sin timeout) ejecuta el `while (true) {}` de nivel superior de forma síncrona y nunca retorna.
3. El event loop de la instancia de Logto core queda bloqueado de forma permanente: ninguna otra solicitud HTTP (de ningún tenant alojado en esa instancia de proceso) puede atenderse. El proceso debe reiniciarse forzosamente.
Caso B — emisión de tokens colgada en todo el tenant:
1. El mismo principal persiste en cambio (mediante `PUT /configs/jwt-customizer/:tokenTypePath`):
```js
async function getCustomJwtClaims(payload) {
return new Promise(() => {}); // never resolves
}
```
2. Cada solicitud posterior de cualquier usuario del tenant para obtener un access token o client-credentials de ese tipo activa `getExtraTokenClaimsForJwtCustomization` → `runScriptInLocalVm` → la llamada `await runInNewContext(...)`, que ahora nunca resuelve para esa solicitud.
3. Cada una de esas solicitudes queda colgada indefinidamente (manteniendo abierta su conexión HTTP y los recursos asociados). Repetir la operación produce agotamiento de recursos. La emisión de tokens para ese tipo queda efectivamente rota para todo el tenant hasta que un operador elimine el customizer defectuoso directamente en la base de datos (la propia Management API también quedaría colgada al intentar redeplegar o ejecutar el script).
## Prueba de concepto (reproducción genérica, sin necesidad de aplicación objetivo ni Docker)
```js
const { runInNewContext } = require('node:vm');
// Case A: no timeout guards the compile/top-level-exec call.
const scriptA = `
const stop = Date.now() + 2000; // bounded here only so the PoC terminates
while (Date.now() < stop) {}
function getCustomJwtClaims(payload) { return {}; }
`;
const t0 = Date.now();
runInNewContext(scriptA + ';getCustomJwtClaims;', Object.freeze({ fetch: async () => {} }));
console.log('blocked', Date.now() - t0, 'ms with ZERO timeout enforcement (a real `while(true){}` never returns)');
// Case B: timeout:3000 does not bound the async body.
const scriptB = `function getCustomJwtClaims(payload) { return new Promise(() => {}); }`;
const fn = runInNewContext(scriptB + ';getCustomJwtClaims;', Object.freeze({ fetch: async () => {} }));
const p = runInNewContext('(async () => customFunction(payload))();',
Object.freeze({ customFunction: fn, payload: {} }), { timeout: 3000 });
console.log('runInNewContext returned syn
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
npm@logto/core |
Sin parche | — | — | — |
Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/logto-io/logto/security/advisories/GHSA-5wr4-942j-h43mLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
