Hoch

toml-node: DoS mit quadratischer Komplexität über lange punktierte Schlüssel oder Tabellenpfade in toml.parse()

  • Veröffentlicht: 22.10.2026
  • Aktualisiert: 26.10.2026 10:00

Zusammenfassung

toml.parse() ist anfällig für einen Denial-of-Service mit quadratischer Komplexität (O(n²)) über einen einzelnen langen punktierten Schlüssel, Tabellen-Header oder Inline-Tabellen-Schlüssel. Ein manipuliertes Dokument von rund ~100KB führt zu einem mehrsekündigen synchronen Stillstand; ein Dokument von rund ~200KB bringt den Node.js-Prozess direkt mit einem nicht abfangbaren Out-of-Memory-Fehler zum Absturz. Dies ist ein separater, ungepatchter Codepfad, der unabhängig von dem zuvor behobenen Stack-Overflow-DoS (GHSA-82x6-q7mm-w9cf) existiert — er erfordert keinerlei Array-/Inline-Tabellen-Verschachtelung und wird nachweislich nicht von der Option maxDepth beeinflusst, die das frühere Problem behoben hat.

Betroffene Komponente / Version

  • Paket: toml (npm), Repository BinaryMuse/toml-node
  • Funktionen: assign(), deepRef(), setNestedKey() in lib/compiler.js
  • Bestätigt im geprüften Checkout bei Commit 1b2ac40 (2026-07-16), einen Commit nach dem Tag v5.0.0 (eine reine Changelog-Änderung) — d. h. vorhanden in v5.0.0, der neuesten Version. Nicht erschöpfend gegen jedes frühere Release überprüft, aber die betroffenen Funktionen stehen nicht im Zusammenhang mit den BigInt/Temporal-Änderungen in v5.0.0 (gemäß CHANGELOG.md), weshalb die Schwachstelle wahrscheinlich auch vor dieser Version existierte.

Details

toml.parse(input, options) (index.js:5-9) leitet den vom Aufrufer übergebenen String ohne Längen- oder Strukturvalidierung an parser.parse() und danach compiler.compile() weiter. Innerhalb von lib/compiler.js durchlaufen drei separate Funktionen jeweils die Segmente eines punktierten Schlüssels in einer for-Schleife und berechnen bei jeder Iteration den vollständigen Pfad-Präfix-String von Grund auf neu:

  • assign() (Zeilen 69-107, die Senke in Zeile 81): var intermediatePath = makeFullPath(keys.slice(0, i + 1)); — wird bei Zuweisungen von punktierten Schlüsseln auf oberster Ebene wie a.b.c = 1 erreicht.
  • deepRef() (Zeilen 247-281, die Senke in Zeile 252): dasselbe Muster über pathKey(keys.slice(0, i + 1)) — wird von Tabellen-Headern [a.b.c] und Arrays von Tabellen [[a.b.c]] über setPath()/addTableArray() erreicht.
  • setNestedKey() (Zeilen 184-202, die Senke in Zeile 187): dasselbe Muster — wird von punktierten Schlüsseln in Inline-Tabellen wie t = { a.b.c = 1 } erreicht.

keys.slice(0, i + 1) reserviert ein neues Array der Länge i; pathKey()/makeFullPath() (Zeilen 311-317) führt dann .map(quoteDottedString).join(".") aus, ebenfalls O(i). Da dies für jedes der n Segmente eines punktierten Schlüssels geschieht, beträgt der Gesamtaufwand O(1 + 2 + ... + n) = O(n²), nicht O(n). Der String wird auf dem regulären Pfad bedingungslos berechnet (und wird nur jemals verwendet, wenn kurz vor dem Auslösen eines Fehlers gestanden wird), sodass kein vorzeitiger Abbruch existiert, der dies in der Praxis kostengünstig machen würde.

Es existiert keinerlei Beschränkung für die Anzahl der Segmente punktierter Schlüssel: dot_ended_table_key_part+ und inline_dot_key_part+ in src/toml.pegjs (Zeilen 122, 311) sind unbegrenzte +-Wiederholungen, die iterativ und nicht über die Grammatikregel value geparst werden — daher greift die bestehende Verschachtelungssperre MAX_DEPTH/maxDepth (src/toml.pegjs:141-151, durchgesetzt im generierten lib/parser.js:1022) überhaupt nicht für die Schlüssellänge. Dies wurde direkt verifiziert: Das Setzen von options.maxDepth: 1 (der strengste mögliche Wert) bei einem Schlüssel mit 16,000 Segmenten zeigte keinen messbaren Zeitunterschied zum unbeschränkten Fall.

Proof of Concept

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));

Gemessene Zeiten (Node v22, direkte Ausführung gegen dieses Repository):

n (Segmente) Eingabegröße Zeit
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 Prozessabsturz (OOM)

Das Verdoppeln von n von 8,000→16,000 vervierfacht die Laufzeit näherungsweise (~4.2x), was charakteristisch für O(n²) anstelle des erwarteten O(n) (~2x) ist. Dies wurde unabhängig mit identischem Skalierungsverhalten für die Tabellen-Header-Variante ([k0. ... .k15999], nutzt deepRef()) und die Inline-Tabellen-Variante (t = { k0. ... .k15999 = 1 }, nutzt setNestedKey()) reproduziert.

Dies wurde zudem in eine eigenschaftsbasierte Fuzzing-Umgebung (fast-check, ausgeführt unter Node) verallgemeinert, die die Invariante "eine Verdopplung der Eingabegröße sollte die Parse-Zeit nicht mehr als grob verdoppeln" über 12 strukturelle Dimensionen der Grammatik/des Compilers hinweg automatisiert testet; sie markiert bei jedem Durchlauf unabhängig alle drei oben genannten Codepfade neu, wobei nach Folgeuntersuchungen keine weiteren Dimensionen als anfällig bestätigt wurden. Das Fuzzing-Harness ist auf Anfrage erhältlich.

Auswirkungen

Node.js ist Single-Threaded — ein synchroner, mehrsekündiger bis zum Absturz führender Aufruf von parse() blockiert die gesamte Ereignisschleife des aufrufenden Prozesses und verzögert jede andere Anfrage/Operation, die dieser Prozess verarbeitet, nicht nur die des Angreifers. Im Extremfall handelt es sich nicht nur um ein Hängenbleiben: Ein nicht abgefangener, prozessbeendender Out-of-Memory-Absturz durch eine vom Angreifer bereitgestellte Zeichenkette von ca. ~200KB ist ein vollständiger Denial-of-Service, der keine Authentifizierung erfordert — lediglich die Möglichkeit, eine Zeichenkette durch eine Anwendung parsen zu lassen, die diese Bibliothek nutzt (Konfigurations-Uploads, API-Request-Bodys, importierte Manifeste oder beliebige vorgesehene Einsatzzwecke dieser Bibliothek).

Danksagung

Entdeckt und gemeldet von SecDim Security Research secdim.com | @secdim | security@secdim.com

Was zu tun ist

Auf Version 5.0.1 oder höher aktualisieren.

Vorgeschlagene Fehlerbehebung

Bauen Sie das Pfadpräfix schrittweise als fortlaufend erweiterten String auf, während die Schleife jedes Segment durchläuft (fügen Sie pro Iteration ein bereits in Anführungszeichen gesetztes Segment an einen bestehenden String an), anstatt bei jeder Iteration ein Array neu aufzuteilen und das gesamte Präfix von Grund auf neu zusammenzusetzen. Zum Beispiel in 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];
  }
  // ...
}

Die identische Vorgehensweise gilt für deepRef() und setNestedKey(). Als Defense-in-Depth-Maßnahme sollte zusätzlich erwogen werden, die Gesamtanzahl der Schlüsselsegmente oder die Gesamteingabegröße zu begrenzen, so wie maxDepth bereits die Verschachtelung begrenzt.

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
npm-Paket toml < 5.0.1 5.0.1

Verweise

CVSS-Wert -
CVSS-Vektor
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
Schwäche (CWE)
CWE-407
Plattform
npm
Paket
toml
Veröffentlicht
22.10.2026
Aktualisiert
26.10.2026 10:00

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

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

Schwachstellenhistorie: toml

Alle veröffentlichten Schwachstellen dieses Pakets (npm-Paket), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Einträge insgesamt
6
Erste → letzte
09.2026 10.2026
Ohne Fix
0
In Angriffen ausgenutzt
0

Verteilung nach Schweregrad

  • Hoch 6

Veröffentlichungen pro Jahr

  1. 2026: 6
  1. toml-node: DoS mit quadratischer Komplexität über lange punktierte Schlüssel oder Tabellenpfade in toml.parse() dieser Eintrag
    Hoch CVE-2026-114143 < 5.0.1 5.0.1
  2. Hoch · 7.5 CVE-2026-77465 < 4.2.0 4.2.0

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.