Alta

toml-node: DoS de complejidad cuadrática mediante claves con puntos o rutas de tablas largas en toml.parse()

  • Publicada: 22.10.2026
  • Actualizado: 26.10.2026 10:00

Resumen

toml.parse() es vulnerable a una denegación de servicio con complejidad cuadrática (O(n²)) a través de una única clave con puntos larga, encabezado de tabla o clave de tabla en línea. Un documento manipulado de ~100KB provoca un bloqueo síncrono de varios segundos; un documento de ~200KB provoca la caída inmediata del proceso de Node.js debido a un error de falta de memoria (OOM) no interceptable. Esta es una ruta de código separada y no corregida distinta del DoS por desbordamiento de pila solucionado previamente (GHSA-82x6-q7mm-w9cf) — no requiere ningún anidamiento de matrices o tablas en línea y se ha confirmado que no se ve afectada por la opción maxDepth que corrigió dicho problema anterior.

Componente / versión afectados

  • Paquete: toml (npm), repositorio BinaryMuse/toml-node
  • Funciones: assign(), deepRef(), setNestedKey() en lib/compiler.js
  • Confirmado como presente en la copia de trabajo auditada en el commit 1b2ac40 (2026-07-16), un commit después de la etiqueta v5.0.0 (un cambio exclusivo del changelog) — es decir, presente en v5.0.0, la última versión disponible. No se ha verificado exhaustivamente en cada versión anterior, pero las funciones afectadas no están relacionadas con los cambios de BigInt/Temporal de v5.0.0 (según CHANGELOG.md), por lo que es probable que el defecto preceda también a esa versión.

Detalles

toml.parse(input, options) (index.js:5-9) reenvía la cadena suministrada por el llamador a parser.parse() y luego a compiler.compile() sin validación de longitud ni estructural. Dentro de lib/compiler.js, tres funciones independientes recorren los segmentos de una clave con puntos en un bucle for y, en cada iteración, recalculan la cadena de prefijo de ruta completa desde cero:

  • assign() (líneas 69-107, el sumidero en la línea 81): var intermediatePath = makeFullPath(keys.slice(0, i + 1)); — alcanzado en asignaciones de clave con puntos de nivel superior como a.b.c = 1.
  • deepRef() (líneas 247-281, el sumidero en la línea 252): el mismo patrón a través de pathKey(keys.slice(0, i + 1)) — alcanzado desde encabezados de tabla [a.b.c] y matriz de tablas [[a.b.c]] mediante setPath()/addTableArray().
  • setNestedKey() (líneas 184-202, el sumidero en la línea 187): el mismo patrón — alcanzado desde claves con puntos en tablas en línea como t = { a.b.c = 1 }.

keys.slice(0, i + 1) asigna un nuevo array de longitud i; pathKey()/makeFullPath() (líneas 311-317) luego ejecuta .map(quoteDottedString).join("."), también O(i). Dado que esto se ejecuta en cada uno de los n segmentos de una clave con puntos, el trabajo total es O(1 + 2 + ... + n) = O(n²), no O(n). La cadena se calcula incondicionalmente en la ruta normal (solo se llega a usar si se va a lanzar un error), por lo que no existe una salida temprana que haga que esto sea liviano en la práctica.

No existe ningún límite en el recuento de segmentos de claves con puntos: dot_ended_table_key_part+ y inline_dot_key_part+ en src/toml.pegjs (líneas 122, 311) son repeticiones + ilimitadas, analizadas de forma iterativa en lugar de a través de la regla value de la gramática — por lo que la protección de anidamiento existente MAX_DEPTH/maxDepth (src/toml.pegjs:141-151, aplicada en el lib/parser.js:1022 generado) no se aplica en absoluto a la longitud de la clave. Esto se confirmó directamente: establecer options.maxDepth: 1 (el valor más estricto posible) contra una clave de 16,000 segmentos no produjo ninguna diferencia medible en los tiempos en comparación con el caso sin restricciones.

Prueba de concepto

js
const toml = require('toml');

// n-segment dotted key: "k0.k1.k2. ... .k{n-1} = 1"
function segKey(n) {
  const parts = [];
  for (let i = 0; i < n; i++) parts.push('k' + i);
  return parts.join('.') + ' = 1\n';
}

// ~100.9 KB input -- takes ~6.6-6.8 seconds
toml.parse(segKey(16000));

// ~200 KB input -- crashes the Node process:
// "FATAL ERROR: Ineffective mark-compacts near heap limit - JavaScript heap out of memory"
toml.parse(segKey(32000));

Tiempos medidos (Node v22, ejecución directa contra este repositorio):

n (segmentos) tamaño de entrada tiempo
1,000 ~4.9 KB 34 ms
8,000 ~46.9 KB 1.6 s
16,000 ~100.9 KB 6.8 s
32,000 ~200 KB caída del proceso (OOM)

Duplicar n de 8,000→16,000 aproximadamente cuadruplica el tiempo de ejecución (~4.2x), la firma característica de O(n²) en lugar del O(n) esperado (~2x). Esto se reprodujo de forma independiente con un comportamiento de escala idéntico para la variante de encabezado de tabla ([k0. ... .k15999], que ejercita deepRef()) y la variante de tabla en línea (t = { k0. ... .k15999 = 1 }, que ejercita setNestedKey()).

Esto también se generalizó en un entorno de fuzzing basado en propiedades (fast-check, ejecutado en Node) que comprueba automáticamente la invariante de que "duplicar el tamaño de entrada no debería más que aproximadamente duplicar el tiempo de análisis sintáctico" a través de 12 dimensiones estructurales de la gramática/compilador; este entorno vuelve a señalar de forma independiente las tres rutas de código mencionadas en cada ejecución, sin que se hayan confirmado dimensiones adicionales vulnerables tras una investigación de seguimiento. El entorno de pruebas está disponible bajo petición.

Impacto

Node.js es de un solo hilo — una llamada sincrónica a parse() que tarde varios segundos o que provoque una caída bloquea todo el bucle de eventos del proceso que la invoca, deteniendo cualquier otra solicitud u operación que dicho proceso esté gestionando, no solo la del atacante. En el extremo superior, no se trata únicamente de un bloqueo: una caída por falta de memoria no interceptada que finalice el proceso a partir de una cadena suministrada por el atacante de ~200KB supone una denegación total de servicio que no requiere autenticación — únicamente la capacidad de hacer que una aplicación que utilice esta biblioteca analice una cadena (subida de configuración, cuerpo de solicitud API, manifiesto importado o cualquiera de los casos de uso previstos de la biblioteca).

Créditos

Descubierto y reportado por SecDim Security Research secdim.com | @secdim | security@secdim.com

Qué hacer

Actualice a la versión 5.0.1 o posterior.

Mitigación sugerida

Construya el prefijo de la ruta como una cadena extendida incrementalmente a medida que el bucle recorre cada segmento (añada un segmento ya entrecomillado por iteración a una cadena en ejecución) en lugar de volver a recortar un array y unir todo el prefijo desde cero en cada iteración. Por ejemplo, en assign():

js
function assign(node) {
  var keys = node.key;
  var value = node.value;
  var off = node.offset;
  if (!Array.isArray(keys)) keys = [keys];
  var reduced = reduceValueNode(value);

  var target = context;
  var pathStr = pathKey(currentPath); // computed once, not per segment
  for (var i = 0; i < keys.length - 1; i++) {
    var k = keys[i];
    var quotedK = quoteDottedString(k);
    var intermediatePath = pathStr ? pathStr + "." + quotedK : quotedK; // O(new segment), not O(i)
    pathStr = intermediatePath;
    // ...same conditional logic as today, using intermediatePath
    target = target[k];
  }
  // ...
}

El mismo tratamiento se aplica a deepRef() y setNestedKey(). Como medida de defensa en profundidad, considere también limitar el recuento total de segmentos de clave o el tamaño general de entrada, del mismo modo que maxDepth ya limita el anidamiento.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Paquete de npm toml < 5.0.1 5.0.1

Referencias

Puntuación CVSS -
Vector CVSS
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Debilidad (CWE)
CWE-407
Plataforma
npm
Paquete
toml
Publicada
22.10.2026
Actualizado
26.10.2026 10:00

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

OSV / GitHub Advisory Database - GHSA-9j65-hcg3-gc64 - CC BY 4.0

Historial de vulnerabilidades: toml

Todas las vulnerabilidades publicadas de este paquete (Paquete de npm), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.

Entradas en total
6
Primera → última
09.2026 10.2026
Sin corrección
0
Explotada en ataques
0

Distribución por gravedad

  • Alta 6

Divulgaciones por año

  1. 2026: 6
  1. toml-node: DoS de complejidad cuadrática mediante claves con puntos o rutas de tablas largas en toml.parse() esta entrada
    Alta CVE-2026-114143 < 5.0.1 5.0.1
  2. Alta · 7.5 CVE-2026-77465 < 4.2.0 4.2.0

Identifica las vulnerabilidades de tu aplicación

Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.