Security News
Cloudflare Adds Security.txt Setup Wizard
Cloudflare has launched a setup wizard allowing users to easily create and manage a security.txt file for vulnerability disclosure on their websites.
dompurify
Advanced tools
DOMPurify is a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG. It's written in JavaScript and works in all modern browsers (Safari, Opera (15+), Internet Explorer (10+), Firefox and Chrome - as well as almost anything else usin
DOMPurify is a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML, and SVG. It helps prevent Cross-Site Scripting (XSS) attacks by sanitizing HTML content to ensure it's safe to insert into the DOM. It is written in JavaScript and works in all modern web browsers.
Sanitizing HTML strings
This feature allows you to sanitize HTML strings to prevent XSS attacks. The code sample demonstrates how to sanitize a string that contains a potentially malicious script. The result of this code would be a safe string with the malicious parts removed.
DOMPurify.sanitize('<img src=x onerror=alert(1)//>');
Configuring the sanitizer
DOMPurify can be configured to allow certain tags, attributes, or schemes. In the code sample, the sanitizer is configured to allow only 'img' tags and will strip out any other tags, including scripts or event handlers.
DOMPurify.sanitize('<img src=x onerror=alert(1)//>', {ALLOWED_TAGS: ['img']});
Hooking into sanitization
DOMPurify allows you to add hooks that can modify the content during the sanitization process. In the code sample, a hook is added that will be called after the attributes of all nodes have been sanitized, allowing for custom manipulation of the nodes.
DOMPurify.addHook('afterSanitizeAttributes', function(node) { /* manipulate node */ });
sanitize-html is another HTML sanitizer that can clean up user-generated HTML, preventing XSS attacks. It is similar to DOMPurify but has a different API and set of defaults. It also allows for a high degree of customization in terms of what tags and attributes are allowed.
xss is a package that aims to filter input from users to prevent XSS attacks. It is similar to DOMPurify but includes different options and is more focused on filtering input as opposed to sanitizing existing HTML content.
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 is written in JavaScript and works in all modern browsers (Safari, Opera (15+), Internet Explorer (10+), Edge, Firefox and Chrome - as well as almost anything else using Blink or WebKit). It doesn't break on IE6 or other legacy browsers. It either uses a fall-back or simply does nothing.
Our automated tests cover 12 different browsers right now. We also cover Node.js v4.0.0, v5.0.0 and v6.0.0, running DOMPurify on jsdom.
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
DOMPurify sanitizes HTML and prevents XSS attacks. You can feed DOMPurify with string full of dirty HTML and it will return a string 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.
It's easy. Just include DOMPurify on your website.
<script type="text/javascript" src="src/purify.js"></script>
<script type="text/javascript" src="dist/purify.min.js"></script>
Afterwards you can sanitize strings by executing the following code:
var clean = DOMPurify.sanitize(dirty);
The resulting HTML can be written into a DOM element using innerHTML
or the DOM using document.write()
. That is fully up to you. But keep in mind, if you use the sanitized HTML with jQuery's very insecure elm.html()
method, then the SAFE_FOR_JQUERY
flag has to be set to make sure it's safe! Other than that, all is fine.
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.
If you're using an AMD module loader like Require.js, you can load this script asynchronously as well:
require(['dompurify'], function(DOMPurify) {
var clean = DOMPurify.sanitize(dirty);
});
DOMPurify also works server-side with node.js as well as client-side via Browserify or similar translators. Node.js 0.x is not supported; either io.js or Node.js 4.x or newer is required.
npm install dompurify
const createDOMPurify = require('dompurify');
const jsdom = require('jsdom');
const window = jsdom.jsdom('', {
features: {
FetchExternalResources: false, // disables resource loading over HTTP / filesystem
ProcessExternalResources: false // do not execute JS within script blocks
}
}).defaultView;
const DOMPurify = createDOMPurify(window);
const clean = DOMPurify.sanitize(dirty);
Strictly speaking, DOMPurify creates a document without a browsing context and you can replace it with const window = jsdom.jsdom().defaultView;
, however, the longer case protects against accidental bugs in jsdom or DOMPurify.
Of course there is a demo! Play with DOMPurify
If that happens, you probably qualify for a juicy 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 have a look at their website and the bug bounty info.
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!
DOMPurify.sanitize('<img src=x onerror=alert(1)//>'); // becomes <img src="x">
DOMPurify.sanitize('<svg><g/onload=alert(2)//<p>'); // becomes <svg><g></g></svg>
DOMPurify.sanitize('<p>abc<iframe/\/src=jAva	script:alert(3)>def'); // becomes <p>abc</p>
DOMPurify.sanitize('<math><mi//xlink:href="data:x,<script>alert(4)</script>">'); // becomes <math></math>
DOMPurify.sanitize('<TABLE><tr><td>HELLO</tr></TABL>'); // becomes <table><tbody><tr><td>HELLO</td></tr></tbody></table>
DOMPurify.sanitize('<UL><li><A HREF=//google.com>click</UL>'); // becomes <ul><li><a href="//google.com">click</a></li></ul>
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()
methods but requires the SAFE_FOR_JQUERY
flag for that - see below.
DOMPurify offers a fall-back behavior for older MSIE browsers. It uses the MSIE-only toStaticHTML
feature to sanitize. Note however that in this fall-back mode, pretty much none of the configuration flags shown below have any effect. You need to handle that yourself.
If not even toStaticHTML
is supported, DOMPurify does nothing at all. It simply returns exactly the string that you fed it.
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.
// make output safe for usage in jQuery's $()/html() method (default is false)
var clean = DOMPurify.sanitize(dirty, {SAFE_FOR_JQUERY: true});
// strip {{ ... }} and <% ... %> to make output safe for template systems
var clean = DOMPurify.sanitize(dirty, {SAFE_FOR_TEMPLATES: true});
// allow only <b>
var clean = DOMPurify.sanitize(dirty, {ALLOWED_TAGS: ['b']});
// allow only <b> and <q> with style attributes (for whatever reason)
var clean = DOMPurify.sanitize(dirty, {ALLOWED_TAGS: ['b', 'q'], ALLOWED_ATTR: ['style']});
// leave all as it is but forbid <style>
var clean = DOMPurify.sanitize(dirty, {FORBID_TAGS: ['style']});
// leave all as it is but forbid style attributes
var clean = DOMPurify.sanitize(dirty, {FORBID_ATTR: ['style']});
// extend the existing array of allowed tags
var clean = DOMPurify.sanitize(dirty, {ADD_TAGS: ['my-tag']});
// extend the existing array of attributes
var clean = DOMPurify.sanitize(dirty, {ADD_ATTR: ['my-attr']});
// prohibit HTML5 data attributes (default is true)
var clean = DOMPurify.sanitize(dirty, {ALLOW_DATA_ATTR: false});
// allow external protocol handlers in URL attributes (default is false)
// by default only http, https, ftp, ftps, tel and mailto are allowed.
var clean = DOMPurify.sanitize(dirty, {ALLOW_UNKNOWN_PROTOCOLS: true});
// return a DOM HTMLBodyElement instead of an HTML string (default is false)
var clean = DOMPurify.sanitize(dirty, {RETURN_DOM: true});
// return a DOM DocumentFragment instead of an HTML string (default is false)
var clean = DOMPurify.sanitize(dirty, {RETURN_DOM_FRAGMENT: true});
// return a DOM DocumentFragment instead of an HTML string (default is false)
// also import it into the current document (default is false).
// RETURN_DOM_IMPORT must be set if you would like to append
// the returned node to the current document
var clean = DOMPurify.sanitize(dirty, {RETURN_DOM_FRAGMENT: true, RETURN_DOM_IMPORT: true});
document.body.appendChild(clean);
// return entire document including <html> tags (default is false)
var clean = DOMPurify.sanitize(dirty, {WHOLE_DOCUMENT: true});
// disable DOM Clobbering protection on output (default is true, handle with care!)
var clean = DOMPurify.sanitize(dirty, {SANITIZE_DOM: false});
// discard an element's content when the element is removed (default is true)
var clean = DOMPurify.sanitize(dirty, {KEEP_CONTENT: false});
// glue elements like style, script or others to document.body and prevent unintuitive browser behavior in several edge-cases (default is false)
var clean = DOMPurify.sanitize(dirty, {FORCE_BODY: true});
There is even more examples here, showing how you can run, customize and configure DOMPurify to fit your needs.
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
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:
DOMPurify.addHook('beforeSanitizeElements', function(currentNode, data, config) {
// Do something with the current node and return it
return currentNode;
});
We are currently using Travis CI 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://travis-ci.org/cure53/DOMPurify
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).
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.
Several people need to be listed here!
@garethheyes and @filedescriptor for invaluable help, @shafigullin for breaking the library multiple times and thereby strengthening it, @mmrupp and @irsdl for doing the same.
Big thanks also go to @asutherland, @mathias, @cgvwzq, @robbertatwork, @giutro and @fhemberger!
Further, thanks @neilj and @0xsobky for their code reviews and countless small optimizations, fixes and beautifications.
Big thanks also go to @tdeekens for doing all the hard work and getting us on track with Travis CI and BrowserStack. And thanks to @Joris-van-der-Wel for setting up DOMPurify for jsdom and creating the additional test suite.
And last but not least, thanks to BrowserStack for supporting this project with their services for free and delivering excellent, dedicated and very professional support on top of that.
FAQs
DOMPurify is a DOM-only, super-fast, uber-tolerant XSS sanitizer for HTML, MathML and SVG. It's written in JavaScript and works in all modern browsers (Safari, Opera (15+), Internet Explorer (10+), Firefox and Chrome - as well as almost anything else usin
The npm package dompurify receives a total of 5,358,512 weekly downloads. As such, dompurify popularity was classified as popular.
We found that dompurify demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Cloudflare has launched a setup wizard allowing users to easily create and manage a security.txt file for vulnerability disclosure on their websites.
Security News
The Socket Research team breaks down a malicious npm package targeting the legitimate DOMPurify library. It uses obfuscated code to hide that it is exfiltrating browser and crypto wallet data.
Security News
ENISA’s 2024 report highlights the EU’s top cybersecurity threats, including rising DDoS attacks, ransomware, supply chain vulnerabilities, and weaponized AI.