GHSA-3G82-77XR-68X5
js-toml permite recursión no controlada en `load()` que provoca `RangeError` (agotamiento de la pila) con entradas muy anidadas
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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
`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:
- 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).
- 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:
- Analizador (descenso recursivo). `src/load/parser.ts` — las reglas `array` / `inlineTable` recurren a través de `value` en cada nivel de anidamiento.
- 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 exceededCada 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.
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
npmjs-toml |
Corregida | 1.1.3 | -143 d | 2.0.1 no afectada |
1.1.3Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://nvd.nist.gov/vuln/detail/CVE-2026-63386https://github.com/sunnyadn/js-toml/security/advisories/GHSA-3g82-77xr-68x5https://github.com/sunnyadn/js-toml/commit/4e10acf1f99ff3cb443c58b8f0a57664e41e87c6https://github.com/sunnyadn/js-tomlhttps://github.com/sunnyadn/js-toml/releases/tag/v1.1.3Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
