DOMPurify

DOMPurify is a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG.

It's also very simple to use and get started with. DOMPurify was started in February 2014 and, meanwhile, has reached version v3.2.2.

DOMPurify is written in JavaScript and works in all modern browsers (Safari (10+), Opera (15+), Edge, Firefox and Chrome - as well as almost anything else using Blink, Gecko or WebKit). It doesn't break on MSIE or other legacy browsers. It simply does nothing.

Note that DOMPurify v2.5.7 is the latest version supporting MSIE. For important security updates compatible with MSIE, please use the 2.x branch.

Our automated tests cover 24 different browsers right now, more to come. We also cover Node.js v16.x, v17.x, v18.x and v19.x, running DOMPurify on jsdom. Older Node versions are known to work as well, but hey... no guarantees.

DOMPurify is written by security people who have vast background in web attacks and XSS. Fear not. For more details please also read about our Security Goals & Threat Model. Please, read it. Like, really.

What does it do?

DOMPurify sanitizes HTML and prevents XSS attacks. You can feed DOMPurify with string full of dirty HTML and it will return a string (unless configured otherwise) with clean HTML. DOMPurify will strip out everything that contains dangerous HTML and thereby prevent XSS attacks and other nastiness. It's also damn bloody fast. We use the technologies the browser provides and turn them into an XSS filter. The faster your browser, the faster DOMPurify will be.

How do I use it?

It's easy. Just include DOMPurify on your website.

Using the unminified development version

1<script type="text/javascript" src="src/purify.js"></script>

Using the minified and tested production version (source-map available)

1<script type="text/javascript" src="dist/purify.min.js"></script>

Afterwards you can sanitize strings by executing the following code:

1const clean = DOMPurify.sanitize(dirty);

Or maybe this, if you love working with Angular or alike:

1import DOMPurify from 'dompurify';
2
3const clean = DOMPurify.sanitize('<b>hello there</b>');

The resulting HTML can be written into a DOM element using innerHTML or the DOM using document.write(). That is fully up to you. Note that by default, we permit HTML, SVG and MathML. If you only need HTML, which might be a very common use-case, you can easily set that up as well:

1const clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { html: true } });

Is there any foot-gun potential?

Well, please note, if you first sanitize HTML and then modify it afterwards, you might easily void the effects of sanitization. If you feed the sanitized markup to another library after sanitization, please be certain that the library doesn't mess around with the HTML on its own.

Okay, makes sense, let's move on

After sanitizing your markup, you can also have a look at the property DOMPurify.removed and find out, what elements and attributes were thrown out. Please do not use this property for making any security critical decisions. This is just a little helper for curious minds.

Running DOMPurify on the server

DOMPurify technically also works server-side with Node.js. Our support strives to follow the Node.js release cycle.

Running DOMPurify on the server requires a DOM to be present, which is probably no surprise. Usually, jsdom is the tool of choice and we strongly recommend to use the latest version of jsdom.

Why? Because older versions of jsdom are known to be buggy in ways that result in XSS even if DOMPurify does everything 100% correctly. There are known attack vectors in, e.g. jsdom v19.0.0 that are fixed in jsdom v20.0.0 - and we really recommend to keep jsdom up to date because of that.

Please also be aware that tools like happy-dom exist but are not considered safe at this point. Combining DOMPurify with happy-dom is currently not recommended and will likely lead to XSS.

Other than that, you are fine to use DOMPurify on the server. Probably. This really depends on jsdom or whatever DOM you utilize server-side. If you can live with that, this is how you get it to work:

1npm install dompurify
2npm install jsdom

For jsdom (please use an up-to-date version), this should do the trick:

1const createDOMPurify = require('dompurify');
2const { JSDOM } = require('jsdom');
3
4const window = new JSDOM('').window;
5const DOMPurify = createDOMPurify(window);
6const clean = DOMPurify.sanitize('<b>hello there</b>');

Or even this, if you prefer working with imports:

1import { JSDOM } from 'jsdom';
2import DOMPurify from 'dompurify';
3
4const window = new JSDOM('').window;
5const purify = DOMPurify(window);
6const clean = purify.sanitize('<b>hello there</b>');

If you have problems making it work in your specific setup, consider looking at the amazing isomorphic-dompurify project which solves lots of problems people might run into.

1npm install isomorphic-dompurify

1import DOMPurify from 'isomorphic-dompurify';
2
3const clean = DOMPurify.sanitize('<s>hello</s>');

Is there a demo?

Of course there is a demo! Play with DOMPurify

What if I find a security bug?

First of all, please immediately contact us via email so we can work on a fix. PGP key

Also, you probably qualify for a bug bounty! The fine folks over at Fastmail use DOMPurify for their services and added our library to their bug bounty scope. So, if you find a way to bypass or weaken DOMPurify, please also have a look at their website and the bug bounty info.

Some purification samples please?

How does purified markup look like? Well, the demo shows it for a big bunch of nasty elements. But let's also show some smaller examples!

1DOMPurify.sanitize('<img src=x onerror=alert(1)//>'); // becomes <img src="x">
2DOMPurify.sanitize('<svg><g/onload=alert(2)//<p>'); // becomes <svg><g></g></svg>
3DOMPurify.sanitize('<p>abc<iframe//src=jAva&Tab;script:alert(3)>def</p>'); // becomes <p>abc</p>
4DOMPurify.sanitize('<math><mi//xlink:href="data:x,<script>alert(4)</script>">'); // becomes <math><mi></mi></math>
5DOMPurify.sanitize('<TABLE><tr><td>HELLO</tr></TABL>'); // becomes <table><tbody><tr><td>HELLO</td></tr></tbody></table>
6DOMPurify.sanitize('<UL><li><A HREF=//google.com>click</UL>'); // becomes <ul><li><a href="//google.com">click</a></li></ul>

What is supported?

DOMPurify currently supports HTML5, SVG and MathML. DOMPurify per default allows CSS, HTML custom data attributes. DOMPurify also supports the Shadow DOM - and sanitizes DOM templates recursively. DOMPurify also allows you to sanitize HTML for being used with the jQuery $() and elm.html() API without any known problems.

What about legacy browsers like Internet Explorer?

DOMPurify does nothing at all. It simply returns exactly the string that you fed it. DOMPurify exposes a property called isSupported, which tells you whether it will be able to do its job, so you can come up with your own backup plan.

What about DOMPurify and Trusted Types?

In version 1.0.9, support for Trusted Types API was added to DOMPurify. In version 2.0.0, a config flag was added to control DOMPurify's behavior regarding this.

When DOMPurify.sanitize is used in an environment where the Trusted Types API is available and RETURN_TRUSTED_TYPE is set to true, it tries to return a TrustedHTML value instead of a string (the behavior for RETURN_DOM and RETURN_DOM_FRAGMENT config options does not change).

Note that in order to create a policy in trustedTypes using DOMPurify, RETURN_TRUSTED_TYPE: false is required, as createHTML expects a normal string, not TrustedHTML. The example below shows this.

1window.trustedTypes!.createPolicy('default', {
2  createHTML: (to_escape) =>
3    DOMPurify.sanitize(to_escape, { RETURN_TRUSTED_TYPE: false }),
4});

Can I configure DOMPurify?

Yes. The included default configuration values are pretty good already - but you can of course override them. Check out the /demos folder to see a bunch of examples on how you can customize DOMPurify.

General settings

1// strip {{ ... }}, ${ ... } and <% ... %> to make output safe for template systems
2// be careful please, this mode is not recommended for production usage.
3// allowing template parsing in user-controlled HTML is not advised at all.
4// only use this mode if there is really no alternative.
5const clean = DOMPurify.sanitize(dirty, {SAFE_FOR_TEMPLATES: true});
6
7
8// change how e.g. comments containing risky HTML characters are treated.
9// be very careful, this setting should only be set to `false` if you really only handle 
10// HTML and nothing else, no SVG, MathML or the like. 
11// Otherwise, changing from `true` to `false` will lead to XSS in this or some other way.
12const clean = DOMPurify.sanitize(dirty, {SAFE_FOR_XML: false});

Control our allow-lists and block-lists

1// allow only <b> elements, very strict
2const clean = DOMPurify.sanitize(dirty, {ALLOWED_TAGS: ['b']});
3
4// allow only <b> and <q> with style attributes
5const clean = DOMPurify.sanitize(dirty, {ALLOWED_TAGS: ['b', 'q'], ALLOWED_ATTR: ['style']});
6
7// allow all safe HTML elements but neither SVG nor MathML
8// note that the USE_PROFILES setting will override the ALLOWED_TAGS setting
9// so don't use them together
10const clean = DOMPurify.sanitize(dirty, {USE_PROFILES: {html: true}});
11
12// allow all safe SVG elements and SVG Filters, no HTML or MathML
13const clean = DOMPurify.sanitize(dirty, {USE_PROFILES: {svg: true, svgFilters: true}});
14
15// allow all safe MathML elements and SVG, but no SVG Filters
16const clean = DOMPurify.sanitize(dirty, {USE_PROFILES: {mathMl: true, svg: true}});
17
18// change the default namespace from HTML to something different
19const clean = DOMPurify.sanitize(dirty, {NAMESPACE: 'http://www.w3.org/2000/svg'});
20
21// leave all safe HTML as it is and add <style> elements to block-list
22const clean = DOMPurify.sanitize(dirty, {FORBID_TAGS: ['style']});
23
24// leave all safe HTML as it is and add style attributes to block-list
25const clean = DOMPurify.sanitize(dirty, {FORBID_ATTR: ['style']});
26
27// extend the existing array of allowed tags and add <my-tag> to allow-list
28const clean = DOMPurify.sanitize(dirty, {ADD_TAGS: ['my-tag']});
29
30// extend the existing array of allowed attributes and add my-attr to allow-list
31const clean = DOMPurify.sanitize(dirty, {ADD_ATTR: ['my-attr']});
32
33// prohibit ARIA attributes, leave other safe HTML as is (default is true)
34const clean = DOMPurify.sanitize(dirty, {ALLOW_ARIA_ATTR: false});
35
36// prohibit HTML5 data attributes, leave other safe HTML as is (default is true)
37const clean = DOMPurify.sanitize(dirty, {ALLOW_DATA_ATTR: false});

Control behavior relating to Custom Elements

1// DOMPurify allows to define rules for Custom Elements. When using the CUSTOM_ELEMENT_HANDLING
2// literal, it is possible to define exactly what elements you wish to allow (by default, none are allowed).
3//
4// The same goes for their attributes. By default, the built-in or configured allow.list is used.
5//
6// You can use a RegExp literal to specify what is allowed or a predicate, examples for both can be seen below.
7// The default values are very restrictive to prevent accidental XSS bypasses. Handle with great care!
8
9const clean = DOMPurify.sanitize(
10    '<foo-bar baz="foobar" forbidden="true"></foo-bar><div is="foo-baz"></div>',
11    {
12        CUSTOM_ELEMENT_HANDLING: {
13            tagNameCheck: null, // no custom elements are allowed
14            attributeNameCheck: null, // default / standard attribute allow-list is used
15            allowCustomizedBuiltInElements: false, // no customized built-ins allowed
16        },
17    }
18); // <div is=""></div>
19
20const clean = DOMPurify.sanitize(
21    '<foo-bar baz="foobar" forbidden="true"></foo-bar><div is="foo-baz"></div>',
22    {
23        CUSTOM_ELEMENT_HANDLING: {
24            tagNameCheck: /^foo-/, // allow all tags starting with "foo-"
25            attributeNameCheck: /baz/, // allow all attributes containing "baz"
26            allowCustomizedBuiltInElements: true, // customized built-ins are allowed
27        },
28    }
29); // <foo-bar baz="foobar"></foo-bar><div is="foo-baz"></div>
30
31const clean = DOMPurify.sanitize(
32    '<foo-bar baz="foobar" forbidden="true"></foo-bar><div is="foo-baz"></div>',
33    {
34        CUSTOM_ELEMENT_HANDLING: {
35            tagNameCheck: (tagName) => tagName.match(/^foo-/), // allow all tags starting with "foo-"
36            attributeNameCheck: (attr) => attr.match(/baz/), // allow all containing "baz"
37            allowCustomizedBuiltInElements: true, // allow customized built-ins
38        },
39    }
40); // <foo-bar baz="foobar"></foo-bar><div is="foo-baz"></div>

Control behavior relating to URI values

1// extend the existing array of elements that can use Data URIs
2const clean = DOMPurify.sanitize(dirty, {ADD_DATA_URI_TAGS: ['a', 'area']});
3
4// extend the existing array of elements that are safe for URI-like values (be careful, XSS risk)
5const clean = DOMPurify.sanitize(dirty, {ADD_URI_SAFE_ATTR: ['my-attr']});
6

Control permitted attribute values

1// allow external protocol handlers in URL attributes (default is false, be careful, XSS risk)
2// by default only http, https, ftp, ftps, tel, mailto, callto, sms, cid and xmpp are allowed.
3const clean = DOMPurify.sanitize(dirty, {ALLOW_UNKNOWN_PROTOCOLS: true});
4
5// allow specific protocols handlers in URL attributes via regex (default is false, be careful, XSS risk)
6// by default only http, https, ftp, ftps, tel, mailto, callto, sms, cid and xmpp are allowed.
7// Default RegExp: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
8const clean = DOMPurify.sanitize(dirty, {ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|xxx):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i});
9

Influence the return-type

1// return a DOM HTMLBodyElement instead of an HTML string (default is false)
2const clean = DOMPurify.sanitize(dirty, {RETURN_DOM: true});
3
4// return a DOM DocumentFragment instead of an HTML string (default is false)
5const clean = DOMPurify.sanitize(dirty, {RETURN_DOM_FRAGMENT: true});
6
7// use the RETURN_TRUSTED_TYPE flag to turn on Trusted Types support if available
8const clean = DOMPurify.sanitize(dirty, {RETURN_TRUSTED_TYPE: true}); // will return a TrustedHTML object instead of a string if possible
9
10// use a provided Trusted Types policy
11const clean = DOMPurify.sanitize(dirty, {
12    // supplied policy must define createHTML and createScriptURL
13    TRUSTED_TYPES_POLICY: trustedTypes.createPolicy({
14        createHTML(s) { return s},
15        createScriptURL(s) { return s},
16    }
17});

Influence how we sanitize

1// return entire document including <html> tags (default is false)
2const clean = DOMPurify.sanitize(dirty, {WHOLE_DOCUMENT: true});
3
4// disable DOM Clobbering protection on output (default is true, handle with care, minor XSS risks here)
5const clean = DOMPurify.sanitize(dirty, {SANITIZE_DOM: false});
6
7// enforce strict DOM Clobbering protection via namespace isolation (default is false)
8// when enabled, isolates the namespace of named properties (i.e., `id` and `name` attributes)
9// from JS variables by prefixing them with the string `user-content-`
10const clean = DOMPurify.sanitize(dirty, {SANITIZE_NAMED_PROPS: true});
11
12// keep an element's content when the element is removed (default is true)
13const clean = DOMPurify.sanitize(dirty, {KEEP_CONTENT: false});
14
15// glue elements like style, script or others to document.body and prevent unintuitive browser behavior in several edge-cases (default is false)
16const clean = DOMPurify.sanitize(dirty, {FORCE_BODY: true});
17
18// remove all <a> elements under <p> elements that are removed
19const clean = DOMPurify.sanitize(dirty, {FORBID_CONTENTS: ['a'], FORBID_TAGS: ['p']});
20
21// change the parser type so sanitized data is treated as XML and not as HTML, which is the default
22const clean = DOMPurify.sanitize(dirty, {PARSER_MEDIA_TYPE: 'application/xhtml+xml'});

Influence where we sanitize

1// use the IN_PLACE mode to sanitize a node "in place", which is much faster depending on how you use DOMPurify
2const dirty = document.createElement('a');
3dirty.setAttribute('href', 'javascript:alert(1)');
4
5const clean = DOMPurify.sanitize(dirty, {IN_PLACE: true}); // see https://github.com/cure53/DOMPurify/issues/288 for more info

There is even more examples here, showing how you can run, customize and configure DOMPurify to fit your needs.

Persistent Configuration

Instead of repeatedly passing the same configuration to DOMPurify.sanitize, you can use the DOMPurify.setConfig method. Your configuration will persist until your next call to DOMPurify.setConfig, or until you invoke DOMPurify.clearConfig to reset it. Remember that there is only one active configuration, which means once it is set, all extra configuration parameters passed to DOMPurify.sanitize are ignored.

Hooks

DOMPurify allows you to augment its functionality by attaching one or more functions with the DOMPurify.addHook method to one of the following hooks:

• beforeSanitizeElements
• uponSanitizeElement (No 's' - called for every element)
• afterSanitizeElements
• beforeSanitizeAttributes
• uponSanitizeAttribute
• afterSanitizeAttributes
• beforeSanitizeShadowDOM
• uponSanitizeShadowNode
• afterSanitizeShadowDOM

It passes the currently processed DOM node, when needed a literal with verified node and attribute data and the DOMPurify configuration to the callback. Check out the MentalJS hook demo to see how the API can be used nicely.

Example:

1DOMPurify.addHook(
2  'uponSanitizeAttribute',
3  function (currentNode, hookEvent, config) {
4    // Do something with the current node
5    // You can also mutate hookEvent for current node (i.e. set hookEvent.forceKeepAttr = true)
6    // For other than 'uponSanitizeAttribute' hook types hookEvent equals to null
7  }
8);

Removed Configuration

Option	Since	Note
SAFE_FOR_JQUERY	2.1.0	No replacement required.

Continuous Integration

We are currently using Github Actions in combination with BrowserStack. This gives us the possibility to confirm for each and every commit that all is going according to plan in all supported browsers. Check out the build logs here: https://github.com/cure53/DOMPurify/actions

You can further run local tests by executing npm test. The tests work fine with Node.js v0.6.2 and jsdom@8.5.0.

All relevant commits will be signed with the key 0x24BB6BF4 for additional security (since 8th of April 2016).

Development and contributing

Installation (npm i)

We support npm officially. GitHub Actions workflow is configured to install dependencies using npm. When using deprecated version of npm we can not fully ensure the versions of installed dependencies which might lead to unanticipated problems.

Scripts

We rely on npm run-scripts for integrating with our tooling infrastructure. We use ESLint as a pre-commit hook to ensure code consistency. Moreover, to ease formatting we use prettier while building the /dist assets happens through rollup.

These are our npm scripts:

• npm run dev to start building while watching sources for changes
• npm run test to run our test suite via jsdom and karma
  • test:jsdom to only run tests through jsdom
  • test:karma to only run tests through karma
• npm run lint to lint the sources using ESLint (via xo)
• npm run format to format our sources using prettier to ease to pass ESLint
• npm run build to build our distribution assets minified and unminified as a UMD module
  • npm run build:umd to only build an unminified UMD module
  • npm run build:umd:min to only build a minified UMD module

Note: all run scripts triggered via npm run <script>.

There are more npm scripts but they are mainly to integrate with CI or are meant to be "private" for instance to amend build distribution files with every commit.

Security Mailing List

We maintain a mailing list that notifies whenever a security-critical release of DOMPurify was published. This means, if someone found a bypass and we fixed it with a release (which always happens when a bypass was found) a mail will go out to that list. This usually happens within minutes or few hours after learning about a bypass. The list can be subscribed to here:

https://lists.ruhr-uni-bochum.de/mailman/listinfo/dompurify-security

Feature releases will not be announced to this list.

Who contributed?

Many people helped and help DOMPurify become what it is and need to be acknowledged here!

hash_kitten ❤️, kevin_mizu ❤️, icesfont ❤️ dcramer 💸, JGraph 💸, baekilda 💸, Healthchecks 💸, Sentry 💸, jarrodldavis 💸, CynegeticIO, ssi02014 ❤️, GrantGryczan, Lowdefy, granlem, oreoshake, tdeekens ❤️, peernohell ❤️, is2ei, SoheilKhodayari, franktopel, NateScarlet, neilj, fhemberger, Joris-van-der-Wel, ydaniv, terjanq, filedescriptor, ConradIrwin, gibson042, choumx, 0xSobky, styfle, koto, tlau88, strugee, oparoz, mathiasbynens, edg2s, dnkolegov, dhardtke, wirehead, thorn0, styu, mozfreddyb, mikesamuel, jorangreef, jimmyhchan, jameydeorio, jameskraus, hyderali, hansottowirtz, hackvertor, freddyb, flavorjones, djfarrelly, devd, camerondunford, buu700, buildog, alabiaga, Vector919, Robbert, GreLI, FuzzySockets, ArtemBernatskyy, @garethheyes, @shafigullin, @mmrupp, @irsdl,ShikariSenpai, ansjdnakjdnajkd, @asutherland, @mathias, @cgvwzq, @robbertatwork, @giutro, @CmdEngineer_, @avr4mit and especially @securitymb ❤️ & @masatokinugawa ❤️

Testing powered by

And last but not least, thanks to BrowserStack Open-Source Program for supporting this project with their services for free and delivering excellent, dedicated and very professional support on top of that.