/

CVE-2026-31872

Severity:

HIGH RISK

(7.5)

Authorization Bypass / Access Control Misconfiguration

CVE-2026-31872

Analyzed

Vulnerability type

Category:

Authorization Bypass / Access Control Misconfiguration

CWE:

CWE-284

Impact:

Unauthorized Information Disclosure of Protected Fields

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 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 protectedFields configured (e.g., authenticated user, API client, or compromised app context).
  • Trigger point: Queries that use dot-notation (e.g., protectedField.subField) in where filters or order/sort arguments.
  • Why exploitation is possible: The authorization layer applies protectedFields to 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 protectedFields to 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 protectedFields logic 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 protectedFields semantics.
  • Configuration and policy review:
  • Review CLP and protectedFields configuration 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.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/releases/tag/8.6.32
github.comgithub.com/parse-community/parse-server/releases/tag/9.6.0-alpha.6
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-r2m8-pxm9-9c4g

Frequently asked

questions

Exploitability depends on how heavily your application relies on protectedFields to guard sensitive data and how much query freedom clients have. Any environment where untrusted clients can issue or influence where/sort parameters against classes with protected fields is potentially exposed.

Not necessarily. The attacker typically needs only the level of access required to query the affected classes (for example, a standard authenticated user or even an anonymous client, depending on your CLPs). They do not need administrative or server-level access—just the ability to send crafted queries.

Ensure that access control checks treat field paths holistically: normalize dot-notation and nested fields to their root protected field and apply protectedFields consistently to any descendant. Combine this with stricter CLPs and, where possible, limit which fields are queryable or sortable by each role.

Architect authorization so it is centralized, schema-aware, and path-normalizing. During design and review, explicitly test for bypasses via nested fields, dot-notation, and alternative query operators. Regularly add security-focused tests around CLPs, enforce least privilege for data exposure, and integrate automated checks that flag new query capabilities that might sidestep existing protections.

Find out what's already
exploitable in your codebase.