/

CVE-2026-49448

Severity:

CRITICAL RISK

(9.8)

Authentication Bypass via Source Stage Skipping (CWE-287) in authentik Identity Provider

CVE-2026-49448

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287

Impact:

Unauthorized Access / Authentication Bypass

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

A logic flaw in authentik's authentication pipeline allows the Source stage to be bypassed when an empty POST request is sent.

Under certain configurations, this can let an attacker skip a critical verification step and potentially gain unauthorized access to protected resources.

Affected context

This vulnerability affects authentik deployments that use the Source stage as part of their authentication or enrollment flows.

The issue manifests in environments where HTTP POST requests to the relevant stage endpoint are accepted without robust validation of request body content, allowing the stage logic to complete or be skipped even when the POST is effectively empty.

Impact is most significant when the Source stage is relied upon to enforce identity proofing, upstream identity verification, or other gatekeeping checks before account or session establishment.

Exploit preconditions

  • Attack surface: Public or internal authentik HTTP endpoints that expose the Source stage as part of an authentication or enrollment flow.
  • Required access: Network access to the authentik service; no valid credentials are necessarily required if the endpoint is externally reachable.
  • Trigger point: Sending an empty or effectively content-less POST request to the Source stage endpoint during a flow that expects user or source data.
  • Why exploitation is possible: The flow control logic treats an empty POST as a condition that allows the Source stage to be skipped or considered complete, rather than rejecting the request or enforcing mandatory checks, undermining authentication guarantees (CWE-287).

Why this happens

The root cause lies in improper enforcement of authentication and verification requirements in the Source stage's request-handling logic.

Instead of strictly validating that a POST request contains the required parameters, state, or source-specific data, the implementation allows the stage to progress when the request body is empty.

This behavior effectively weakens the authentication pipeline, creating an unexpected shortcut where a mandatory stage can be bypassed.

Conceptually, this is an instance of CWE-287: Improper Authentication, where the system fails to correctly verify the identity-related context before allowing flow progression or access.

Potential impact

  • An attacker may bypass a configured Source stage and progress further in an authentication or enrollment flow.
  • Accounts could be created or sessions established without proper upstream identity verification.
  • Access controls that assume the Source stage ran successfully can be weakened or invalidated.
  • Depending on deployment and flow design, attackers could gain unauthorized access to applications or sensitive data integrated with authentik.

General mitigation guidance

Effective mitigation focuses on hardening authentication flow logic and enforcing strict validation at each stage:

  • Require that all mandatory stages (including Source) explicitly validate input presence, structure, and semantics before allowing the flow to proceed.
  • Treat empty or malformed POST requests to authentication stages as failures that terminate or restart the flow, rather than as signals to skip checks.
  • Design flows so that each stage has a clear contract: required inputs, preconditions, and explicit failure modes, avoiding implicit "success" on missing data.
  • Minimize reliance on a single stage for critical checks; use layered verification where feasible (e.g., combining source verification with additional policy checks).
  • Apply least-privilege principles to derived identities and sessions, assuming that individual stages might fail and validating authorization separately from weak identity signals.

How teams detect issues like this

Detection can combine code-level analysis and behavioral monitoring:

  • Static analysis / code review: Look for flow or stage handlers that:
  • Accept POST requests but do not check for required fields before advancing the flow.
  • Use lenient conditions (e.g., treating None or empty payloads as valid) in authentication or identity-establishing logic.
  • Allow success or continuation paths without explicit verification outcomes.
  • Configuration and flow review: Audit authentik flows to confirm that each stage defines required inputs and explicit failure behavior for missing data.
  • Runtime monitoring: Inspect logs for suspicious patterns such as:
  • Frequent empty POST requests to authentication stages.
  • Flows completing Source stages without associated source data or events.
  • Policy enforcement: Integrate automated checks in CI/CD to flag newly added authentication stages that omit strict validation of incoming data, using SAST tools or custom linters where available.

Sources

SourceLink
github.comgithub.com/goauthentik/authentik/security/advisories/GHSA-xp7f-xjjx-gwm8

Frequently asked

questions

Exploitability depends on how exposed the relevant Source stage endpoints are and how critical that stage is within your flows. If an attacker can reach a vulnerable flow that trusts the Source stage for identity verification, bypassing it with an empty POST can be highly impactful.

Not necessarily. If the Source stage endpoint is reachable without prior authentication and is used early in the flow, an attacker may only need network access to the authentik service to attempt the bypass.

Ensure that all authentication stages—especially the Source stage—enforce strict input requirements and explicitly fail when required data is missing or empty, rather than implicitly treating such requests as acceptable or skippable.

Adopt a defensive design for authentication flows: define clear contracts for each stage, validate that all necessary inputs are present and well-formed, enforce explicit failure paths on invalid or missing data, and regularly review flow definitions and code for paths that allow progression without successful verification.

Find out what's already
exploitable in your codebase.