toml-node: DoS mit quadratischer Komplexität über lange punktierte Schlüssel oder Tabellenpfade in toml.parse()
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), RepositoryBinaryMuse/toml-node - Funktionen:
assign(),deepRef(),setNestedKey()inlib/compiler.js - Bestätigt im geprüften Checkout bei Commit
1b2ac40(2026-07-16), einen Commit nach dem Tagv5.0.0(eine reine Changelog-Änderung) — d. h. vorhanden inv5.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 inv5.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 wiea.b.c = 1erreicht.deepRef()(Zeilen 247-281, die Senke in Zeile 252): dasselbe Muster überpathKey(keys.slice(0, i + 1))— wird von Tabellen-Headern[a.b.c]und Arrays von Tabellen[[a.b.c]]übersetPath()/addTableArray()erreicht.setNestedKey()(Zeilen 184-202, die Senke in Zeile 187): dasselbe Muster — wird von punktierten Schlüsseln in Inline-Tabellen wiet = { 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
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():
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.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| npm-Paket | toml | < 5.0.1 | 5.0.1 |
Verweise
- https://github.com/BinaryMuse/toml-node/security/advisories/GHSA-9j65-hcg3-gc64
- https://nvd.nist.gov/vuln/detail/CVE-2026-114143
- https://github.com/BinaryMuse/toml-node/commit/609c873fffea0a27ebe5b4dd098eed2b3daf3606
- https://github.com/BinaryMuse/toml-node
- https://github.com/BinaryMuse/toml-node/releases/tag/v5.0.1
- 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
- 2026: 6
-
toml-node: DoS mit quadratischer Komplexität über lange punktierte Schlüssel oder Tabellenpfade in toml.parse() dieser Eintrag
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.