Description

toml-node is a TOML parser for Node.js and the browser. Prior to 4.1.2, toml.parse() in lib/compiler.js can be tricked by a table path such as a.b.y.__proto__.__proto__, allowing traversal from a scalar value into Number.prototype and Object.prototype. The currentPath tracking value uses both arrays and strings, so valueAssignments records a comma-joined path such as a,b.y while deepRef checks the dot-joined path a.b.y, allowing the duplicate-key guard to miss and attacker-controlled keys to be written to Object.prototype. A table-array prefix-clearing path in addTableArray can also erase guard state before the same __proto__ traversal. Injected properties become visible throughout the Node.js process and can cause denial of service, logic or authorization bypass, or code execution when an application contains a suitable gadget. This issue is fixed in version 4.1.2.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.2",
  "pubDate": "2026-09-03T21:17:21.513Z",
  "pubdate": "2026-09-03T21:17:21.513Z",
  "executiveSummary": "A prototype pollution vulnerability exists in the toml-node library prior to version 4.1.2. The vulnerability resides in lib/compiler.js, specifically within the logic handling table paths during TOML parsing.\nBy crafting a malicious TOML input containing specific table paths—such as 'a.b.y.__proto__.__proto__'—an attacker can bypass duplicate-key guards and inject arbitrary properties into the global Object.prototype or Number.prototype.\nThis vulnerability allows an attacker to manipulate the underlying JavaScript environment, potentially leading to denial of service, logic bypasses, authorization circumvention, or remote code execution if the application contains compatible gadget chains.\nThe flaw stems from a discrepancy between how the library tracks current paths (comma-joined) versus how it performs deep reference lookups (dot-joined), allowing the collision detection mechanism to fail. Additionally, the addTableArray function can prematurely clear guard state, facilitating the traversal.\nThe vulnerability affects all Node.js and browser-based implementations using toml-node versions prior to 4.1.2. Given that prototype pollution impacts the entire process lifetime, this represents a critical risk to application integrity.",
  "technicalDetails": "The vulnerability is primarily located in lib/compiler.js within the toml-node library. The root cause is a synchronization failure in the internal path-tracking mechanism used to prevent illegal property assignment.\nThe library tracks the current assignment path using both array-based structures and comma-joined strings, while performing deep reference validation (deepRef) using dot-joined paths. This inconsistency creates a scenario where an attacker-supplied path, formatted as 'a.b.y.__proto__.__proto__', bypasses the duplicate-key guard. Because the validation logic and the assignment logic interpret the path representation differently, the library fails to identify that the input is attempting to traverse into sensitive internal prototypes.\nThe exploitation flow begins by submitting a specially crafted TOML document. When the parser reaches the malicious key sequence, it fails to correctly resolve the object structure, resulting in the object reference escaping the intended scope. By accessing the __proto__ property, the attacker gains the ability to inject properties into the base Object.prototype.\nFurthermore, the addTableArray function contributes to the vulnerability by clearing the state of the guard mechanism too early in the parsing cycle. This creates a window of opportunity where subsequent property assignments can overwrite or add fields to the global prototype without triggering the standard security assertions.\nOnce the prototype is polluted, the injected properties are globally visible across the entire Node.js process. This persistent state modification can be leveraged to alter the behavior of existing objects or built-in methods. In a Node.js environment, this is particularly dangerous because many third-party libraries rely on the integrity of the base prototype for configuration, security decisions, or execution flow control. Successful exploitation does not require authentication or specific privilege levels, provided the attacker can influence the input parsed by the toml-node library. The resulting impact is contingent on the presence of gadget properties that, when manipulated, allow the attacker to redirect application logic, gain unauthorized access, or achieve code execution."
}