mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-04 18:40:54 +00:00
316 lines
24 KiB
Markdown
316 lines
24 KiB
Markdown
# DOM XSS
|
|
|
|
<details>
|
|
|
|
<summary><strong>Impara l'hacking di AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
* 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**](https://github.com/sponsors/carlospolop)!
|
|
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Unisciti al** [**💬**](https://emojipedia.org/speech-balloon/) [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo Telegram**](https://t.me/peass) o **seguimi** su **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
* **Condividi i tuoi trucchi di hacking inviando PR al** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **e al** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
## 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**](https://github.com/wisec/domxsswiki/wiki)
|
|
{% endhint %}
|
|
|
|
**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
|
|
```
|
|
**Sink comuni:**
|
|
|
|
| [**Redirect aperto**](dom-xss.md#open-redirect) | [**Iniezione di JavaScript**](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 del link**](dom-xss.md#link-manipulation) | `someDOMElement.innerHTML` | `jQuery.parseHTML()` |
|
|
| `jQuery.globalEval()` | `someDOMElement.href` | `someDOMElement.outerHTML` | `$.parseHTML()` |
|
|
| `$.globalEval()` | `someDOMElement.src` | `someDOMElement.insertAdjacentHTML` | [**Iniezione di 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 di 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()` | [**WebSocket-URL poisoning**](dom-xss.md#websocket-url-poisoning) |
|
|
| [**Iniezione di SQL lato client**](dom-xss.md#client-side-sql-injection) | [**Manipolazione del messaggio 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. 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
|
|
|
|
* [https://github.com/mozilla/eslint-plugin-no-unsanitized](https://github.com/mozilla/eslint-plugin-no-unsanitized)
|
|
|
|
## Esempi
|
|
|
|
### Redirect aperto
|
|
|
|
Da: [https://portswigger.net/web-security/dom-based/open-redirection](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:
|
|
```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 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:
|
|
```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 vengono create 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
|
|
|
|
Da: [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 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:
|
|
```javascript
|
|
document.domain
|
|
```
|
|
### WebSocket-URL poisoning
|
|
|
|
Da: [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.
|
|
|
|
### Manipolazione dei link
|
|
|
|
Da: [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** 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:
|
|
```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 che viene 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 al browser dell'utente all'apertura o alla scrittura di un file locale arbitrario.
|
|
|
|
Sinks:
|
|
```javascript
|
|
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](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:
|
|
```javascript
|
|
executeSql()
|
|
```
|
|
### Manipolazione dell'HTML5-storage
|
|
|
|
Da: [https://portswigger.net/web-security/dom-based/html5-storage-manipulation](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:
|
|
```javascript
|
|
sessionStorage.setItem()
|
|
localStorage.setItem()
|
|
```
|
|
### Iniezione di 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 di XPath basate sul DOM** si verificano quando uno script incorpora **dati controllabili dall'attaccante in una query XPath**.
|
|
|
|
Sink:
|
|
```javascript
|
|
document.evaluate()
|
|
someDOMElement.evaluate()
|
|
```
|
|
### Iniezione di 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 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:
|
|
```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** 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](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:
|
|
```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
|
|
|
|
Da: [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 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:
|
|
```javascript
|
|
requestFileSystem()
|
|
RegExp()
|
|
```
|
|
## Dom Clobbering
|
|
|
|
<details>
|
|
|
|
<summary><strong>Impara l'hacking di AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
* 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**](https://github.com/sponsors/carlospolop)!
|
|
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Unisciti al** [**💬**](https://emojipedia.org/speech-balloon/) [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo Telegram**](https://t.me/peass) o **seguimi** su **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
* **Condividi i tuoi trucchi di hacking inviando PR al** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **e al** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|