/

CVE-2026-48489

Severity:

HIGH RISK

(7.5)

Access Control Bypass (CWE-863) via Symfony Failure Path

CVE-2026-48489

Analyzed

Vulnerability type

Category:

Access Control Bypass

CWE:

CWE-863

Impact:

Unauthorized Access to Protected Routes

Severity:

HIGH RISK

(7.5)

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 Symfony's DefaultAuthenticationFailureHandler allows unauthenticated clients to dispatch subrequests to access_control-protected GET routes when failure_forward: true is enabled and _failure_path is supplied in the request.

Under these conditions, firewall listeners can be skipped, potentially exposing protected endpoints to users who have not successfully authenticated.

Affected context

This vulnerability arises in Symfony-based applications using the security component where:

  • The DefaultAuthenticationFailureHandler is in use
  • failure_forward: true is configured on the firewall
  • The application respects the request-supplied _failure_path parameter

In such setups, failed login attempts can be transformed into subrequests targeting GET routes that are normally protected by access_control, but which may be processed without the expected firewall listener checks.

Exploit preconditions

  • Attack surface: Publicly exposed login or authentication endpoints in a Symfony application.
  • Required access: Ability to issue HTTP requests to the affected application (no prior authentication is required).
  • Trigger point: A failing authentication attempt where the attacker supplies a crafted _failure_path that points to a protected GET route.
  • Why exploitation is possible: The failure handler trusts the request-provided _failure_path and forwards the subrequest while failure_forward: true is enabled, allowing the subrequest to bypass normal firewall listener execution and reach routes that should require authentication.

Why this happens

The underlying issue is an access control misconfiguration pattern mapped to CWE-863: Incorrect Authorization.

Symfony's DefaultAuthenticationFailureHandler is honoring a user-controlled _failure_path parameter when forwarding on authentication failure, effectively allowing untrusted input to influence the internal routing of subrequests.

Because the forwarded subrequest can target access_control-protected GET routes without re-engaging the usual firewall listeners, the intended authorization checks are not consistently applied, resulting in a logic flaw where protected functionality becomes reachable to unauthenticated users.

Potential impact

  • Unauthenticated users may access routes that were intended to be restricted to logged-in users.
  • Sensitive information exposed via protected GET endpoints could be disclosed.
  • Business logic tied to protected routes can be invoked without proper authentication.
  • Application-level security assumptions around firewall and access_control enforcement can be undermined.

General mitigation guidance

Effective mitigation centers on reducing trust in request-controlled routing parameters and enforcing consistent authorization checks:

  • Avoid honoring user-supplied path parameters (such as _failure_path) for security-sensitive flows, or constrain them to a fixed, vetted set of destinations.
  • Ensure that failure handlers and other internal dispatch mechanisms always pass through the same firewall and access_control rules as direct requests.
  • Separate public and protected endpoints clearly and avoid reusing protected routes as failure or redirection targets.
  • Design authentication workflows so that failure handling does not provide alternative, less-checked code paths into protected functionality.

How teams detect issues like this

Detection typically focuses on identifying inconsistent authorization flows and untrusted routing inputs:

  • Use static analysis or code review to flag handlers that rely on request parameters (e.g., _failure_path) to determine internal routing or forwarding targets.
  • Review security configuration for failure_forward: true and confirm that forwarded requests still traverse firewall and access_control logic.
  • Implement application-level tests that attempt to access protected routes via failed authentication flows and alternative dispatch paths.
  • Employ automated configuration and code scanning tools that highlight discrepancies between declared access control rules and actual execution paths.

Sources

SourceLink
github.comgithub.com/symfony/symfony/commit/c48a4276309e11aedeeb0ce3a89dfbf0b4fe04ff
github.comgithub.com/symfony/symfony/releases/tag/v5.4.53
github.comgithub.com/symfony/symfony/releases/tag/v6.4.41
github.comgithub.com/symfony/symfony/releases/tag/v7.4.13
github.comgithub.com/symfony/symfony/security/advisories/GHSA-6h46-9jf5-q59x

Frequently asked

questions

Yes. The flaw is triggered by a failing authentication attempt, so an attacker only needs the ability to send crafted requests to the login endpoint with a malicious _failure_path.

Only network access to the affected Symfony application is required. No prior authentication or special privileges are needed to attempt exploitation, as the attack targets the error-handling path of login requests.

The safest pattern is to avoid using user-controlled parameters to determine failure paths and to ensure that any forwarded requests on authentication failure always pass through the same firewall and access_control checks as normal requests.

Treat internal routing and forwarding decisions as security-sensitive, avoid trusting request-supplied paths for protected flows, and validate that alternative execution paths (such as error handlers, redirects, and subrequests) consistently enforce authorization policies in tests and code reviews.

Find out what's already
exploitable in your codebase.