# DOM XSS {{#include ../../banners/hacktricks-training.md}} ## 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**](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**](dom-xss.md#open-redirect) | [**Javascript Injection**](dom-xss.md#javascript-injection) | [**Manipolazione dei dati DOM**](dom-xss.md#dom-data-manipulation) | **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**](dom-xss.md#local-file-path-manipulation) | `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**](dom-xss.md#ajax-request-manipulation) | `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**](dom-xss.md#link-manipulation) | `someDOMElement.innerHTML` | `jQuery.parseHTML()` | | `jQuery.globalEval()` | `someDOMElement.href` | `someDOMElement.outerHTML` | `$.parseHTML()` | | `$.globalEval()` | `someDOMElement.src` | `someDOMElement.insertAdjacentHTML` | [**Iniezione JSON lato client**](dom-xss.md#client-side-sql-injection) | | **\`\`**[**Manipolazione dello storage HTML5**](dom-xss.md#html-5-storage-manipulation) | `someDOMElement.action` | `someDOMElement.onevent` | `JSON.parse()` | | `sessionStorage.setItem()` | [**Iniezione XPath**](dom-xss.md#xpath-injection) | `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**](dom-xss.md#cookie-manipulation) | | `requestFileSystem()` | **\`\`**[**Manipolazione del dominio del documento**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()` | `document.cookie` | | `RegExp()` | `document.domain` | `history.pushState()` | [**Avvelenamento dell'URL WebSocket**](dom-xss.md#websocket-url-poisoning) | | [**Iniezione SQL lato client**](dom-xss.md#client-side-sql-injection) | [**Manipolazione dei messaggi Web**](dom-xss.md#web-message-manipulation) | `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](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](https://github.com/kevin-mizu/domloggerpp) ## Esempi ### Open Redirect Da: [https://portswigger.net/web-security/dom-based/open-redirection](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() ``` ### Manipolazione dei cookie Da: [https://portswigger.net/web-security/dom-based/cookie-manipulation](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](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](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](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](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](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](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](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](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](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](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](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](https://portswigger.net/web-security/dom-based/controlling-the-web-message-source). 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](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](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}} {{#include ../../banners/hacktricks-training.md}}