Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted JSON with __proto__ key
-
DeliveryApplication passes input to defaultsDeep() without sanitization
-
ExploitdefaultsDeep() writes to Object.prototype
-
ExecutionAll process objects inherit injected properties
-
ImpactLogic bypass or denial of service achieved
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V3 - Web Frontend Security Prototype pollution prevention
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the consuming application passes untrusted, user-controlled input to the defaultsDeep() function without prior key sanitization. If the application accepts structured input (e.g., JSON API bodies, query parameters parsed as objects) and feeds it to defaultsDeep() - a common pattern for configuration merging or default-value injection - then remote unauthenticated exploitation is possible (per CVSS PR:N). Exploitation is limited to Node.js applications that (1) import @phun-ky/defaults-deep versions below 2.0.5 and (2) expose an integration path between external input and the defaultsDeep() call. Applications that only pass internal, developer-controlled objects to defaultsDeep() are not exploitable. The vulnerability does not affect browser environments in isolation - it targets server-side Node.js process memory. |
| Impact | The CVSS 3.1 score of 7.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L) reflects worst-case conditions: a public-facing endpoint that passes raw user input to defaultsDeep() with no prior sanitization, requiring zero authentication or interaction. In practice, real-world risk is substantially conditional - exploitation requires an application integration path where untrusted data reaches the function, which is a non-trivial deployment assumption for a utility library. No EPSS score was provided in the input data, limiting probabilistic exploitation assessment. No CISA KEV listing and no confirmed public POC exist, meaning this is currently theoretical-to-low real-world risk for most deployments. The impact triad (C:L/I:L/A:L) reflects that prototype pollution is rarely a direct RCE primitive but can enable logic bypasses, property injection into framework internals, or denial of service depending on downstream code patterns. For applications that directly proxy API request bodies into defaultsDeep(), the risk elevation is real and immediate. |
| Exploit ScenarioDerived | An attacker sends a POST request to an application endpoint that accepts JSON, embedding a payload such as {"__proto__": {"isAdmin": true}} or {"constructor": {"prototype": {"polluted": "yes"}}}. If the application passes this body directly to defaultsDeep(), Object.prototype is modified in the running Node.js process, causing every subsequent object property lookup for isAdmin or polluted to return the attacker-injected value, potentially bypassing authorization checks or triggering unexpected application behavior. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 31, 2026
Prototype pollution in @phun-ky/defaults-deep prior to version 2.0.5 allows remote unauthenticated attackers to write arbitrary properties to Object.prototype by supplying crafted objects containing keys such as __proto__, constructor, or prototype to the defaultsDeep() function. The root cause is that the library performed recursive object merging without filtering these special property names, enabling full process-wide prototype chain manipulation. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack class is well-understood and exploitation is straightforward wherever untrusted input reaches the affected function.
RemediationAI
Upgrade @phun-ky/defaults-deep to version 2.0.5 or later, which is the vendor-confirmed fixed release available at https://github.com/phun-ky/defaults-deep/releases/tag/2.0.5 and patched via commit 807dba930f8718f9126cad59d949b8fd3539b059. For teams unable to upgrade immediately, the vendor-recommended workaround is to sanitize all untrusted input before passing it to defaultsDeep() by recursively removing or rejecting object keys named __proto__, constructor, and prototype at every nesting level. Note that this workaround is operationally fragile - incomplete traversal depth or missed input vectors will leave the application exposed - so patching to 2.0.5 is strongly preferred. No additional compensating controls (WAF rules, network restrictions) are effective against this vulnerability class since it is a library-level API contract issue, not a network protocol flaw.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes) describes the root cause: the defaultsDeep() function in @phun-ky/defaults-deep (npm package, CPE pkg:npm/@phun-ky_defaults-deep) recursively traverses and merges source objects into a target without sanitizing property names at any depth level. JavaScript's prototype chain means that assigning to target['__proto__']['x'] = value writes to Object.prototype, making the property 'x' visible on every subsequently created plain object in the same V8 process. The same effect can be achieved via the 'constructor' and 'prototype' keys. This pattern is a known class of vulnerabilities in deep-merge utility libraries (e.g., the historical lodash, merge, and jQuery incidents), and the fix - confirmed in the PR diff at commit 807dba9 - adds an explicit blocklist guard for these three key names during recursive traversal.
Know when Prototype Pollution gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L
Network vector and no privileges required reflect worst-case API exposure; limited C/I/A impact consistent with prototype pollution's indirect, application-dependent consequences.
Primary rating from Vendor (https://github.com/phun-ky/defaults-deep).
CVSS VectorVendor: https://github.com/phun-ky/defaults-deep
DescriptionCVE.org
Impact
A prototype pollution vulnerability exists in @phun-ky/defaults-deep prior to version 2.0.5.
The library recursively merged user-supplied objects without filtering unsafe property names such as __proto__, constructor, and prototype. An attacker able to supply crafted input could cause properties to be written to Object.prototype, resulting in prototype pollution affecting all objects within the running process.
Applications that pass untrusted input to defaultsDeep() may be impacted. Depending on how the application uses merged objects, this could lead to unexpected behavior, logic bypasses, denial of service, or other security issues.
Patches
This issue has been fixed in version 2.0.5.
Users should upgrade to version 2.0.5 or later.
The fix prevents unsafe prototype-related keys (__proto__, constructor, and prototype) from being processed during recursive merge operations and includes regression tests covering known prototype pollution vectors.
Workarounds
Users unable to upgrade should ensure that untrusted input is sanitized before being passed to defaultsDeep().
At a minimum, applications should reject or remove the following property names from all levels of user-controlled objects:
__proto__constructorprototype
Upgrading to a patched version remains the recommended mitigation.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
Applications using @phun-ky/defaults-deep are at risk from prototype pollution attacks that could compromise process integrity and enable unauthorized code execution through untrusted input. Patches are available and remediation requires immediate inventory and deployment planning across all affected systems.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Prototype Pollution
View allPrototype pollution in Adobe Acrobat Reader versions 24.001.30356, 26.001.21367 and earlier enables arbitrary code execu
All versions of package dojo are vulnerable to Prototype Pollution via the setObject function. Rated critical severity (
Prototype pollution in the farinspace Partners WordPress plugin (versions up to and including 0.2.0) enables remote unau
The package handlebars before 4.7.7 are vulnerable to Prototype Pollution when selecting certain compiling options to co
This affects the package ini before 1.3.6. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitabl
Prototype pollution vulnerability in 'deephas' versions 1.0.0 through 1.0.5 allows attacker to cause a denial of service
A Prototype Pollution issue in Cronvel Tree-kit v.0.7.4 and before allows a remote attacker to execute arbitrary code vi
A Prototype Pollution issue in Aliconnect /sdk v.0.0.6 allows an attacker to execute arbitrary code via the aim function
All versions of the package safe-eval are vulnerable to Prototype Pollution via the safeEval function, due to improper s
This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr
Prototype Pollution in chargeover redoc v2.0.9-rc.69 allows attackers to execute arbitrary code or cause a Denial of Ser
alizeait unflatto <= 1.0.2 was discovered to contain a prototype pollution via the method exports.unflatto at /dist/inde
EUVD-2026-51592
GHSA-mj3g-7xcc-x4vh
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB