Italian - Ht
HackTricks Training Twitter Linkedin Sponsor

DOM XSS

Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!

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.

Puoi trovare un elenco più aggiornato di fonti e sinks su 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

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)!
PreviousDOM InvaderNextIframes in XSS, CSP and SOP

Last updated