Skip to main content

graphql-go EUVDEUVD-2026-65681

| CVE-2026-80051 MEDIUM
Improper Validation of Specified Type of Input (CWE-1287)
2026-08-25 mitre GHSA-w74q-3pp2-465h
5.9
CVSS 4.0 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Access GraphQL endpoint
  2. Delivery
    Craft scalar variable with deeply nested mismatched type
  3. Exploit
    Submit malformed GraphQL request
  4. Execution
    coerceString/coerceBool recurses without type rejection
  5. Persist
    Go call stack exhausted
  6. Impact
    Fatal 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

graphql-go 0 ≤0.8.1

Affected Packages

euvd graphql_go 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

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

Vendor (mitre) PRIMARY 5.9 MEDIUM
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
vuln.today AI 5.9 MEDIUM

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.

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

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

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

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
popular Go GraphQL library across Go-based web services
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High

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 MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

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.

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