Skip to main content

Symfony Routing CVE-2026-48784

| EUVDEUVD-2026-44371 MEDIUM
Encoding Error (CWE-172)
2026-06-15 https://github.com/symfony/symfony GHSA-h5x3-xfc9-m39h
5.1
CVSS 4.0 · Vendor: https://github.com/symfony/symfony
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify route with permissive slash-accepting parameter
  2. Delivery
    Submit chained '../' value as route parameter
  3. Exploit
    UrlGenerator encodes only alternating dot-segments via strtr overlap bug
  4. Execution
    Generated URL contains mix of encoded and raw dot-segments
  5. Persist
    RFC 3986-conformant consumer normalizes path before percent-decoding
  6. Impact
    Request resolves to unintended resource outside originating route

Vulnerability Assessment

Weakness
CWE
Exploitation Conditions

Two specific non-default conditions must both be present for exploitation to be possible. First, at least one Symfony route must define a path parameter with a permissive requirement that explicitly allows forward slashes - for example, ['path' => '.+'] or ['path' => '.*'] in the route definition. Default Symfony route parameters use [^/]+ and are therefore not exploitable regardless of input. Second, a strict RFC 3986-conformant consumer must process the generated URL downstream of Symfony: this includes reverse proxies (nginx with merge_slashes-class normalization, Varnish, HAProxy in strict mode), API gateways, or HTTP client libraries that perform dot-segment removal before percent-decoding. WHATWG-conformant browsers are explicitly excluded from the defense model and do not trigger this path. Exploitation is further limited to chained sequences of two or more consecutive ../ or ./ segments; a single ../ or ./ was correctly encoded by the original strtr implementation and remains safe.

Impact

No CVSS score has been assigned by NVD or the vendor at time of analysis, so risk signals must be derived from structural and contextual evidence. The vulnerability is not present in CISA KEV, no EPSS score is available, and no public proof-of-concept has been identified - exploitation likelihood appears low at this time. The attack surface is narrow: both a non-default permissive route parameter requirement (.+, .*) and an RFC 3986-conformant downstream consumer must be present simultaneously; neither condition exists in a baseline Symfony deployment. The 'Information Disclosure' tag and CWE-172 classification indicate the impact ceiling is path traversal to unintended resources, not code execution. The existence of a prior related vulnerability (CVE-2026-45065) in the same code path suggests the encoding logic was under-tested for chained sequences and systemic review was warranted. Patch availability across all maintained branches (5.4, 6.4, 7.4, 8.0, 8.1) lowers residual risk significantly for patched deployments. Applications not exposing slash-accepting route parameters are not affected regardless of patch status.

Exploit ScenarioDerived

An attacker identifies a Symfony application with a route such as /files/{path} where the path parameter uses a .+ requirement permitting slashes, and submits a request with a path value of ../../... The UrlGenerator produces /files/%2E%2E/../%2E%2E instead of the correct /files/%2E%2E/%2E%2E/%2E%2E. When this URL is forwarded by a reverse proxy performing RFC 3986 dot-segment normalization, it resolves to / or another unintended base path, potentially exposing resources that the routing layer was intended to protect. No public proof-of-concept code has been identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jun 15, 2026

Symfony's UrlGenerator encodes only alternating dot-segments in chained ../ or ./ sequences due to a strtr() advancement bug, producing URLs that RFC 3986-conformant reverse proxies, API gateways, and HTTP clients collapse to unintended paths. Routes exposing parameters with permissive requirements (.+, .*) that permit slashes are the exploitable surface when attacker-controlled values contain multiple consecutive dot-segments. No active exploitation is confirmed (not in CISA KEV, no EPSS score assigned), but vendor-confirmed patches are available across all maintained Symfony branches, and the vulnerability shares the same route round-trip integrity class as the previously disclosed CVE-2026-45065.

RemediationAI

Upgrade symfony/routing or symfony/symfony to a patched release: 5.4.53, 6.4.41, 7.4.13, or 8.0.13, as documented in the advisory at https://github.com/symfony/symfony/security/advisories/GHSA-h5x3-xfc9-m39h. The single authoritative fix commit is https://github.com/symfony/symfony/commit/4b63c3a3f7af04ecd79c89a594b0b02a01990b1d. If immediate patching is not feasible, audit all route definitions for parameters using permissive requirements such as .+ or .* that allow slashes, and tighten those constraints to explicitly reject dot-containing values (e.g., [^./]+); this eliminates the attack surface without upgrading but requires application-level review and may break legitimate use cases where slash-delimited path parameters are intentional. A secondary compensating control is to validate route parameter values at the application boundary before passing them to UrlGenerator, rejecting inputs containing consecutive dot-segment patterns. No generic network-level controls (WAF rules, port blocking) reliably address this issue because the flaw is in URL generation logic rather than inbound request parsing.

Affected VersionsENISA

routing < 5.4.53
symfony 6.0.0-BETA1, < 6.4.41
routing 7.0.0-BETA1, < 7.4.13
symfony < 5.4.53
symfony 8.0.0-BETA1, < 8.0.13
routing 6.0.0-BETA1, < 6.4.41
symfony 7.0.0-BETA1, < 7.4.13
routing 8.0.0-BETA1, < 8.0.13

Affected Packages

composer symfony/routing fix: 5.4.53, 6.4.41, 7.4.13, 8.0.13
composer symfony/symfony fix: 5.4.53, 6.4.41, 7.4.13, 8.0.13
euvd routing fix: 5.4.53
euvd routing_6_0_0_beta1 fix: 6.4.41
euvd routing_7_0_0_beta1 fix: 7.4.13
euvd routing_8_0_0_beta1 fix: 8.0.13
euvd symfony fix: 5.4.53
euvd symfony_6_0_0_beta1 fix: 6.4.41
euvd symfony_7_0_0_beta1 fix: 7.4.13
euvd symfony_8_0_0_beta1 fix: 8.0.13

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 10 packages in composer, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The defect resides in Symfony\Component\Routing\Generator\UrlGenerator::doGenerate() within the symfony/routing and symfony/symfony Composer packages (CPE: pkg:composer/symfony_routing, pkg:composer/symfony_symfony). The method is responsible for percent-encoding . and .. path segments so that generated URLs survive RFC 3986 §5.2.4 dot-segment normalization intact - a normalization step that strict consumers perform before percent-decoding. The original implementation used strtr($url, ['/../' => '/%2E%2E/', '/./' => '/%2E/']), but PHP's strtr advances its scan position past the trailing / of each consumed match; in a chained sequence like /../../../, this causes every second dot-segment to be left as a raw ... The root cause is classified as CWE-172 (Encoding Error). The fix replaces the strtr call with an explode('/', $url)/foreach/implode pass that evaluates each segment individually and is immune to the overlap problem. WHATWG-conformant browsers already interpret %2E/%2E%2E as dot-segments and were never protected by this encoding; the defense applies exclusively to RFC 3986-conformant server-to-server or server-to-proxy communication.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (https://github.com/symfony/symfony) PRIMARY 5.1 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:A/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N
vuln.today AI 5.4 MEDIUM

AC:H because exploitation requires both non-default permissive slash-accepting route constraints and an RFC 3986-conformant downstream consumer; S:C because normalized URLs can reach resources outside the originating route's intended scope.

3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N
4.0 AV:N/AC:H/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N

Primary rating from Vendor (https://github.com/symfony/symfony).

CVSS VectorVendor: https://github.com/symfony/symfony

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
Low
Subsequent system: Integrity
Low
Subsequent system: Availability
None

Lifecycle Timeline

1
CVSS changed
Jul 14, 2026 - 20:22 NVD
5.1 (MEDIUM)

DescriptionCVE.org

Description

Symfony\Component\Routing\Generator\UrlGenerator::doGenerate() percent-encodes . and .. path segments so that the generated URL still resolves to the originating route after RFC 3986 §5.2.4 dot-segment removal (which strict RFC-3986 consumers - routers, reverse proxies, HTTP clients - perform *before* percent-decoding).

The encoding was implemented as strtr($url, ['/../' => '/%2E%2E/', '/./' => '/%2E/']) plus a trailing-segment fixup. strtr advances past the trailing / of each match, so the next dot-segment in a chained sequence was left unescaped:

InputOutput (before fix)Expected
/../../..//%2E%2E/../%2E%2E//%2E%2E/%2E%2E/%2E%2E/
/foo/../../../bar/foo/%2E%2E/../%2E%2E/bar/foo/%2E%2E/%2E%2E/%2E%2E/bar

When a route exposes a parameter constrained by a permissive requirement (.+, .*, or similar) that accepts dots and slashes, attacker-controlled chained .. or . segments produce a generated URL that, under strict RFC 3986 normalization, collapses to a different path than the originating route. The Twig path() / url() helpers and any server-side use of UrlGenerator are affected. Same class of route round-trip integrity issue as CVE-2026-45065.

Note: WHATWG-conformant browsers treat %2E/%2E%2E as dot-segments during URL parsing, so the encoding never protected browser-side traversal. The defense exists for RFC-3986-conformant consumers; restoring it for chained segments closes the gap there.

Resolution

UrlGenerator now matches every /. or /.. dot-segment in a single left-to-right preg_replace_callback pass using a lookahead that does not consume the trailing /, so adjacent dot-segments are encoded correctly.

The patches for this issue are available here for branch 5.4 (and forward-ported to 6.4, 7.4, 8.0 and 8.1).

Credits

Symfony would like to thank Alex Pott for reporting the issue and Nicolas Grekas for providing the fix.

Threat Intelligence Overview

EPSS Score
0.4%
Top 66% exploitable
Threat Intel
1
1 source
Social Media
2
Sightings
Data Quality
4 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy