llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · js-toml

GHSA-3G82-77XR-68X5

js-toml permite recursión no controlada en `load()` que provoca `RangeError` (agotamiento de la pila) con entradas muy anidadas

Parche disponible
Descargar PNG JSON
CVSS
—
medium
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -143 d de la divulgación
Exposición24 hDesde la divulgación, 20 nov 2026, 9:40 a. m.
Detección24 minDesde 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 (media) y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Riesgo con buenos modales, atiéndela con calma.Si haces parches mensuales, ya estás cubierto.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 1.1.3
Monitoreo
Detectada +1
30 jun 26
20 nov 26
21 nov 26
30 jun 26
5 ago 26
10 sept 26
16 oct 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 1.1.3 js-toml · -143 d desde divulgación
Divulgación Publicada GHSA-3G82-77XR-68X5 divulgada
Divulgación Modificada Última actualización del registro
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

Resumen

`load()` analiza TOML no confiable mediante un analizador de descenso recursivo (Chevrotain) y un intérprete recursivo de recorrido de árbol. Ni el analizador ni el intérprete imponen una profundidad máxima de anidamiento ni de claves. Un documento pequeño controlado por un atacante, con anidamiento profundo (arreglos, tablas en línea) o con una clave con puntos muy larga, provoca recursión más allá del límite de la pila de llamadas de V8, y `load()` lanza un `RangeError: Maximum call stack size exceeded` no capturado.

Esto es un problema por dos razones:

  1. Denegación de servicio. Una carga mínima (≈2 KB) aborta el análisis de forma fiable. En cualquier servicio que analice TOML proporcionado por usuarios, un `RangeError` no gestionado puede hacer caer el worker o el proceso (error 500 / bucle de reinicios).
  2. Violación del contrato de errores. La biblioteca indica entradas inválidas mediante `SyntaxParseError` (ver `src/load/exception.ts`; toda la suite de pruebas verifica `SyntaxParseError`). Los consumidores que siguen este contrato —

```js
try { load(input); }
catch (e) {
if (e instanceof SyntaxParseError) return badRequest();
throw e; // inesperado -> se propaga
}
```

— volverán a lanzar el `RangeError` en lugar de tratar la entrada como malformada, convirtiendo una entrada malformada en un error fatal inesperado.

Impacto

  • Un atacante no autenticado que pueda suministrar una cadena TOML a una aplicación que use `js-toml` puede forzar a `load()` a lanzar un error distinto de `SyntaxParseError`.
  • Si el error no es capturado por un manejador genérico, el proceso de Node.js termina (impacto en la disponibilidad).
  • Incluso cuando se captura de forma genérica, se rompe el contrato de tipos de error documentado o esperado, lo que puede eludir ramas de validación de entradas que dependen de `SyntaxParseError`.

No hay impacto en la confidencialidad ni en la integridad. El error se lanza de forma síncrona y es capturable, por lo que un consumidor que captura *todas* las excepciones no se cae; por eso la severidad se evalúa como Baja–Media y no como Alta.

Código afectado / causa raíz

En ningún punto del pipeline de análisis existe un límite de profundidad. La recursión ocurre en (al menos) dos lugares independientes:

  1. Analizador (descenso recursivo). `src/load/parser.ts` — las reglas `array` / `inlineTable` recurren a través de `value` en cada nivel de anidamiento.
  2. Intérprete (recorrido de árbol). `src/load/interpreter.ts` — `assignValue`, `createTable` y `getOrCreateArray` recurren por cada segmento de clave con puntos, y `cleanInternalProperties` recurre por cada nivel de profundidad de objeto.

Dado que no existe un límite configurable ni fijo, la profundidad de recursión está limitada únicamente por la pila de V8, y el desbordamiento se manifiesta como un `RangeError` sin procesar.

Pasos para reproducir (PoC)

Entorno utilizado: Node.js v20, `js-toml@1.1.2`.

import { load, SyntaxParseError } from 'js-toml';

function probe(label, toml) {
  try {
    load(toml);
    console.log(`[OK]            ${label}`);
  } catch (e) {
    const expected = e instanceof SyntaxParseError;
    console.log(`[${e.constructor.name}${expected ? '' : ' (UNEXPECTED)'}] ${label}: ${String(e.message).split('\n')[0]}`);
  }
}

// 1) Arreglos anidados en profundidad (carga de ~2 KB)
probe('nested array depth 1000', 'x = ' + '['.repeat(1000) + ']'.repeat(1000));

// 2) Tablas en línea anidadas en profundidad
let v = '1';
for (let i = 0; i < 1000; i++) v = `{ a = ${v} }`;
probe('nested inline table depth 1000', 'x = ' + v);

// 3) Clave con puntos muy profunda (recursión del intérprete)
const key = Array.from({ length: 5000 }, (_, i) => 'a' + i).join('.');
probe('dotted key depth 5000', `${key} = 1`);
Salida observada
[RangeError (UNEXPECTED)] nested array depth 1000: Maximum call stack size exceeded
[RangeError (UNEXPECTED)] nested inline table depth 1000: Maximum call stack size exceeded
[RangeError (UNEXPECTED)] dotted key depth 5000: Maximum call stack size exceeded

Cada caso lanza `RangeError`, no `SyntaxParseError`. El desbordamiento ocurre en pocos milisegundos, por lo que no es un problema de agotamiento de CPU, sino un aborto inmediato y determinista.

Notas sobre los umbrales (dependen de la máquina; los valores exactos varían según el tamaño de la pila):
- Los arreglos anidados y las tablas en línea desbordan aproximadamente a una profundidad de ~1000 (recursión del analizador).
- Las claves con puntos desbordan aproximadamente a una profundidad de ~5000 (recursión del intérprete); la profundidad 1000 sigue funcionando.

Remediación sugerida

Imponer un límite explícito y documentado de profundidad de anidamiento o de claves, y reportar las violaciones como `SyntaxParseError` (coherente con el resto de gestiones de entradas inválidas). Por ejemplo:

  • Registrar la profundidad actual en el analizador o en el intérprete y lanzar `SyntaxParseError` (p. ej., `"Maximum nesting depth exceeded"`) al alcanzar un límite configurable (p. ej., 100–1000), antes de que la pila nativa se desborde.
  • Como respaldo defensivo, envolver el cuerpo de `load()` de nivel superior para que un `RangeError` lanzado por agotamiento de la pila se convierta en `SyntaxParseError`, garantizando que el contrato de errores documentado se cumpla para toda entrada malformada.

Es preferible un límite configurable (con un valor por defecto seguro) para que los documentos profundos legítimos puedan optar por un límite mayor.

Divulgación

Reportado en privado mediante un Security Advisory de GitHub. Disponibles para proporcionar reproductores adicionales o para probar un parche candidato.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
js-toml< 1.1.3
1.1.3
2.0.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npmjs-toml
Corregida 1.1.3 -143 d 2.0.1 no afectada
Versiones corregidas1.1.3
Explotación

Arsenal público

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

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-63386
Otrahttps://github.com/sunnyadn/js-toml/security/advisories/GHSA-3g82-77xr-68x5
Otrahttps://github.com/sunnyadn/js-toml/commit/4e10acf1f99ff3cb443c58b8f0a57664e41e87c6
Otrahttps://github.com/sunnyadn/js-toml
Otrahttps://github.com/sunnyadn/js-toml/releases/tag/v1.1.3

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