Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach GraphQL endpoint unauthenticated
-
DeliverySend request with ~30-char PhoneNumber value
-
ExploitTrigger exponential regex backtracking in validation
-
ExecutionBlock Node.js event loop
-
ImpactStall entire server process (DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The target GraphQL server must use graphql-scalars between 1.24.1 and 2.0.0 and expose GraphQLPhoneNumber on a field argument, an input-object field, or a variable that accepts untrusted/anonymous input; serialize is additionally affected when unvalidated stored values are returned through a PhoneNumber field. No authentication, user interaction, or non-default configuration is otherwise required, because parseLiteral runs during document validation and parseValue during variable coercion before any resolver authentication or authorization - a single ~30-character request suffices. The one real limiting factor is schema exposure: if no PhoneNumber scalar is applied to attacker-controllable input, the flaw is not reachable. Versions 1.24.0 and earlier use the linear pattern /^\+[1-9]\d{6,14}$/ and are not affected. Vendor-stated mitigations until upgrading: replace the scalar with the fixed linear pattern, run Node with --enable-experimental-regexp-engine-on-excessive-backtracks (not accepted via NODE_OPTIONS), or pin graphql-scalars <=1.24.0 (which changes accepted values); the complete fix is upgrading to 2.0.1. |
| Impact | This is a genuine, actionable availability risk but not a drop-everything emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) is consistent with the mechanism described: a network-reachable, low-complexity, unauthenticated request causes a high-availability impact with no confidentiality or integrity effect - a classic ReDoS (CWE-1333) denial of service. The critical corroborating detail from the GHSA advisory is that graphql-js runs parseLiteral during document validation and parseValue during variable coercion BEFORE any resolver-level authentication or authorization, which independently supports the PR:N choice (no auth needed) and raises real-world concern because no credentials gate the attack. The vuln.today decision label is 'this_week', not act_now/emergency, which aligns with a serious-but-not-actively-mass-exploited issue. There is no CISA KEV listing and no EPSS score was provided in the input, so widespread active exploitation is NOT established - exploitation status is based on the public advisory and its PoC only. A detailed, measured proof-of-concept (timing tables, payload '1'.repeat(30)+'x') is published in the GHSA advisory, lowering the barrier to weaponization. The main factor that moderates risk below the raw 7.5 is a precondition the CVSS vector does not capture: the server must actually expose the GraphQLPhoneNumber scalar on untrusted input. MISSING DATA: no EPSS, no KEV, and no SSVC automatable/technical-impact breakdown were supplied, so prioritization rests on CVSS plus the vendor advisory rather than exploitation-probability telemetry. |
| Exploit ScenarioDerived | An anonymous client sends a single small HTTP GraphQL request (query or variables) containing a PhoneNumber value of roughly 30 characters - a run of digits followed by one character that forces the match to fail, e.g. '1' repeated 30 times plus 'x'. Because graphql-js validates the literal and coerces the variable before authentication, the exponential-backtracking regex runs on the main thread and blocks the Node.js event loop for seconds (around 40 characters would busy a process for hours), stalling all concurrent requests. A working, measured PoC is published in the GHSA advisory; attack complexity is low and no user interaction or authentication is required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 23, 2026
Denial of service in the GraphQLPhoneNumber scalar of the graphql-scalars npm package (versions 1.24.1 through 2.0.0) lets an unauthenticated remote client stall a Node.js server process with a single request of roughly 30 characters placed in any PhoneNumber-typed argument, input-object field or variable. The scalar's regex backtracks exponentially on a run of digits followed by a failing character, and graphql-js runs parseLiteral during document validation and parseValue during variable coercion before any resolver authentication or authorization, so the work happens even on requests that would ultimately be rejected. The advisory (GHSA-x8rm-f576-gq67) includes a reproduction script with measured timings and the maintainers have released version 2.0.1 with a linear-time pattern; there is no CISA KEV listing, and the preconditions are limited to schemas that actually expose this scalar on attacker-controllable input.
RemediationAI
Vendor-released patch: graphql-scalars 2.0.1 (release https://github.com/graphql-hive/graphql-scalars/releases/tag/v2.0.1, commit 210fd2485641afa2452800c00144245c74361701) replaces the ambiguous pattern with an equivalent linear-time expression, so upgrading to 2.0.1 is the complete fix with no change in which phone numbers are accepted. If the upgrade cannot be shipped immediately, the vendor documents three interim options: substitute the PhoneNumber scalar in your schema with an implementation using the fixed linear pattern; start Node with --enable-experimental-regexp-engine-on-excessive-backtracks (or call v8.setFlagsFromString with that value before the regex first runs) so V8 falls back to its linear-time engine after excessive backtracking, noting that the flag is not accepted through NODE_OPTIONS; or pin graphql-scalars to 1.24.0 or earlier, which restores the linear regex but narrows accepted values to '+'-prefixed E.164 strings and can therefore break existing clients. As an additional hardening measure the advisory suggests rejecting values above a sane length before matching, since the grammar has no upper bound and E.164 permits at most 15 digits; a regression test asserting that parseValue('1'.repeat(40) + 'x') throws immediately will catch reintroduction.
Affected VersionsENISA
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
graphql-scalars is a widely used library of custom GraphQL scalar types for type-safe schema validation. Since release 1.24.1, the GraphQLPhoneNumber scalar has used the regular expression /^\+?\d{1,3}(\-|\x20)?\(?\d+\)?((\-|\x20)?\d+)+$/ to also accept extensions and human formatting such as '+1 (123) 456-7890'. The subexpression \d+\)?((\-|\x20)?\d+)+$ permits the optional separator, so a single run of digits can be partitioned between the inner \d+ and the outer + iterations in exponentially many ways; when the overall match must fail (for example a trailing non-digit), the engine enumerates all of them. That is classic CWE-1333 inefficient regular expression complexity, or ReDoS. Impact is amplified by GraphQL's execution model: parseLiteral is invoked while the document is being validated and parseValue while variables are coerced, both of which occur before execution and before any authentication or authorization in resolvers or context. Because Node.js runs JavaScript on a single event loop thread, the backtracking blocks all concurrent requests to the process; the advisory reports 6.59 s for 30 digits on Node 22.19.0 with time doubling per additional digit, and the serialize path uses the same regex, so unvalidated stored values returned through a PhoneNumber field are also affected. GraphQL servers running graphql 16.14.2 and 17.0.2, and an end-to-end GraphQL Yoga deployment, are confirmed impacted in the advisory.
Know when Graphql Scalars 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
Validation/coercion run before auth so PR:N; a single small network request with low complexity causes event-loop stall, so AV:N/AC:L and A:H only, C/I:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
GraphQL Scalars is a library of custom GraphQL scalars for creating precise type-safe GraphQL schemas. From 1.24.1 until 2.0.1, GraphQLPhoneNumber in src/scalars/PhoneNumber.ts uses ambiguous nested digit quantifiers that backtrack exponentially when a PhoneNumber value contains a run of digits followed by a character that makes the match fail. GraphQL evaluates parseLiteral during document validation and parseValue during variable coercion before resolver authentication or authorization, so a small unauthenticated request can block the Node.js event loop and stall the server process. serialize is also affected when unvalidated stored values are returned through the scalar. This issue is fixed in version 2.0.1.
Blast Radius
ecosystem impact- 117 npm packages depend on graphql-scalars (19 direct, 99 indirect)
Ecosystem-wide dependent count for version 2.0.1.
Articles & Coverage 1
Technical POC Analysis
CWE-1333 (Inefficient Regular Expression Complexity, i.e.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity denial-of-service vulnerability in the graphql-scalars npm package affects any Node.js service that exposes the PhoneNumber GraphQL scalar to untrusted input, allowing a single unauthenticated request to stall the server process. This could cause application downtime and service outages, impacting customers and business operations. Leadership should prioritize remediation because the attack requires minimal effort and is enabled by default in versions 1.24.1 through 2.0.0.
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.
EUVD-2026-109185
GHSA-x8rm-f576-gq67
NVD
CVE.org
EPSS
VulDB
Exploit-DB