/

CVE-2026-32594

Severity:

HIGH RISK

(7.3)

Missing Authentication in Parse Server

CVE-2026-32594

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthorized Access and Policy Bypass via GraphQL WebSocket Endpoint

Severity:

HIGH RISK

(7.3)

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 GraphQL WebSocket endpoint for subscriptions fails to enforce the usual Express middleware chain responsible for authentication, introspection control, and query complexity limits.

As a result, an attacker can open a WebSocket connection and perform GraphQL operations without valid credentials, bypass schema introspection restrictions, and issue excessively complex queries that evade configured safeguards.

Affected context

This vulnerability affects deployments of Parse Server that expose the GraphQL WebSocket endpoint for subscriptions in versions prior to 8.6.40 and 9.6.0-alpha.14.

It manifests when the WebSocket-based GraphQL subscription transport is reachable over the network and is expected to be protected by the same middleware stack as HTTP GraphQL requests, but in practice is handled through a separate code path that omits these checks.

Environments that rely on application keys, disabled public introspection, and query complexity limits for protection are particularly exposed.

Exploit preconditions

  • Attack surface: Network-accessible GraphQL WebSocket subscription endpoint on Parse Server.
  • Required access: Ability to initiate a WebSocket connection to the server; no valid application key or API key is required.
  • Trigger point: Establishing a GraphQL WebSocket subscription connection and sending GraphQL operations (queries, mutations, subscriptions) over that channel.
  • Why exploitation is possible: The WebSocket subscription endpoint does not pass through the Express middleware chain, so authentication, introspection restrictions, and query complexity enforcement are never applied to these requests.

Why this happens

The root cause is a mismatch between security assumptions and actual request handling for WebSocket-based GraphQL subscriptions.

While HTTP GraphQL requests are routed through an Express middleware chain that performs authentication, controls schema introspection, and enforces query complexity limits, the WebSocket subscription endpoint follows a separate execution path that omits this middleware.

This design oversight corresponds to CWE-306: Missing Authentication for Critical Function, where a critical interface (GraphQL operations over WebSockets) is left unprotected or less protected than intended, allowing unauthenticated use of capabilities that should require authorization and policy checks.

Potential impact

  • Unauthorized execution of GraphQL operations (queries, mutations, subscriptions) without valid application or API keys.
  • Access to GraphQL schema details via introspection even when public introspection is configured as disabled.
  • Bypass of configured query complexity or depth limits, potentially leading to resource-intensive operations.
  • Increased risk of data exposure depending on existing GraphQL schema authorization rules.
  • Potential denial-of-service conditions due to arbitrarily complex or numerous GraphQL operations sent over unauthenticated WebSocket connections.

General mitigation guidance

Mitigation should focus on ensuring that all GraphQL entry points, including WebSocket-based subscriptions, are consistently subject to the same security controls as HTTP endpoints.

Common defensive patterns include:

  • Routing GraphQL WebSocket connections through the same authentication and authorization middleware chain used for HTTP GraphQL requests.
  • Implementing a centralized access control layer for GraphQL that is transport-agnostic (applies equally to HTTP, WebSocket, and any future protocols).
  • Enforcing introspection controls at the resolver or schema layer so that introspection is not accessible when globally disabled, regardless of transport.
  • Applying query complexity and depth limits in a shared execution pipeline for both HTTP and WebSocket operations.
  • Restricting network exposure of the GraphQL WebSocket endpoint (e.g., via API gateways, reverse proxies, or firewalls) so that only trusted clients or networks can access it.
  • Using least-privilege design in schema and resolvers so that even if an endpoint is mistakenly unauthenticated, data access is still constrained.

How teams detect issues like this

Effective detection involves verifying that all protocol handlers for GraphQL are consistently protected and monitored:

  • Static analysis / configuration review:
  • Inspect server routing to ensure WebSocket subscription handlers invoke the same authentication and authorization middleware as HTTP handlers.
  • Check that introspection and query complexity enforcement logic is centralized and not bound only to HTTP-specific code paths.
  • Code review signals:
  • Separate GraphQL WebSocket setup code that bypasses or duplicates security logic instead of reusing centralized middleware.
  • Conditional authentication logic that only applies to REST or HTTP GraphQL routes.
  • Dynamic and runtime checks:
  • Attempt to connect to the GraphQL WebSocket endpoint without credentials in a staging environment to see whether operations succeed.
  • Use observability tools to identify GraphQL subscription connections that are missing expected authentication claims or headers.
  • Automated tooling:
  • Integrate API security scanners or GraphQL-specific security testing tools to probe both HTTP and WebSocket endpoints for authentication and policy inconsistencies.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/pull/10189
github.comgithub.com/parse-community/parse-server/pull/10190
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-p2x3-8689-cwpg

Frequently asked

questions

Yes. If the GraphQL WebSocket subscription endpoint is exposed over the internet or another untrusted network, an attacker can remotely connect and execute operations without valid credentials.

No. The core issue is that the WebSocket endpoint does not enforce the usual authentication middleware, so a client can interact with GraphQL operations without a valid application key or API key.

The safest approach is to ensure that all GraphQL transports (HTTP and WebSocket) share a unified security pipeline: the same authentication, authorization, introspection controls, and query complexity limits should be applied consistently, ideally via centralized middleware or execution hooks.

To prevent recurrence, treat every new protocol or endpoint as part of a common security architecture: centralize access control and policy enforcement, require design and security reviews for new entry points like WebSockets or server-sent events, and include automated tests that verify authentication and policy enforcement across all GraphQL interfaces.

Find out what's already
exploitable in your codebase.