GHSA-6m44-fpc8-c3rq: High severity pip/mistune vulnerability
Summary Mistune v3.3.2 is vulnerable to a Denial of Service (DoS) attack via uncontrolled recursion in the HTML rendering of deeply-nested emphasis tokens. By submitting Markdown containing approximately 1,000 consecutive asterisk characters, an attacker causes the Python process to crash with RecursionError.
Details The InlineParser's processemphasisdelimiters() creates deeply nested <strong> tokens from consecutive emphasis markers (every 2 asterisks add one nesting level). With 1,000 consecutive asterisks, approximately 500 levels of nesting are produced. The HTMLRenderer.rendertoken() method (src/mistune/renderers/html.py:40-57) renders these tokens recursively: when a token has children, line 48 calls self.rendertokens(token['children'], state), entering child rendering. Each nesting level produces ~2 stack frames, so 500 levels ≈ 1,000 frames, exceeding Python's default recursion limit (sys.getrecursionlimit() = 1000). The emphasis() and strong() methods (lines 80-84) wrap recursively rendered child content in <em> and <strong> tags, perpetuating the recursion. This vulnerability affects all mistune APIs including markdown() and html().
Core vulnerable code path:
python src/mistune/renderers/html.py:40-57 def rendertoken(self, token: Dict[str, Any], state: BlockState) -> str: func = self.getmethod(token["type"]) attrs = token.get("attrs") if "raw" in token: text = token["raw"] elif "children" in token: text = self.rendertokens(token["children"], state) else: if attrs: return func(attrs) else: return func() if attrs: return func(text, attrs) else: return func(text)
The recursive call to rendertokens() on line 48 processes nested child tokens. With 500 levels of nested emphasis/strong tokens, this recursion exceeds Python's default recursion limit of 1000, causing a RecursionError.
python src/mistune/renderers/html.py:80-84 def emphasis(self, text: str) -> str: return "<em>" + text + "</em>"
def strong(self, text: str) -> str: return "<strong>" + text + "</strong>"
The emphasis() and strong() methods wrap their text content (which is itself the recursively-rendered output of nested child tokens) in HTML tags, creating the chain of recursion: each call to strong() includes rendered children that themselves call strong(), etc.
POC
wiki from mistune import html
payload = '' 1000 try: result = html(payload) print('No crash - recursion handled') except RecursionError as e: print(f'[VULN] RecursionError: {e} - Process would crash!') except Exception as e: print(f'Error: {type(e).name}: {e}')
<img width="1139" height="664" alt="1" src="https://github.com/user-attachments/assets/d2095b9f-0a6a-4bef-8013-cbc6946cf8f1" />
Impact CVSS 3.1: 7.5 (High) — AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H. An attacker can crash any server process using mistune with approximately 2KB of Markdown input. In web applications, this can be triggered through user-generated content such as forum posts or comments, causing denial of service for all concurrent users sharing the same Python process. Both mistune.markdown() and mistune.html() are affected.
Remediation 1. Add a maximum nesting depth limit in the emphasis parsing stage, similar to BlockParser's maxnestedlevel mechanism (currently at DEFAULTMAXNESTEDLEVEL = 20). When the limit is exceeded, treat excess emphasis markers as literal text. 2. Alternatively, refactor HTMLRenderer to use an explicit stack-based iterative approach instead of recursive calls for rendering nested tokens. 3. As a defense-in-depth measure, document the recursion risk and recommend that applications deploying mistune set a higher recursion limit or implement request-level timeouts.
Affected Software
Remediation
Recommended actions to resolve this vulnerability, in priority order.
- Upgrade
Upgrade
pip/mistuneto a version that resolves this vulnerability.Fixed in 3.3.3 - Configuration
Implement a maximum nesting depth limit in the emphasis parsing stage (similar to BlockParser's max_nested_level mechanism using DEFAULT_MAX_NESTED_LEVEL = 20). When the nesting limit is exceeded, treat excess emphasis markers as literal text instead of recursively rendering nested child tokens.
mistune HTML rendering (InlineParser emphasis/_process_emphasis_delimiters and HTMLRenderer.render_token) maximum nesting depth limit for emphasis parsing/rendering (max_nested_level) = DEFAULT_MAX_NESTED_LEVEL = 20 (or lower recursion-safe equivalent; treat excess emphasis markers as literal text) - Compensating control
As a defense-in-depth measure, document the recursion risk for applications deploying mistune (both mistune.markdown() and mistune.html()). Recommend setting a higher Python recursion limit (sys.getrecursionlimit()) or implementing request-level timeouts to mitigate DoS from deeply nested emphasis/strong tokens.
Event History
Frequently Asked Questions
Which applications are exposed to this issue?
Any application using Mistune v3.3.2 to render attacker-controlled Markdown through its APIs, including markdown() and html(), is exposed. The affected path is the HTML renderer.
What does an attacker need to do to trigger the denial of service?
The attacker only needs to submit Markdown containing roughly 1,000 consecutive asterisk characters. No authentication or user interaction is required according to the supplied vector.
Are default Python settings sufficient to make this exploitable?
Yes. The described input creates about 500 nested strong tokens and roughly 1,000 stack frames during rendering, which exceeds Python's stated default recursion limit of 1,000.
How can operators recognize an attempted or successful trigger?
A successful trigger causes the Python process to crash with a RecursionError while rendering deeply nested emphasis or strong tokens. Inputs with unusually long consecutive runs of asterisk emphasis delimiters are relevant indicators.