/

CVE-2026-34532

Severity:

CRITICAL RISK

(9.1)

Authorization Bypass in Parse Server Cloud Functions

CVE-2026-34532

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Unauthenticated Access to Protected Cloud Functions

Severity:

CRITICAL RISK

(9.1)

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

A logic flaw in Parse Server's Cloud Function routing allows attackers to bypass validator-based access controls by crafting function names that traverse the JavaScript prototype chain.

When certain combinations of function-declared handlers and plain-object or arrow-function validators are used, unauthenticated callers can invoke Cloud Functions that should be protected by requireUser, requireMaster, or custom validators.

Affected context

This vulnerability affects Parse Server deployments that expose Cloud Functions over HTTP or through client SDKs and rely on validators for access control.

It becomes relevant when:

  • Cloud Function handlers are declared using the function keyword, and
  • The associated validators are implemented as plain objects or arrow functions, and
  • The application depends on validator-based controls (e.g., requireUser, requireMaster, custom checks) to restrict access.

In such setups, the internal trigger store can resolve handlers via the JavaScript prototype chain while the validator store does not mirror this resolution, creating an inconsistency in how protection is applied.

Exploit preconditions

  • Attack surface: Public or semi-public endpoints exposing Parse Server Cloud Functions (e.g., REST endpoints, mobile/web SDK calls).
  • Required access: Network access to the Parse Server API; no valid user session or credentials are strictly required if the target function relies solely on validators for protection.
  • Trigger point: Invocation of a Cloud Function using a specially crafted function name that appends prototype.constructor in the URL or client request.
  • Why exploitation is possible: The trigger store resolves the Cloud Function handler through its prototype chain, but the validator store does not perform equivalent prototype traversal. As a result, the handler is found and executed while no matching validator is applied, effectively skipping access control checks.

Why this happens

The root cause lies in inconsistent authorization enforcement between handler resolution and validator resolution within the Cloud Function trigger mechanism.

In certain configurations, the handler lookup walks the JavaScript prototype chain (e.g., via prototype.constructor), but the validator lookup operates only on a direct mapping without mirroring this prototype traversal. This mismatch means a handler can be successfully resolved and executed even when no corresponding validator is found for the traversed name.

Conceptually, this maps to CWE-863: Incorrect Authorization, where a component performs access control checks against one logical identifier or path while executing actions based on another, more permissive resolution path. The underlying bug class is an authorization logic error tied to prototype inheritance behavior in JavaScript and incomplete alignment of access control with actual execution paths.

Potential impact

  • Unauthenticated callers may invoke Cloud Functions intended to require authenticated users.
  • Attackers could gain access to operations protected by requireMaster, potentially exposing or modifying sensitive application data.
  • Business logic that assumes validated or privileged contexts can be executed without any of the expected preconditions.
  • Data integrity and confidentiality may be compromised if privileged Cloud Functions perform administrative actions, bulk updates, or sensitive queries.
  • Application-level invariants and security controls implemented in Cloud Functions can be bypassed, leading to broader compromise depending on function capabilities.

General mitigation guidance

Effective mitigation focuses on aligning authorization checks with all actual execution paths and reducing reliance on fragile name-based or prototype-sensitive patterns:

  • Ensure that access control is enforced as close as possible to the execution point of Cloud Functions, using mechanisms that are not influenced by prototype chain traversal.
  • Prefer authorization schemes that bind validators to handlers in a structurally robust manner (e.g., explicit registration APIs or metadata) rather than relying on parallel maps that can diverge.
  • Avoid patterns where handler and validator resolution can differ (such as relying implicitly on JavaScript prototype mechanics); treat prototype-accessible properties as part of the attack surface.
  • Apply defense-in-depth by validating authorization both at the routing layer and inside function bodies, especially for highly sensitive operations.
  • Use least-privilege design for Cloud Functions so that even if a function is reached unexpectedly, it operates with minimal capabilities and access to sensitive data.

How teams detect issues like this

Detection can focus on both code-level patterns and behavioral anomalies in production:

  • Static analysis / code review:
  • Look for Cloud Functions where handlers are declared using the function keyword while validators are plain objects or arrow functions, particularly when bound indirectly.
  • Flag any logic that constructs function names or allows user input to influence Cloud Function routing keys.
  • Review the mapping between trigger registration and validators to confirm one-to-one, structurally enforced relationships.
  • Policy enforcement:
  • Enforce coding standards that require explicit, centralized registration of Cloud Functions and their validators, avoiding parallel structures that can drift.
  • Require that sensitive operations include in-function authorization checks and not rely solely on external validators.
  • Runtime monitoring:
  • Monitor logs for Cloud Function calls that lack associated validator execution or originate from unauthenticated contexts where authentication is expected.
  • Alert on suspicious function names that include prototype-related segments (e.g., prototype.constructor) or other unusual property access patterns.

Automated code review tools and application security scanners can help flag these patterns, but manual review of Cloud Function registration and authorization logic remains important.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/commit/4fc48cf28f22eea200d74d883505f485234a48d7
github.comgithub.com/parse-community/parse-server/commit/dc59e272665644083c5b7f6862d88ce1ef0b2674
github.comgithub.com/parse-community/parse-server/pull/10342
github.comgithub.com/parse-community/parse-server/pull/10343
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-vpj2-qq7w-5qq6

Frequently asked

questions

Yes. Any attacker with network access to the Parse Server API can potentially exploit this issue by crafting specific Cloud Function invocation requests, without needing valid user credentials, if the target function relies on validators for protection.

Not necessarily. The vulnerability specifically allows bypassing validators such as requireUser and requireMaster. If a Cloud Function is only guarded by such validators and not by other mechanisms (e.g., IP allowlists, gateway-level checks), an unauthenticated caller can attempt to exploit it.

The safest pattern is to ensure that handler resolution and authorization enforcement are tightly coupled and use the same resolution logic, eliminating any discrepancy introduced by prototype traversal. Additionally, enforce in-function authorization checks for sensitive operations and avoid designs where validators can be skipped due to alternate naming or inheritance paths.

To prevent similar issues, design access control so it is:

  • Centralized and consistent across all execution paths,
  • Independent of prototype-chain or name-mangling behavior,
  • Validated during code review and automated testing.

Combining strong coding standards, automated checks for authorization coverage, and routine security reviews of routing and function registration logic helps reduce the risk of future authorization bypasses.

Find out what's already
exploitable in your codebase.