अपडेट पर वापस जाएँ
New releaseAug 3, 2026

DOMPurify v3.4.13

DOMPurify - HTML, MathML और SVG के लिए एक DOM-मात्र, अति-तेज़, अति-सहिष्णु XSS सैनिटाइज़र। DOMPurify एक सुरक्षित डिफ़ॉल्ट के साथ काम करता है, लेकिन बहुत सारी कॉन्फ़िगरेबिलिटी और हुक्स प्रदान करता है। डेमो:

साझा करें

DOMPurify

npm License Downloads dependents npm package minimized gzipped size (select exports) Cloudback

OpenSSF Best Practices Build & Test OpenSSF Scorecard Socket Badge snyk.io package health

DOMPurify HTML, MathML और SVG के लिए एक DOM-आधारित, अति-तेज़, अति-सहिष्णु XSS सैनिटाइज़र है।

इसे उपयोग करना और शुरू करना भी बहुत आसान है। DOMPurify की शुरुआत फरवरी 2014 में हुई थी और इस बीच यह संस्करण v3.4.14 तक पहुँच चुका है।

DOMPurify JavaScript के रूप में चलता है और सभी आधुनिक ब्राउज़रों (Safari (10+), Opera (15+), Edge, Firefox और Chrome - साथ ही Blink, Gecko या WebKit का उपयोग करने वाली लगभग हर चीज़) में काम करता है। यह MSIE या अन्य पुराने ब्राउज़रों पर नहीं टूटता। यह बस कुछ नहीं करता।

ध्यान दें कि DOMPurify v2.5.9 MSIE का समर्थन करने वाला नवीनतम संस्करण है। MSIE के साथ संगत महत्वपूर्ण सुरक्षा अपडेट के लिए, कृपया 2.x शाखा का उपयोग करें।

हमारे स्वचालित परीक्षण हर पुश पर वर्तमान इंजनों (Ubuntu, macOS और Windows पर Chromium, Firefox और WebKit) पर 9 ब्राउज़र/OS संयोजनों को कवर करते हैं, और एक अलग मैट्रिक्स पुराने इंजन स्नैपशॉट (लगभग Chromium 110, Firefox 108 और WebKit 16.4, लगभग तीन साल पुराने) पर सूट को फिर से चलाता है ताकि पुराने ब्राउज़रों पर होने वाली रिग्रेशन भी पकड़ी जा सकें। हम jsdom पर DOMPurify के साथ Node.js v20, v22, v24, v25 और v26 भी चलाते हैं। पुराने Node संस्करण भी काम करते हैं, लेकिन... कोई गारंटी नहीं।

DOMPurify सुरक्षा विशेषज्ञों द्वारा लिखा गया है जिनके पास वेब हमलों और XSS का व्यापक अनुभव है। डरने की ज़रूरत नहीं। अधिक विवरण के लिए कृपया हमारे Security Goals & Threat Model के बारे में भी पढ़ें। कृपया, इसे पढ़ें। सच में। और यदि आप विस्तृत विवरण पसंद करते हैं, तो Attack Classes & Bypass History पृष्ठ उन पार्सर-म्यूटेशन, नेमस्पेस, क्लोबरिंग और टेम्पलेट ट्रिक्स की सूची देता है जिनसे DOMPurify बचाव करता है।

DOMPurify परियोजना ने HTML Sanitizer API के निर्माण को प्रेरित किया, जो पहले से ही कई ब्राउज़रों में शिप हो रहा है। यही क्षमता अब सीधे WHATWG HTML specification में मानकीकृत की जा रही है।

विषय-सूची

यह क्या करता है?

DOMPurify HTML को सैनिटाइज़ करता है और XSS हमलों को रोकता है। आप DOMPurify को उदाहरण के लिए गंदे HTML से भरी एक स्ट्रिंग दे सकते हैं और यह (जब तक अन्यथा कॉन्फ़िगर न किया गया हो) स्वच्छ HTML वाली एक स्ट्रिंग लौटाएगा। DOMPurify उन सभी चीज़ों को हटा देगा जिनमें खतरनाक HTML होता है और इस तरह XSS हमलों और अन्य गंदगी को रोकेगा। यह बहुत तेज़ भी है। हम उन तकनीकों का उपयोग करते हैं जो ब्राउज़र प्रदान करता है और उन्हें XSS फ़िल्टर में बदल देते हैं। आपका ब्राउज़र जितना तेज़ होगा, DOMPurify उतना ही तेज़ होगा।

मैं इसका उपयोग कैसे करूँ?

यह आसान है। बस अपनी वेबसाइट पर DOMPurify शामिल करें।

अनमिनिफाइड संस्करण का उपयोग करना (सोर्स-मैप उपलब्ध)```html

### मिनिफाइड और परीक्षण किए गए प्रोडक्शन संस्करण का उपयोग करना (सोर्स-मैप उपलब्ध)```html
<script type="text/javascript" src="dist/purify.min.js"></script>

बाद में आप निम्नलिखित कोड को निष्पादित करके स्ट्रिंग्स को सैनिटाइज़ कर सकते हैं:```js const clean = DOMPurify.sanitize(dirty);

या शायद यह, अगर आपको Angular या इसी तरह के फ्रेमवर्क के साथ काम करना पसंद है:```js
import DOMPurify from 'dompurify';

const clean = DOMPurify.sanitize('<b>hello there</b>');

परिणामी HTML को innerHTML का उपयोग करके किसी DOM एलिमेंट में, या DOM में document.write() का उपयोग करके लिखा जा सकता है। यह पूरी तरह आप पर निर्भर है। ध्यान दें कि डिफ़ॉल्ट रूप से, हम HTML, SVG और MathML की अनुमति देते हैं। यदि आपको केवल HTML की आवश्यकता है, जो एक बहुत ही सामान्य उपयोग-मामला हो सकता है, तो आप इसे आसानी से इस प्रकार सेट कर सकते हैं:```js const clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { html: true } });

### क्या कोई फुट-गन (Foot-gun) संभावना है?

खैर, कृपया ध्यान दें, यदि आप _पहले_ HTML को सैनिटाइज़ करते हैं और फिर उसे _बाद में_ संशोधित करते हैं, तो आप आसानी से **सैनिटाइज़ेशन के प्रभावों को शून्य** कर सकते हैं। यदि आप सैनिटाइज़ किए गए मार्कअप को सैनिटाइज़ेशन के _बाद_ किसी अन्य लाइब्रेरी को देते हैं, तो सुनिश्चित करें कि वह लाइब्रेरी अपने आप HTML के साथ छेड़छाड़ न करे। सुरक्षित-उपयोग के तरीकों और उन टैग्स/एट्रिब्यूट्स के बारे में जानने के लिए [Security Goals & Threat Model](https://github.com/cure53/DOMPurify/wiki/Security-Goals-&-Threat-Model) देखें, और यह जानने के लिए कि पोस्ट-प्रोसेसिंग और मार्कअप संदर्भ बदलना सैनिटाइज़ेशन को क्यों विफल करता है, [Attack Classes & Bypass History](https://github.com/cure53/DOMPurify/wiki/Attack-Classes-&-Bypass-History) देखें।

### ठीक है, समझ में आया, आगे बढ़ते हैं

अपने मार्कअप को सैनिटाइज़ करने के बाद, आप `DOMPurify.removed` प्रॉपर्टी पर भी नज़र डाल सकते हैं और पता लगा सकते हैं कि कौन से तत्व और एट्रिब्यूट्स बाहर फेंके गए थे। कृपया **इस प्रॉपर्टी का उपयोग** किसी भी सुरक्षा-महत्वपूर्ण निर्णय लेने के लिए **न करें**। यह केवल जिज्ञासु मन वालों के लिए एक छोटा सा सहायक है।

### सर्वर पर DOMPurify चलाना

DOMPurify तकनीकी रूप से Node.js के साथ सर्वर-साइड पर भी काम करता है। हमारा समर्थन [Node.js रिलीज़ चक्र](https://nodejs.org/en/about/previous-releases) का पालन करने का प्रयास करता है।

सर्वर पर DOMPurify चलाने के लिए एक DOM की उपस्थिति आवश्यक है, जो शायद कोई आश्चर्य की बात नहीं है। आमतौर पर, [jsdom](https://github.com/jsdom/jsdom) ही पसंदीदा टूल है और हम **दृढ़ता से अनुशंसा** करते हैं कि _jsdom_ का नवीनतम संस्करण उपयोग करें।

क्यों? क्योंकि _jsdom_ के पुराने संस्करण ज्ञात रूप से बगी हैं, जिसके परिणामस्वरूप XSS हो सकता है _भले ही_ DOMPurify सब कुछ 100% सही करे। उदाहरण के लिए, _jsdom v19.0.0_ में **ज्ञात हमले के वेक्टर** हैं जो _jsdom v20.0.0_ में ठीक कर दिए गए हैं - और इसीलिए हम वास्तव में _jsdom_ को अपडेट रखने की सलाह देते हैं।

कृपया यह भी ध्यान रखें कि [happy-dom](https://github.com/capricorn86/happy-dom) जैसे टूल मौजूद हैं, लेकिन इस समय **सुरक्षित नहीं माने जाते**। DOMPurify को _happy-dom_ के साथ जोड़ना वर्तमान में अनुशंसित नहीं है और संभवतः XSS का कारण बनेगा। आपके द्वारा चुना गया सर्वर-साइड DOM आपके ट्रस्टेड कंप्यूटिंग बेस का हिस्सा क्यों है, इसकी पृष्ठभूमि के लिए [Attack Classes & Bypass History](https://github.com/cure53/DOMPurify/wiki/Attack-Classes-&-Bypass-History) देखें।

इसके अलावा, आप सर्वर पर DOMPurify का उपयोग करने के लिए स्वतंत्र हैं। शायद। यह वास्तव में _jsdom_ या जो भी DOM आप सर्वर-साइड पर उपयोग करते हैं, उस पर निर्भर करता है। यदि आप उसके साथ रह सकते हैं, तो इसे काम करने का तरीका इस प्रकार है:```bash
npm install dompurify
npm install jsdom

For jsdom (कृपया एक अद्यतन संस्करण उपयोग करें), यह काम कर जाना चाहिए:```js const createDOMPurify = require('dompurify'); const { JSDOM } = require('jsdom');

const window = new JSDOM('').window; const DOMPurify = createDOMPurify(window); const clean = DOMPurify.sanitize('hello there');

या भी, यदि आप imports के साथ काम करना पसंद करते हैं:```js
import { JSDOM } from 'jsdom';
import DOMPurify from 'dompurify';

const window = new JSDOM('').window;
const purify = DOMPurify(window);
const clean = purify.sanitize('<b>hello there</b>');

अगर आपको इसे अपने विशेष सेटअप में काम करवाने में समस्या आ रही है, तो शानदार isomorphic-dompurify प्रोजेक्ट पर एक नज़र डालने पर विचार करें, जो उन कई समस्याओं को हल करता है जिनका सामना लोग कर सकते हैं।```bash npm install isomorphic-dompurify

यहाँ आपका अनुवाद है:

- **`--no-verify`**: सभी सत्यापन चरणों को छोड़ देता है (जैसे कि सत्यापन, निर्भरता जाँच, आदि)।
- **`--no-install`**: निर्भरताओं को स्थापित नहीं करता है, केवल उन्हें डाउनलोड करता है।
- **`--no-cleanup`**: अस्थायी फ़ाइलों को साफ़ नहीं करता है (डिबगिंग के लिए उपयोगी)।
- **`--no-banner`**: स्टार्टअप पर बैनर/लोगो प्रदर्शित नहीं करता है।
- **`--no-color`**: रंगीन आउटपुट अक्षम करता है (सादा टेक्स्ट)।
- **`--no-interactive`**: इंटरैक्टिव प्रॉम्प्ट अक्षम करता है (स्वचालित/स्क्रिप्टेड उपयोग के लिए)।
- **`--no-progress`**: प्रगति बार/प्रतिशत प्रदर्शन अक्षम करता है।
- **`--no-spinner`**: लोडिंग स्पिनर/एनिमेशन अक्षम करता है।
- **`--no-emoji`**: आउटपुट में इमोजी का उपयोग अक्षम करता है।
- **`--no-unicode`**: आउटपुट में यूनिकोड वर्णों का उपयोग अक्षम करता है (ASCII-केवल आउटपुट)।
- **`--no-ansi`**: ANSI एस्केप कोड अक्षम करता है (पूरी तरह से सादा टेक्स्ट आउटपुट)।
- **`--no-utf8`**: UTF-8 एन्कोडिंग अक्षम करता है (प्लेटफ़ॉर्म-विशिष्ट एन्कोडिंग का उपयोग करता है)।
- **`--no-ssl`**: SSL/TLS सत्यापन अक्षम करता है (केवल डिबगिंग के लिए, उत्पादन में उपयोग न करें)।
- **`--no-check-certificate`**: सर्वर प्रमाणपत्र सत्यापन अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-hostname`**: होस्टनाम सत्यापन अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-revocation`**: प्रमाणपत्र निरस्तीकरण जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-validity`**: प्रमाणपत्र वैधता अवधि जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-expiry`**: प्रमाणपत्र समाप्ति जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-signature`**: हस्ताक्षर सत्यापन अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-hash`**: हैश सत्यापन अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-checksum`**: चेकसम सत्यापन अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-integrity`**: अखंडता सत्यापन अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-permissions`**: फ़ाइल अनुमति जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-ownership`**: फ़ाइल स्वामित्व जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-links`**: लिंक जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-symlinks`**: सिमलिंक जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-hardlinks`**: हार्डलिंक जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-mounts`**: माउंट पॉइंट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-filesystem`**: फ़ाइल सिस्टम जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-disk-space`**: डिस्क स्थान जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-memory`**: मेमोरी जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cpu`**: CPU जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-network`**: नेटवर्क जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-internet`**: इंटरनेट कनेक्टिविटी जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-proxy`**: प्रॉक्सी जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-firewall`**: फ़ायरवॉल जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-antivirus`**: एंटीवायरस जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sandbox`**: सैंडबॉक्स जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-container`**: कंटेनर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-virtualization`**: वर्चुअलाइज़ेशन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cloud`**: क्लाउड जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-docker`**: Docker जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-kubernetes`**: Kubernetes जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-helm`**: Helm जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-terraform`**: Terraform जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-ansible`**: Ansible जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-puppet`**: Puppet जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-chef`**: Chef जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-salt`**: Salt जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-nagios`**: Nagios जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-zabbix`**: Zabbix जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-prometheus`**: Prometheus जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-grafana`**: Grafana जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-kibana`**: Kibana जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-elasticsearch`**: Elasticsearch जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-logstash`**: Logstash जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-beats`**: Beats जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-filebeat`**: Filebeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-metricbeat`**: Metricbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-packetbeat`**: Packetbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-heartbeat`**: Heartbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-auditbeat`**: Auditbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-winlogbeat`**: Winlogbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-journalbeat`**: Journalbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-functionbeat`**: Functionbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-heartbeat`**: Heartbeat जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-uptime`**: अपटाइम जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-latency`**: विलंबता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-throughput`**: थ्रूपुट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-bandwidth`**: बैंडविड्थ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-packet-loss`**: पैकेट हानि जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-jitter`**: जिटर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-qos`**: QoS जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sla`**: SLA जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-slo`**: SLO जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sli`**: SLI जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-kpi`**: KPI जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-metrics`**: मेट्रिक्स जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-logs`**: लॉग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-traces`**: ट्रेस जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-events`**: इवेंट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-alerts`**: अलर्ट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-notifications`**: सूचनाएँ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-webhooks`**: वेबहुक जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-api`**: API जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-rest`**: REST जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-graphql`**: GraphQL जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-grpc`**: gRPC जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-websocket`**: WebSocket जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sse`**: SSE जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-mqtt`**: MQTT जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-amqp`**: AMQP जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-kafka`**: Kafka जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-rabbitmq`**: RabbitMQ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-redis`**: Redis जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-memcached`**: Memcached जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-mongodb`**: MongoDB जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-mysql`**: MySQL जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-postgresql`**: PostgreSQL जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sqlite`**: SQLite जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-mariadb`**: MariaDB जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-oracle`**: Oracle जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sqlserver`**: SQL Server जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cassandra`**: Cassandra जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-couchdb`**: CouchDB जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-couchbase`**: Couchbase जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-dynamodb`**: DynamoDB जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-neo4j`**: Neo4j जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-elasticache`**: ElastiCache जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-rds`**: RDS जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-s3`**: S3 जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-ec2`**: EC2 जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-lambda`**: Lambda जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cloudfront`**: CloudFront जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-route53`**: Route 53 जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-iam`**: IAM जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-vpc`**: VPC जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-subnet`**: सबनेट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-security-group`**: सुरक्षा समूह जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-nacl`**: NACL जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-load-balancer`**: लोड बैलेंसर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-auto-scaling`**: ऑटो-स्केलिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cloudwatch`**: CloudWatch जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cloudtrail`**: CloudTrail जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-config`**: Config जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-guardduty`**: GuardDuty जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-inspector`**: Inspector जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-macie`**: Macie जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-secrets-manager`**: Secrets Manager जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-kms`**: KMS जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-certificate-manager`**: Certificate Manager जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-waf`**: WAF जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-shield`**: Shield जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-firewall-manager`**: Firewall Manager जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-network-firewall`**: Network Firewall जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-ddos`**: DDoS जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-rate-limit`**: दर सीमा जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-throttling`**: थ्रॉटलिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-quota`**: कोटा जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-billing`**: बिलिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-cost`**: लागत जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-budget`**: बजट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-usage`**: उपयोग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-limits`**: सीमाएँ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-capacity`**: क्षमता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-resources`**: संसाधन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-dependencies`**: निर्भरता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-conflicts`**: संघर्ष जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-compatibility`**: संगतता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-requirements`**: आवश्यकताएँ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-prerequisites`**: पूर्वापेक्षाएँ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-conditions`**: शर्तें जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-constraints`**: बाधाएँ जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-validations`**: सत्यापन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-tests`**: परीक्षण जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-coverage`**: कवरेज जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-quality`**: गुणवत्ता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-security`**: सुरक्षा जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-vulnerabilities`**: भेद्यता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-exploits`**: एक्सप्लॉइट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-malware`**: मैलवेयर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-ransomware`**: रैंसमवेयर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-phishing`**: फ़िशिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-spam`**: स्पैम जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-adware`**: एडवेयर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-spyware`**: स्पाइवेयर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-trojan`**: ट्रोजन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-worm`**: वर्म जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-rootkit`**: रूटकिट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-backdoor`**: बैकडोर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-botnet`**: बॉटनेट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-c2`**: C2 जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-command-control`**: कमांड-एंड-कंट्रोल जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-exfiltration`**: डेटा एक्सफ़िल्ट्रेशन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-loss`**: डेटा हानि जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-breach`**: डेटा उल्लंघन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-leak`**: डेटा रिसाव जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-theft`**: डेटा चोरी जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-corruption`**: डेटा भ्रष्टाचार जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-integrity`**: डेटा अखंडता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-availability`**: डेटा उपलब्धता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-confidentiality`**: डेटा गोपनीयता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-privacy`**: डेटा गोपनीयता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-protection`**: डेटा सुरक्षा जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-governance`**: डेटा शासन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-compliance`**: डेटा अनुपालन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-audit`**: डेटा ऑडिट जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-retention`**: डेटा प्रतिधारण जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-backup`**: डेटा बैकअप जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-recovery`**: डेटा पुनर्प्राप्ति जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-data-disaster-recovery`**: आपदा पुनर्प्राप्ति जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-business-continuity`**: व्यवसाय निरंतरता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-high-availability`**: उच्च उपलब्धता जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-failover`**: फेलओवर जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-redundancy`**: अतिरेक जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-load-balancing`**: लोड संतुलन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-clustering`**: क्लस्टरिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-replication`**: प्रतिकृति जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-sharding`**: शार्डिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-partitioning`**: विभाजन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-indexing`**: अनुक्रमण जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-caching`**: कैशिंग जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-optimization`**: अनुकूलन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-performance`**: प्रदर्शन जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-benchmark`**: बेंचमार्क जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-stress`**: स्ट्रेस जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-load`**: लोड जाँच अक्षम करता है (केवल डिबगिंग के लिए)।
- **`--no-check-soak`**:```js
import DOMPurify from 'isomorphic-dompurify';

const clean = DOMPurify.sanitize('<s>hello</s>');

क्या कोई डेमो है?

बिल्कुल एक डेमो है! DOMPurify के साथ खेलें

अगर मुझे कोई सुरक्षा बग मिले तो क्या करूँ?

सबसे पहले, कृपया तुरंत ईमेल के माध्यम से हमसे संपर्क करें ताकि हम एक फिक्स पर काम कर सकें। PGP key

साथ ही, आप शायद बग बाउंटी के लिए योग्य हैं! Fastmail के अच्छे लोग अपनी सेवाओं के लिए DOMPurify का उपयोग करते हैं और हमारी लाइब्रेरी को अपने बग बाउंटी दायरे में जोड़ा है। इसलिए, यदि आप DOMPurify को बायपास या कमजोर करने का कोई तरीका ढूंढते हैं, तो कृपया उनकी वेबसाइट और बग बाउंटी जानकारी पर भी नज़र डालें।

कुछ प्यूरीफिकेशन नमूने कृपया?

प्यूरीफाइड मार्कअप कैसा दिखता है? खैर, डेमो इसे बहुत सारे खतरनाक तत्वों के लिए दिखाता है। लेकिन आइए कुछ छोटे उदाहरण भी दिखाएँ!```js DOMPurify.sanitize(''); // becomes DOMPurify.sanitize('<g/onload=alert(2)//

'); // becomes DOMPurify.sanitize('

abcdef

'); // becomes

abc

DOMPurify.sanitize('<mi//xlink:href="data:x,">'); // becomes DOMPurify.sanitize(''); // becomes
HELLO
HELLO
DOMPurify.sanitize('
  • <A HREF=//google.com>click
'); // becomes 

ये सिर्फ़ एक झलक हैं। इन नमूनों के स्रोत हमले वर्गों की पूरी सूची के लिए - mutation XSS, namespace confusion, DOM clobbering, rawtext breakouts, और बाकी - [Attack Classes & Bypass History](https://github.com/cure53/DOMPurify/wiki/Attack-Classes-&-Bypass-History) देखें।

## क्या समर्थित है?

DOMPurify वर्तमान में HTML5, SVG और MathML का समर्थन करता है। DOMPurify डिफ़ॉल्ट रूप से CSS, HTML कस्टम डेटा विशेषताओं की अनुमति देता है। DOMPurify Shadow DOM का भी समर्थन करता है - और DOM टेम्पलेट्स को पुनरावर्ती रूप से सैनिटाइज़ करता है। DOMPurify आपको jQuery `$()` और `elm.html()` API के साथ उपयोग के लिए HTML को सैनिटाइज़ करने की भी अनुमति देता है, बिना किसी ज्ञात समस्या के। डिफ़ॉल्ट रूप से अनुमत तत्वों और विशेषताओं के सटीक सेट के लिए, [Default TAGs & ATTRIBUTEs allow-list & blocklist](https://github.com/cure53/DOMPurify/wiki/Default-TAGs-ATTRIBUTEs-allow-list-&-blocklist) विकी पृष्ठ देखें।

## पुराने ब्राउज़रों जैसे Internet Explorer के बारे में क्या?

DOMPurify कुछ भी नहीं करता है। यह केवल वही स्ट्रिंग लौटाता है जो आपने उसे दी थी। DOMPurify `isSupported` नामक एक प्रॉपर्टी उजागर करता है, जो आपको बताती है कि क्या यह अपना काम कर पाएगा, ताकि आप अपनी खुद की बैकअप योजना बना सकें।

## DOMPurify और Trusted Types के बारे में क्या?

संस्करण 1.0.9 में, [Trusted Types API](https://github.com/w3c/webappsec-trusted-types) ([MDN](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API)) के लिए समर्थन DOMPurify में जोड़ा गया था।
संस्करण 2.0.0 में, इस संबंध में DOMPurify के व्यवहार को नियंत्रित करने के लिए एक कॉन्फ़िग फ़्लैग जोड़ा गया था।

जब `DOMPurify.sanitize` का उपयोग ऐसे वातावरण में किया जाता है जहाँ Trusted Types API उपलब्ध है और `RETURN_TRUSTED_TYPE` को `true` पर सेट किया गया है, तो यह स्ट्रिंग के बजाय `TrustedHTML` मान लौटाने का प्रयास करता है (`RETURN_DOM` और `RETURN_DOM_FRAGMENT` कॉन्फ़िग विकल्पों का व्यवहार नहीं बदलता है)।

ध्यान दें कि DOMPurify का उपयोग करके `trustedTypes` में एक पॉलिसी बनाने के लिए, `RETURN_TRUSTED_TYPE: false` आवश्यक है, क्योंकि `createHTML` एक सामान्य स्ट्रिंग की अपेक्षा करता है, न कि `TrustedHTML` की। नीचे दिया गया उदाहरण यह दर्शाता है।```js
window.trustedTypes.createPolicy('default', {
  createHTML: (to_escape) =>
    DOMPurify.sanitize(to_escape, { RETURN_TRUSTED_TYPE: false }),
});

जब कोई TRUSTED_TYPES_POLICY प्रदान नहीं किया जाता है, तो DOMPurify अपनी स्वयं की आंतरिक Trusted Types नीति बनाने का प्रयास करता है, जिसका नाम dompurify होता है। यदि आपका पृष्ठ पहले से ही अपनी स्वयं की नीति को एक सख्त CSP के साथ परिभाषित करता है (उदाहरण के लिए trusted-types my-organization) जो dompurify नाम की नीति की अनुमति नहीं देता है, तो यह प्रयास ब्राउज़र द्वारा अवरुद्ध कर दिया जाता है और एक TrustedTypes policy dompurify could not be created. चेतावनी के साथ-साथ एक CSP उल्लंघन लॉग होता है।

DOMPurify को अपनी आंतरिक फ़ॉलबैक नीति बनाने से रोकने के लिए, TRUSTED_TYPES_POLICY: null पास करें। यह सही विकल्प है जब आप अपनी स्वयं की नीति के createHTML के अंदर से DOMPurify.sanitize को कॉल करते हैं, और इसका मतलब है कि आपको अपने CSP की trusted-types अनुमति सूची में dompurify जोड़ने की आवश्यकता नहीं है।```js window.trustedTypes.createPolicy('my-organization', { createHTML: (input) => DOMPurify.sanitize(input, { TRUSTED_TYPES_POLICY: null }), });

अपनी स्वयं की रैपिंग नीति को DOMPurify के `TRUSTED_TYPES_POLICY` के रूप में वापस न दें (उदाहरण के लिए `DOMPurify.setConfig({ TRUSTED_TYPES_POLICY: myPolicy })` के माध्यम से) जब उस नीति का `createHTML` पहले से ही `DOMPurify.sanitize` को कॉल करता है। यह परिभाषा के अनुसार चक्रीय है - सैनिटाइज़ करना नीति को कॉल करेगा, जो DOMPurify को फिर से कॉल करके सैनिटाइज़ करता है - और DOMPurify अनंत पुनरावृत्ति को रोकने के लिए एक वर्णनात्मक `TypeError` फेंक देगा। आपकी अपनी नीति को DOMPurify को कॉल करना चाहिए; DOMPurify को आपकी नीति को कॉल करने के लिए कॉन्फ़िगर नहीं किया जाना चाहिए।

यदि आप चाहते हैं कि यह `default`-नीति पैटर्न पूरे पेज पर स्वचालित रूप से लागू हो - ताकि हर HTML सिंक सैनिटाइज़ हो, जिसमें लीगेसी कोड, तृतीय-पक्ष विजेट्स, और हजारों `innerHTML` असाइनमेंट शामिल हैं जिन्हें आप आसानी से ढूंढ या फिर से नहीं लिख सकते - तो [DOMFortify](https://github.com/cure53/DOMFortify) पर एक नज़र डालें। यह DOMPurify द्वारा समर्थित ठीक ऐसी ही Trusted Types `default` नीति स्थापित करता है और स्क्रिप्ट सिंक (`eval`, `script.src`, ...) को सीधे अस्वीकार कर देता है। यह जानबूझकर एक अलग प्रोजेक्ट है: DOMPurify एक केंद्रित सैनिटाइज़र बना रहता है, और DOMFortify दस्तावेज़-व्यापी प्रवर्तन परत को संभालता है जो जानबूझकर DOMPurify के दायरे से बाहर है।

## क्या मैं DOMPurify को कॉन्फ़िगर कर सकता हूँ?

हाँ। शामिल डिफ़ॉल्ट कॉन्फ़िगरेशन मान पहले से ही काफी अच्छे हैं - लेकिन आप निश्चित रूप से उन्हें ओवरराइड कर सकते हैं। [`/demos`](https://github.com/cure53/DOMPurify/tree/main/demos) फ़ोल्डर देखें जहाँ आप [DOMPurify को कस्टमाइज़](https://github.com/cure53/DOMPurify/tree/main/demos#what-is-this) करने के कई उदाहरण देख सकते हैं।

इससे पहले कि आप अनुमति-सूची (`ADD_TAGS`, `ADD_ATTR`, `CUSTOM_ELEMENT_HANDLING`, …) को चौड़ा करें या किसी डिफ़ॉल्ट को ढीला करें, [उन टैग्स और विशेषताओं](https://github.com/cure53/DOMPurify/wiki/Security-Goals-&-Threat-Model#dangerous-tags-and-attributes-think-twice-before-allow-listing) को देखना उचित है जिनके बारे में दो बार सोचना चाहिए - कुछ गैर-स्पष्ट तरीकों से खतरनाक हैं।

### सामान्य सेटिंग्स```js
// strip {{ ... }}, ${ ... } and <% ... %> to make output safe for template systems
// be careful please, this mode is not recommended for production usage.
// allowing template parsing in user-controlled HTML is not advised at all.
// only use this mode if there is really no alternative.
const clean = DOMPurify.sanitize(dirty, { SAFE_FOR_TEMPLATES: true });

// change how e.g. comments containing risky HTML characters are treated.
// be very careful, this setting should only be set to `false` if you really only handle
// HTML and nothing else, no SVG, MathML or the like.
// Otherwise, changing from `true` to `false` will lead to XSS in this or some other way.
const clean = DOMPurify.sanitize(dirty, { SAFE_FOR_XML: false });

हमारी अनुमति-सूचियों और ब्लॉक-सूचियों को नियंत्रित करें```js

// allow only elements, very strict const clean = DOMPurify.sanitize(dirty, { ALLOWED_TAGS: ['b'] });

// allow only and with style attributes const clean = DOMPurify.sanitize(dirty, { ALLOWED_TAGS: ['b', 'q'], ALLOWED_ATTR: ['style'], });

// allow all safe HTML elements but neither SVG nor MathML // note that the USE_PROFILES setting will override the ALLOWED_TAGS setting // so don't use them together const clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { html: true } });

// allow all safe SVG elements and SVG Filters, no HTML or MathML const clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { svg: true, svgFilters: true }, });

// allow all safe MathML elements and SVG, but no SVG Filters const clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { mathMl: true, svg: true }, });

// change the default namespace from HTML to something different const clean = DOMPurify.sanitize(dirty, { NAMESPACE: 'http://www.w3.org/2000/svg', });

// leave all safe HTML as it is and add elements to block-list const clean = DOMPurify.sanitize(dirty, { FORBID_TAGS: ['style'] });

// leave all safe HTML as it is and add style attributes to block-list const clean = DOMPurify.sanitize(dirty, { FORBID_ATTR: ['style'] });

// extend the existing array of allowed tags and add to allow-list const clean = DOMPurify.sanitize(dirty, { ADD_TAGS: ['my-tag'] });

// extend the existing array of allowed attributes and add my-attr to allow-list const clean = DOMPurify.sanitize(dirty, { ADD_ATTR: ['my-attr'] });

// use functions to control which additional tags and attributes are allowed const allowlist = { one: ['attribute-one'], two: ['attribute-two'], }; const clean = DOMPurify.sanitize( '', { ADD_TAGS: (tagName) => { return Object.keys(allowlist).includes(tagName); }, ADD_ATTR: (attributeName, tagName) => { return allowlist[tagName]?.includes(attributeName) || false; }, } ); //

// prohibit ARIA attributes, leave other safe HTML as is (default is true) const clean = DOMPurify.sanitize(dirty, { ALLOW_ARIA_ATTR: false });

// prohibit HTML5 data attributes, leave other safe HTML as is (default is true) const clean = DOMPurify.sanitize(dirty, { ALLOW_DATA_ATTR: false });

### कस्टम एलिमेंट्स से संबंधित नियंत्रण व्यवहार```js
// DOMPurify allows to define rules for Custom Elements. When using the CUSTOM_ELEMENT_HANDLING
// literal, it is possible to define exactly what elements you wish to allow (by default, none are allowed).
//
// The same goes for their attributes. By default, the built-in or configured allow.list is used.
//
// You can use a RegExp literal to specify what is allowed or a predicate, examples for both can be seen below.
// When using a predicate function for attributeNameCheck, it can optionally receive the tagName as a second parameter
// for more granular control over which attributes are allowed for specific elements.
// The default values are very restrictive to prevent accidental XSS bypasses. Handle with great care!

const clean = DOMPurify.sanitize(
  '<foo-bar baz="foobar" forbidden="true"></foo-bar><div is="foo-baz"></div>',
  {
    CUSTOM_ELEMENT_HANDLING: {
      tagNameCheck: null, // no custom elements are allowed
      attributeNameCheck: null, // default / standard attribute allow-list is used
      allowCustomizedBuiltInElements: false, // no customized built-ins allowed
    },
  }
); // <div is=""></div>

const clean = DOMPurify.sanitize(
  '<foo-bar baz="foobar" forbidden="true"></foo-bar><div is="foo-baz"></div>',
  {
    CUSTOM_ELEMENT_HANDLING: {
      tagNameCheck: /^foo-/, // allow all tags starting with "foo-"
      attributeNameCheck: /baz/, // allow all attributes containing "baz"
      allowCustomizedBuiltInElements: true, // customized built-ins are allowed
    },
  }
); // <foo-bar baz="foobar"></foo-bar><div is="foo-baz"></div>

const clean = DOMPurify.sanitize(
  '<foo-bar baz="foobar" forbidden="true"></foo-bar><div is="foo-baz"></div>',
  {
    CUSTOM_ELEMENT_HANDLING: {
      tagNameCheck: (tagName) => tagName.match(/^foo-/), // allow all tags starting with "foo-"
      attributeNameCheck: (attr) => attr.match(/baz/), // allow all containing "baz"
      allowCustomizedBuiltInElements: true, // allow customized built-ins
    },
  }
); // <foo-bar baz="foobar"></foo-bar><div is="foo-baz"></div>

// Example with attributeNameCheck receiving tagName as a second parameter
const clean = DOMPurify.sanitize(
  '<element-one attribute-one="1" attribute-two="2"></element-one><element-two attribute-one="1" attribute-two="2"></element-two>',
  {
    CUSTOM_ELEMENT_HANDLING: {
      tagNameCheck: (tagName) => tagName.match(/^element-(one|two)$/),
      attributeNameCheck: (attr, tagName) => {
        if (tagName === 'element-one') {
          return ['attribute-one'].includes(attr);
        } else if (tagName === 'element-two') {
          return ['attribute-two'].includes(attr);
        } else {
          return false;
        }
      },
      allowCustomizedBuiltInElements: false,
    },
  }
); // <element-one attribute-one="1"></element-one><element-two attribute-two="2"></element-two>

URI मानों से संबंधित नियंत्रण व्यवहार```js

// extend the existing array of elements that can use Data URIs const clean = DOMPurify.sanitize(dirty, { ADD_DATA_URI_TAGS: ['a', 'area'] });

// extend the existing array of elements that are safe for URI-like values (be careful, XSS risk) const clean = DOMPurify.sanitize(dirty, { ADD_URI_SAFE_ATTR: ['my-attr'] });

### नियंत्रण अनुमत विशेषता मान```js
// allow external protocol handlers in URL attributes (default is false, be careful, XSS risk)
// by default only http, https, ftp, ftps, tel, mailto, callto, sms, cid, xmpp and matrix are allowed.
const clean = DOMPurify.sanitize(dirty, { ALLOW_UNKNOWN_PROTOCOLS: true });

// allow specific protocol handlers in URL attributes via regex (default is false, be careful, XSS risk)
// by default only (protocol-)relative URLs, http, https, ftp, ftps, tel, mailto, callto, sms, cid, xmpp and matrix are allowed.
// Default RegExp: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
const clean = DOMPurify.sanitize(dirty, {
  ALLOWED_URI_REGEXP:
    /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i,
});

रिटर्न-टाइप को प्रभावित करें```js

// return a DOM HTMLBodyElement instead of an HTML string (default is false) const clean = DOMPurify.sanitize(dirty, { RETURN_DOM: true });

// return a DOM DocumentFragment instead of an HTML string (default is false) const clean = DOMPurify.sanitize(dirty, { RETURN_DOM_FRAGMENT: true });

// use the RETURN_TRUSTED_TYPE flag to turn on Trusted Types support if available const clean = DOMPurify.sanitize(dirty, { RETURN_TRUSTED_TYPE: true }); // will return a TrustedHTML object instead of a string if possible

// use a provided Trusted Types policy const clean = DOMPurify.sanitize(dirty, { // supplied policy must define createHTML and createScriptURL TRUSTED_TYPES_POLICY: trustedTypes.createPolicy('dompurify', { createHTML(s) { return s; }, createScriptURL(s) { return s; }, }), });

// opt out of DOMPurify's internal dompurify Trusted Types policy entirely // (useful when your CSP trusted-types allowlist does not include dompurify) const clean = DOMPurify.sanitize(dirty, { TRUSTED_TYPES_POLICY: null });

### प्रभावित करें कि हम कैसे सैनिटाइज़ करते हैं```js
// return entire document including <html> tags (default is false)
const clean = DOMPurify.sanitize(dirty, { WHOLE_DOCUMENT: true });

// disable DOM Clobbering protection on output (default is true, handle with care, minor XSS risks here)
const clean = DOMPurify.sanitize(dirty, { SANITIZE_DOM: false });

// enforce strict DOM Clobbering protection via namespace isolation (default is false)
// when enabled, isolates the namespace of named properties (i.e., `id` and `name` attributes)
// from JS variables by prefixing them with the string `user-content-`
const clean = DOMPurify.sanitize(dirty, { SANITIZE_NAMED_PROPS: true });

// keep an element's content when the element is removed (default is true)
const 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)
const clean = DOMPurify.sanitize(dirty, { FORCE_BODY: true });

// remove all <a> elements under <p> elements that are removed
const clean = DOMPurify.sanitize(dirty, {
  FORBID_CONTENTS: ['a'],
  FORBID_TAGS: ['p'],
});

// extend the default FORBID_CONTENTS list to also remove <a> elements under <p> elements
const clean = DOMPurify.sanitize(dirty, {
  ADD_FORBID_CONTENTS: ['a'],
  FORBID_TAGS: ['p'],
});

// change the parser type so sanitized data is treated as XML and not as HTML, which is the default
const clean = DOMPurify.sanitize(dirty, {
  PARSER_MEDIA_TYPE: 'application/xhtml+xml',
});

जहाँ हम सैनिटाइज़ करते हैं, वहाँ प्रभाव```js

// use the IN_PLACE mode to sanitize a node "in place", which is much faster depending on how you use DOMPurify const dirty = document.createElement('a'); dirty.setAttribute('href', 'javascript:alert(1)');

const clean = DOMPurify.sanitize(dirty, { IN_PLACE: true }); // see https://github.com/cure53/DOMPurify/issues/288 for more info

यहाँ [और भी उदाहरण](https://github.com/cure53/DOMPurify/tree/main/demos#what-is-this) उपलब्ध हैं, जो दिखाते हैं कि आप DOMPurify को अपनी आवश्यकताओं के अनुसार कैसे चला, अनुकूलित और कॉन्फ़िगर कर सकते हैं।

## स्थायी कॉन्फ़िगरेशन

हर बार `DOMPurify.sanitize` को एक ही कॉन्फ़िगरेशन पास करने के बजाय, आप `DOMPurify.setConfig` विधि का उपयोग कर सकते हैं। आपका कॉन्फ़िगरेशन तब तक बना रहेगा जब तक आप `DOMPurify.setConfig` को अगली बार कॉल नहीं करते, या जब तक आप इसे रीसेट करने के लिए `DOMPurify.clearConfig` को आमंत्रित नहीं करते। याद रखें कि केवल एक सक्रिय कॉन्फ़िगरेशन होता है, जिसका अर्थ है कि एक बार सेट हो जाने पर, `DOMPurify.sanitize` को पास किए गए सभी अतिरिक्त कॉन्फ़िगरेशन पैरामीटर अनदेखा कर दिए जाते हैं।

## हुक

DOMPurify आपको `DOMPurify.addHook` विधि के साथ निम्नलिखित हुकों में से एक या अधिक फ़ंक्शन जोड़कर इसकी कार्यक्षमता बढ़ाने की अनुमति देता है:

- `beforeSanitizeElements`
- `uponSanitizeElement` (कोई 's' नहीं - प्रत्येक तत्व के लिए कॉल किया जाता है)
- `afterSanitizeElements`
- `beforeSanitizeAttributes`
- `uponSanitizeAttribute`
- `afterSanitizeAttributes`
- `beforeSanitizeShadowDOM`
- `uponSanitizeShadowNode`
- `afterSanitizeShadowDOM`

यह वर्तमान में संसाधित DOM नोड, आवश्यकता पड़ने पर सत्यापित नोड और विशेषता डेटा के साथ एक लिटरल, और DOMPurify कॉन्फ़िगरेशन को कॉलबैक को पास करता है। यह देखने के लिए कि API का उपयोग कितनी अच्छी तरह किया जा सकता है, [MentalJS हुक डेमो](https://github.com/cure53/DOMPurify/blob/main/demos/hooks-mentaljs-demo.html) देखें।

_उदाहरण_:```js
DOMPurify.addHook(
  'uponSanitizeAttribute',
  function (currentNode, hookEvent, config) {
    // Do something with the current node
    // You can also mutate hookEvent for current node (i.e. set hookEvent.forceKeepAttr = true)
    // For other than 'uponSanitizeAttribute' hook types hookEvent equals to null
  }
);

हुक से sanitize() को कॉल करने पर एक नोट

DOMPurify.sanitize() पुनः-प्रवेशनीय (re-entrant) नहीं है। कृपया इसे किसी हुक के अंदर से, या किसी कॉन्फ़िगरेशन कॉलबैक जैसे CUSTOM_ELEMENT_HANDLING.tagNameCheck या attributeNameCheck से कॉल न करें। वे कॉलबैक एक सक्रिय सैनिटाइज़र पास के बीच में चलते हैं।

एक नेस्टेड sanitize() कॉल उसे दी गई कॉन्फ़िगरेशन को फिर से पढ़ता है और ऐसा करते हुए, उस कॉन्फ़िगरेशन को बदल देता है जिसे बाहरी पास अभी भी उपयोग कर रहा है। बाहरी दस्तावेज़ का शेष भाग तब आपकी कॉन्फ़िगरेशन के बजाय नेस्टेड कॉल की कॉन्फ़िगरेशन के विरुद्ध सैनिटाइज़ किया जाता है। चूँकि नेस्टेड कॉल आमतौर पर डिफ़ॉल्ट कॉन्फ़िगरेशन के साथ चलती है, एक सख्त ALLOWED_TAGS अनुमति-सूची दस्तावेज़ के बीच में चुपचाप डिफ़ॉल्ट तक विस्तृत हो सकती है, बिना किसी त्रुटि या चेतावनी के।

यदि आपको नेस्टेड मार्कअप को सैनिटाइज़ करने की आवश्यकता है, उदाहरण के लिए किसी विशेषता मान के अंदर ले जाया गया HTML फ़्रैगमेंट, तो आपके पास दो सुरक्षित विकल्प हैं। या तो अपनी कॉन्फ़िगरेशन को प्रति कॉल पास करने के बजाय DOMPurify.setConfig के साथ एक बार सेट करें, क्योंकि एक स्थायी कॉन्फ़िगरेशन नेस्टेड कॉल द्वारा साझा की जाती है और पूरे पास के दौरान प्रभावी रहती है; या हुक के दौरान फ़्रैगमेंट एकत्र करें और बाहरी कॉल के लौटने के बाद उन्हें एक अलग sanitize() कॉल से सैनिटाइज़ करें।

हटाई गई कॉन्फ़िगरेशन

विकल्पसे (Since)नोट
SAFE_FOR_JQUERY2.1.0कोई प्रतिस्थापन आवश्यक नहीं।

सतत एकीकरण (Continuous Integration)

हम वर्तमान में Playwright के साथ GitHub Actions का उपयोग कर रहे हैं। यह हमें हर कमिट पर पुष्टि करने देता है कि सब कुछ प्रासंगिक आधुनिक ब्राउज़रों में काम करता है, और एक अलग अनुसूचित और मर्ज-पर वर्कफ़्लो पुराने इंजन स्नैपशॉट पर सूट को फिर से चलाता है ताकि पुराने ब्राउज़रों पर टूटना भी पकड़ा जा सके। बिल्ड लॉग यहाँ देखें: https://github.com/cure53/DOMPurify/actions

आप npm run test चलाकर स्थानीय परीक्षण भी चला सकते हैं।

सभी प्रासंगिक कमिट अतिरिक्त सुरक्षा के लिए कुंजी 0x24BB6BF4 के साथ हस्ताक्षरित होंगे (8 अप्रैल 2016 से)।

विकास और योगदान

स्थापना (npm i)

हम आधिकारिक तौर पर npm का समर्थन करते हैं। GitHub Actions वर्कफ़्लो npm का उपयोग करके निर्भरताएँ स्थापित करने के लिए कॉन्फ़िगर किया गया है। npm के पुराने संस्करण का उपयोग करते समय, हम स्थापित निर्भरताओं के संस्करणों को पूरी तरह से सुनिश्चित नहीं कर सकते, जिससे अप्रत्याशित समस्याएँ हो सकती हैं।

स्क्रिप्ट

हम अपने प्री-कमिट वर्कफ़्लो के भाग के रूप में कोड स्थिरता सुनिश्चित करने में मदद के लिए xo के माध्यम से ESLint का उपयोग करते हैं। इसके अलावा, हम स्रोत और Markdown स्वरूपण के लिए Prettier का उपयोग करते हैं, और /dist संपत्तियाँ rollup के माध्यम से बनाई जाती हैं।

ये हमारी npm स्क्रिप्ट हैं:

  • npm run dev स्रोतों में परिवर्तन देखते हुए असंपीड़ित UMD बंडल बनाने के लिए
  • npm run test स्रोतों को लिंट करने, jsdom के माध्यम से परीक्षण चलाने, और Playwright के माध्यम से Chromium में ब्राउज़र परीक्षण चलाने के लिए
    • npm run test:jsdom केवल jsdom के माध्यम से परीक्षण चलाने के लिए
    • npm run test:happydom happy-dom के माध्यम से सूट चलाने के लिए (एक असमर्थित वातावरण; मजबूती जाँच के रूप में रखा गया, संगतता वादा नहीं)
    • npm run test:browser केवल Playwright के माध्यम से परीक्षण चलाने के लिए
    • npm run test:browser:legacy पुराने ब्राउज़र इंजनों पर सूट चलाने के लिए (PW_MODULE को एक पिन किए गए पुराने Playwright इंस्टॉलेशन पर इंगित करें; .github/workflows/legacy-browsers.yml देखें)
    • npm run test:ci jsdom और Playwright के लिए CI परीक्षण प्रवाह चलाने के लिए
    • npm run test:fuzz sanitize() और CONFIG को कवर करने वाला एक छोटा फ़ज़र चलाने के लिए
  • npm run bench निर्मित dist/purify.cjs पर jsdom माइक्रो-बेंचमार्क चलाने के लिए (पहले बिल्ड करें; --json और --compare a.json b.json शाखाओं के बीच A/B रन का समर्थन करते हैं - परिणाम दिशात्मक हैं, वास्तविक ब्राउज़रों में उपयोगकर्ता-सामना वाले दावों की पुष्टि करें)
  • npm run coverage एक इंस्ट्रूमेंटेड बंडल बनाने, jsdom सूट चलाने, और coverage/index.html पर एक स्थानीय HTML लाइन/शाखा कवरेज रिपोर्ट लिखने के लिए (केवल jsdom दायरा, CI में नहीं चलाया जाता)
    • npm run build:cov केवल इंस्ट्रूमेंटेड कवरेज बंडल बनाने के लिए
  • npm run lint xo के माध्यम से ESLint का उपयोग करके स्रोतों को लिंट करने के लिए
  • npm run format Prettier के साथ JavaScript/TypeScript और Markdown स्रोतों को प्रारूपित करने के लिए
    • npm run format:js केवल JavaScript/TypeScript स्रोतों को प्रारूपित करने के लिए
    • npm run format:md केवल Markdown फ़ाइलों को प्रारूपित करने के लिए
  • npm run build प्रकार घोषणाएँ और वितरण बंडल बनाने के लिए, फिर उत्पन्न प्रकारों को ठीक करने और साफ करने के लिए
    • npm run build:types केवल TypeScript घोषणा फ़ाइलें उत्सर्जित करने के लिए
    • npm run build:rollup सभी Rollup बंडल बनाने के लिए
    • npm run build:umd केवल एक असंपीड़ित UMD बंडल बनाने के लिए
    • npm run build:umd:min केवल एक संपीड़ित UMD बंडल बनाने के लिए
    • npm run build:es केवल ES मॉड्यूल बंडल बनाने के लिए
    • npm run build:cjs केवल CommonJS बंडल बनाने के लिए
    • npm run build:fix-types उत्पन्न प्रकार फ़ाइलों को पोस्ट-प्रोसेस करने के लिए
    • npm run build:cleanup अस्थायी उत्पन्न प्रकार आउटपुट को साफ करने के लिए
  • npm run verify-typescript TypeScript सत्यापन स्क्रिप्ट चलाने के लिए
  • npm run commit-amend-build बिल्ड आउटपुट को संशोधित करने के लिए अनुरक्षक सहायक स्क्रिप्ट चलाने के लिए

नोट: सभी रन स्क्रिप्ट npm run <script> के माध्यम से ट्रिगर होती हैं।

अधिक npm स्क्रिप्ट हैं लेकिन वे मुख्य रूप से CI के साथ एकीकृत करने के लिए हैं या "निजी" होने के लिए हैं, उदाहरण के लिए हर कमिट के साथ वितरण बिल्ड फ़ाइलों को संशोधित करना।

सुरक्षा मेलिंग सूची

हम एक मेलिंग सूची बनाए रखते हैं जो जब भी DOMPurify का सुरक्षा-महत्वपूर्ण रिलीज़ प्रकाशित होता है तो सूचित करती है। इसका मतलब है, यदि किसी को बायपास मिला और हमने इसे एक रिलीज़ के साथ ठीक किया (जो हमेशा होता है जब बायपास मिलता है) तो एक मेल उस सूची में जाएगा। यह आमतौर पर बायपास के बारे में जानने के कुछ मिनटों या कुछ घंटों के भीतर होता है। सूची यहाँ सदस्यता ली जा सकती है:

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

फ़ीचर रिलीज़ इस सूची में घोषित नहीं किए जाएँगे।

किसने योगदान दिया?

कई लोगों ने DOMPurify को वह बनाने में मदद की है जो आज है, और वे स्वीकृति के पात्र हैं!

offset, Bankde, lukewarlow, DEMON1A, fg0x0, kodareef5, DavidOliver, 1Jesper1, bencalif, trace37labs, eddieran, christos-eth, researchatfluidattacks, frevadiscor, Rotzbua, binhpv, MariusRumpf, prasadrajandran, Cybozu 💛💸, hata6502 💸, openclaw 💸, intra-mart-dh 💸, nelstrom ❤️, hash_kitten ❤️, kevin_mizu ❤️, icesfont ❤️, reduckted ❤️, 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, davecardwell, Develop-KIM, asamuzaK, fishjojo1 ❤️, Rikuxx0, donmccurdy, hhk-png, elrion018, michalnieruchalski-tiugo, reey, KanhaKanhaiya, odaysec, Akokonunes, alirezarouhbakhsh, Jaybhade और विशेष रूप से @securitymb ❤️ और @masatokinugawa ❤️

और पढ़ें

श्रेणियाँ

रक्षात्मक उपकरणस्थैतिक विश्लेषणकोड विश्लेषणवेब सुरक्षालर्निंग और शिक्षाAPI सुरक्षा