CVE-2026-134243 in Parse Server
Summary
by MITRE • 11/21/2026
Parse Server before 8.6.122 and 9.0.0 before 9.11.1-alpha.2 does not prevent dot notation keys from changing a field that a beforeSave trigger keeps constant or reverts, affecting Object, Array, GeoPoint, Polygon, Bytes (on MongoDB), and ACL fields on create and update. A client allowed to write the object can modify such a field, such as a constant role list, to bypass Cloud Code authorization checks.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/21/2026
The vulnerability identified in Parse Server versions prior to 8.6.122 and 9.0.0 before 9.11.1-alpha.2 represents a critical failure in the enforcement of server-side logic during object persistence operations. This flaw specifically impacts the interaction between client-initiated write requests and Cloud Code triggers, particularly the beforeSave trigger mechanism which is designed to enforce business logic and authorization rules prior to data being committed to the database. The core technical issue lies in how Parse Server processes field updates when dot notation keys are utilized within JSON payloads sent by clients. In standard REST API usage, developers often rely on the assumption that if a Cloud Code beforeSave trigger explicitly sets or reverts a specific field value, that server-side decision will be immutable and final for that operation. However, due to this vulnerability, the internal processing order allows client-supplied data using dot notation syntax to override these enforced values after the trigger has executed but before the object is saved.
This behavior creates a significant authorization bypass scenario where an attacker or malicious client can manipulate fields that were intended to be constant by application logic. For instance, if an administrator configures a role list field via a beforeSave trigger to ensure all new objects receive specific default roles, a user with write access to the object class could include a dot notation key in their request payload targeting that same field. Because Parse Server fails to prevent this override, the client-supplied value takes precedence over the server-enforced constant. This affects multiple data types including Object fields, Array fields, GeoPoint objects, Polygon structures, Bytes on MongoDB backends, and Access Control List (ACL) configurations. The ability to modify ACLs is particularly severe as it allows an attacker to potentially escalate privileges or restrict access for other users by altering the security descriptors of shared resources directly through the API rather than through authorized administrative interfaces.
The operational impact of this vulnerability extends beyond simple data integrity issues into fundamental security failures regarding authentication and authorization controls. By bypassing Cloud Code logic, attackers can circumvent custom business rules that rely on these triggers to validate input or enforce state transitions. This effectively nullifies a primary defense mechanism in Parse Server applications where complex permission models are implemented via server-side code rather than static ACLs alone. An attacker does not need elevated privileges; they only require standard write access to the affected object class, which is often granted broadly for usability reasons. Consequently, sensitive data structures that depend on consistent field values for security decisions become compromised, leading to potential unauthorized data exposure or modification of critical system states.
From a classification perspective, this vulnerability aligns with CWE-693, Protection Mechanism Failure, as the software fails to prevent an attacker from bypassing its intended protective measures through specific input manipulation. It also relates closely to CWE-829, Inclusion of Functionality from Untrusted Control Sphere, because the server accepts and processes data structures that override internal control logic. Furthermore, this technique maps to MITRE ATT&CK tactic T1078, Valid Accounts, specifically within the context of abusing legitimate access rights to escalate privileges or bypass controls. The use of dot notation serves as a specific exploitation vector for CWE-20, Improper Input Validation, where the parser incorrectly prioritizes client input over server-enforced constraints during the serialization and persistence phase.
Mitigation strategies must prioritize immediate version upgrades to address this logic flaw at its source. Organizations running Parse Server should upgrade to version 8.6.122 or later for the legacy branch, or version 9.11.1-alpha.2 and above for the development branch, as these releases contain patches that enforce strict ordering of operations ensuring server-side trigger decisions are immutable during save operations. In environments where immediate upgrading is not feasible due to dependency constraints, temporary mitigations should focus on restricting client write permissions more granularly. Developers can implement additional validation layers in beforeSave triggers that explicitly reject any request containing dot notation keys targeting protected fields, although this approach increases complexity and may impact performance. Additionally, auditing logs for unusual patterns of field updates following save operations can help detect exploitation attempts while the patch is being deployed. Long-term architectural improvements should involve moving critical authorization logic away from relying solely on mutable object states during creation or update cycles, instead leveraging immutable server-side validations that do not depend on post-trigger state preservation against client overrides.