Summary
Parse Server exposes internal _GraphQLConfig and _Audience classes through generic REST API routes without enforcing master key authorization.
When these routes are accessible, an attacker can read, modify, or delete GraphQL configuration and push audience data, effectively bypassing intended master key protection on the dedicated endpoints.
Affected context
This vulnerability affects Parse Server deployments that:
- Expose the generic
/classes/*REST API routes to clients (e.g., web, mobile, service integrations), and - Rely on master key–protected endpoints like
/graphql-configand/push_audiencesto safeguard internal configuration and audience data.
In such setups, the internal classes _GraphQLConfig and _Audience become directly addressable via /classes/_GraphQLConfig and /classes/_Audience without master key enforcement, undermining the intended access control model.
Exploit preconditions
- Attack surface: Public or semi-public Parse Server REST API, specifically the generic
/classesroutes. - Required access: Ability to send HTTP requests to the Parse Server API with any valid application-level context (or, in some deployments, even unauthenticated access if allowed by configuration).
- Trigger point: Requests to:
GET /classes/_GraphQLConfig,PUT /classes/_GraphQLConfig,DELETE /classes/_GraphQLConfigGET /classes/_Audience,PUT /classes/_Audience,DELETE /classes/_Audience- Why exploitation is possible: The internal classes
_GraphQLConfigand_Audienceare not excluded from the generic class CRUD routes, and authorization checks on these generic endpoints do not enforce the master key requirements that are correctly applied on the dedicated/graphql-configand/push_audiencesendpoints.
Why this happens
The core issue is a missing or inconsistent authorization check on internal resources when accessed through a more generic API surface.
Parse Server correctly enforces master key requirements on specialized endpoints (/graphql-config, /push_audiences), but the same internal resources are also reachable via the generic /classes mechanism.
Because the access control policy is not uniformly applied to these alternative routes, internal classes _GraphQLConfig and _Audience can be read or modified without master key authentication.
This aligns with CWE-862: Missing Authorization, where sensitive operations are exposed without the necessary permission checks, often due to incomplete coverage or overlooked code paths in the authorization layer.
Potential impact
- Attackers can read GraphQL configuration, potentially revealing schema details, operational settings, or internal behaviors.
- Attackers can modify GraphQL configuration, which may:
- Enable or disable operations
- Alter security-related settings
- Change exposed schema surfaces in unexpected ways
- Attackers can read push audience data, exposing targeting information and potentially sensitive segmentation logic.
- Attackers can modify or delete push audiences, allowing:
- Disruption of push notification campaigns
- Mis-targeting of users or services
- Abuse of push infrastructure for spam or phishing campaigns
- Overall degradation of trust in the backend configuration, with potential cascading effects on availability, integrity, and confidentiality of application behavior.
General mitigation guidance
Mitigation strategies should focus on enforcing consistent authorization policies and isolating internal classes from generic data access paths:
- Clearly separate internal/system classes from user-facing data models and prevent them from being addressable via generic CRUD endpoints.
- Apply centralized authorization checks that map each route (including generic ones) to appropriate access policies, ensuring that master key–protected operations cannot be reached through alternative paths.
- Introduce explicit allowlists or denylists for classes accessible via
/classes/*, so internal configuration and control-plane data are never exposed as regular objects. - Minimize the exposure of Parse Server APIs to the public Internet; where possible, place administrative or configuration endpoints behind internal networks, VPNs, or API gateways with additional authentication and authorization layers.
- Adopt the principle of least privilege for client apps: ensure that typical client keys or tokens cannot perform administrative operations even if a routing oversight exists.
How teams detect issues like this
Detection efforts can leverage both code-level and runtime observations:
- Static analysis and code review:
- Look for internal or system classes that share persistence or routing mechanisms with user data without explicit access control guards.
- Review the authorization middleware or hooks for coverage across both specialized and generic endpoints, ensuring internal resources are consistently protected.
- Flag patterns where route handlers or controllers bypass centralized authorization logic or rely on default policies for sensitive objects.
- Configuration and policy enforcement:
- Implement API gateway or WAF rules that block access to known internal class names via generic routes (e.g.,
_GraphQLConfig,_Audience). - Use policy-as-code tools to express and verify that configuration/control-plane classes are never readable or writable by non-admin roles.
- Runtime monitoring:
- Log all access to internal classes and administrative endpoints, and alert on unexpected access from client contexts or anonymous users.
- Monitor for anomalous changes to GraphQL configuration or push audiences, especially outside expected deployment or maintenance windows.
- Automated security testing tools and API scanners can be configured to probe for internal class access through generic endpoints, improving early detection.

