Skip to main content

SunEditor CVE-2026-59167

| EUVDEUVD-2026-85324 CRITICAL
Cross-site Scripting (XSS) (CWE-79)
2026-09-23 GitHub_M GHSA-6rf4-v2fh-m6p4
10.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Attacker submits crafted editor content
  2. Delivery
    Sanitizer fails to strip namespaced/custom element handler
  3. Exploit
    Payload stored and served to victim
  4. Execution
    Victim interacts with element
  5. Persist
    Handler executes script in app origin
  6. Impact
    Session/data theft or unauthorized actions

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires a downstream application that (a) embeds SunEditor prior to 2.47.11, (b) accepts editor content from one (attacker) user, and (c) renders that content to other users without additional server-side sanitization. The specific technical trigger is a namespaced or custom HTML element (matching the pre-fix disallowed-tag regex gap, later broadened to cover style|meta|link|[a-z]+:[a-z]+) that retains an event-handler attribute the sanitizer failed to reject. Exploitation is LIMITED by required victim interaction with the crafted element (the handler fires on interaction, not passively) and by the application's content-rendering model - a single-user editor with no cross-user display of content is not exploitable. The default __allowedScriptTag setting also affects which tags are stripped.

Impact

The input assigns a CVSS 3.1 base score of 10.0 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H), which is substantially overstated for a stored XSS in a client-side editor library. Two vector choices are inconsistent with the description: (1) UI:N contradicts the text 'when a user interacts with the element, the retained handler can execute script' - the retained event-handler attributes (e.g. onmouseover/onclick) require victim interaction, so UI:R is correct; and (2) C:H/I:H/A:H overstates typical XSS impact - script execution in the app origin realistically yields C:L/I:L with no availability impact, though the S:C scope change (attacker content executing in the hosting application's origin) is appropriate. There is no EPSS score, no CISA KEV listing, and no public POC provided, so all exploitation-likelihood signals are absent rather than elevated. This is a genuine but moderate-severity defense-in-depth issue in a JavaScript library, not a 10.0 emergency: exploitation depends on a downstream application choosing to render attacker-controlled SunEditor content to other users. Treat as a routine dependency-update priority, not an actively-exploited critical.

Exploit ScenarioDerived

In an application that uses SunEditor (< 2.47.11) and renders one user's editor content to other users (e.g. comments, profiles, CMS posts), an attacker submits content containing a namespaced or custom HTML element carrying an event-handler attribute that the flawed sanitizer in src/lib/core.js fails to strip. When a victim later views and interacts with (hovers/clicks) that element, the retained handler runs JavaScript in the application's origin, enabling session/data theft or unauthorized actions. No public exploit code is identified at time of analysis, though the fixing commit publicly reveals the sanitizer-bypass mechanism.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 23, 2026

Stored cross-site scripting in SunEditor prior to 2.47.11 allows an attacker-supplied editor payload to survive the library's built-in sanitizer and execute JavaScript in a victim's browser origin. The sanitizer in src/lib/core.js fails to consistently reject namespaced or custom HTML elements, so an event-handler attribute (for example an on-click handler) can be retained on a crafted element; when a downstream application stores content from one user and renders it to another, the handler fires on victim interaction. Exploitation therefore requires a multi-user rendering workflow plus victim interaction with the crafted element, and there is no public exploit identified at time of analysis; the 10.0 base score carried in some feeds is substantially overstated relative to the independent assessment (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N), which reflects a bounded stored-XSS impact rather than unauthenticated, no-interaction compromise.

RemediationAI

Vendor-released patch: 2.47.11 - upgrade SunEditor to 2.47.11 or later (release notes: https://github.com/JiHong88/suneditor/releases/tag/2.47.11), which is the definitive fix and applies the broadened disallowed-tag regex (now including style|meta|link|[a-z]+:[a-z]+) and routes code-view output through _deleteDisallowedTags (commit https://github.com/JiHong88/suneditor/commit/a94ace269c7102bfb6de58a27a6547bc4eb09045, advisory https://github.com/JiHong88/suneditor/security/advisories/GHSA-6rf4-v2fh-m6p4). If upgrading is not immediately possible, do not rely on the library's client-side sanitizer alone: re-sanitize stored editor content server-side with an explicit allowlist (for example DOMPurify or an equivalent HTML sanitizer configured to strip all event-handler attributes and to reject namespaced, custom, style, meta and link elements before persistence and again at render); the trade-off is that legitimate custom tags used by the host application may be stripped, so the allowlist must be tuned to the application's content model. Additionally, restrict the rendering model so that content authored by one user is never displayed raw to another user without escaping, and deploy a Content-Security-Policy that disallows inline event handlers (script-src without 'unsafe-inline'), noting that CSP only mitigates and does not remove the underlying injection, and may break inline scripts elsewhere in the application. As there is no vendor-released patch for builds older than 2.47.11 and no public exploit identified at time of analysis, treating all pre-2.47.11 editor content as untrusted and re-sanitizing any already-stored content is the key compensating action.

Affected VersionsENISA

suneditor < 2.47.11

Affected Packages

npm suneditor fix: 2.47.11

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

SunEditor is a dependency-free vanilla JavaScript WYSIWYG editor; the vulnerable component is the client-side sanitizer implemented in src/lib/core.js (CWE-79, improper neutralization of input during web page generation). The flaw is a filter-parsing gap rather than a memory-safety issue: the library builds a regular expression of disallowed tags and applies it to editor output, but prior to 2.47.11 that pattern did not cover every element class. The fix in commit a94ace269c7102bfb6de58a27a6547bc4eb09045 broadens the disallowed-tag prefix to include 'style|meta|link' and, critically, '[a-z]+:[a-z]+', which is the pattern class matching namespaced elements such as '<foo:bar ...>'; it also routes the code-view output through _deleteDisallowedTags so the raw code view is sanitized as well. Because the sanitizer is purely client-side and regex-based, any element form the pattern misses (custom/unknown elements, namespaced tags) passes through with its attributes intact, including event-handler attributes such as on-click, on-mouseover, or on-error. The CPE cpe:2.3:a:jihong88:suneditor:*:*:*:*:*:*:*:* confirms the affected package is the upstream jihong88/suneditor distribution across all versions before the fixed release; the security default of the __allowedScriptTag option also influences which tag families get stripped, so installations that altered that option may have differing exposure.

Know when Suneditor gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 10.0 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 5.4 MEDIUM

Stored XSS via editor content submission (PR:L for a content-authoring user), firing on victim interaction (UI:R), executing in the hosting app origin (S:C) with typical C:L/I:L and no availability impact.

3.1 AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:P/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Sep 23, 2026 - 15:02 EUVD
CVE Published
Sep 23, 2026 - 13:52 cve.org
CRITICAL 10.0

DescriptionCVE.org

SunEditor is a lightweight and powerful WYSIWYG editor in vanilla JavaScript with no dependencies. Prior to 2.47.11, the sanitizer in src/lib/core.js does not consistently reject namespaced or custom HTML elements, allowing event-handler attributes to remain on crafted elements. When an application renders attacker-controlled editor content and a user interacts with the element, the retained handler can execute script in the application's browser origin, enabling stored cross-site scripting, data exposure, or unauthorized browser-context actions. This issue is fixed in version 2.47.11.

Technical POC Analysis

Bug class: CWE-79 - Improper Neutralization of Input During Web Page Generation, specifically a sanitizer bypass.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

SunEditor versions prior to 2.47.11 are affected by a stored cross-site scripting vulnerability that can be exploited by an authenticated user to inject malicious content, which then executes in another user's browser upon interaction. The absence of a vendor-released patch means organizations that rely on SunEditor for collaborative content creation face a persistent risk of session hijacking or data theft, though exploitation requires a multi-user workflow and victim interaction, and no public exploit has been identified. Leadership should direct resources to mitigate this risk across all affected applications.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include enforcing strict server-side sanitization of all user-supplied content before storage and rendering, implementing a robust Content Security Policy (CSP) that disallows inline scripts, disabling support for custom or namespaced HTML elements in SunEditor configuration if possible, and restricting editor use to trusted users until a patch is available.

Threat Intelligence Overview

EPSS Score
0.4%
Top 69% exploitable
Prevalence
Medium
popular open-source vanilla-JS WYSIWYG editor, common but not ubiquitous
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Medium
Technical Impact
Total

Priority Score

50
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +50
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy