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
protectedFieldsto hide sensitive attributes from clients, and - LiveQuery is enabled for those same classes, and
- Clients are allowed to subscribe to LiveQuery with arbitrary
whereclauses.
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
wherefilters referencing protected fields (directly, via dot-notation, or operators like$regex). - Trigger point: Attacker establishes one or more LiveQuery subscriptions whose
whereclause 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
protectedFieldsand 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
whereclauses, 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.

