/

CVE-2026-30966

Severity:

CRITICAL RISK

(10.0)

Authorization Bypass / Improper Access Control

CVE-2026-30966

Analyzed

Vulnerability type

Category:

Authorization Bypass / Improper Access Control

CWE:

CWE-284

Impact:

Complete Authorization Bypass and Privilege Escalation via Role Manipulation

Severity:

CRITICAL RISK

(10.0)

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 relationship tables that back Role memberships and Relation fields to any client that has only the application key, without requiring the master key or proper authorization checks.

An attacker can directly create, read, update, or delete records in these internal tables to inject themselves into privileged roles or bypass role-based Class-Level Permissions (CLP), effectively gaining full access to protected data and operations.

Affected context

This vulnerability affects Parse Server deployments where:

  • Clients can access the REST API or GraphQL API with an application key.
  • Internal tables that store Relation field mappings (including Role membership tables) are reachable using those APIs.
  • Role-based Class-Level Permissions (CLP) or pointerFields CLP are used to protect data or operations.

In such environments, access to internal relationship tables is not sufficiently restricted to the master key or to hardened administrative flows, allowing regular clients to interact with sensitive authorization metadata.

Exploit preconditions

  • Attack surface: Parse Server REST API and GraphQL API endpoints.
  • Required access:
  • Ability to send authenticated requests using the application key.
  • No master key or elevated administrative credentials are required.
  • Trigger point:
  • Direct operations (create, read, update, delete) on internal tables that back:
  • Parse Role membership relationships.
  • Relation fields used in pointerFields CLP.
  • Why exploitation is possible:
  • Internal relationship tables are exposed to the same logical access path as regular application data.
  • Authorization logic does not enforce master-key or equivalent strong checks for operations on these internal tables.
  • As a result, any client with an application key can modify role membership mappings and relation-backed access control links.

Why this happens

The core issue is an improper access control design where authorization metadata is treated like ordinary application data.

Internal tables that define which users belong to which Roles, and which objects are related through protected Relation fields, are accessible via public APIs using only the application key.

This maps to CWE-284: Improper Access Control, because:

  • Security-sensitive resources (Role memberships and relation records underpinning CLP) are not bound to stricter credentials (such as the master key).
  • Access control checks fail to recognize these tables as part of the authorization control plane and do not enforce administrative-only access.

Conceptually, the bug is that authorization configuration is read/write accessible through normal data paths, allowing an attacker to rewrite who is authorized.

Potential impact

  • Attacker may inject their account into any Parse Role, effectively granting themselves all permissions associated with that role.
  • Attacker could gain full read, write, and delete access to classes that are intended to be protected by role-based Class-Level Permissions (CLP).
  • Attacker can bypass pointerFields CLP by manipulating underlying Relation-backed tables, undermining field-level or relationship-based access restrictions.
  • Complete compromise of application data confidentiality, integrity, and availability where authorization is enforced via Roles or relation-based CLP.
  • Potential lateral movement within the application's logical permission model, impersonating privileged staff, administrators, or system processes.

General mitigation guidance

Mitigations focus on strengthening access control around authorization metadata and segregating control-plane data from regular data paths:

  • Restrict access to internal relationship and Role membership tables so that only trusted, privileged contexts (e.g., master-key operations, server-side code, or dedicated admin APIs) can read or modify them.
  • Treat Role definitions, membership tables, and Relation-backed ACL/CLP metadata as configuration/authorization state, not as general application data, and enforce stricter policies accordingly.
  • Apply a deny-by-default policy for internal classes: internal tables should not be directly accessible over public client APIs unless explicitly and narrowly allowed.
  • Introduce explicit server-side access layers (cloud functions, admin endpoints) for any required administrative operations, instead of allowing raw table operations from untrusted clients.
  • Minimize reliance on application keys as a security boundary; treat them as identifiers, not authenticators, and combine with strong authentication and per-user authorization checks.
  • Ensure that role-based CLP and pointerFields CLP are enforced at the business logic level, independent of direct access to underlying relation mappings, where feasible.

These patterns help ensure that a compromise of a low-trust credential (like an application key) does not translate into the ability to rewrite authorization rules.

How teams detect issues like this

Detection strategies can focus on both code/configuration review and runtime monitoring:

  • Static and configuration analysis:
  • Review ACL/CLP configurations to verify that internal Role and Relation tables are not exposed to ordinary client roles.
  • Use policy-as-code or schema validation to flag any internal classes or tables that are not explicitly locked down or that share the same access rules as public data.
  • Apply static analysis or configuration scanning tools that look for patterns where authorization data (roles, memberships, relation mappings) is accessible via generic data APIs.
  • Code and architecture review:
  • Examine API routes and GraphQL schemas to ensure that any types or queries that expose internal relationship tables require elevated credentials or are disabled for client access.
  • Look for any functionality where clients can perform CRUD operations on tables that underpin access control logic, roles, or permissions.
  • Runtime and log-based monitoring:
  • Monitor logs for unusual patterns of access to internal Role or relationship tables, such as large numbers of writes, role assignment changes originating from untrusted client contexts, or unexpected clients manipulating relation mappings.
  • Implement anomaly detection around changes to Role membership and relation-backed CLP, triggering alerts when non-admin clients perform such operations.
  • Automated governance:
  • Integrate security checks into CI/CD pipelines to enforce policies that prevent exposing authorization metadata through public schemas or endpoints.

Together, these techniques help identify both vulnerable configurations and active attempts to manipulate authorization structures.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/releases/tag/8.6.20
github.comgithub.com/parse-community/parse-server/releases/tag/9.5.2-alpha.7
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-5f92-jrq3-28rc

Frequently asked

questions

Any client that can reach the Parse Server REST or GraphQL API and possesses the application key can attempt to exploit this issue, regardless of user authentication state, because the vulnerable internal tables are accessible without the master key.

The attacker needs network access to the Parse Server API endpoint and knowledge of the application key, which is often embedded in client applications. No master key or administrator credentials are required, making this a low-barrier privilege escalation.

The safest approach is to enforce strict access control on all internal role and relationship tables so they are only modifiable via trusted server-side operations (e.g., master-key scoped functions or admin-only APIs), and never directly writable by regular client requests using only the application key.

Treat authorization structures (roles, memberships, ACL mappings, relation-backed CLP data) as part of the security control plane and isolate them from general data paths. Apply least privilege, deny-by-default policies, require strong credentials or trust boundaries for any modifications, and validate these rules through automated tests, security reviews, and CI-enforced policies.

Find out what's already
exploitable in your codebase.