Summary
Parse Server's class-level protectedFields permission can be bypassed when attackers use dot-notation in query filters and sort parameters to access sub-fields of protected properties.
This bypass enables a binary oracle-style information disclosure, allowing gradual enumeration of data that should be shielded by protectedFields in both MongoDB and PostgreSQL-backed deployments.
Affected context
The vulnerability arises in Parse Server deployments that use class-level permissions (CLPs) with protectedFields to restrict access to sensitive data.
It manifests when client applications can submit queries using dot-notation in where clauses or sort parameters, while the access control logic does not consistently apply protectedFields rules to sub-fields of protected properties.
Both MongoDB and PostgreSQL backends are impacted, and the issue is relevant whenever untrusted clients can construct or influence Parse queries directly.
Exploit preconditions
- Attack surface: Parse Server query API (REST, GraphQL, or SDKs that allow where/sort expressions).
- Required access: Ability to issue queries against classes with
protectedFieldsconfigured (e.g., authenticated user, API client, or compromised app context). - Trigger point: Queries that use dot-notation (e.g.,
protectedField.subField) inwherefilters ororder/sort arguments. - Why exploitation is possible: The authorization layer applies
protectedFieldsto the top-level field name but fails to enforce equivalent restrictions on sub-fields referenced via dot-notation, allowing an oracle-style inference of protected data.
Why this happens
This vulnerability stems from incomplete enforcement of access control rules, mapping directly to CWE-284: Improper Access Control.
The protectedFields CLP mechanism is designed to prevent specific fields from being read by certain users or roles, but the implementation assumes protection at the top-level key only.
When dot-notation is used (e.g., nested JSON or document fields), the access control checks do not normalize or canonicalize the field path back to its protected parent.
As a result, the query engine still evaluates filters and sort operations on sub-fields of protected properties, leaking side-channel information about the underlying values and enabling an attacker to iteratively infer them.
Potential impact
- Unauthorized discovery of sensitive user attributes stored in protected fields.
- Enumeration of protected application metadata (e.g., feature flags, internal state, configuration-like fields).
- Circumvention of privacy controls that rely on
protectedFieldsto hide specific properties from certain roles. - Increased effectiveness of targeted attacks (e.g., account takeover attempts informed by leaked profile attributes).
- Regulatory or compliance exposure where protected data includes personal or regulated information.
General mitigation guidance
Effective mitigation generally focuses on strengthening and centralizing access control enforcement around field paths:
- Treat nested and dot-notation field references as canonical children of their top-level fields, and apply
protectedFieldslogic uniformly to both. - Normalize/resolve field paths (e.g.,
profile.address.city) to their root protected field (e.g.,profile) before performing authorization checks. - Design queries and APIs so clients have limited flexibility in constructing arbitrary field expressions, preferring server-side whitelists of readable fields.
- Apply least-privilege principles to roles and CLPs, ensuring the minimum set of fields is exposed to each client role.
- Use defense-in-depth by applying validation and authorization checks at multiple layers (e.g., API gateway, business logic, and data access layer) rather than relying on a single check.
How teams detect issues like this
Detection focuses on identifying inconsistent authorization behavior and risky query patterns:
- Static analysis / code review:
- Look for code paths where client-controlled query objects are passed directly into Parse Server query APIs without normalization or validation of field paths.
- Check custom schema, plugins, or middleware that interact with nested fields to ensure they honor
protectedFieldssemantics. - Configuration and policy review:
- Review CLP and
protectedFieldsconfiguration to spot classes with sensitive data and broad read permissions. - Verify that any custom authorization logic accounts for nested/dot-notation fields.
- Runtime monitoring and logging:
- Log queries that reference protected fields or their children via dot-notation; alert on unusual patterns or high-volume probing behavior.
- Implement anomaly detection for sequences of binary-style probing queries suggesting an oracle attack.
- Automated testing:
- Add regression tests that attempt to query or sort on sub-fields of protected fields and assert that no information is exposed.
- Incorporate these tests into CI pipelines to guard future changes to CLP/authorization logic.

