Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as client with class write access
-
DeliverySend write with crafted dot-notation or ACL key matching built-in member
-
ExploitPollute shared JavaScript prototype during write/response build
-
ExecutionCorrupt built-in function used process-wide
-
ImpactAll subsequent requests fail until server restart
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V3 - Web Frontend Security Prototype pollution prevention
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a client that already holds write access to a Parse class (authenticated per PR:L). The attacker then sends a write request whose key is either a dot notation field key or an ACL entry name matching a built-in JavaScript object member - for example toString, valueOf or hasOwnProperty - which is expanded into an object without an own-property check. The advisory states the dot notation vector requires no special configuration, so default deployments are affected; the highest-impact keys __proto__ and constructor are already blocked by the default requestKeywordDenylist. Limiting factors: the attacker must possess class write capability, and impact is availability-only (service denial until restart). Multi-tenant processes serving several applications are affected across all of them, amplifying impact. There is no complete configuration-only workaround for the dot notation vector; the vendor states upgrading to the patched release is the recommended fix, with extending the denylist (while retaining defaults) to also reject toString/valueOf/hasOwnProperty offered only as a partial pre-upgrade mitigation. |
| Impact | This is a medium-severity, authenticated denial-of-service issue, not a high-priority emergency. The CVSS 4.0 vector (CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:N/VI:N/VA:H) scores 6.0 and tells a coherent story: network-reachable (AV:N) but requiring low privileges (PR:L) - specifically a client that already holds class write access - with impact confined entirely to availability (VA:H) and no confidentiality or integrity impact (VC:N/VI:N). The AT:P flag reflects that the most severe outcome depends on the crafted key matching a specific built-in object member. The vuln.today priority is 'this_month', consistent with a serviceable-but-not-urgent DoS. No EPSS score is provided, the CVE is not listed in CISA KEV, and no exploit/PoC reference is present in the input - only vendor advisories (GHSA and VulnCheck) - so there is no public exploit identified at time of analysis. The practical risk is real for multi-tenant Parse Server deployments, because the advisory states the dot notation vector requires no special configuration and a single tenant's write can deny service across all applications sharing the process until restart; but the requirement for class write access and the availability-only impact keep this below credential-theft or RCE-class urgency. One data inconsistency to note: the input tags include 'Information Disclosure', which contradicts the CVSS impact metrics (VC:N - no confidentiality impact) and the advisory, which describes a denial of service only. |
| Exploit ScenarioDerived | An attacker who holds write access to a Parse class (for example a registered client of a multi-tenant Parse Server) submits a write request containing a dot notation field key, or an ACL entry whose name matches a built-in JavaScript object member such as toString, valueOf or hasOwnProperty. Because user-controlled keys are expanded into objects without own-property checks, this corrupts a shared runtime prototype, and in the worst case a built-in function used throughout the process; subsequent unrelated requests from all clients then fail until the server is restarted. No public working exploit is identified in the provided sources; exploitation is remote over the network but requires the low-privilege class write capability (PR:L). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Prototype pollution in Parse Server allows any client holding write access to a Parse class to corrupt a shared JavaScript prototype by submitting a crafted field key in dot notation or an ACL entry name that matches a built-in object member such as toString, valueOf or hasOwnProperty. The most severe outcome corrupts a built-in function used throughout the server process, after which unrelated requests fail until the server is restarted, denying service to every client of that instance - and in a multi-tenant deployment, across all applications served by that process. The issue is confirmed to affect Parse Server releases before 8.6.108 and 9.0.0 through 9.10.5-alpha.9; the dot notation vector requires no special configuration, though the highest-impact keys (__proto__ and constructor) are already rejected by the default requestKeywordDenylist. Exploitation requires authenticated class write capability (PR:L) and the impact is availability-only; no public exploit code or active exploitation has been identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade to Parse Server 8.6.108 for the 8.x branch or 9.10.5-alpha.9 (or later) for the 9.x branch, which introduce own-property checks wherever a user-controlled key is expanded into an object. The corresponding upstream fixes are PR https://github.com/parse-community/parse-server/pull/10790 (Parse Server 9) and PR https://github.com/parse-community/parse-server/pull/10791 (Parse Server 8), documented in advisory https://github.com/parse-community/parse-server/security/advisories/GHSA-rx55-fw4j-pvpx. As a partial pre-upgrade mitigation, retain the default requestKeywordDenylist (which already blocks __proto__ and constructor) and extend it to also reject keys such as toString, valueOf and hasOwnProperty; the vendor describes this only as partial, and the trade-off is that any legitimate schema or ACL entry using those names would be rejected. There is no complete configuration-only workaround for the dot notation vector - the vendor states that upgrading to the patched release is the recommended fix - and because pollution corrupts process-wide state, restarting the server only restores availability temporarily until a patched build is deployed.
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 behind Parse Platform, exposing class-based object storage over a REST/GraphQL API backed by MongoDB or PostgreSQL. The flaw is CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes, i.e. prototype pollution): when Parse Server expands a user-controlled key into an object, it does so without an own-property check, so a key naming an inherited member can resolve to - or assign onto - Object.prototype or another shared runtime object. Per the vendor advisory, the missing checks occur in several places: while building write responses, in the PostgreSQL storage layer's dot notation handling, and when constructing ACL representations both on read and on the MongoDB write path. Two vectors are described - a dot notation field key in a write request, which the advisory states needs no special configuration, and an ACL entry whose name matches a built-in object member. Because the polluted object is shared across the Node.js process, corruption of a built-in function such as toString or valueOf breaks unrelated request handling process-wide, producing a denial of service that persists until restart rather than being scoped to the attacking application. The default requestKeywordDenylist already blocks __proto__ and constructor, which limits the most direct pollution path but does not cover the other built-in member names. CPE records identify the affected package as parse-community:parse-server (npm parse-server).
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:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
PR:L because the attacker needs class write access; AV:N/AC:L as the dot notation vector needs no special configuration; impact is availability-only (A:H, C:N, I:N) causing service denial until restart.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
Parse Server before 8.6.108 and 9.0.0 before 9.10.5-alpha.9 contains a prototype pollution vulnerability because user-controlled keys are expanded into objects without own-property checks. Clients with class write access can send dot notation field keys or ACL entry names matching built-in object members to corrupt built-in functions, causing all requests to fail until server restart.
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
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-113923
GHSA-5gp4-jgm9-v67j
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB