Skip to main content

deepmerge EUVDEUVD-2026-83258

| CVE-2026-93753 HIGH
Improperly Controlled Modification of Object Prototype Attributes (Prototype Pollution) (CWE-1321)
2026-09-18 VulnCheck GHSA-gcqx-w48m-w2h4
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify endpoint merging untrusted JSON
  2. Delivery
    Submit source object with __proto__ key
  3. Exploit
    mergeObject writes to prototype unvalidated
  4. Execution
    Object.prototype polluted globally
  5. Persist
    App reads inherited property without own-check
  6. Impact
    Logic corruption, DoS, or gadget-driven code execution

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 the consuming application to pass attacker-controlled source objects into deepmerge's merge operation (e.g. merging untrusted JSON request bodies or config into a target), AND to later access object properties without own-property (hasOwnProperty) checks so the polluted prototype value is inherited and used. The flaw is in mergeObject() which fails to filter dangerous keys such as '__proto__'/'constructor'/'prototype'. Limiting factors: this is a library primitive with no standalone exploit - apps that validate/sanitize input, use Object.create(null) targets, or always use own-property checks are not impacted. Affects deepmerge through 4.3.1.

Impact

The vendor CVSS 4.0 score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VI:H) rates this as high-severity, driven entirely by an integrity impact (VC:N/VA:N - no confidentiality or availability effect), which is consistent with CWE-1321 prototype pollution. However, the raw vector overstates real-world risk: prototype poisoning in a merge library is a library-level primitive, not a directly triggerable end-to-end exploit. Actual impact is fully GATED on the consuming application (1) passing attacker-controlled objects into deepmerge and (2) later reading properties without own-property checks (the description itself states this dependency). That makes AC:L/AT:N optimistic - a realistic assessment is AC:H / AT:P. No EPSS score, no CISA KEV listing, and no explicit public exploit code were provided in the input (reported by VulnCheck via GitHub issue #273); exploitation status is therefore 'no public exploit identified at time of analysis.' The severity is thus better read as a widely-reachable-but-conditional weakness rather than a confirmed high-priority remote exploit. Impact when the gadget chain exists ranges from logic corruption/DoS to potential RCE, but the base VI:H is only realized in vulnerable app patterns.

Exploit ScenarioDerived

An application uses deepmerge (≤4.3.1) to merge user-submitted JSON (e.g. config, profile, or API request bodies) into a defaults object. An attacker submits a payload containing a '__proto__' or 'constructor.prototype' key, which mergeObject() writes without key validation, polluting Object.prototype so all objects inherit an attacker-controlled property; the app then behaves unexpectedly when reading that property without a hasOwnProperty check. No public PoC was included in the input, though the VulnCheck advisory and GitHub issue #273 document the flaw.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 18, 2026

Prototype pollution in the deepmerge JavaScript library (all versions through 4.3.1) allows an attacker who controls a source object passed into a merge operation to inject properties such as '__proto__', 'constructor', or 'prototype' into the resulting object's prototype chain. The impact is latency-dependent: applications that merge untrusted data (for example, a JSON request body) and then read properties without own-property checks will silently inherit attacker-chosen values, which can corrupt application logic, bypass authorization checks, or influence downstream behaviour. The flaw is a library primitive rather than a standalone exploit, and no public exploit code was identified at time of analysis; the vendor CVSS 4.0 score of 8.7 reflects integrity impact only (VC:N/VA:N), and an independent assessment rates it considerably lower (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) because exploitation requires the consuming application to both pass attacker-controlled source objects and perform unchecked inherited-property reads.

RemediationAI

No vendor-released patch version is identified in the available data at time of analysis, so remediation must begin with dependency triage: inventory every path to deepmerge (npm ls deepmerge) and, where possible, replace the merge call with a maintained alternative or an in-house merge that skips dangerous keys. Track the upstream issue at https://github.com/TehShrike/deepmerge/issues/273 and the project page https://github.com/TehShrike/deepmerge for a fixed release, and upgrade as soon as a patched version above 4.3.1 is published; note that 'code injection' and 'prototype pollution' tags apply, so patched versions should be verified by re-running a prototype-pollution test case ('__proto__', 'constructor', 'prototype' keys) before closing the finding. Until then, the most effective control is input sanitisation on the merge boundary: recursively strip or reject '__proto__', 'constructor' and 'prototype' keys from any source object before merging (JSON.parse with a reviver, or a schema validator such as JSON Schema/Ajv with additionalProperties restrictions), with the trade-off that a denylist must be applied at every nesting level and can be bypassed by unusual key encodings if implemented carelessly. A stronger structural control is to merge into a null-prototype object (Object.create(null)) or a Map, which removes Object.prototype from the lookup chain entirely - the trade-off is that null-prototype objects break code and third-party libraries that rely on inherited methods such as hasOwnProperty or toString, so those call sites must be audited first. Consuming code should also adopt defensive reads (Object.prototype.hasOwnProperty.call(obj, key) or the 'in' operator with explicit own-checks) so a polluted prototype cannot supply a value the application then trusts, and any authorisation, defaults, or feature-flag lookups performed on merged objects should be reviewed for inherited-value reliance. The reporter's advisory at https://www.vulncheck.com/advisories/deepmerge-through-4.3.1-prototype-poisoning-via-mergeobject should be used to confirm scope before concluding a deployment is unaffected.

Affected VersionsENISA

deepmerge 0 ≤4.3.1

Affected Packages

euvd deepmerge no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

deepmerge is a widely used JavaScript utility that recursively merges plain objects; the defect is in its mergeObject() routine (see index.js, around lines 39-60 in the referenced commit), which iterates over source keys and assigns them to the target without filtering keys that are meaningful to JavaScript's prototype machinery. This is CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes, i.e. prototype pollution). Because JavaScript resolves property reads through the prototype chain, a key such as '__proto__' can walk up and mutate Object.prototype (or an intermediate prototype) so that subsequently created or read objects inherit the injected value; 'constructor'/'prototype' chains can achieve the same effect. The root cause is the absence of an own-property/denylist check on keys before assignment, combined with the fact that the merge writes into ordinary object literals that carry Object.prototype. The vulnerability is not memory-safety related and produces no confidentiality or availability loss in the assessed model - the CPE cpe:2.3:a:tehshrike:deepmerge:*:*:*:*:*:*:*:* covers the whole product line, with the issue report describing versions through 4.3.1. It is classified by the reporter under tags including Code Injection and Prototype Pollution; the practical severity therefore depends entirely on how the host application uses the merged object and whether it guards reads with hasOwnProperty.

Know when Deepmerge 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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
vuln.today AI 3.7 LOW

Network-reachable and unauthenticated, but AC:H because impact requires the app to forward untrusted input to merge and read polluted props without own-checks; integrity-only, base I:L (can escalate).

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

deepmerge through 4.3.1 contains a prototype poisoning vulnerability in the mergeObject() function that fails to properly validate keys being written to target objects. Attackers can supply malicious source objects in merge operations to inject attacker-controlled properties into the returned object's prototype, causing applications to inherit unintended values when accessing properties without own-property checks.

Executive ViewAI

Why It Matters

The deepmerge JavaScript library, used in many Node.js applications for object merging, contains a high-severity vulnerability (CVE-2026-93753) affecting all versions through 4.3.1. This flaw could allow attackers to manipulate application logic and bypass authorization checks in systems that merge untrusted input, posing a risk to data integrity and access controls. No public exploit has been identified, and no vendor-released patch identified at time of analysis, leaving organizations reliant on interim mitigations.

Business Impact: High
Compensating Controls

Sanitize input to strip keys such as '__proto__', 'constructor', and 'prototype' before merging; use Object.create(null) as the target object for merge operations; avoid merging untrusted data with deepmerge; implement own-property checks when accessing properties of merged objects; and monitor vendor advisories for a patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
High
deepmerge is an extremely popular npm utility, a common transitive dependency in JS apps
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 12 Not-Affected
SUSE Linux Enterprise Micro 5.3 Affected
SUSE Linux Enterprise Micro 5.4 Affected
SUSE Linux Enterprise Micro 5.5 Not-Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy