CVE-2026-72749 in n8n
Summary
by MITRE • 08/11/2026
n8n before 1.123.67, 2.31.5, and 2.32.1 contains a prototype pollution vulnerability in the Edit Fields (Set) node. The node assigns output fields via a dot-notation path setter without restricting the field name, allowing an authenticated user to name a field after an inherited built-in method path and corrupt a shared global in the main Node.js process. Because that global is used on the request-authentication path, the instance then fails every authenticated request, causing an instance-wide denial of service for all users until the process is restarted.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 08/11/2026
The vulnerability under discussion represents a critical prototype pollution flaw affecting n8n versions prior to 1.123.67, 2.31.5, and 2.32.1 within the Edit Fields (Set) node functionality. This issue stems from inadequate input validation mechanisms that permit authenticated users to manipulate field names through dot-notation path setters without proper sanitization. The fundamental technical flaw occurs when user-provided data is directly assigned to object properties using unsafe assignment patterns, allowing malicious actors to target inherited built-in methods of JavaScript's Object prototype. When an attacker crafts a field name that corresponds to a method like constructor or _proto_, the vulnerability enables pollution of the global prototype chain, which subsequently affects all objects sharing that prototype.
The operational impact of this vulnerability extends beyond simple data corruption into full system denial of service scenarios. The affected node operates within the core Node.js process where authentication mechanisms rely on shared global state, making this attack vector particularly dangerous. Once the prototype pollution occurs, every authenticated request processed by the system fails because the polluted global objects become unusable in the authentication path. This creates a cascading failure that affects all users simultaneously, rendering the entire n8n instance inaccessible until manual process restart is performed. The vulnerability essentially compromises the fundamental integrity of the application's runtime environment and authentication infrastructure.
From a cybersecurity perspective, this vulnerability aligns with CWE-471, which categorizes prototype pollution as a form of indirect injection attack where attackers manipulate object prototypes to affect program behavior. The ATT&CK framework would classify this under T1211 - Exploitation for Privilege Escalation and T1499.004 - Endpoint Denial of Service, as it enables authenticated users to cause system-wide service disruption. The attack requires only basic authentication privileges within the n8n environment, making it particularly dangerous in multi-user scenarios where privilege separation is inadequate. Organizations should implement immediate mitigations including patching to supported versions, implementing strict input validation for field names, and potentially introducing additional sandboxing mechanisms around the Edit Fields node functionality to prevent prototype manipulation attacks from affecting core system processes.
The technical exploitation chain demonstrates how seemingly benign configuration options can become dangerous when combined with insufficient input sanitization. The vulnerability exploits Node.js's prototype inheritance model where all objects inherit methods from their constructor's prototype property, making it possible for attackers to pollute these shared properties. This type of vulnerability is particularly challenging to detect during routine security assessments because the malicious behavior may not manifest immediately but rather causes subtle failures that appear unrelated to the initial attack vector. System administrators should monitor for unusual authentication failures and process restarts as potential indicators of exploitation attempts, while also implementing network-level monitoring to detect suspicious field name patterns in API requests.