/

CVE-2026-31800

Severity:

CRITICAL RISK

(9.1)

Missing Authorization in Parse Server REST API

CVE-2026-31800

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Configuration and Data Manipulation

Severity:

CRITICAL RISK

(9.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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-config and /push_audiences to 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 /classes routes.
  • 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/_GraphQLConfig
  • GET /classes/_Audience, PUT /classes/_Audience, DELETE /classes/_Audience
  • Why exploitation is possible: The internal classes _GraphQLConfig and _Audience are 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-config and /push_audiences endpoints.

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.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/releases/tag/8.6.25
github.comgithub.com/parse-community/parse-server/releases/tag/9.5.2-alpha.12
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-7xg7-rqf6-pw6c

Frequently asked

questions

Yes, it can typically be exploited remotely by anyone who can reach the Parse Server REST API, provided that the /classes endpoints are exposed and not further restricted by network or gateway controls.

No, that is the core issue. The _GraphQLConfig and _Audience classes can be accessed via generic /classes routes without providing the master key, bypassing the stronger protection applied on the dedicated administrative endpoints.

Apply strict, centralized authorization for all access paths to internal configuration and control-plane data. Ensure that internal classes are either completely hidden from generic CRUD routes or explicitly require the same high-privilege context (such as the master key) regardless of the endpoint used.

Design APIs so that sensitive resources are never exposed through generic mechanisms, enforce least privilege at every layer, and use security reviews and automated tests to verify that every route touching internal or administrative data is covered by explicit authorization checks. Periodic audits of API routes and class accessibility can further reduce the risk of missing checks.

Find out what's already
exploitable in your codebase.