Skip to main content

Symfony Yaml CVE-2026-45305

| EUVDEUVD-2026-44359 HIGH
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-05-27 https://github.com/symfony/symfony GHSA-9frc-8383-795m
8.7
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. Recon
    Identify endpoint parsing untrusted YAML
  2. Delivery
    Craft oversized %YAML header payload
  3. Exploit
    Submit request to trigger cleanup() regex
  4. Install
    Parser enters catastrophic backtracking
  5. C2
    CPU pinned, worker hangs
  6. Execute
    Repeat to exhaust workers
  7. Impact
    Service denied to legitimate users

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires that the target application passes attacker-influenced data into Symfony's YAML parser (Yaml::parse / Parser::parse) - the vulnerable code path is Parser::cleanup(), which only runs when the input begins with a preamble line: a '%YAML' directive header, one or more leading '#' comment lines, a '---' document-start marker, or a trailing '...' document-end marker. The attacker controls that preamble line and makes it oversized (the advisory's tests use ~100,000-character headers and ~140,000-character comments/markers) to trigger catastrophic backtracking. The CVSS vector is AV:N/AC:L/PR:N/UI:N, so no authentication or user interaction is required at the protocol level. The real limiting factor is application design: if the app never parses untrusted YAML - only trusted, developer-authored config files - the vulnerability is not reachable by external attackers, so realistic exposure hinges on whether YAML parsing is fed external input.

Impact

The signals are internally consistent but point to a moderate, availability-only issue rather than a top-tier emergency. The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N) scores 8.7 driven entirely by VA:H (availability high) with no confidentiality or integrity impact - it is purely a DoS. EPSS is very low (0.08%, 23rd percentile), the CVE is not on CISA KEV, and the tag is simply 'Denial Of Service', all reinforcing that this is not being mass-exploited. The important caveat: the network/unauthenticated rating is only realized when the target application actually feeds attacker-controlled data into the YAML parser (e.g., user-uploaded config, API payloads). Applications that only parse trusted, developer-authored YAML face negligible real-world risk despite the high base score. This is a patch-in-normal-maintenance-window issue, not a drop-everything one, unless the app exposes YAML parsing to untrusted input.

Exploit ScenarioDerived

An attacker submits a YAML payload to any endpoint that eventually calls Symfony's YAML parser - for example an API field, uploaded configuration file, or webhook body - containing a '%YAML:' header (or leading comment) padded with tens of thousands of characters, mirroring the patch's own test case ("%YAML:" followed by 100,000 '1' characters). The parser enters catastrophic backtracking and pins a CPU core, and repeating the request across worker processes exhausts the server's capacity, denying service to legitimate users. No authentication or user interaction is needed where the parser sits behind unauthenticated input; the trigger strings are documented in the public advisory and test suite though no packaged exploit tool was identified.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv2 – Jul 14, 2026

Denial of service in the Symfony Yaml component (symfony/yaml and the monolithic symfony/symfony) allows remote attackers to hang the parser via catastrophic regular-expression backtracking in Parser::cleanup(). Supplying a YAML document with an oversized %YAML directive header, leading comment, or document-start/end marker forces the CPU to spin for an arbitrarily long time (CWE-1333), stalling any application that parses attacker-influenced YAML. No public weaponized exploit is identified, though the advisory and patch tests disclose the trigger payloads; EPSS is low at 0.08%, and the issue is not on CISA KEV.

Earlier versions of this analysis (1)
v1 May 27, 2026 - 22:37

Catastrophic backtracking in Symfony's YAML component (symfony/yaml) allows denial of service via crafted input to the Parser::cleanup() method. The four regexes responsible for stripping %YAML directive headers, leading comments, and document start/end markers contain overlapping quantifiers - notably [\d.]+ and .* both matching the dot character - enabling an attacker supplying a single oversized directive header or comment line to cause the PHP process to hang indefinitely. Affected branches span symfony/yaml and symfony/symfony packages across the 5.4, 6.x, and 7.x release lines. No public exploit identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.

RemediationAI

Vendor-released patch: upgrade to the fixed release for your branch - 5.4.52, 6.4.40, 7.4.12, or 8.0.12 - via 'composer update symfony/yaml' (or symfony/symfony). The corresponding release tags are published at https://github.com/symfony/symfony/releases/tag/v5.4.52, v6.4.40, v7.4.12, and v8.0.12, and the upstream fix commit is https://github.com/symfony/symfony/commit/9749cd43c5e09b3735093623670b21b9d8a056cb. If an immediate upgrade is not possible, the effective compensating control is to avoid passing untrusted or externally controlled input to the YAML parser: validate and cap input size before calling Yaml::parse()/Parser::parse() (reject or truncate documents whose preamble lines exceed a small sane length, e.g. a few kilobytes), or place the parsing endpoint behind size limits and per-request CPU/time limits (set_time_limit, request timeout) so a single hung parse cannot exhaust workers. The trade-off is that strict size caps may reject legitimate large documents and CPU timeouts will abort in-progress requests, so tune thresholds to your data. Full advisory: https://github.com/symfony/symfony/security/advisories/GHSA-9frc-8383-795m.

Affected VersionsENISA

yaml < 5.4.52
symfony < 5.4.52
symfony 7.0.0-BETA1, < 7.4.12
yaml 7.0.0-BETA1, < 7.4.12
yaml 6.0.0-BETA1, < 6.4.40
yaml 8.0.0-BETA1, < 8.0.12
symfony 8.0.0-BETA1, < 8.0.12
symfony 6.0.0-BETA1, < 6.4.40

Affected Packages

composer symfony/symfony fix: 5.4.52, 6.4.40, 7.4.12, 8.0.12
composer symfony/yaml fix: 5.4.52, 6.4.40, 7.4.12, 8.0.12
euvd symfony fix: 5.4.52
euvd symfony_6_0_0_beta1 fix: 6.4.40
euvd symfony_7_0_0_beta1 fix: 7.4.12
euvd symfony_8_0_0_beta1 fix: 8.0.12
euvd yaml fix: 5.4.52
euvd yaml_6_0_0_beta1 fix: 6.4.40
euvd yaml_7_0_0_beta1 fix: 7.4.12
euvd yaml_8_0_0_beta1 fix: 8.0.12

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 affected code is Symfony's pure-PHP YAML parser. Before parsing, Parser::cleanup() strips optional preamble lines using four PCRE regexes. The flawed patterns - most notably '#^%YAML[: ][\d.]+.*\n#u' - mixed a greedy '[\d.]+' quantifier with a following '.*' that both match the '.' character, creating overlapping, ambiguous quantifiers. On a long crafted header the regex engine explores exponentially many backtracking paths (classic ReDoS / inefficient regular expression complexity, CWE-1333). The fix rewrites all four regexes with possessive quantifiers ('[\d.]++', '[^\n]*+') and unambiguous character classes so no backtracking is possible. CPE data confirms the impacted Composer packages pkg:composer/symfony_yaml and the aggregate pkg:composer/symfony_symfony.

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 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Remote, low-complexity, no auth or interaction when untrusted YAML is parsed; impact is availability-only (A:H) with no confidentiality or integrity effect and no scope change.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/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
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Analysis Updated
Jul 14, 2026 - 19:37 vuln.today
v2 - CVSS changed
CVSS changed
Jul 14, 2026 - 19:22 NVD
8.7 (HIGH)

DescriptionCVE.org

Description

Symfony\Component\Yaml\Parser::cleanup() strips the optional %YAML directive header, leading comments, and document start/end markers before parsing. The original regexes contained overlapping quantifiers, most notably '#^%YAML[: ][\d.]+.*\n#u', whose [\d.]+ and .* overlap on the dot, that exhibit catastrophic backtracking on crafted input. A single oversized %YAML directive header (or comment / document-marker line) makes the parser hang for an arbitrarily long time, denying service.

Resolution

The four regexes in Parser::cleanup() (YAML directive header, leading comments, document-start marker, document-end marker) have been rewritten with possessive quantifiers and unambiguous character classes so backtracking cannot occur.

The patch for this issue is available here for branch 5.4.

Credits

Symfony would like to thank Pietro Tirenna (Shielder) for reporting the issue and Nicolas Grekas for fixing it.

Executive ViewAI

Why It Matters

The Symfony YAML component (symfony/yaml and symfony/symfony) contains a denial-of-service vulnerability (CVSS 8.7) that allows remote attackers to hang the parser and stall production applications by submitting malformed YAML documents. Organizations using Symfony framework should prioritize patching to restore resilience against service disruption attacks.

Business Impact: Medium
Compensating Controls

Apply vendor patch. Interim mitigations pending patch deployment: implement input validation to reject oversized YAML directives and headers, enforce strict timeouts on YAML parsing operations, and restrict YAML parsing to trusted data sources where feasible.

Threat Intelligence Overview

EPSS Score
0.1%
Top 77% exploitable
Prevalence
High
Symfony is a top-tier PHP framework; symfony/yaml is very widely deployed
Threat Intel
1
1 source
Social Media
2
Sightings
Data Quality
6 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Yes
Human Impact
Medium

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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