Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker submits crafted editor content
-
DeliverySanitizer fails to strip namespaced/custom element handler
-
ExploitPayload stored and served to victim
-
ExecutionVictim interacts with element
-
PersistHandler executes script in app origin
-
ImpactSession/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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
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.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
EUVD-2026-85324
GHSA-6rf4-v2fh-m6p4
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB