@graphql-tools/utils CVE-2026-104852
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend single crafted GraphQL query
-
DeliveryAlias fields to constructor/__proto__/prototype
-
ExploitKeys collide during cross-subgraph merge
-
ExecutionmergeDeep walks prototype chain
-
PersistOverwrite Function.prototype.call
-
ImpactGateway denial of service until restart
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 a GraphQL gateway or schema-stitching deployment built on @graphql-tools/utils <= 12.0.0 (e.g. Hive Gateway, which also required its own delegate/federation fix in PR 2600) where at least one object type is merged from two subgraphs - the normal |
| Impact | This is a genuine, actionable priority rather than a paper-high CVSS. All signals align toward real risk: the CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, VA:H) describes a remote, unauthenticated, low-complexity attack that a single GraphQL query triggers, and the GHSA advisory publishes a working trigger query, so exploitation is trivial and reproducible. The impact profile is availability-only (VC:N/VI:N/VA:H) - despite the CWE-1321 'prototype pollution' classification, the realistic outcome described is a persistent denial of service: overwriting Function.prototype.call breaks every subsequent request until the process is restarted, i.e. an unauthenticated client can take a gateway offline. The one tempering signal is the input vector's AT:P (attack requirement present), reflecting that the server must actually merge an object across two subgraphs; however, the advisory states this is the 'ordinary @shareable or entity case,' so in practice the precondition is satisfied by typical federation deployments and does not meaningfully reduce exposure. No EPSS score and no CISA KEV entry were provided; absence of KEV is expected for a freshly disclosed npm library CVE and should not be read as low risk. Note the impact is NOT confidentiality or integrity (VC/VI = N) - this is destructive availability, not code execution, which should be reflected in prioritization. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a single crafted GraphQL query to a federated gateway (e.g. Hive Gateway) in which a shared object type is resolved from two subgraphs, aliasing response fields to |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 05, 2026
Prototype pollution in @graphql-tools/utils mergeDeep() lets a remote, unauthenticated client submit a single aliased GraphQL query that overwrites inherited JavaScript built-ins such as Function.prototype.call, causing denial of service against the gateway or schema-stitching service until it is restarted. Only deployments built on @graphql-tools/utils <= 12.0.0 that actually merge objects returned from two subgraphs (the ordinary @shareable field or cross-subgraph entity case, e.g. Hive Gateway) invoke the vulnerable code path; single-subgraph servers are not affected. Both CVSS 4.0 (8.2, AV:N/AC:L/AT:P/PR:N/UI:N/VA:H) and the assessor's CVSS 3.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) agree on high availability impact with no confidentiality or integrity impact, and no public exploit code has been identified at time of analysis.
Earlier versions of this analysis (1)
Prototype pollution in the mergeDeep utility of @graphql-tools/utils (versions <= 12.0.0) lets a remote, unauthenticated client crash a federated or stitched GraphQL gateway with a single query. By aliasing response fields to constructor, __proto__ or prototype, the attacker causes colliding keys from two subgraphs to make mergeDeep recurse through inherited properties until it writes attacker-supplied data onto Function.prototype.call, corrupting the runtime so that every subsequent request fails until the process is restarted. The issue is a genuine high-severity denial of service (CVSS:3.1 AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H) reachable in the ordinary @shareable field or entity-merge case; no public exploit code was identified at time of analysis, and no confirmed active exploitation (CISA KEV) is reported, but the attack requires only a normal query and no authentication. A vendor patch is available in @graphql-tools/utils 12.0.1, with an accompanying mitigation in Hive Gateway.
RemediationAI
Upgrade @graphql-tools/utils to version 12.0.1 or later - the vendor-released fix is tagged at https://github.com/ardatan/graphql-tools/releases/tag/@graphql-tools/utils@12.0.1 via https://github.com/ardatan/graphql-tools/pull/8423 (commit 0b9529f1988fd36186a7c106a6efe0356f1b7f2e), which rejects __proto__, constructor, and prototype as source keys and uses hasOwnProperty for merge targets. Hive Gateway and other federated consumers must additionally apply https://github.com/graphql-hive/gateway/pull/2600, which strips prototype-polluting keys recursively from subgraph results in @graphql-tools/delegate and @graphql-tools/federation before merging; upgrading only the utils package in such deployments leaves the nested-key path reachable. Where an immediate upgrade is not possible, the most effective compensating control is to avoid executing the multi-subgraph merge path - run a single-subgraph, non-stitched GraphQL server, or disable @shareable/entity merging for object types supplied by more than one subgraph - at the cost of losing federation features. Deployments that cannot remove the merge path can front the gateway with a request-inspection WAF rule that rejects documents aliasing any field to constructor, __proto__, or prototype; this is brittle because aliases can be nested arbitrarily deep and the query above shows the payload does not need to be adjacent to the root. Restarting a polluted process is only a stopgap, since the attacker can re-trigger the condition with a single request.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a prototype pollution issue (CWE-1321) in the mergeDeep utility shipped as pkg:npm/@graphql-tools_utils. When a federated gateway merges results returned by two subgraphs, response object keys are used as merge targets. Because the pre-12.0.1 implementation tested key existence with the in operator rather than Object.prototype.hasOwnProperty and did not skip dangerous key names, a client-controlled key such as constructor or __proto__ - easily produced with a GraphQL field alias - caused the recursive merge to walk the prototype chain ({}.constructor → Object, Object.__proto__ → Function.prototype) and write attacker-supplied subgraph data onto Function.prototype.call or Object.prototype. GraphQL response data is normally produced by JSON.parse, which materialises __proto__ as a real own enumerable property, making the payload reachable where an object literal would not be. The pollution is process-global, so every subsequent request in that Node.js process fails until restart. The upstream fix adds a __proto__/constructor/prototype deny-list at every recursion level, switches the existence check to hasOwnProperty, and defensively strips polluting keys at every depth from subgraph results before merging.
Know when Graphql 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
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
A single unauthenticated query over the network triggers it (AV:N/AC:L/PR:N/UI:N); impact is availability-only process breakage within the same component (A:H, C/I:N, S:U).
Primary rating from Vendor (https://github.com/ardatan/graphql-tools).
CVSS VectorVendor: https://github.com/ardatan/graphql-tools
Lifecycle Timeline
2DescriptionCVE.org
Closed by https://github.com/ardatan/graphql-tools/pull/8423 Mitigated in Hive Gateway by https://github.com/graphql-hive/gateway/pull/2600
A client can alias fields to constructor, __proto__ or prototype so that the response keys from two subgraphs collide on those names during result merging. Because mergeDeep recursed through inherited properties, the merge walked {}.constructor to Object, then Object.__proto__ to Function.prototype, and wrote a subgraph-supplied value over Function.prototype.call, breaking every subsequent request in the process until restart. This is remotely triggerable by an unauthenticated client with a single query against any supergraph that merges an object from two subgraphs, which is the ordinary @shareable or entity case, so it is a denial of service rather than a theoretical hardening issue.
{
shared {
fieldA
constructor: fieldB {
__proto__: child {
call: value
}
}
}
}Blast Radius
ecosystem impact- 100 npm packages depend on @graphql-tools/utils (6 direct, 94 indirect)
Ecosystem-wide dependent count for version 12.0.1.
Technical POC Analysis
CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes / prototype pollution) in mergeDeep(), packages/utils/src/mergeDeep.ts in npm package @graphql-tools/utils.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
The @graphql-tools/utils library, used in GraphQL gateways and schema-stitching services like Hive Gateway, contains a prototype pollution vulnerability (CVE-2026-104852) that allows unauthenticated remote attackers to cause a denial of service, forcing a restart of the affected service. Organizations operating multi-subgraph GraphQL architectures with versions 12.0.0 or earlier are at risk, while single-subgraph deployments remain unaffected. Leadership should prioritize patching to prevent availability disruptions to customer-facing APIs and internal services.
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.
Affected Products (CPE)CVE.org
Unauthenticated denial of service in GitLab CE/EE (all versions from 18.4.6 before 19.1.8, 19.2 before 19.2.6, and 19.3
Unauthenticated attackers can publish arbitrary persisted query documents and claim (squat) query aliases on WordPress s
Stump through 0.1.10 allows any authenticated user with the shared AccessSmartList permission to overwrite, delete, or t
Versions of the package graphql from 16.3.0 and before 16.8.1 are vulnerable to Denial of Service (DoS) due to insuffici
Server-side request forgery in Chaskiq through 2.0.3 allows unauthenticated attackers to make the server fetch arbitrary
JWT authentication bypass in @neo4j/graphql allows unauthenticated remote clients to forge arbitrary JWT claims over Gra
Uncontrolled resource consumption in the Strawberry GraphQL library's legacy graphql-ws subscription handler (versions 0
Authentication bypass in @neo4j/graphql exposes admin-restricted custom-resolver fields to any authenticated user holdin
silverstripe-graphql is a package which serves Silverstripe data in GraphQL representations. Rated high severity (CVSS 7
`silverstripe/graphql` serves Silverstripe data as GraphQL representations. Rated high severity (CVSS 7.5), this vulnera
Field-level read permission bypass in Twenty CRM before 2.22.0 lets an authenticated workspace member or API key that is
Unauthenticated attackers can retrieve hidden catalog entities from Vendure's publicly accessible Shop API by setting th
GHSA-7mx3-vvmw-hjmv
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB