24 KiB
DOM XSS
Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!
- Lavori in una azienda di sicurezza informatica? Vuoi vedere la tua azienda pubblicizzata in HackTricks? o vuoi avere accesso all'ultima versione di PEASS o scaricare HackTricks in PDF? Controlla i PACCHETTI DI ABBONAMENTO!
- Scopri The PEASS Family, la nostra collezione di esclusive NFT
- Ottieni il merchandising ufficiale di PEASS & HackTricks
- Unisciti al 💬 gruppo Discord o al gruppo Telegram o seguimi su Twitter 🐦@carlospolopm.
- Condividi i tuoi trucchi di hacking inviando PR al repo hacktricks e al repo hacktricks-cloud.
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 esempio eval(), document.body.innerHTML) che possono eseguire o renderizzare contenuti dannosi se vengono forniti dati maligni.
- Le fonti sono input che possono essere manipolati dagli attaccanti, inclusi URL, cookie e messaggi web.
- I sinks sono punti finali potenzialmente pericolosi in cui i dati maligni possono causare effetti avversi, come l'esecuzione di script.
Il rischio si presenta quando i dati fluiscono da una fonte a un sink senza una corretta convalida o sanificazione, consentendo attacchi come XSS.
{% hint style="info" %} Puoi trovare un elenco più aggiornato di fonti e sinks su https://github.com/wisec/domxsswiki/wiki {% endhint %}
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
Sink comuni:
| Redirect aperto | Iniezione di JavaScript | 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 del link | someDOMElement.innerHTML |
jQuery.parseHTML() |
jQuery.globalEval() |
someDOMElement.href |
someDOMElement.outerHTML |
$.parseHTML() |
$.globalEval() |
someDOMElement.src |
someDOMElement.insertAdjacentHTML |
Iniezione di JSON lato client |
| ``Manipolazione dello storage HTML5 | someDOMElement.action |
someDOMElement.onevent |
JSON.parse() |
sessionStorage.setItem() |
Iniezione di 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() |
WebSocket-URL poisoning |
| Iniezione di SQL lato client | Manipolazione del messaggio Web | history.replaceState() |
WebSocket |
executeSql() |
postMessage() |
`` | `` |
Il sink innerHTML non accetta elementi script su nessun browser moderno, né gli eventi svg onload verranno attivati. Ciò significa che sarà necessario utilizzare elementi alternativi come img o iframe.
Questo tipo di XSS è probabilmente il più difficile da trovare, poiché è necessario esaminare il codice JS, verificare se sta utilizzando un oggetto il cui valore è controllato, e in tal caso, verificare se c'è un modo per sfruttarlo per eseguire JS arbitrario.
Strumenti per trovarli
Esempi
Redirect aperto
Da: https://portswigger.net/web-security/dom-based/open-redirection
Le vulnerabilità di redirect aperto nel DOM si verificano quando uno script scrive dati, che un attaccante può controllare, in un sink in grado di avviare la navigazione tra domini.
È fondamentale capire che è possibile eseguire codice arbitrario, come javascript:alert(1), se si ha il controllo sull'inizio dell'URL in cui si verifica il reindirizzamento.
Sink:
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
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 effettuare un attacco di fissazione della sessione se il cookie è coinvolto nel tracciamento delle sessioni degli utenti. Il principale punto di ingresso associato a questa vulnerabilità è:
Punti di ingresso:
document.cookie
Iniezione di JavaScript
Da: https://portswigger.net/web-security/dom-based/javascript-injection
Le vulnerabilità di iniezione di JavaScript basate su DOM vengono create 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()
Manipolazione del dominio del documento
Da: 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 controllabili da un attaccante.
La proprietà document.domain svolge un ruolo chiave nell'applicazione della politica della stessa origine da parte dei browser. Quando due pagine provenienti da origini diverse impostano il loro document.domain allo stesso valore, possono interagire senza restrizioni. Sebbene i browser impongano certi limiti ai valori assegnabili a document.domain, impedendo l'assegnazione di valori completamente non correlati all'origine effettiva della pagina, esistono eccezioni. Tipicamente, i browser consentono l'uso di domini figlio o genitore.
Sinks:
document.domain
WebSocket-URL poisoning
Da: 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.
Manipolazione dei link
Da: https://portswigger.net/web-security/dom-based/link-manipulation
Le vulnerabilità di manipolazione dei link basate su DOM si verificano quando uno script scrive dati controllabili dall'attaccante su un target 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 che viene emessa utilizzando un oggetto XmlHttpRequest.
Sinks:
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 al browser dell'utente all'apertura o alla scrittura di un file locale arbitrario.
Sinks:
FileReader.readAsArrayBuffer()
FileReader.readAsBinaryString()
FileReader.readAsDataURL()
FileReader.readAsText()
FileReader.readAsFile()
FileReader.root.getFile()
FileReader.root.getFile()
Iniezione di SQL lato client
Da: https://portswigger.net/web-security/dom-based/client-side-sql-injection
Le vulnerabilità di iniezione di SQL lato client si verificano quando uno script incorpora dati controllabili dall'attaccante in una query di SQL lato client in modo non sicuro.
Sink:
executeSql()
Manipolazione dell'HTML5-storage
Da: https://portswigger.net/web-security/dom-based/html5-storage-manipulation
Le vulnerabilità di manipolazione dell'HTML5-storage si verificano quando uno script memorizza dati controllabili dall'attaccante nell'HTML5 storage 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. Ciò potrebbe consentire a un attaccante di sfruttare il meccanismo di memorizzazione per condurre altri attacchi basati sul DOM, come cross-site scripting e injection di JavaScript.
Sinks:
sessionStorage.setItem()
localStorage.setItem()
Iniezione di XPath
Da: https://portswigger.net/web-security/dom-based/client-side-xpath-injection
Le vulnerabilità di iniezione di XPath basate sul DOM si verificano quando uno script incorpora dati controllabili dall'attaccante in una query XPath.
Sink:
document.evaluate()
someDOMElement.evaluate()
Iniezione di JSON lato client
Da: https://portswigger.net/web-security/dom-based/client-side-json-injection
Le vulnerabilità di iniezione di 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.
Sink:
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 si verificano 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.
Sink:
Il metodo postMessage() per l'invio di messaggi web può portare a vulnerabilità se l'ascoltatore degli eventi per la ricezione dei messaggi gestisce i dati in ingresso in modo non sicuro.
Manipolazione dei dati DOM
Da: https://portswigger.net/web-security/dom-based/dom-data-manipulation
Le vulnerabilità della manipolazione dei dati DOM si verificano 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.
Sink:
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
Da: 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 una API problematica. Ciò include API che, quando invocate, possono portare il computer dell'utente a consumare quantità eccessive di CPU o spazio su disco. Tali vulnerabilità possono avere effetti collaterali significativi, come il browser che limita la funzionalità del sito web rifiutando i tentativi di archiviare dati in localStorage o terminando script occupati.
Sinks:
requestFileSystem()
RegExp()
Dom Clobbering
Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!
- Lavori in una azienda di sicurezza informatica? Vuoi vedere la tua azienda pubblicizzata in HackTricks? O vuoi avere accesso all'ultima versione di PEASS o scaricare HackTricks in PDF? Controlla i PIANI DI ABBONAMENTO!
- Scopri The PEASS Family, la nostra collezione di esclusive NFT
- Ottieni il merchandising ufficiale di PEASS & HackTricks
- Unisciti al 💬 gruppo Discord o al gruppo Telegram o seguimi su Twitter 🐦@carlospolopm.
- Condividi i tuoi trucchi di hacking inviando PR al repo hacktricks e al repo hacktricks-cloud.