Skip to main content

league/commonmark CVE-2026-86430

| EUVDEUVD-2026-72388 HIGH
Inefficient Algorithmic Complexity (CWE-407)
2026-09-07 VulnCheck GHSA-hxrj-xxg4-w3qp
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Recon
    Identify Markdown-rendering endpoint
  2. Delivery
    Craft single-line backtick-run or nested-bracket payload
  3. Exploit
    Submit HTTP request with crafted Markdown body
  4. Install
    Parser enters O(n²) processing without PCRE bail-out
  5. C2
    PHP worker thread held for tens of seconds
  6. Execute
    Flood with concurrent requests
  7. Impact
    Server 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.

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

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

Alert me

AnalysisAIv1 – 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

commonmark 0.6.0 <2.9.1

Affected Packages

composer league/commonmark fix: 2.9.1
euvd commonmark fix: 2.9.1

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

Vendor (VulnCheck) 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

No authentication or special configuration required; default CommonMarkConverter on any network-accessible endpoint is vulnerable with full availability impact and no C/I exposure.

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 (VulnCheck).

CVSS VectorVendor: VulnCheck

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
Patch available
Sep 07, 2026 - 14:02 EUVD
CVE Published
Sep 07, 2026 - 12:53 cve.org
HIGH 8.7

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 79% exploitable
Prevalence
Medium
popular PHP Markdown library, common in Laravel and PHP web projects
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.3%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

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.

CVE-2019-10010 MEDIUM POC
6.1 Mar 24

Cross-site scripting (XSS) vulnerability in the PHP League CommonMark library before 0.18.3 allows remote attackers to i

CVE-2018-20583 MEDIUM POC
6.1 Dec 30

Cross-site scripting (XSS) vulnerability in the PHP League CommonMark library versions 0.15.6 through 0.18.x before 0.18

CVE-2026-86434 HIGH
8.7 Sep 07

Quadratic CPU exhaustion in league/commonmark 2.0.0-2.8.3 allows unauthenticated remote attackers to deny service by sub

CVE-2026-86433 HIGH
8.7 Sep 07

Quadratic-time algorithmic complexity in league/commonmark's Attributes extension exposes PHP applications to remote den

CVE-2026-86429 HIGH
8.7 Sep 07

Quadratic parsing complexity in league/commonmark (thephpleague/commonmark, versions ≥1.5.0 and <2.9.1) allows unauthent

CVE-2026-86435 HIGH
8.7 Sep 07

Quadratic-blowup denial of service in league/commonmark's Footnote extension allows remote unauthenticated attackers to

CVE-2026-86428 HIGH
8.7 Sep 07

Quadratic CPU exhaustion in league/commonmark's optional AttributesExtension (versions 1.5.0 through 2.9.2) allows unaut

CVE-2026-105830 HIGH
8.7 Oct 08

Quadratic-time denial of service in league/commonmark 2.0.0 through 2.10.1 lets unauthenticated remote attackers exhaust

CVE-2026-86432 MEDIUM
6.9 Sep 07

Quadratic memory and output amplification in league/commonmark's XmlRenderer affects all 2.x releases from 2.0.0 through

CVE-2026-86431 MEDIUM
6.9 Sep 07

Cross-site scripting in league/commonmark 2.7.0-2.9.0 allows unauthenticated attackers to inject arbitrary JavaScript in

CVE-2026-30838 MEDIUM
6.1 Mar 07

The DisallowedRawHtml extension in PHP Commonmark (league/commonmark) versions prior to 2.8.1 can be bypassed by injecti

CVE-2026-105829 MEDIUM
5.3 Oct 08

Stored cross-site scripting in league/commonmark from 1.3.0 through 2.10.1 lets any user who can post Markdown bypass th

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