DOM XSS

Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

• Check the subscription plans!

• Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.

• Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.

Vulnerabilità DOM

Le vulnerabilità DOM si verificano quando i dati provenienti da fonti controllate dagli attaccanti (come location.search, document.referrer o document.cookie) vengono trasferiti in modo non sicuro a sink. I sink sono funzioni o oggetti (ad es., eval(), document.body.innerHTML) che possono eseguire o rendere contenuti dannosi se ricevono dati malevoli.

• Fonti sono input che possono essere manipolati dagli attaccanti, inclusi URL, cookie e messaggi web.

• Sink sono endpoint potenzialmente pericolosi dove dati malevoli possono portare a effetti negativi, come l'esecuzione di script.

Il rischio sorge quando i dati fluiscono da una fonte a un sink senza una corretta validazione o sanificazione, consentendo attacchi come XSS.

Puoi trovare un elenco più aggiornato di fonti e sink in https://github.com/wisec/domxsswiki/wiki

Fonti comuni:

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

Sinks comuni:

Open Redirect	Javascript Injection	Manipolazione dei dati DOM	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	``Manipolazione del percorso del file locale	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()
``Manipolazione della richiesta Ajax	FileReader.readAsFile()	someDOMElement.backgroundImage	constructor()
XMLHttpRequest.setRequestHeader()	FileReader.root.getFile()	someDOMElement.cssText	init()
XMLHttpRequest.open()	FileReader.root.getFile()	someDOMElement.codebase	index()
XMLHttpRequest.send()	Manipolazione dei link	someDOMElement.innerHTML	jQuery.parseHTML()
jQuery.globalEval()	someDOMElement.href	someDOMElement.outerHTML	$.parseHTML()
$.globalEval()	someDOMElement.src	someDOMElement.insertAdjacentHTML	Iniezione JSON lato client
``Manipolazione dello storage HTML5	someDOMElement.action	someDOMElement.onevent	JSON.parse()
sessionStorage.setItem()	Iniezione XPath	document.write()	jQuery.parseJSON()
localStorage.setItem()	document.evaluate()	document.writeln()	$.parseJSON()
**[**`Negazione del servizio`**](dom-xss.md#denial-of-service)**	someDOMElement.evaluate()	document.title	``Manipolazione dei cookie
requestFileSystem()	``Manipolazione del dominio del documento	document.implementation.createHTMLDocument()	document.cookie
RegExp()	document.domain	history.pushState()	Avvelenamento dell'URL WebSocket
Iniezione SQL lato client	Manipolazione dei messaggi web	history.replaceState()	WebSocket
executeSql()	postMessage()	``	``

Il sink innerHTML non accetta elementi script su nessun browser moderno, né gli eventi svg onload verranno attivati. Questo significa che dovrai utilizzare elementi alternativi come img o iframe.

Questo tipo di XSS è probabilmente il più difficile da trovare, poiché devi guardare all'interno del codice JS, vedere se sta utilizzando qualche oggetto il cui valore controlli, e in tal caso, vedere se c'è qualche modo per abusarne per eseguire JS arbitrario.

Strumenti per trovarli

• https://github.com/mozilla/eslint-plugin-no-unsanitized

• Estensione del browser per controllare ogni dato che raggiunge un potenziale sink: https://github.com/kevin-mizu/domloggerpp

Esempi

Open Redirect

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

Le vulnerabilità di open redirect nel DOM si verificano quando uno script scrive dati, che un attaccante può controllare, in un sink capace di avviare la navigazione tra domini.

È fondamentale comprendere che l'esecuzione di codice arbitrario, come javascript:alert(1), è possibile se hai il controllo sull'inizio dell'URL in cui si verifica il reindirizzamento.

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()

Manipolazione dei cookie

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

Le vulnerabilità di manipolazione dei cookie basate su DOM si verificano quando uno script incorpora dati, che possono essere controllati da un attaccante, nel valore di un cookie. Questa vulnerabilità può portare a comportamenti imprevisti della pagina web se il cookie viene utilizzato all'interno del sito. Inoltre, può essere sfruttata per eseguire un attacco di session fixation se il cookie è coinvolto nel tracciamento delle sessioni utente. Il sink principale associato a questa vulnerabilità è:

Sinks:

document.cookie

Iniezione di JavaScript

From: https://portswigger.net/web-security/dom-based/javascript-injection

Le vulnerabilità di iniezione di JavaScript basate sul DOM si creano quando uno script esegue dati, che possono essere controllati da un attaccante, come codice JavaScript.

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

Le vulnerabilità di manipolazione del dominio del documento si verificano quando uno script imposta la proprietà document.domain utilizzando dati che un attaccante può controllare.

La proprietà document.domain gioca un ruolo chiave nell'applicazione della politica di stessa origine da parte dei browser. Quando due pagine di origini diverse impostano il loro document.domain sullo stesso valore, possono interagire senza restrizioni. Sebbene i browser impongano certi limiti sui valori assegnabili a document.domain, impedendo l'assegnazione di valori completamente non correlati all'origine della pagina effettiva, esistono eccezioni. Tipicamente, i browser consentono l'uso di domini o domini genitori.

Sinks:

document.domain

WebSocket-URL poisoning

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

WebSocket-URL poisoning si verifica quando uno script utilizza dati controllabili come URL di destinazione per una connessione WebSocket.

Sinks:

Il costruttore WebSocket può portare a vulnerabilità di WebSocket-URL poisoning.

Link manipulation

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

Le vulnerabilità di manipolazione dei link basate su DOM sorgono quando uno script scrive dati controllabili dall'attaccante a un obiettivo di navigazione all'interno della pagina corrente, come un link cliccabile o l'URL di invio di un modulo.

Sinks:

someDOMElement.href
someDOMElement.src
someDOMElement.action

Manipolazione delle richieste Ajax

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

Le vulnerabilità di manipolazione delle richieste Ajax si verificano quando uno script scrive dati controllabili dall'attaccante in una richiesta Ajax emessa utilizzando un oggetto XmlHttpRequest.

Sinks:

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

Manipolazione del percorso del file locale

From: https://portswigger.net/web-security/dom-based/local-file-path-manipulation

Le vulnerabilità di manipolazione del percorso del file locale si verificano quando uno script passa dati controllabili dall'attaccante a un'API di gestione dei file come parametro filename. Questa vulnerabilità può essere sfruttata da un attaccante per costruire un URL che, se visitato da un altro utente, potrebbe portare al browser dell'utente che apre o scrive un file locale arbitrario.

Sinks:

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

Iniezione SQL lato client

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

Le vulnerabilità di iniezione SQL lato client si verificano quando uno script incorpora dati controllabili dall'attaccante in una query SQL lato client in modo non sicuro.

Sinks:

executeSql()

Manipolazione dello storage HTML5

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

Le vulnerabilità di manipolazione dello storage HTML5 sorgono quando uno script memorizza dati controllabili dall'attaccante nello storage HTML5 del browser web (localStorage o sessionStorage). Sebbene questa azione non sia intrinsecamente una vulnerabilità di sicurezza, diventa problematica se l'applicazione successivamente legge i dati memorizzati e li elabora in modo non sicuro. Questo potrebbe consentire a un attaccante di sfruttare il meccanismo di storage per condurre altri attacchi basati su DOM, come il cross-site scripting e l'iniezione di JavaScript.

Sinks:

sessionStorage.setItem()
localStorage.setItem()

XPath injection

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

Le vulnerabilità di iniezione XPath basate su DOM si verificano quando uno script incorpora dati controllabili dall'attaccante in una query XPath.

Sinks:

document.evaluate()
someDOMElement.evaluate()

Iniezione JSON lato client

Da: https://portswigger.net/web-security/dom-based/client-side-json-injection

Le vulnerabilità di iniezione JSON basate su DOM si verificano quando uno script incorpora dati controllabili dall'attaccante in una stringa che viene analizzata come una struttura dati JSON e poi elaborata dall'applicazione.

Sinks:

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

Web-message manipulation

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

Le vulnerabilità dei messaggi web sorgono quando uno script invia dati controllabili dall'attaccante come messaggio web a un altro documento all'interno del browser. Un esempio di manipolazione vulnerabile dei messaggi web può essere trovato presso l'Accademia di Sicurezza Web di PortSwigger.

Sinks:

Il metodo postMessage() per inviare messaggi web può portare a vulnerabilità se l'ascoltatore di eventi per ricevere messaggi gestisce i dati in arrivo in modo non sicuro.

DOM-data manipulation

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

Le vulnerabilità di manipolazione dei dati DOM sorgono quando uno script scrive dati controllabili dall'attaccante in un campo all'interno del DOM che viene utilizzato nell'interfaccia utente visibile o nella logica lato client. Questa vulnerabilità può essere sfruttata da un attaccante per costruire un URL che, se visitato da un altro utente, può alterare l'aspetto o il comportamento dell'interfaccia utente lato client.

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

Le vulnerabilità di denial-of-service basate su DOM si verificano quando uno script passa dati controllabili dall'attaccante in modo non sicuro a un'API problematica della piattaforma. Questo include API che, quando invocate, possono portare il computer dell'utente a consumare eccessive quantità di CPU o spazio su disco. Tali vulnerabilità possono avere effetti collaterali significativi, come la restrizione della funzionalità del sito web da parte del browser rifiutando i tentativi di memorizzare dati in localStorage o terminando script occupati.

Sinks:

requestFileSystem()
RegExp()

Dom Clobbering

Dom Clobbering

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE) Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)

Supporta HackTricks

• Controlla i piani di abbonamento!

• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.

• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos di github.