Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply malicious themeCSS in diagram source
-
DeliveryMermaid compileCSS expands sibling combinator to page scope
-
ExploitCSS rules escape SVG container
-
ExecutionStyles applied to sibling DOM elements
-
ImpactAttacker-controlled visual overlay rendered on host page
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires two simultaneous conditions: first, the application must render user-supplied Mermaid diagram source that includes attacker-controlled CSS properties - specifically via |
| Impact | No CVSS vector was provided with this CVE, so all metric assessments are inferred. The vulnerability is not listed in CISA KEV and no public exploit tooling exists, though the advisory publishes a functional proof-of-concept CSS payload. EPSS data is not available. Real-world risk is meaningfully constrained by the exploitation precondition: the SVG must have sibling DOM elements, which is explicitly a non-default condition - standard use of |
| Exploit ScenarioDerived | An attacker submits a Mermaid diagram with a malicious |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 06, 2026
CSS injection in the Mermaid JavaScript diagramming library (npm) allows sibling CSS combinators (~ and +) to escape the diagram's SVG container and apply attacker-controlled styles to adjacent DOM elements on the host page. Affected are applications using Mermaid below v11.16.1 or below v10.9.8 that render user-supplied diagram source and where the SVG element has sibling nodes in the DOM - a non-default condition. An attacker supplying malicious diagram content can perform UI redressing, hide legitimate page content, or create phishing-style visual overlays; the vendor explicitly confirms JavaScript execution is not possible via this vector. No public exploit tool is identified at time of analysis, though a working proof-of-concept payload is embedded in the GitHub security advisory.
RemediationAI
Upgrade to Mermaid v11.16.1 (v11 users) or v10.9.8 (v10 users); release pages are at https://github.com/mermaid-js/mermaid/releases/tag/mermaid%4011.16.1 and https://github.com/mermaid-js/mermaid/releases/tag/v10.9.8 respectively. The underlying fix is in commits 12d472c9ed43f94814b110da8d7a9ae6dd5266ed (v11) and 7e83f1533318b307764d961906a73377266f4c5e (v10). If upgrading is not immediately possible, three workarounds are available with no known functional side effects: (1) wrap any manually-inserted Mermaid SVG in a dedicated container with no other children (e.g., <div><svg>...</svg></div>) - this is the lowest-overhead mitigation and directly eliminates the sibling selector escape path; (2) replace manual SVG insertion with mermaid.run() or mermaid.initialize(), which apply the wrapper automatically; or (3) set securityLevel: 'sandbox' in Mermaid config to enforce stronger isolation, noting this may restrict some diagram theming features, or set the secure config key to block user-controlled themeCSS, fontFamily, altFontFamily, and themeVariables properties specifically.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Mermaid (pkg:npm/mermaid) is a widely-used JavaScript library that converts diagram syntax into SVG rendered in the browser. Its compileCSS middleware scopes all CSS rules to the diagram's SVG by prefixing selectors with the element's unique ID (e.g., #mermaid-123). However, CSS nesting syntax causes sibling combinators to expand unexpectedly: & ~ * { ... } becomes #svgId ~ *, a valid selector that targets all DOM elements following the SVG - outside the diagram boundary entirely. CWE-94 (Improper Control of Generation of Code) is the assigned root cause class, reflecting that user-controlled diagram input influences CSS generation in a way that escapes the intended scope. The fix in PR #8022 (commit 12d472c9) addresses the sibling combinator handling in compileCSS. Note that input metadata tags this as 'RCE,' which is explicitly contradicted by the advisory stating JavaScript execution is not achievable through this vector.
Know when the next one hits your stack
- 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:N/SC:L/SI:L/SA:L
AV:N as diagram is submitted over the network; AC:H because exploitation requires non-default SVG-sibling DOM layout; S:C as CSS escapes SVG scope to host page; no availability impact.
Primary rating from Vendor (https://github.com/mermaid-js/mermaid).
CVSS VectorVendor: https://github.com/mermaid-js/mermaid
Lifecycle Timeline
1DescriptionCVE.org
Summary
Mermaid does not fully restrict CSS to the rendered SVG subtree. Although selectors are prefixed with #mermaid-X, sibling (~ and +) combinators can still escape the Mermaid container and inject styles to DOM elements adjacent to the diagram <svg>.
Most users of mermaid would not be affected by this, as mermaid adds its <svg> as an only child of it's parent element. However, you may be affected if you manually insert the <svg> (or other elements) into the DOM yourself.
Details
Mermaid namespaces CSS through with a middleware intended to scope all rules to the diagram's SVG element. CSS nesting expands & ~ * { ... } to #svgId ~ *, which selects all sibling elements following the SVG in the DOM, outside the diagram boundary.
Impact
An attacker able to supply diagram source to a page (e.g., user-generated content rendered by Mermaid) could inject CSS rules affecting sibling elements to the diagram <svg> on the host page. This can be used for UI redressing, hiding content, conditional CSS-based probing, or phishing-style visual manipulation.
JavaScript execution is not possible via this vector.
Patches
This has been patched in https://github.com/mermaid-js/mermaid/commit/12d472c9ed43f94814b110da8d7a9ae6dd5266ed and released in Mermaid v11.16.1.
A backport has been made for the v10 branch in 7e83f1533318b307764d961906a73377266f4c5e and was released in Mermaid v10.9.8
Workarounds
If you are inserting the <svg> into the DOM yourself, you can wrap it in an element with no other children, e.g. <div><svg>...</svg></div> or element.innerHTML = svg. Alternatively, you can use mermaid.run() or mermaid.initialize() which will do this for you.
Setting "securityLevel": "sandbox" will also prevent this, or setting the secure config value in the mermaid config to avoid allowing diagrams to modify fontFamily, themeCSS, altFontFamily, and themeVariables.
To test, you can try using a themeCSS with & + * { /* my CSS here */} and see if it's applied outside of your mermaid <svg>.
---
config:
themeCSS: |-
& + * { background:red !important; width:100vw !important; height:100vh !important; position:fixed !important; inset:0 !important; }
---
infoReferences
- GHSA-87f9-hvmw-gh4p/CVE-2026-41159 (related vulnerability)
- https://github.com/mermaid-js/mermaid/commit/12d472c9ed43f94814b110da8d7a9ae6dd5266ed
- https://github.com/mermaid-js/mermaid/releases/tag/mermaid%4011.16.1
- https://github.com/mermaid-js/mermaid/commit/7e83f1533318b307764d961906a73377266f4c5e
- https://github.com/mermaid-js/mermaid/releases/tag/v10.9.8
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-54243
GHSA-6x64-9x62-f2gx
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB