CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-67422

CVE-2026-67422: Regular Expression Denial of Service in pymdown-extensions

Alon Barad
Alon Barad
Software Engineer

Aug 8, 2026·5 min read·87 visits

Executive Summary (TL;DR)

Inefficient regular expressions in multiple inline processors of pymdown-extensions allow unauthenticated attackers to cause complete CPU exhaustion and Denial of Service with short, crafted Markdown payloads of fewer than 50 bytes.

A high-severity Regular Expression Denial of Service (ReDoS) vulnerability in pymdown-extensions versions prior to 11.0.1 affects the Caret, Tilde, BetterEm, and MagicLink inline processors. When parsing user-supplied Markdown content containing malicious sequences of formatting delimiters, the regular expression engine is forced into catastrophic backtracking, resulting in CPU exhaustion and application denial of service.

Vulnerability Overview

The Python package pymdown-extensions provides a set of formatting and feature extensions for the standard Python Markdown implementation. These extensions are widely deployed in web applications, content management systems, wiki platforms, and static site generator pipelines to process user-supplied Markdown content into HTML.

The attack surface exists in the inline text parsers, which process formatted text runs such as superscripts, subscripts, emphasis, and auto-linked URLs. Specifically, the Caret, Tilde, BetterEm, and MagicLink inline processors fail to restrict backtracking pathways when evaluating complex or malformed sequences of formatting delimiters. This behavior exposes the system to unauthenticated, remote Regular Expression Denial of Service (ReDoS) attacks under CWE-1333.

Root Cause Analysis

Python's native re module uses a Non-deterministic Finite Automaton (NFA) regular expression engine. NFA engines evaluate inputs via backtracking, testing matching combinations sequentially until a match is found or all possibilities are exhausted. If a regular expression contains nested or overlapping quantifiers, the number of potential matching pathways grows exponentially with the length of the input string.

The vulnerability in the delimiter-based processors (Caret, Tilde, and BetterEm) stems from the nested non-capturing groups designed to match formatting runs. For example, the STAR_EM2 pattern contains the nested group ((?:[^\*]|\*{2,})+?). Within this group, the engine can match a contiguous run of asterisks by repeating the outer group, matching two asterisks via \*{2,}, or partitioning the run into multiple smaller matches. When presented with an unmatched input containing many contiguous delimiters, the engine must evaluate every possible integer partition of that delimiter run, leading to O(2^N) complexity.

In the MagicLink processor, the host-matching sub-pattern [^_\W][-\w]*(?:\.[-\w.]+)* contains overlapping paths. The character class [-\w.]+ inside the nested group includes the literal dot character, while the outer group is also repeated over dots. A long domain containing multiple dots that ultimately fails downstream validation causes the engine to evaluate every permutation of dot matches, exhausting CPU cycles.

Code Analysis

The vulnerability was resolved by converting overlapping patterns into mutually exclusive paths and simulating possessive quantifiers to prevent backtracking. The key modification in the delimiter-based processors (such as Caret and BetterEm) involves adding a negative lookahead to the delimiter quantifier.

# Vulnerable configuration in BetterEm
STAR_EM2 = r'(?<!\*)(\*)(?![\*\s])((?:[^\*]|\*{2,})+?)(?<![\*\s])(\*)(?!\*)'
 
# Patched configuration in BetterEm (11.0.1)
STAR_EM2 = r'(?<!\*)(\*)(?![\*\s])((?:[^\*]|\*{2,}(?!\*))+?)(?<![\*\s])(\*)(?!\*)'

By appending (?!\*) to \*{2,}, the engine is forced to consume all contiguous asterisks in a single step. The negative lookahead prevents the engine from splitting the delimiter run into smaller components for alternative evaluation loops, effectively blocking the backtracking pathway.

For magiclink.py, the nested quantifier structures were flattened entirely. The patch replaces the nested loops with a single non-overlapping choice.

# Vulnerable host pattern in MagicLink
RE_LINK_OLD = r'(?:ht|f)tps?://[^_\W][-\w]*(?:\.[-\w.]+)*'
 
# Patched host pattern in MagicLink (11.0.1)
RE_LINK_NEW = r'(?:ht|f)tps?://[^_\W](?:[-\w]|\.(?!=$))*'

In the patched version, the sequence matches either a word character or a literal dot that is not at the end of the line. Because these choices are mutually exclusive, the processing time scales linearly, O(N), preventing ReDoS.

Exploitation Methodology

An attacker does not require authentication or specific system configuration to exploit this vulnerability. The only prerequisite is an exposed application endpoint that accepts and renders markdown content, such as a comment section, wiki editor, or API endpoint.

The payload is crafted to satisfy the initial assertion of a parser but fail the final boundary constraint, forcing a full backtrack. For example, sending a string starting with a single caret, followed by a alphanumeric character, and ending with a run of thirty carets (e.g., ^a^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^) will trigger the vulnerability in the Caret processor.

Because the input string lacks a valid closing boundary, the parser must backtrack through all possible groupings of the thirty trailing carets. A run of this length forces billions of operations, pinning a single CPU core at 100% utilization. If the web server runs a synchronous single-threaded process model, that worker process becomes entirely unresponsive to any subsequent requests.

Impact Assessment

The security impact of CVE-2026-67422 is high availability disruption. While it does not allow remote code execution or data leakage directly, the ease of triggering CPU exhaustion makes it highly effective for targeted denial of service.

In typical web environments, server workers (such as Gunicorn or uWSGI threads) are limited. An attacker can systematically disable all active workers by submitting a handful of concurrent requests containing the crafted payload, causing a complete application outage. The vulnerability receives a CVSS v3.1 base score of 7.5 due to its network-accessible, unauthenticated nature and low attack complexity.

Remediation and Mitigation

The primary remediation step is upgrading the pymdown-extensions library to version 11.0.1 or higher. This update replaces the inefficient regular expressions with safe, non-backtracking alternatives.

For systems where an immediate upgrade is not feasible, temporary mitigation strategies can be applied at the application boundary. Developers should enforce a strict length limit on all user-submitted Markdown inputs to reduce the performance impact of backtracking. Additionally, Web Application Firewalls (WAFs) or input validation layers can be configured to reject strings containing excessive consecutive repetitions of formatting delimiters like asterisks, carets, or tildes.

Official Patches

facelessuserPatch commit resolving ReDoS in multiple processors

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
EPSS Probability
0.58%
Top 55% most exploited

Affected Systems

Applications rendering Markdown using Python Markdown with the pymdown-extensions library.Static site generators and documentation build pipelines utilizing the BetterEm, Caret, Tilde, or MagicLink extensions.

Affected Versions Detail

Product
Affected Versions
Fixed Version
pymdown-extensions
facelessuser
< 11.0.111.0.1
AttributeDetail
CWE IDCWE-1333
Attack VectorNetwork
CVSS Score7.5 (High)
EPSS Score0.00582 (Percentile: 44.59%)
ImpactDenial of Service (CPU Exhaustion)
Exploit StatusProof-of-Concept Available
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499.004Endpoint Denial of Service: Application Exhaustion Flood
Impact
CWE-1333
Inefficient Regular Expression Complexity

The application uses a regular expression that can take an exponential amount of time to compute relative to the size of the input string, leading to Denial of Service.

Known Exploits & Detection

GitHub AdvisoryProof of concept and security details covering the ReDoS vulnerabilities.

References & Sources

  • [1]GitHub Security Advisory GHSA-gm37-52c6-37mw
  • [2]Patch Commit c684985

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•GHSA-6856-87HX-P5X7
7.5

CVE-2026-105544: Local Elevation of Privilege in .NET Test Platform CLI

CVE-2026-105544 is a high-severity local elevation of privilege vulnerability in Microsoft .NET and Microsoft.TestPlatform.CLI. Improper access control on local inter-process communication mechanisms and execution brokers allows an authorized local attacker to cross security boundaries and execute arbitrary code in the context of a higher-privileged user running a test execution cycle.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 3 hours ago•CVE-2026-114152
8.8

CVE-2026-114152: Stack-Based Buffer Overflow and Untrusted Pointer Dereference in Microsoft DiaSymReader.Native

CVE-2026-114152 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple servicing branches of the Microsoft .NET runtime (.NET 8.0, 9.0, 10.0, and 11.0) on Windows platforms. The vulnerability exists within the native symbol reader library, Microsoft.DiaSymReader.Native, specifically inside the DiaObjectFile::ApplyFixup method during the processing of Common Object File Format (COFF) relocation records. By supplying a malformed object file or Program Database (PDB) symbol file containing out-of-bounds relocation offsets or invalid symbol table indices, an unauthenticated attacker can trigger an untrusted pointer dereference (CWE-822) and a stack-based buffer overflow (CWE-121). Successful exploitation occurs when a victim opens, compiles, or debugs a malicious project or symbol artifact, leading to arbitrary code execution within the security context of the active developer environment or build process.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 4 hours ago•CVE-2026-118745
8.8

CVE-2026-118745: Remote Code Execution via Heap-Based Buffer Overflow in Microsoft Visual Studio and .NET DiaSymReader

CVE-2026-118745 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple supported versions of the .NET runtime (8.0, 9.0, 10.0, and 11.0) on Windows systems. The flaw is a heap-based buffer overflow (CWE-122) located within the native symbol reading library, Microsoft.DiaSymReader.Native, specifically in the routines responsible for extracting and parsing Program Database (.pdb) line number metadata. An attacker can exploit this vulnerability by supplying a crafted .pdb file alongside a repository, project, or compiled binary. When a developer or automated diagnostic process parses the malformed debug symbols, an out-of-bounds heap write occurs, permitting arbitrary code execution within the security context of the active user process.

Amit Schendel
Amit Schendel
7 views•10 min read
•about 5 hours ago•CVE-2026-109481
7.5

CVE-2026-109481: Cross-Site Request Forgery Leading to Elevation of Privilege in ASP.NET Core

CVE-2026-109481 is a high-severity Cross-Site Request Forgery (CSRF) vulnerability in the ASP.NET Core Blazor Server and interactive component architecture. The flaw exists within the internal circuit state synchronization endpoint (`/_blazor/refresh`), which fails to enforce antiforgery token validation or verify cross-origin request headers. By inducing an authenticated victim to issue a cross-site request targeting a pre-allocated circuit identifier, an unauthenticated attacker can bind the victim's security principal to the attacker's active SignalR circuit, resulting in full privilege elevation within the application scope.

Amit Schendel
Amit Schendel
6 views•9 min read
•about 6 hours ago•CVE-2026-126187
9.5

CVE-2026-126187: Unauthenticated Remote Code Execution in React Server Components

A critical deserialization vulnerability exists in React Server Components (RSC) packages (`react-server-dom-webpack`, `react-server-dom-parcel`, and `react-server-dom-turbopack`) across versions 19.0.0 through 19.3.0. The flaw occurs during the processing of React Flight protocol streams when handling multiple typed arrays sharing a backing ArrayBuffer alongside attacker-controlled inputs. By combining byte-stream buffer detachment semantics with unvalidated thenable invocation and exposed internal response states, an unauthenticated attacker can achieve remote code execution on server runtimes supporting React Server Components.

Alon Barad
Alon Barad
24 views•11 min read
•about 7 hours ago•CVE-2026-125123
2.3

CVE-2026-125123: Improper Output Neutralization and CI Workflow Command Injection in compose-lint CLI Parser

An improper output neutralization vulnerability (CWE-117 / CWE-150) exists in compose-lint version 0.31.0. When compose-lint is invoked on untrusted file paths without a preceding '--' option delimiter, Python's standard argparse module rejects malformed or dash-prefixed paths and writes them directly to standard error without passing through the application's output sanitizer. An attacker submitting a pull request containing crafted directory or file names with carriage returns or Unicode whitespace can inject arbitrary CI workflow commands into GitHub Actions or Azure Pipelines job logs.

Alon Barad
Alon Barad
5 views•10 min read