CVE-2025-24981: MDC Markdown Parser XSS Vulnerability

CVE-2025-24981 Overview

CVE-2025-24981 is a Cross-Site Scripting (XSS) vulnerability affecting MDC (Markdown Components), a tool designed to parse regular Markdown and write documents that interact deeply with Vue components. The vulnerability exists in the unsafe parsing logic of URLs from markdown content, which allows attackers to bypass existing security guards around the javascript: protocol scheme through HTML entity hex encoding.

Critical Impact

Attackers can inject arbitrary JavaScript code through malicious markdown content by encoding javascript: URLs with HTML entities, potentially leading to complete compromise of user sessions and data theft.

Affected Products

• MDC (Markdown Components) versions prior to 0.13.3
• Nuxt applications using vulnerable MDC module versions
• Any application parsing untrusted markdown content through affected MDC versions

Discovery Timeline

• 2025-02-06 - CVE CVE-2025-24981 published to NVD
• 2025-02-06 - Last updated in NVD database

Technical Details for CVE-2025-24981

Vulnerability Analysis

The vulnerability stems from insufficient input validation in the URL parsing logic implemented in props.ts. The security mechanism relies on a deny-list approach to filter potentially malicious payloads by matching protocol schemes like javascript: and similar dangerous prefixes. However, this approach fails to account for HTML entity encoding, specifically hex-encoded representations of characters.

When an adversary provides JavaScript URLs with HTML entities encoded via hex strings (e.g., javascript: instead of javascript:), the deny-list check is bypassed because the raw comparison fails to match the encoded variant. The markdown parser then renders these as legitimate anchor links, which when clicked by a user, execute arbitrary JavaScript in the context of the victim's browser session.

This vulnerability is classified as CWE-79 (Cross-Site Scripting). Applications that consume the MDC library and perform markdown parsing from unvalidated sources are particularly at risk, as they may inadvertently render XSS payloads in their Vue components.

Root Cause

The root cause lies in the deny-list implementation within props.ts that performs direct string matching against protocol prefixes without first normalizing or decoding the input. The original validation simply checked if a value started with known unsafe prefixes like javascript:, vbscript:, or data:text/html. This approach is fundamentally flawed because attackers can represent the same characters using various encoding schemes that the browser will decode at render time.

Attack Vector

The attack vector is network-based and requires no authentication or user interaction beyond clicking a malicious link. An attacker can craft markdown content containing anchor links with HTML entity-encoded JavaScript URLs. When this markdown is parsed by a vulnerable MDC version and rendered in a Vue application, the malicious links appear legitimate. Upon user interaction with these links, the encoded JavaScript is decoded by the browser and executed in the user's session context, enabling session hijacking, credential theft, or defacement attacks.

   'data:text/xml'
 ]
 
+function isAnchorLinkAllowed(value: string) {
+  const decodedUrl = decodeURIComponent(value)
+  const urlSanitized = decodedUrl.replace(/&#x([0-9a-f]+);?/gi, '')
+    .replace(/&#(\d+);?/g, '')
+    .replace(/&[a-z]+;?/gi, '')
+
+  try {
+    const url = new URL(urlSanitized)
+    if (unsafeLinkPrefix.some(prefix => url.protocol.toLowerCase().startsWith(prefix))) {
+      return false
+    }
+  } catch {
+    return false
+  }
+
+  return true
+}
+
 export const validateProp = (attribute: string, value: string) => {
   if (attribute.startsWith('on')) {
     return false
   }
 
   if (attribute === 'href' || attribute === 'src') {
-    return !unsafeLinkPrefix.some(prefix => value.toLowerCase().startsWith(prefix))
+    return isAnchorLinkAllowed(value)
   }

Source: GitHub Commit Update

Detection Methods for CVE-2025-24981

Indicators of Compromise

• Presence of HTML entity encoded strings in markdown content, particularly hex sequences like j or decimal sequences targeting characters in javascript:
• Unusual anchor tags in rendered HTML containing partially encoded protocol schemes
• JavaScript execution events triggered from anchor link clicks in markdown-rendered content
• Error logs indicating URL parsing failures or malformed protocol detection

Detection Strategies

• Implement Content Security Policy (CSP) headers to detect and block inline JavaScript execution from untrusted sources
• Monitor application logs for markdown content containing suspicious HTML entity patterns
• Deploy web application firewalls (WAF) with rules to detect encoded javascript: protocol variants
• Use browser developer tools or security plugins to identify XSS-vulnerable anchor elements in rendered pages

Monitoring Recommendations

• Enable verbose logging for markdown parsing operations to capture input content before rendering
• Set up alerts for CSP violation reports indicating blocked script execution attempts
• Monitor user-generated content submissions for patterns matching HTML entity encoded URLs
• Track dependency versions across applications to identify systems running vulnerable MDC versions

How to Mitigate CVE-2025-24981

Immediate Actions Required

• Upgrade MDC to version 0.13.3 or later immediately across all affected applications
• Audit all markdown content sources to identify potentially malicious input that may have been submitted
• Implement Content Security Policy headers as a defense-in-depth measure against XSS
• Review application logs for any evidence of exploitation attempts using encoded JavaScript URLs

Patch Information

The vulnerability has been addressed in MDC version 0.13.3. The fix introduces a new isAnchorLinkAllowed() function that properly sanitizes URLs by first decoding URL-encoded characters, then stripping HTML entities (both hex and decimal formats), and finally validating the resulting URL against the deny-list of unsafe protocols. This ensures that encoded bypass attempts are normalized before security checks are applied. All users are advised to upgrade to version 0.13.3 or later. The security patch can be reviewed in the GitHub Commit Update.

Workarounds

• There are no known workarounds for this vulnerability according to the security advisory
• As a temporary measure, restrict markdown parsing to trusted content sources only
• Implement server-side content filtering to strip HTML entity encoded patterns before markdown processing
• Deploy CSP headers with strict script-src directives to limit the impact of any successful XSS exploitation

# Update MDC to patched version
npm update @nuxt/mdc@0.13.3

# Or using yarn
yarn upgrade @nuxt/mdc@0.13.3

# Verify installed version
npm list @nuxt/mdc