/

CVE-2026-30863

Severity:

CRITICAL RISK

(9.8)

Improper Authentication in Parse Server OAuth JWT Adapters

CVE-2026-30863

Analyzed

Vulnerability type

Category:

Improper Authentication

CWE:

CWE-287, CWE-863

Impact:

Authentication Bypass and Account Compromise

Severity:

CRITICAL RISK

(9.8)

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 Google, Apple, and Facebook auth adapters can skip audience claim validation when their audience-related configuration (Google/Apple clientId, Facebook appIds) is not set, causing JWT verification to accept tokens for other applications.

Under these conditions, an attacker can present a validly signed identity token issued for a different app and be authenticated as any user on the target Parse Server instance.

Affected context

This vulnerability affects Parse Server deployments that integrate Google, Apple, or Facebook as identity providers and rely on JWT-based identity tokens.

The issue arises when the adapter-specific audience configuration is left unset or misconfigured:

  • Google/Apple: clientId not provided
  • Facebook: appIds not configured

In such environments, the JWT verification logic does not enforce that the token's aud (audience) or equivalent claim matches the intended Parse Server application, weakening the trust boundary between identity providers and the backend.

Exploit preconditions

  • Attack surface: Public authentication endpoints on the Parse Server that accept Google, Apple, or Facebook tokens.
  • Required access: Ability to obtain a valid identity token (JWT) from the same identity provider but for a different registered application (e.g., attacker controls or uses another app with the same IdP).
  • Configuration condition: The relevant adapter audience configuration is unset:
  • Google/Apple: missing or empty clientId
  • Facebook: missing or empty appIds
  • Trigger point: The attacker submits the foreign-app JWT to the Parse Server login / auth endpoint.
  • Why exploitation is possible: The JWT verification step only checks signature validity and some token fields, silently skipping audience validation when configuration is absent, so any correctly signed token from the IdP is treated as valid for this Parse Server.

Why this happens

The root cause is an incomplete authentication check where JWT audience (aud) validation is conditionally enforced based on configuration, and silently disabled when that configuration is missing.

Instead of failing closed when clientId or appIds are not configured, the adapters proceed with verification and treat any correctly signed JWT from the identity provider as acceptable.

This maps to:

  • CWE-287: Improper Authentication – the system incorrectly accepts authentication tokens without verifying they were intended for this relying party.
  • CWE-863: Incorrect Authorization – once a foreign token is accepted, access control decisions are made under the false assumption that the presented identity is legitimately authenticated for this backend.

Abstractly, the pattern is: security-critical verification logic that becomes permissive when configuration is missing or incomplete, instead of enforcing strict failure.

Potential impact

  • An attacker may authenticate to the Parse Server using a JWT issued for a different application.
  • An attacker may impersonate arbitrary users whose identities they can map or influence via the external IdP.
  • An attacker could gain full access to user data exposed through Parse APIs under the compromised accounts.
  • An attacker could escalate to administrative or privileged accounts if those are reachable via the affected authentication path.
  • Session fixation or lateral movement between different applications relying on the same identity provider may become possible.

General mitigation guidance

Effective mitigation focuses on enforcing strict token audience validation and avoiding permissive defaults:

  • Treat missing or incomplete identity provider configuration (such as clientId or appIds) as a hard failure, not a reason to skip checks.
  • Always validate that the JWT aud (or equivalent) claim matches an explicit, expected identifier for the Parse Server application.
  • Use a "fail closed" design: if any critical JWT claim (audience, issuer, expiration, nonce where applicable) cannot be validated against configuration, reject the token.
  • Centralize token verification logic to avoid divergent implementations that might omit claim checks.
  • Reduce the privileges granted to identities authenticated via third-party providers, especially for administrative operations, so that a single check failure is less catastrophic.
  • Maintain clear configuration management practices, including validation at service startup to ensure auth adapters are not running with missing required parameters.

How teams detect issues like this

Detection typically involves code, configuration, and runtime analysis:

  • Static analysis and code review:
  • Look for conditional JWT validation logic where audience checks depend on configuration values being set.
  • Flag verification routines that do not compare the aud (and issuer) against explicit expected values.
  • Identify patterns where missing configuration defaults to permissive behavior rather than failing.
  • Configuration audits:
  • Periodically scan Parse Server configurations for unset or empty clientId (Google/Apple) and appIds (Facebook) when the corresponding adapters are enabled.
  • Enforce policies that treat missing auth configuration as a deployment error.
  • Runtime and log analysis:
  • Instrument authentication flows to log when tokens are accepted without full claim validation, or when expected configuration values are missing.
  • Monitor for unusual login patterns, such as multiple accounts apparently authenticating from the same external app or client identifier.
  • Automated tooling:
  • Integrate security linters or SAST tools that understand common JWT verification pitfalls.
  • Use CI/CD policy checks to block deployments where critical authentication settings are not explicitly configured.

Sources

SourceLink
github.comgithub.com/parse-community/parse-server/security/advisories/GHSA-x6fw-778m-wr9v

Frequently asked

questions

Yes. If the affected adapters are exposed over the network and the configuration is incomplete, an attacker can remotely present a valid JWT from the same identity provider but issued to another app and be accepted as an authenticated user.

The attacker needs the ability to obtain a valid identity token from Google, Apple, or Facebook for some application they can access. They do not need direct access to the Parse Server configuration; the exploit works if the server is misconfigured and accepts such tokens.

Ensure that audience-related configuration (clientId for Google/Apple, appIds for Facebook) is explicitly set and that JWT verification fails closed when these values are missing or do not match. All tokens must be checked for correct audience, issuer, and other critical claims before authentication is granted.

Design authentication flows so that missing or invalid configuration causes hard startup failures, centralize JWT verification with mandatory claim checks, and include authentication configuration validation in deployment pipelines and security reviews. Regularly test authentication endpoints with negative test cases, including tokens from other apps, to confirm strict audience enforcement.

Find out what's already
exploitable in your codebase.