/

CVE-2026-32098

Severity:

HIGH RISK

(7.5)

Information Exposure in Parse Server Protected Fields

CVE-2026-32098

Analyzed

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200

Impact:

Sensitive Data Disclosure

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's LiveQuery feature can be abused to infer the values of protected fields by observing whether subscription events are delivered for queries that filter on those fields.

An attacker who can create LiveQuery subscriptions can turn the server into a boolean oracle, gradually learning sensitive field values in classes that both use protectedFields and have LiveQuery enabled.

Affected context

This vulnerability appears in Parse Server deployments where:

  • Class-Level Permissions define protectedFields to hide sensitive attributes from clients, and
  • LiveQuery is enabled for those same classes, and
  • Clients are allowed to subscribe to LiveQuery with arbitrary where clauses.

In that context, even though protected fields are not returned in query results, their values can still influence whether LiveQuery events are sent, allowing an attacker to infer those values indirectly.

Exploit preconditions

  • Attack surface: Parse Server LiveQuery endpoint (typically WebSocket-based).
  • Required access: Ability to authenticate or connect as any user permitted to:
  • Subscribe to LiveQuery on a target class, and
  • Use where filters referencing protected fields (directly, via dot-notation, or operators like $regex).
  • Trigger point: Attacker establishes one or more LiveQuery subscriptions whose where clause predicates depend on the value of one or more protected fields.
  • Why exploitation is possible: LiveQuery filtering logic evaluates predicates against full object state, including protected fields, and then exposes the evaluation result as a side effect: if the predicate is true, the server sends an event; if false, it stays silent. This turns access-controlled data into a boolean side channel.

Why this happens

The root cause is a mismatch between data access controls and event emission behavior in the LiveQuery subsystem.

Class-Level Permissions with protectedFields are designed to prevent direct exposure of certain fields in query results.

However, LiveQuery still allows clients to construct where clauses that reference those fields, and the evaluation outcome affects whether an event is sent.

Because the presence or absence (or timing) of an event becomes observable to the client, the system leaks information about the underlying protected data without ever including it in the payload.

Conceptually, this maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, realized via a boolean oracle/side-channel on access-controlled fields.

Potential impact

  • Attackers can infer the values of fields that are intended to be protected by Class-Level Permissions.
  • Sensitive attributes (e.g., flags, roles, feature toggles, account states) can be learned through repeated LiveQuery probes.
  • Incremental reconstruction of user or object profiles by combining multiple boolean tests.
  • Violation of privacy or business logic confidentiality even when direct read access to protected fields is denied.
  • Potential use of leaked information to fine-tune further attacks such as targeted phishing, privilege escalation attempts, or business abuse.

General mitigation guidance

Effective mitigation focuses on aligning event semantics with access control so that protected data does not influence observable behavior:

  • Ensure LiveQuery filters cannot reference protected fields, including via nested/dot-notation paths or pattern operators such as $regex, when the subscriber is not authorized to read those fields.
  • Decouple event delivery from raw predicate evaluation on protected fields; for example, apply ACL/CLP and field-level checks before deciding whether an event should be sent to a subscriber.
  • Treat the fact that "an object matches a given predicate" as potentially sensitive if the predicate depends on protected data, and avoid exposing that match result to unauthorized clients.
  • Apply a principle of least privilege to LiveQuery subscriptions: constrain who can subscribe to which classes and what filters they can use, especially on classes that contain highly sensitive data.
  • Favor safe-by-default server configurations where real-time subscriptions on sensitive classes are disabled unless explicitly assessed and approved.

How teams detect issues like this

Teams can look for this class of issue through a combination of code-level and behavior-level analysis:

  • Code review: Inspect LiveQuery implementation paths for places where full objects (including protected fields) drive predicate evaluation and event emission without re-applying field-level permissions per-subscriber.
  • Static analysis: Define rules that flag uses of access-controlled or protected fields in query-building logic that feed real-time subscription or notification systems without adequate authorization checks.
  • Configuration review: Periodically audit Parse Server configuration to identify classes where protectedFields and LiveQuery are both enabled, then verify that subscription authorization logic accounts for field protections.
  • Runtime monitoring: Watch for clients creating unusually granular or patterned LiveQuery subscriptions, especially with many slightly varied where clauses, which may indicate oracle-style probing of protected values.
  • Automated security testing tools and fuzzers tailored to API query interfaces can help detect boolean oracle behavior by observing response/event patterns in response to crafted predicates.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/releases/tag/8.6.35
github.comgithub.com/parse-community/parse-server/releases/tag/9.6.0-alpha.9
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-j7mm-f4rv-6q6q

Frequently asked

questions

Yes. If the Parse Server LiveQuery endpoint is exposed to the internet and a remote client can authenticate (or otherwise connect) and create subscriptions on affected classes, the attack can be carried out remotely through crafted LiveQuery filters.

Not necessarily. The attacker only needs the same level of access as any client allowed to subscribe to LiveQuery on the target class. Exploitation does not require direct read access to the protected fields—only the ability to filter on them and observe event delivery.

The most robust fix pattern is to ensure that protected or otherwise access-controlled fields cannot influence observable outcomes for unauthorized clients. In practice, this means enforcing field-level permissions when evaluating LiveQuery filters and preventing unprivileged subscribers from using predicates that reference protected fields.

When adding real-time or event-driven features, design access control such that all outputs (including the presence, absence, or timing of events) are treated as sensitive if they depend on protected data. Model protected fields as part of the threat surface for side channels, and enforce a consistent authorization model across queries, subscriptions, and notifications. Regular security design reviews for real-time APIs can help catch these issues early.

Find out what's already
exploitable in your codebase.