Summary
An authentication bypass in Parse Server's third-party login handling allows an attacker to impersonate any user who has linked an external authentication provider, as long as the attacker knows that user's provider ID.
When the allowExpiredAuthDataToken option is set to true, Parse Server may issue a valid session token without verifying valid credentials, effectively granting full account access.
Affected context
This vulnerability occurs in Parse Server deployments that:
- Are configured with third-party authentication providers (e.g., OAuth, social login).
- Have the
allowExpiredAuthDataTokenserver option explicitly set totrue. - Accept login requests that reference previously linked provider IDs.
In this configuration, Parse Server may treat possession or knowledge of a provider ID as sufficient proof of identity, even when the linked authentication data is expired or no longer validated against the provider.
Exploit preconditions
- Attack surface: Public Parse Server login endpoints that support third-party provider authentication.
- Required access: Ability to send crafted authentication requests to the Parse Server; knowledge of a target user's provider ID (e.g., OAuth subject ID, social login identifier).
- Trigger point: A login attempt against an account that has linked an external provider, while
allowExpiredAuthDataTokenis enabled. - Why exploitation is possible: The server's authentication logic relies on the presence of third-party auth data and the provider ID, but with
allowExpiredAuthDataToken = true, it may skip or weaken checks against the external provider and accept stale or insufficient auth data as valid proof of identity.
Why this happens
The root cause lies in incorrect authentication logic for third-party provider accounts when expired auth data is allowed.
Instead of strictly verifying that an access token or assertion from the provider is valid and current, the implementation effectively trusts the linkage record and its provider ID as sufficient to authenticate, as long as expired tokens are permitted.
This maps to CWE-287: Improper Authentication, where the system fails to verify the claimant's identity with robust evidence and instead bases access control on an identifier that is not secret and not designed to function as an authentication factor.
Potential impact
- Full account takeover for users with linked third-party authentication providers.
- Unauthorized access to personal or sensitive data stored under compromised Parse users.
- Abuse of application functionality under another user's identity (e.g., actions, transactions, or content changes).
- Escalation to administrative capabilities if privileged accounts use third-party authentication.
- Lateral movement within an ecosystem that trusts Parse-issued session tokens across multiple services.
General mitigation guidance
Effective mitigation focuses on tightening authentication semantics and removing trust in weak identifiers:
- Ensure third-party authentication flows always require proof of possession of a valid, non-expired token or assertion from the provider, independent of local flags.
- Treat provider IDs as identifiers only, never as secrets or sufficient authenticators.
- Avoid configuration options that permit expired or unverifiable auth data to be treated as valid; prefer fail-closed behavior when verification is not possible.
- Introduce defense-in-depth checks that tie session issuance to successful external provider validation and robust token lifetime checks.
- Apply least privilege to accounts and sessions so that a single account compromise has constrained impact.
How teams detect issues like this
Detection strategies are primarily focused on configuration review and authentication flow analysis:
- Use configuration audits (code-based or infrastructure-as-code scans) to flag Parse Server instances where
allowExpiredAuthDataTokenis set totrue. - Apply static and dynamic application security testing to inspect login paths, verifying that session tokens are only issued after validating current, non-expired credentials with third-party providers.
- During code review, look for authentication flows that:
- Accept an external identifier (e.g., provider ID) without verifying the corresponding token.
- Treat expired or unverifiable external auth data as acceptable for login.
- Implement logging and anomaly detection on authentication endpoints to identify patterns where logins occur without corresponding third-party provider interactions or from unusual IPs/devices for a given account.

