CVE-2026-63376: 
JavaScript Analyse et atténuation des vulnérabilités

CVE-2026-63376 is a prototype pollution vulnerability in toml-node (npm package toml) by BinaryMuse, a TOML parser for Node.js and the browser. The flaw allows an unauthenticated attacker to inject arbitrary properties into Object.prototype by supplying a crafted TOML document to toml.parse(), corrupting the JavaScript prototype chain for the entire Node.js process. All versions prior to 4.1.2 are affected; the issue was first published on July 1, 2026, and added to the GitHub Advisory Database on September 3, 2026. It carries a CVSS v3.1 base score of 8.2 (High) (Github Advisory).

The root cause is CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes — Prototype Pollution) arising from two compounding defects in lib/compiler.js (Github Advisory):

1. Unrestricted prototype traversal: The deepRef function resolves table paths by executing ctx = ctx[key] for every key segment without checking for reserved keys such as __proto__. When traversal reaches a scalar value (e.g., the number 1 at a.b.y), subsequent __proto__ segments walk through Number.prototype and then Object.prototype, bypassing the null-prototype hardening applied only to compiler-created container tables.
2. Duplicate-key guard desynchronization: currentPath is inconsistently typed — stored as an array by setPath but as a string by addTableArray. When assign builds a value's full path, JavaScript coerces the array to a comma-joined string (e.g., "a,b.y"), while deepRef checks a dot-joined path ("a.b.y"). The valueAssignments set lookup therefore misses, and the guard that should reject traversal through an existing scalar never fires.

A second attack route uses a table-array prefix ([[a]]) to trigger addTableArray's prefix-clearing loop, which wipes guard state before the __proto__ descent. No authentication or special privileges are required; the attacker only needs to supply a TOML string that the application passes to toml.parse() (Github Advisory, Fix Commit).

Successful exploitation corrupts Object.prototype for the entire Node.js process — not just the parsed result object — making injected properties visible on every plain object created thereafter. Depending on application-specific gadgets, this can lead to denial of service (corrupting runtime-relied-upon properties), logic and authorization bypass (overriding boolean flags or access-control checks read from plain objects), and potentially remote code execution when a suitable sink exists. The toml package reports approximately 14.8 million weekly downloads and ~1,340 direct dependents, meaning applications using front-matter or configuration loaders that delegate to toml are also transitively exposed (Github Advisory).

No public proof-of-concept exploit code has been observed, and there is no evidence of in-the-wild exploitation at this time (Github Advisory). The EPSS score is 0.0, reflecting low current exploitation probability. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. However, the attack requires no authentication, no user interaction, and low complexity — any application that accepts attacker-influenced TOML input (e.g., uploaded configuration files, project manifests, multi-tenant settings) is at risk. The vulnerability was credited to Duy Bui / @calif.io (Github Advisory).

1. Identify a target: Find a Node.js application that uses the toml npm package (versions < 4.1.2) and accepts attacker-controlled TOML input — such as an uploaded configuration file, project manifest, or API endpoint that parses TOML.
2. Craft a malicious TOML payload (comma-desynchronization route): Construct a TOML document that first defines a scalar value at a nested path, then references that path extended with .__proto__.__proto__ to reach Object.prototype:

[a.b]
y = 1
[a.b.y.__proto__.__proto__]
polluted = "yes"

3. Craft an alternative payload (prefix-clear route): Use a table-array header to wipe guard state, then descend through __proto__:

aa = 1
[[a]]
[aa.__proto__.__proto__]
polluted = "yes"

4. Submit the payload: Deliver the crafted TOML string to the application through the identified input vector (file upload, API call, form field, etc.).
5. Verify prototype pollution: After parsing, any newly created plain object in the process will inherit the injected property (e.g., ({}).polluted === "yes"), confirming Object.prototype was modified.
6. Leverage application gadgets: Identify code paths in the application that read properties from plain objects for authorization checks, feature flags, or code execution sinks, and craft injected property names/values to bypass controls or trigger code execution (Github Advisory).

• Logs: Application logs showing TOML parse errors or unexpected behavior immediately after processing user-supplied TOML input; Node.js process crashes or unhandled exceptions referencing prototype-related property access.
• File System: Presence of TOML files in upload directories or temp folders containing __proto__ key segments (e.g., strings matching __proto__.__proto__ in TOML content).
• Process Behavior: Unexpected changes in application authorization decisions, feature flag evaluations, or configuration values that affect all requests after a specific TOML parse event; Node.js process exhibiting anomalous behavior (unexpected command execution, outbound connections) consistent with gadget-chain exploitation.
• Network: Unusual outbound connections from the Node.js application process following ingestion of user-supplied TOML data, which may indicate successful RCE via a gadget chain (Github Advisory).

Primary remediation: Upgrade the toml npm package to version 4.1.2 or later, which fixes both the prototype traversal defect and the path-format desynchronization in lib/compiler.js (Fix Commit, Github Advisory).

Workarounds (if immediate upgrade is not possible):

• Validate or sanitize TOML input before parsing to reject strings containing __proto__, constructor, or prototype key segments.
• Run the TOML parser in a sandboxed environment (e.g., a separate worker process or VM context) to limit the blast radius of prototype pollution.
• Audit indirect dependencies (e.g., front-matter, configuration loaders) that may use toml as an engine and apply the same upgrade.