DOM XSS

Reading time: 10 minutes

tip

Impara e pratica l'Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'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.

Vulnerabilità DOM

Le vulnerabilità DOM si verificano quando i dati provenienti da fonti controllate dall'attaccante (come location.search, document.referrer o document.cookie) vengono trasferiti in modo non sicuro a sinks. I sinks 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.
Sinks 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.

note

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

Fonti comuni:

javascript

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()`
[`Denial of Service`](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:

javascript

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

Da: 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:

javascript

document.cookie

Iniezione di JavaScript

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

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

Sinks:

javascript

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

Manipolazione del dominio del documento

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. Anche se i browser impongono 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:

javascript

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:

javascript

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:

javascript

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

Manipolazione del percorso del file locale

Da: 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 il browser dell'utente ad aprire o scrivere un file locale arbitrario.

Sinks:

javascript

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

Iniezione SQL lato client

Da: 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:

javascript

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:

javascript

sessionStorage.setItem()
localStorage.setItem()

Iniezione XPath

Da: 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:

javascript

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 sul 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:

javascript

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

Manipolazione dei messaggi web

Da: 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.

Manipolazione dei dati DOM

Da: 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:

javascript

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:

javascript

requestFileSystem()
RegExp()

Dom Clobbering

{{#ref}} dom-clobbering.md {{#endref}}

tip

Impara e pratica l'Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'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.