Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAccess GraphQL endpoint
-
DeliveryCraft scalar variable with deeply nested mismatched type
-
ExploitSubmit malformed GraphQL request
-
ExecutioncoerceString/coerceBool recurses without type rejection
-
PersistGo call stack exhausted
-
ImpactFatal error terminates server process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Specified type validation
|
| Exploitation Conditions | Exploitation requires submitting a GraphQL request in which a scalar variable (declared as String, ID, or Boolean) is assigned a deeply nested composite value rather than a flat scalar - a structure that does not arise in typical JSON-over-HTTP GraphQL traffic. The description explicitly states the crash does not occur in 'any typical case of JSON sent to a website,' and the CVSS 4.0 AT:P (Attack Requirements: Present) confirms a specific non-standard input structure must be deliberately constructed. No authentication is required per PR:N in the CVSS vector, but the attacker must be able to send controlled GraphQL input to the target endpoint. Exploitation is not achievable by standard GraphQL clients or typical API consumers; it requires an attacker who understands the specific nesting condition and intentionally crafts the malicious payload. The limiting factors are: (1) the non-standard input format required, (2) network access to a GraphQL endpoint served by the vulnerable library, and (3) any depth-limiting or input-validation middleware deployed in front of the library would prevent triggering the condition. |
| Impact | The CVSS 4.0 score of 5.9 (Medium) reflects a genuine but conditionally constrained denial-of-service risk. The availability impact is correctly rated High (VA:H) because a successful trigger produces an immediate, unrecoverable Go process crash with no defensive recovery path. Several signals limit practical exploitability: the AV:L (Local) attack vector in the provided CVSS 4.0 vector and the description's explicit qualifier that the crash does not occur in 'any typical case of JSON sent to a website' together indicate that standard HTTP GraphQL clients cannot trivially trigger the condition. The AT:P (Attack Requirements: Present) metric confirms a specific non-default input structure must be constructed. A proof-of-concept is publicly documented on the Openwall security mailing list, confirming the flaw is reproducible and understood, which elevates urgency beyond a theoretical finding. However, no CISA KEV listing exists, so confirmed active exploitation is absent. EPSS data was not provided in the input; the medium CVSS score alone should not drive deprioritization given the zero-recovery nature of Go fatal errors. The absence of a confirmed fix version in any provided reference is a notable operational gap - operators cannot verify remediation without independently monitoring the upstream repository. |
| Exploit ScenarioDerived | An attacker with access to the GraphQL endpoint constructs a query containing a scalar variable declared as a String or Boolean but supplied with a deeply nested composite value. When the graphql-go library attempts to coerce the variable, the coerceString or coerceBool function recurses into the nested structure without type-checking, exhausting the Go call stack and producing a fatal error that immediately terminates the server process without any possibility of recovery. A proof-of-concept demonstrating this technique is publicly available via the Openwall security mailing list. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 25, 2026
Stack overflow denial of service in github.com/graphql-go/graphql (through v0.8.1) crashes any Go server process embedding the library when an attacker submits a specifically crafted GraphQL request containing a deeply nested scalar value of a mismatched type. The coerceString and coerceBool functions in scalars.go violate the GraphQL specification by accepting type-mismatched scalar input instead of returning a request error, and under specific deep-nesting conditions exhaust Go's call stack and trigger an unrecoverable fatal error that immediately terminates the host process. A publicly available proof-of-concept exists via the Openwall security list; however, no active exploitation is confirmed in CISA KEV, and the CVSS 4.0 vector (AV:L, AT:P) combined with the description's explicit caveat that this is not triggered by typical web JSON traffic indicates exploitation requires a non-standard input path.
RemediationAI
No vendor-released patch identified at time of analysis - provided references point only to the vulnerable source code at scalars.go#L307-L315 and the Openwall exploit disclosure, with no fix commit or tagged release cited. Operators should monitor the github.com/graphql-go/graphql GitHub repository for an updated release that enforces scalar type validation per the GraphQL specification. As a primary compensating control, implement GraphQL query depth limiting at the middleware or API gateway layer to reject requests that exceed a maximum nesting depth before they reach the library's coercion functions; this directly blocks the triggering condition described in the CVE and is a broadly recommended GraphQL hardening practice regardless. A secondary control is to restrict access to GraphQL endpoints via network policy or authentication at the gateway to reduce the population of callers who can submit arbitrary input. Note that depth limiting must be applied before the graphql-go library processes the request to be effective, as no in-process recovery is possible once the fatal error is triggered.
Affected VersionsENISA
Affected Packages
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
The affected component is github.com/graphql-go/graphql (CPE: cpe:2.3:a:graphql-go_project:graphql-go:*:*:*:*:*:*:*:*), a pure-Go implementation of the GraphQL specification covering all versions through v0.8.1. CWE-1287 (Improper Validation of Specified Type of Input) describes the root cause: the coerceString and coerceBool scalar coercion functions in scalars.go lines 307-315 do not reject a variable whose runtime value does not match the declared GraphQL scalar type (String, ID, or Boolean). The GraphQL specification mandates that such a mismatch must produce a request error; the library silently processes the value instead. When the mismatched value is a deeply nested data structure, the recursive coercion logic exhausts Go's goroutine call stack, producing a fatal error: stack overflow. Critically, unlike a Go panic - which can be intercepted by recover() - a Go fatal error cannot be caught by any application-level handler and unconditionally terminates the OS process. This makes the impact hard and unrecoverable, affecting every service built as a binary around this library.
Know when Graphql Go 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:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Library is network-facing but AC:H reflects the non-trivial deeply-nested input requirement; fatal crash yields A:H; no confidentiality or integrity impact.
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
DescriptionCVE.org
github.com/graphql-go/graphql (GraphQL for Go) through 0.8.1 does not validate that a scalar variable value matches its declared type. The built-in coerceString and coerceBool functions (scalars.go) accept input whose type does not match the declared String, ID, or Boolean scalar instead of raising the request error that the GraphQL specification mandates. In some cases (but not any typical case of JSON sent to a website), a deeply nested value leads to an unrecoverable "fatal error: stack overflow" condition.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
EUVD-2026-65681
GHSA-w74q-3pp2-465h
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB