Threat Intelligence Database

The Adr viewer's Mistune math plugin (versions >=1.3.0 <1.4.0_5) has a cross-site scripting (XSS) vulnerability due to improper escaping of user input within math delimiters. The plugin renders inline and block math by directly concatenating raw user content into HTML without escaping, even when the parser is configured with escape=True. This allows malicious HTML or script code inside math delimiters to be injected and executed in the browser.

The adr-viewer component of Mistune's HTMLRenderer has a vulnerability (CVE-2026-44897) where the heading ID attribute is inserted into HTML without escaping. This allows an attacker controlling heading text to inject arbitrary HTML attributes, including event handlers, leading to cross-site scripting (XSS). The default behavior uses safe auto-generated IDs, but when a custom heading_id callback returns raw heading text, the vulnerability is triggered. A proof of concept demonstrates injecting a mouseover event that executes JavaScript. A patch is available to address this issue.

### Summary Mistune is vulnerable to a CPU exhaustion DoS due to superlinear (approximately O(n²)) behavior in parse_link_text. A relatively small input consisting of repeated [ characters causes significant parsing slowdown. ### Affected component mistune/inline_parser.py → **parse_link_text** ### Description When parsing Markdown containing many consecutive [ characters, parse_link_text repeatedly scans the input using a regex search inside a loop. Each iteration re-scans a large portion of the remaining string, resulting in quadratic-time behavior. An attacker-controlled Markdown input can therefore trigger excessive CPU usage with a very small payload. ### Root cause The vulnerability stems from a two-loop interaction: - The outer loop in `InlineParser.parse()` (inline_parser.py) advances only 1 character at a time when parse_link() returns None - Each failed attempt calls `parse_link_text()` which performs an O(n) scan to the end of the string looking for a closing `]` - With n consecutive `[` characters, this results in O(n) × O(n) = O(n²) total work ### PoC Run below python script ``` import mistune import time md = mistune.create_markdown() s = "[" * 6400 t = time.perf_counter() md(s) print(time.perf_counter() - t) ``` <img width="2028" height="1277" alt="image" src="https://github.com/user-attachments/assets/15d5bc0b-35f8-4a15-85e0-cbc314a45b06" /> **Benmark poc** Run below code for benchmark ``` import mistune import time md = mistune.create_markdown() sizes = [100,200,400,800,1600,3200,6400] for n in sizes: s = "[" * n t0 = time.perf_counter() md(s) dt = time.perf_counter() - t0 print(f"{n:6d} {dt:.6f}") ``` <img width="2503" height="1341" alt="image" src="https://github.com/user-attachments/assets/f09a7bbb-6927-4ba2-afb1-444dd913b84e" /> ### Observed behaviour ``` python3 benchmark.py 100 0.001609 200 0.003207 400 0.012906 800 0.050220 1600 0.197307 3200 0.801172 6400 3.190393 ``` Execution time grows superlinearly, consistent with O(n²) complex ### Impact This can be used as a denial-of-service attack in any application that parses user-supplied Markdown using Mistune, including: - Web applications (comments, posts, content rendering) - API services processing Markdown - Documentation rendering systems - A small (~6 KB) payload can block CPU for multiple seconds. ### Suggested fix Return the furthest scanned position from parse_link_text even on failure, so the outer loop can skip ahead instead of advancing 1 character at a time ### Security Classification CWE-400: Uncontrolled Resource Consumption Denial of Service (CPU exhaustion)

In `src/mistune/directives/image.py`, the `render_figure()` function concatenates `figclass` and `figwidth` options directly into HTML attributes without escaping (lines 152-168). This allows attribute injection and XSS even when `HTMLRenderer(escape=True)` is used, because these values bypass the inline renderer. Other attributes in the same file (src, alt, style) are properly escaped; figclass/figwidth were missed.

Adr viewer's mistune markdown rendering with the strikethrough, mark, or insert plugins suffers from an algorithmic-complexity denial of service vulnerability (CVE-2026-59922). The formatting parser performs quadratic-time work when processing long runs of repeated markers like `~~x~~`, `==x==`, or `^^x^^`. This causes CPU usage to spike significantly with relatively small crafted inputs. The flaw arises because the parser scans forward from every potential start marker without memoization, resulting in O(N²) complexity. This vulnerability can be triggered by untrusted user input in applications using mistune with these plugins enabled. A patch is available to fix this inefficiency.

Mistune, a Markdown rendering library used in adr-viewer, contains a cross-site scripting (XSS) vulnerability in its safe_url() function. The function attempts to block harmful URL schemes like 'javascript:' by checking the URL prefix but fails to decode percent-encoded characters before this check. This allows an attacker to bypass the filter using percent-encoded 'javascript:' URIs, leading to execution of arbitrary JavaScript when a user clicks a crafted link. The vulnerability affects multiple specific versions of adr-viewer that use the vulnerable Mistune versions. The CVSS score is 6.1 (medium severity).

A path traversal vulnerability exists in the mistune library's Include directive used by adr-viewer when processing markdown files. This flaw allows crafted include paths to access files outside the intended markdown directory. The vulnerability arises because the resolved file path is not properly validated to ensure it remains within a trusted base directory. Applications processing untrusted markdown with this directive enabled may inadvertently expose sensitive files accessible to the running process. A fix is available that involves validating the resolved path before file access.

CVE-2026-59925 is a high-severity algorithmic-complexity denial-of-service (DoS) vulnerability in the adr-viewer product's use of the mistune markdown parser. The flaw arises from quadratic-time parsing of long sequences of emphasis markers like '**x**' or '***x***' in markdown input, causing excessive CPU usage. This vulnerability affects default mistune configurations with no plugins required and can be triggered by attacker-supplied markdown. The issue is due to the parser scanning for matching emphasis closers from every potential start position, resulting in O(N²) work. A patch is available that caps the number of unmatched opening emphasis markers to restore linear-time parsing.

Adr viewer's Mistune component has a cross-site scripting (XSS) vulnerability in the Admonition directive due to unescaped user input in the class option. The render_admonition() function concatenates the :class: option directly into the HTML class attribute without escaping, allowing attribute injection and XSS even when HTMLRenderer is set to escape. The directive name is validated and safe, but the class option is not sanitized. Multiple specific versions of adr-viewer are affected. A patch is available.

A vulnerability in the adr-viewer product using the mistune markdown renderer's Include directive allows uncontrolled recursion via mutual inclusion of markdown files. Two markdown files that include each other cause unbounded recursion, triggering a Python RecursionError that crashes the renderer and results in denial of service. The issue arises because the Include directive only detects direct self-inclusion but not indirect cycles. This vulnerability affects multiple specified versions of adr-viewer and has a medium severity rating with a CVSS score of 5.3. A patch is available to fix this issue by tracking included files and preventing recursive cycles.