Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconIdentify endpoint parsing untrusted YAML
-
DeliveryCraft oversized %YAML header payload
-
ExploitSubmit request to trigger cleanup() regex
-
InstallParser enters catastrophic backtracking
-
C2CPU pinned, worker hangs
-
ExecuteRepeat to exhaust workers
-
ImpactService 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – 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)
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
Affected Packages
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
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
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.
Primary rating from Vendor (https://github.com/symfony/symfony).
CVSS VectorVendor: https://github.com/symfony/symfony
Lifecycle Timeline
2DescriptionCVE.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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-44359
GHSA-9frc-8383-795m
NVD
CVE.org
EPSS
VulDB
Exploit-DB