Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain public Application Id and client key
-
ExploitReplay cached persisted introspection query
-
ExecutionBypass introspection authorization control
-
ImpactRetrieve full GraphQL schema and private field names
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires three concrete preconditions: (1) the Parse Server GraphQL API must be enabled and network-reachable; (2) the attacker must possess the public Application Id and a client key, which are distributed in client applications rather than kept secret; and (3) - the key limiting factor - an introspection query must already have been executed and cached in Apollo Server's automatic persisted query (APQ) cache by a master-key or maintenance-key client, since the attacker replays that cached operation rather than sending introspection text directly. This dependency on a pre-populated privileged cache entry (reflected as AT:P in the CVSS vector) significantly narrows real-world exploitability: on deployments where privileged clients never issue introspection, or where GraphQL is disabled, the attack does not succeed. Impact is limited to schema disclosure (private class and field names); no data modification or server compromise results. |
| Impact | This is a genuine but modest-priority issue - an information-disclosure (GraphQL schema introspection) weakness, not code execution or data compromise. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) reports network reachability with no required privileges or user interaction, but critically includes AT:P (attack requirements): exploitation is NOT self-contained because it depends on an introspection query having been previously cached by a legitimate master-key or maintenance-key client. The only impact is VC:L (limited confidentiality) - disclosure of private class and field names - with no integrity or availability impact, consistent with the 6.3 Medium score and CWE-863 (Incorrect Authorization). No EPSS score, KEV listing, or POC was provided in the input, so there is no signal of active exploitation or weaponization; this is no public exploit identified at time of analysis. One nuance worth verifying: the description says 'unauthenticated attackers,' and the vector carries PR:N, yet the attacker must hold the public Application Id and client key - these are shared client-distribution credentials rather than per-user secrets, so PR:N is defensible, but defenders should note the attacker is not literally credential-less. Net: a real hardening priority for Parse Server operators exposing GraphQL, but a reconnaissance/disclosure flaw rather than a critical breach vector. |
| Exploit ScenarioDerived | An attacker who has extracted the public Application Id and client key from a mobile or web app (both are client-distributed, non-secret values) sends introspection queries to the Parse Server GraphQL endpoint. Because Apollo Server's automatic persisted-query cache stores an introspection operation previously executed by a master- or maintenance-key client, the attacker replays that cached operation by hash and receives the full schema - including private class and field names - bypassing the introspection control. No public exploit code was identified at time of analysis, and success depends on a privileged client having already populated the APQ cache with an introspection query. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 12, 2026
GraphQL schema disclosure in Parse Server allows unauthenticated attackers who hold the public Application ID and client key to recover private class and field names by replaying an introspection operation cached in Apollo Server's automatic persisted query (APQ) registry, because the server's introspection restriction is enforced only against operation text sent with the request and not against operations resolved from the cache. Exploitation is not autonomous: it requires the GraphQL API to be enabled and network-reachable and, critically, that a master- or maintenance-key client has already executed and cached an introspection query, so the attacker replays that privileged cached entry rather than submitting introspection text directly - a prerequisite captured as Attack Requirements: Present in the CVSS 4.0 vector and reflected in an independent rescoring of AV:N/AC:H. Impact is limited to information disclosure (no data modification, no code execution, no server compromise); no public exploit code was identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade Parse Server to 8.6.94 or 9.10.1-alpha.14 (or later), which restores introspection enforcement on the APQ-resolved path; apply via npm (npm install parse-server@8.6.94) and redeploy, then verify the GraphQL endpoint enforces the introspection restriction on a cached hash rather than only on inline query text. Until upgrading, the highest-value compensating controls are: restart the server process, which clears the in-memory APQ registry and removes any cached privileged introspection document (side effect: brief downtime and loss of cached queries, and the exposure recurs if a privileged client issues introspection again); disable automatic persisted queries so every operation must be sent in full text and therefore traverses the introspection check (side effect: larger requests and higher bandwidth/latency, and clients configured to send only hashes may break); and disable or restrict network access to the GraphQL endpoint, for example not mounting the GraphQL API or placing /graphql behind network-level allowlisting (side effect: legitimate GraphQL clients lose access). Note that rotating the Application ID or client key provides no protection here, since those values are public and shipped inside client applications, and that the disclosed private class and field names should be treated as exposed once a cached introspection has been replayed. Details and any vendor-documented workarounds are in the GitHub advisory https://github.com/parse-community/parse-server/security/advisories/GHSA-gxxq-pghq-9vrc.
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
Parse Server is the open-source Node.js backend that powers Parse applications, and it exposes a GraphQL API built on Apollo Server. Apollo's automatic persisted queries (APQ) let a client send only a SHA-256 hash of an operation in the request extensions instead of the full query text; the server looks the hash up in its persisted-query registry (an in-memory cache by default) and, if present, executes the stored document. Parse Server intends to restrict GraphQL schema introspection to privileged clients holding a master or maintenance key, but that control is implemented against the operation text that arrives directly in a request body - an APQ-resolved operation carries no such text, so the check is skipped and the cached document executes unguarded. This is CWE-863 (Incorrect Authorization): the same authorization decision is applied on one code path and omitted on a functionally equivalent one, a classic split-path enforcement flaw. The practical consequence is schema metadata disclosure - private class names, field names, and type structure - which does not by itself grant data access but materially improves an attacker's ability to craft targeted queries and misuse non-public API surface. The CVSS 4.0 vector's AT:P and a rescored CVSS 3.1 vector of AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N both encode the narrow window: the attack succeeds only against a cache that already contains a privileged introspection entry, which is why overall severity is modest rather than critical.
Know when Parse Server 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:L/VI:N/VA:N/SC:N/SI:N/SA:N
Network-reachable with no privileges (client key is public), but AC:H because success depends on a privileged client having pre-cached an introspection query; only limited confidentiality (schema names), no I/A impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Parse Server 8.2.2 before 8.6.94 and 9.0.0 before 9.10.1-alpha.14 applies its GraphQL introspection control only to operation text sent directly with a request, not to operations resolved from Apollo Server's automatic persisted query cache. Unauthenticated attackers holding the public Application Id and client key can replay an introspection query previously cached by a master or maintenance key client to retrieve the schema, including private class and field names.
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.
More in Parse Server
View allParse Server is an open source http web server backend. Rated critical severity (CVSS 10.0), this vulnerability is remot
Unauthenticated query injection in Parse Server before 9.6.0-alpha.12/8.6.38. PoC available.
Parse Server has an incorrect authorization vulnerability enabling unauthorized data access across applications.
### Impact Parse Server's built-in OAuth2 auth adapter exports a singleton instance that is reused directly across all
Parse Server has a CVSS 10.0 access control vulnerability enabling complete bypass of all data access restrictions.
parse-server is a Parse Server for Node.js / Express. Rated critical severity (CVSS 10.0), this vulnerability is remotel
Authentication bypass in Parse Server allows unauthenticated access to protected API endpoints. Parse Server is a popula
SQL injection in Parse Server before 9.6.0-alpha.2/8.6.28.
SQL injection in Parse Server before 9.6.0-alpha.5/8.6.31. Third Parse Server SQLi.
SQL injection in Parse Server before 9.6.0-alpha.5/8.6.31.
Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js. Rated critical s
Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js. Rated critical s
EUVD-2026-97604
GHSA-5rwh-p68m-8595
NVD
CVE.org
EPSS
Exploit-DB