Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconIdentify Markdown-rendering endpoint
-
DeliveryCraft single-line backtick-run or nested-bracket payload
-
ExploitSubmit HTTP request with crafted Markdown body
-
InstallParser enters O(n²) processing without PCRE bail-out
-
C2PHP worker thread held for tens of seconds
-
ExecuteFlood with concurrent requests
-
ImpactServer CPU exhausted, legitimate requests denied
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | All three vulnerable parsing paths are reachable against a stock new CommonMarkConverter() with default configuration and no extensions registered - no special server-side settings are required. For the fenced code block path, the trigger is a single line containing a long backtick run (3 or more backticks), followed by any filler text, followed by at least one trailing backtick; the line need not contain any other Markdown structure. For the reference link path, the document must contain at least one reference definition of any form (e.g., the 8-byte string '[x]: y') anywhere in the input - this unlocks the normalization path for all subsequent nested bracket spans. For the emphasis/delimiter path, a sequence of many consecutive delimiter characters (* _ ~ =) is sufficient. PCRE's built-in backtrack limit does not terminate the fenced code block path, meaning there is no automatic server-side protection from that layer. No authentication, session, or elevated privilege is required at the application level. |
| Impact | The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H) scores 8.7 and accurately reflects the threat model: any network-reachable endpoint that accepts user-supplied Markdown and uses a default CommonMarkConverter instance is vulnerable with no authentication and no special attack complexity. All three paths are individually sufficient to cause denial of service; an attacker can target any one of them. The payload for the fenced code block path is a single line with no special Markdown structure, making automated delivery trivial. Even a mid-sized deployment team should treat this as urgent patching priority given the ease of triggering sustained CPU consumption with sub-kilobyte inputs. No KEV listing exists and no external POC code has been identified beyond the detailed triggering descriptions in the GHSA advisory itself, which effectively serves as a reproduction guide. EPSS was not provided in the input data, so exploitation probability cannot be quantified numerically; however, the extremely low attack complexity and zero authentication requirement suggest high automatable exploitation potential once an operator is targeted. The primary mitigating factor is that impact is limited strictly to availability - there is no confidentiality or integrity exposure confirmed. |
| Exploit ScenarioDerived | An attacker identifies a public comment form, API endpoint, or wiki input field that renders Markdown using league/commonmark with default configuration. They submit a POST request containing a single line of 160,000 backtick characters followed by arbitrary text and one trailing backtick - a payload under 200 KB. The FencedCodeStartParser regex enters catastrophic backtracking, holding one PHP worker thread in CPU-bound parsing for tens of seconds. By sending a modest number of concurrent such requests, the attacker saturates the available PHP-FPM worker pool or server CPU, preventing all legitimate requests from completing until the connections time out. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 07, 2026
Three independent super-linear parsing paths in league/commonmark before 2.9.1 allow unauthenticated remote attackers to exhaust server CPU by submitting crafted Markdown input. The fenced code block path exhibits quadratic complexity due to catastrophic regex backtracking in FencedCodeStartParser, a 320 KB single-line payload taking ~27 seconds to process without triggering PCRE's backtrack limit. The reference link label lookup path performs multiple full-string normalization passes per nested bracket pair, and the emphasis/delimiter path similarly degrades under long delimiter sequences - all three are reachable with a stock CommonMarkConverter and default configuration. No public exploit has been identified at time of analysis, but the GHSA advisory documents precise triggering payloads.
RemediationAI
Upgrade league/commonmark to version 2.9.1 or later via Composer (composer update league/commonmark). The fix is confirmed by two upstream commits: 0768217751fbfaeb8d76762f6944e9af7114295e and d9375fadc308a63a02950a68d822417a6e4c33b2, both referenced in the GHSA advisory at https://github.com/thephpleague/commonmark/security/advisories/GHSA-j8pm-gj4c-rq4x. If immediate upgrade is not feasible, a compensating control is to enforce a strict input length limit on Markdown accepted from untrusted sources - the advisory demonstrates that 320 KB single-line payloads are the primary attack vehicle, so capping individual line length (e.g., via pre-processing that wraps or rejects lines exceeding a few thousand characters) would substantially reduce exploitability. However, this workaround does not address nested-bracket payloads that can fit within shorter documents, so it is not a complete mitigation. Rate-limiting Markdown conversion endpoints and placing CPU time limits on the rendering process (e.g., PHP max_execution_time per request) are additional layers but carry trade-offs in degrading legitimate long-document rendering.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 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
league/commonmark (composer package thephpleague/commonmark, CPE cpe:2.3:a:thephpleague:commonmark:*:*:*:*:*:*:*:*) is a PHP implementation of the CommonMark Markdown specification, widely embedded in PHP frameworks for user-facing Markdown rendering. CWE-407 (Inefficient Algorithmic Complexity) describes the root cause across all three paths. Path 1: FencedCodeStartParser uses the regex /^[ \t]*(?:{3,}(?!.*)|~{3,})/ where the lookahead and backtick quantifier are neither atomic nor possessive, causing the engine to give back one character at a time and re-execute the lookahead on every candidate fence length - classic catastrophic backtracking. Critically, preg_last_error() returns 0 at all tested input sizes, meaning PCRE never reaches pcre.backtrack_limit, so the process sustains CPU saturation indefinitely rather than bailing out with an error. Path 2: CloseBracketParser::tryParseReference() copies the full span between brackets and passes it to ReferenceMap::get(), which runs up to four sequential passes (trim, preg_replace, mb_check_encoding, strtolower or mb_convert_case). Nested brackets trigger one normalization per closing bracket, each on a progressively longer span, yielding O(n²) work. In the 2.x branch, a single 8-byte reference definition anywhere in the document ([x]: y) is sufficient to unlock this path. Path 3: Emphasis, strikethrough, and highlight delimiter processing similarly performs super-linear work on long delimiter runs.
Know when Commonmark gets its next vulnerability
- 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
No authentication or special configuration required; default CommonMarkConverter on any network-accessible endpoint is vulnerable with full availability impact and no C/I exposure.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
league/commonmark versions before 2.9.1 contain multiple denial of service vulnerabilities in fenced code block detection, reference link label lookup, and emphasis delimiter processing that perform super-linear work on crafted input. Attackers can submit specially crafted Markdown with long backtick runs, nested brackets, or delimiter sequences to consume disproportionate CPU time and prevent legitimate requests from completing.
Technical POC Analysis
Three independent inefficiencies in league/commonmark < 2.9.1.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
league/commonmark, a widely-used open-source PHP Markdown parser, contains three parsing inefficiencies enabling unauthenticated remote attackers to exhaust server CPU and cause application unavailability through malformed Markdown input. Any organization deploying this library to process user-supplied content-including forums, comment systems, communication platforms, and content management systems-faces immediate denial-of-service risk.
No vendor-released patch identified at time of analysis. Deploy these interim mitigations: (1) Input-size limits-cap Markdown submissions to 50 KB maximum to block complex payloads; (2) Parsing timeouts-enforce 15-30 second limits per request to terminate runaway operations; (3) Rate-limiting-restrict parsing frequency per user session or source IP; (4) Monitoring-track CPU utilization on parsing endpoints with threshold-based alerts; (5) WAF rules-configure Web Application Firewall to detect and block known problematic patterns (deeply nested brackets, extended delimiter sequences); (6) Service posture-disable Markdown processing for untrusted sources where feasible or migrate to alternative parsers without known super-linear behavior. Apply vendor patch to version 2.9.1 or later immediately upon release.
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.
More in Commonmark
View allCross-site scripting (XSS) vulnerability in the PHP League CommonMark library before 0.18.3 allows remote attackers to i
Cross-site scripting (XSS) vulnerability in the PHP League CommonMark library versions 0.15.6 through 0.18.x before 0.18
Quadratic CPU exhaustion in league/commonmark 2.0.0-2.8.3 allows unauthenticated remote attackers to deny service by sub
Quadratic-time algorithmic complexity in league/commonmark's Attributes extension exposes PHP applications to remote den
Quadratic parsing complexity in league/commonmark (thephpleague/commonmark, versions ≥1.5.0 and <2.9.1) allows unauthent
Quadratic-blowup denial of service in league/commonmark's Footnote extension allows remote unauthenticated attackers to
Quadratic CPU exhaustion in league/commonmark's optional AttributesExtension (versions 1.5.0 through 2.9.2) allows unaut
Quadratic-time denial of service in league/commonmark 2.0.0 through 2.10.1 lets unauthenticated remote attackers exhaust
Quadratic memory and output amplification in league/commonmark's XmlRenderer affects all 2.x releases from 2.0.0 through
Cross-site scripting in league/commonmark 2.7.0-2.9.0 allows unauthenticated attackers to inject arbitrary JavaScript in
The DisallowedRawHtml extension in PHP Commonmark (league/commonmark) versions prior to 2.8.1 can be bypassed by injecti
Stored cross-site scripting in league/commonmark from 1.3.0 through 2.10.1 lets any user who can post Markdown bypass th
EUVD-2026-72388
GHSA-hxrj-xxg4-w3qp
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB