Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify public-facing Keystone GraphQL endpoint
-
DeliveryCraft query with large negative take value
-
ExploitSubmit unauthenticated GraphQL request
-
ExecutionBypass maxTake guard (negative integer < positive bound)
-
PersistDatabase returns unbounded record set
-
ImpactService memory/CPU/connections exhausted
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | The target must be running @keystone-6/core prior to version 6.5.3 with the |
| Impact | The CVSS 7.5 score with vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H accurately reflects real-world risk for publicly exposed deployments. Attack complexity is genuinely low - exploitation requires only a valid GraphQL query with a negative integer, a technique derivable from reading the public advisory and test cases in PR #9859. There is no confidentiality or integrity impact confirmed, limiting the blast radius to availability. KEV status is not listed, meaning active exploitation in the wild has not been confirmed by CISA. EPSS score was not provided in the input data. The 'Authentication Bypass' tag included in CVE metadata is partially misleading - this bypasses a record-count safeguard, not authentication controls. Deployments that restrict GraphQL API access to authenticated sessions or internal networks face substantially reduced risk, as PR:N exploitation requires the endpoint to be reachable by the attacker. For fully public-facing Keystone deployments, this is a credible DoS vector requiring immediate patching. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a GraphQL query such as |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 21, 2026
Unauthenticated resource exhaustion in Keystone CMS (Node.js) prior to version 6.5.3 allows any remote GraphQL client to bypass the configured graphql.maxTake record-count limit by supplying a negative take value, since the comparison (take ?? Infinity) > maxTake evaluates to false for negative integers regardless of their magnitude. The bypass applies to both top-level list queries and relationship sub-queries, enabling an attacker to force the server to retrieve an unbounded number of database records and exhaust service resources. No public exploit code has been identified at time of analysis, though the fix and advisory are publicly available.
RemediationAI
Upgrade @keystone-6/core to version 6.5.3 or later, which corrects the comparison logic in findMany by wrapping the take argument in Math.abs() before evaluating it against graphql.maxTake. The patched release is confirmed at https://github.com/keystonejs/keystone/releases/tag/@keystone-6/core@6.5.3 and the underlying fix is in commit 9fb88b2. If immediate upgrade is not feasible, require authentication for all GraphQL endpoint access via application middleware or API gateway policy - this converts the attack from unauthenticated to at minimum authenticated, reducing exposure. Alternatively, deploy a WAF rule or reverse-proxy middleware that rejects take arguments with negative integer values; note that some GraphQL pagination patterns use negative take for backwards pagination, so test client behavior before blocking. Restricting the Keystone GraphQL endpoint to internal networks or VPN-only access is the strongest compensating control and eliminates unauthenticated exposure entirely. The full advisory and PR discussion are at https://github.com/keystonejs/keystone/security/advisories/GHSA-cqmq-8755-7xvh and https://github.com/keystonejs/keystone/pull/9859.
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
Keystone is an open-source headless CMS built on Node.js and GraphQL, identified by CPE cpe:2.3:a:keystonejs:keystone:*:*:*:*:*:*:*:*. The vulnerability resides in packages/core/src/lib/core/queries/resolvers.ts within the findMany function, which enforces a configurable maximum record return limit via the graphql.maxTake server option. The guard condition (take ?? Infinity) > maxTake is designed to reject oversized take values, but fails for negative integers because a negative number is never arithmetically greater than a positive bound - e.g., -1000000 > 1000 is false. The root cause is CWE-20 (Improper Input Validation): the signed take argument is compared directly without first normalizing it with Math.abs(). The fix, introduced in PR #9859 (commit 9fb88b2), changes the guard to Math.abs(take ?? Infinity) > maxTake. The flaw also affects relationship sub-queries (e.g., user { posts(take: -N) }), meaning deeply nested GraphQL queries can compound the resource impact.
Know when Keystone 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:N/I:N/A:H
Network-reachable GraphQL endpoint requires no auth (PR:N); single crafted query suffices (AC:L); only availability is impacted via unbounded record retrieval.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Keystone is a content management system for Node.js. Prior to 6.5.3, the findMany resolver in packages/core/src/lib/core/queries/resolvers.ts compares the signed take argument directly with graphql.maxTake, allowing a remote unauthenticated GraphQL client to provide a negative take value whose magnitude exceeds the configured bound. The bypass also applies to relationship queries and can return more records than the developer intended, potentially exhausting service resources. This issue is fixed in version 6.5.3.
Blast Radius
ecosystem impact- 5 npm packages depend on @keystone-6/core (5 direct, 0 indirect)
Ecosystem-wide dependent count for version 6.5.3.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
Keystone CMS deployments before version 6.5.3 are vulnerable to resource-exhaustion attacks from any unauthenticated attacker; no public exploit identified at time of analysis. The vulnerability allows attackers to crash services and deny customer access by exhausting database resources. Organizations must patch to version 6.5.3 immediately to restore security.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
CSV Injection (aka Excel Macro Injection or Formula Injection) exists in admin/server/api/download.js and lib/list/getCS
Keystone is a headless CMS for Node.js - built with GraphQL and React.`@keystone-6/core@3.0.0 || 3.0.1` users that use `
@keystone-6/core is a core package for Keystone 6, a content management system for Node.js. Rated critical severity (CVS
An arbitrary file upload vulnerability in the file upload module of Keystone v4.2.1 allows attackers to execute arbitrar
KeystoneJS before 4.0.0-beta.7 allows application-wide CSRF bypass by removing the CSRF parameter and value, aka SecureL
OpenStack Keystone 15.0.0 and 16.0.0 is affected by Data Leakage in the list credentials API. Rated high severity (CVSS
OpenStack Keystone 10.x through 16.x before 16.0.2, 17.x before 17.0.1, 18.x before 18.0.1, and 19.x before 19.0.1 allow
A cross-site scripting (XSS) vulnerability exists in fields/types/markdown/MarkdownType.js in KeystoneJS before 4.0.0-be
A flaw was found in Keystone. Rated medium severity (CVSS 6.6), this vulnerability is remotely exploitable. Public explo
OpenStack Identity (Keystone) before 2013.2.4, 2014.x before 2014.1.2, and Juno before Juno-2 allows remote authenticate
OpenStack Identity (Keystone) before 2014.1.1 does not properly handle when a role is assigned to a group that has the s
OpenStack Identity (Keystone) Folsom 2012.2.4 and earlier, Grizzly before 2013.1.1, and Havana does not immediately revo
EUVD-2026-64134
GHSA-cqmq-8755-7xvh
NVD
CVE.org
EPSS
Exploit-DB