DOM XSS
Last updated
Last updated
Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
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:
Sinks comuni:
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()
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()
FileReader.readAsFile()
someDOMElement.backgroundImage
constructor()
XMLHttpRequest.setRequestHeader()
FileReader.root.getFile()
someDOMElement.cssText
init()
XMLHttpRequest.open()
FileReader.root.getFile()
someDOMElement.codebase
index()
jQuery.globalEval()
someDOMElement.href
someDOMElement.outerHTML
$.parseHTML()
localStorage.setItem()
document.evaluate()
document.writeln()
$.parseJSON()
**[**`Denial of Service`**](dom-xss.md#denial-of-service)**
someDOMElement.evaluate()
document.title
requestFileSystem()
document.implementation.createHTMLDocument()
document.cookie
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.
Estensione del browser per controllare ogni dato che raggiunge un potenziale sink: https://github.com/kevin-mizu/domloggerpp
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:
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:
From: 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:
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:
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.
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:
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:
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 a un'apertura o scrittura di un file locale arbitrario nel browser dell'utente.
Sinks:
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:
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:
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:
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 di dati JSON e poi elaborata dall'applicazione.
Sinks:
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.
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:
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:
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)
