/

CVE-2026-47760

Severity:

HIGH RISK

(8.7)

Cross-Site Scripting (XSS) in TinyMCE Rich Text Editor

CVE-2026-47760

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Arbitrary JavaScript Execution in User's Browser

Severity:

HIGH RISK

(8.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

TinyMCE versions 6.8.0 through 7.0.x contain a cross-site scripting (XSS) vulnerability in the HTML sanitizer's handling of SVG namespaces and nested elements.

Under certain conditions, a crafted SVG payload can bypass attribute sanitization and execute arbitrary JavaScript in the context of the embedding web application.

Affected context

This vulnerability appears when TinyMCE is used to accept, edit, or render rich text that may include SVG content, especially in environments where users can submit HTML or paste content from untrusted sources.

Applications that rely on TinyMCE's built-in sanitization and then reflect the resulting HTML back to other users—such as CMS platforms, forums, messaging systems, or comment fields—are more exposed.

The issue specifically concerns TinyMCE deployments using versions 6.8.0 up to (but not including) 7.1.0 where SVG markup is allowed or not fully stripped before rendering.

Exploit preconditions

  • Attack surface: Web applications embedding TinyMCE where user-controlled content is stored and later rendered to other users (or to privileged operators).
  • Required access: Ability for an attacker to create or modify TinyMCE-edited content (e.g., post an article, submit a comment, edit a profile, or send a message).
  • Trigger point: Viewing a page or component that renders the TinyMCE-sanitized content containing the malicious SVG payload.
  • Why exploitation is possible: The sanitizer does not correctly bound SVG namespace scope and nested elements, allowing certain attributes to evade filtering. This leads to unsafe script-capable constructs being preserved in the DOM and executed by the browser.

Why this happens

The underlying bug is an input sanitization flaw in TinyMCE's HTML cleaning logic, specifically in its treatment of SVG namespaces and nested structures.

Rather than fully constraining the namespace scope and validating attributes in the effective context where they are interpreted by the browser, the sanitizer allows crafted nested SVG elements to reintroduce or transform attributes that should be blocked.

This aligns with CWE-79: Improper Neutralization of Input During Web Page Generation, where untrusted user input is not fully neutralized before being included in web content, allowing execution of arbitrary script in the victim's browser.

Potential impact

  • Execution of arbitrary JavaScript in the victim's browser when viewing compromised content
  • Theft of session identifiers, CSRF tokens, or other sensitive data accessible via the DOM
  • Performance of actions on behalf of the victim within the vulnerable application (stored XSS-driven account takeover)
  • Manipulation or defacement of rendered content and user interface elements
  • Use of the affected application as a vehicle to deliver browser-based attacks or phishing flows

General mitigation guidance

Effective mitigation generally centers on defense-in-depth around HTML and SVG sanitization and minimizing trust in rich content:

  • Treat all user-supplied HTML as untrusted and apply robust, well-reviewed sanitization that accounts for SVG, MathML, and other browser-parsed namespaces.
  • Restrict or fully disable SVG and other complex embedded content where not strictly necessary, falling back to a safer, reduced markup subset.
  • Apply contextual output encoding on the server side when rendering user content, even if TinyMCE sanitization is in place.
  • Enforce strong Content Security Policy (CSP) settings (e.g., disallow inline script, restrict script sources) to reduce the impact of XSS where possible.
  • Prefer secure-by-default editor and sanitizer configurations that minimize allowed tags and attributes, and regularly review allowlists as browser behaviors evolve.
  • Limit the exposure of high-privilege or administrative views to potentially untrusted rich text content, or render such content in reduced/readonly modes with additional filtering.

How teams detect issues like this

Detection efforts can focus on both code and behavior:

  • Static analysis and configuration review:
  • Inspect TinyMCE integration points to understand which tags, attributes, and namespaces are allowed in sanitized output.
  • Review server-side rendering paths to ensure additional encoding or sanitization is in place, particularly around SVG and inline event handlers.
  • Security testing:
  • Conduct targeted XSS testing against TinyMCE-enabled fields using crafted SVG and nested namespace payloads.
  • Include regression tests for XSS involving non-HTML namespaces (SVG, MathML) in automated security test suites.
  • Runtime monitoring:
  • Monitor web application logs and telemetry for anomalous script execution patterns, unexpected DOM modifications, or suspicious content submissions.
  • Use web application firewalls or security gateways with rules aimed at detecting suspicious SVG/script patterns, understanding that these provide partial coverage only.
  • Automated SAST/DAST tools can assist by flagging risky content handling around TinyMCE and highlighting DOM sinks where sanitized content is injected.

Sources

SourceLink
github.comgithub.com/tinymce/tinymce/security/advisories/GHSA-mh5m-5hw4-5c69

Frequently asked

questions

Yes. An attacker who can submit content through TinyMCE (for example via a post, comment, or message) can remotely inject a crafted SVG payload. When another user or administrator views the rendered content, the malicious JavaScript can execute in their browser.

The attacker typically needs only the ability to submit or edit content that is processed by TinyMCE and later displayed to others. In many applications this corresponds to a standard authenticated user, though in some cases it could even be a guest user if anonymous posting is allowed.

Use a hardened HTML sanitization strategy that fully accounts for SVG and other namespaces, and treat TinyMCE's output as untrusted until it has passed through a robust server-side sanitizer. Where practical, disable SVG or other high-risk elements entirely, and enforce least-privilege markup policies.

Adopt a defense-in-depth approach to XSS: combine strict input validation, conservative HTML and SVG allowlists, contextual output encoding, and a restrictive CSP. Regularly update and test editor libraries, and integrate automated security testing focused on rich content features into your development lifecycle.

Find out what's already
exploitable in your codebase.