/

CVE-2026-30947

Severity:

HIGH RISK

(7.5)

Authorization Bypass in Parse Server

CVE-2026-30947

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Unauthorized Data Disclosure via Real-Time Subscriptions

Severity:

HIGH RISK

(7.5)

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 fails to enforce class-level permissions (CLP) on LiveQuery subscriptions, allowing clients to subscribe to any LiveQuery-enabled class regardless of access rules.

As a result, unauthenticated or unauthorized clients can receive real-time events and data changes for objects that should be restricted by CLP, leading to ongoing data exposure.

Affected context

This vulnerability occurs in Parse Server deployments that:

  • Run versions prior to 9.5.2-alpha.3 or 8.6.16
  • Have LiveQuery enabled and in use
  • Rely on class-level permissions (CLP) to restrict access to classes

In this context, LiveQuery subscription paths do not honor CLP rules, so any client able to connect to the LiveQuery endpoint may subscribe to classes that were intended to be access-controlled by CLP for regular queries and operations.

Exploit preconditions

  • Attack surface: Parse Server LiveQuery endpoint (typically WebSocket or similar real-time channel).
  • Required access: Network-level ability to connect to the LiveQuery server (no valid user session or specific role is required).
  • Trigger point: The attacker issues a LiveQuery subscription to a target class that is LiveQuery-enabled, regardless of its CLP configuration.
  • Why exploitation is possible: Authorization logic for class-level permissions is not applied, or is inconsistently applied, to LiveQuery subscription requests, creating a separate path that bypasses CLP checks used for standard data access.

Why this happens

The root cause aligns with CWE-863: Improper Authorization, where the system fails to enforce authorization rules consistently across all access paths.

In this case, Parse Server enforces class-level permissions for typical CRUD and query operations but omits or misapplies those same checks when handling LiveQuery subscriptions.

This creates an authorization gap: the LiveQuery code path trusts that subscriptions are valid without revalidating permissions against CLP, allowing unauthorized clients to observe real-time events for protected classes.

Potential impact

  • Unauthorized clients may receive real-time notifications for data changes in classes that should be restricted by CLP.
  • Sensitive fields or business-critical objects can be exposed as they are created, updated, or deleted.
  • Attackers can passively monitor data usage patterns, user behavior, and internal application events.
  • Data leakage can facilitate further attacks, such as targeted social engineering or abuse of exposed identifiers.
  • Compliance violations may occur if regulated or personal data is exposed to unauthorized parties.

General mitigation guidance

Mitigation focuses on ensuring authorization policies are consistently enforced for all access mechanisms, including real-time features:

  • Align LiveQuery authorization handling with the same class-level permission evaluation used for REST and SDK-based queries.
  • Apply a central authorization layer that all data access paths (REST, SDK, LiveQuery, background jobs) must pass through, minimizing the risk of bypasses.
  • Restrict network exposure of LiveQuery endpoints (e.g., via API gateways, service meshes, or firewall rules) so only trusted frontends can connect.
  • Design data models so especially sensitive data is either not exposed over LiveQuery or is additionally filtered by role, ACL, or field-level restrictions.
  • Employ least-privilege defaults: classes should be non-LiveQuery-enabled or tightly scoped by default, with explicit opt-in for real-time exposure.

How teams detect issues like this

Detection approaches generally center around observing authorization behavior and reviewing real-time access paths:

  • Use static analysis or code review practices to verify that authorization checks are invoked in LiveQuery subscription handlers and any other real-time listeners.
  • Inspect central authorization middleware or policy components to ensure they are consistently called by all entry points, including WebSocket or real-time transports.
  • Implement server-side logging for LiveQuery subscriptions, capturing class names, client identifiers, and effective permissions, and regularly review for anomalous or broad subscriptions.
  • Configure monitoring or SIEM rules to alert on suspicious subscription patterns, such as anonymous users subscribing to sensitive classes.
  • Incorporate automated security testing that exercises LiveQuery endpoints with minimal privileges to confirm that unauthorized data is not returned in real time.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/releases/tag/8.6.16
github.comgithub.com/parse-community/parse-server/releases/tag/9.5.2-alpha.3
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-7ch5-98q2-7289

Frequently asked

questions

Yes. Any client that can reach the LiveQuery endpoint over the network can attempt to subscribe to LiveQuery-enabled classes and receive data, even without valid authentication or proper authorization, depending on deployment configuration.

Not necessarily. The issue specifically allows unauthenticated or unauthorized clients to subscribe to LiveQuery-enabled classes, so authenticated access is not a strict requirement if the LiveQuery endpoint is exposed.

The safest pattern is to centralize authorization enforcement and ensure that the same class-level permissions and access rules applied to standard queries are also applied to LiveQuery and any other real-time or alternative access paths. All subscription requests should be evaluated against CLP and relevant ACLs before being accepted.

Prevent them by designing a unified access-control layer that all data access flows must use, performing security-focused code reviews of non-standard interfaces (such as WebSockets, streaming APIs, and background workers), and including automated tests that verify access control behavior across every supported protocol and feature.

Find out what's already
exploitable in your codebase.