0Pricing
Cyber Security Academy · Leçon

Bases de l’ingénierie inverse et de l’exploitation binaire

Introduction à l’ingénierie inverse et à l’exploitation de binaires.

Bases de l’ingénierie inverse et de l’exploitation binaire est une leçon Cyber Security Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Cyber Security Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Cyber Security Academy comprend 4 leçons au total.

Rétro-ingénierie et exploitation binaire en bref

Deux catégories de CTF étroitement liées concernent les programmes compilés :

  • Rétro-ingénierie — vous analysez un binaire pour comprendre son fonctionnement, souvent afin de retrouver une vérification de mot de passe ou une logique cachée qui affiche le drapeau.
  • Exploitation binaire — vous trouvez un défaut de sécurité mémoire dans un binaire en cours d’exécution et l’exploitez pour détourner l’exécution, souvent afin de lancer un interpréteur de commandes sur un service distant qui contient le drapeau.

La rétro-ingénierie consiste à comprendre ; l’exploitation binaire, à casser. Les deux exigent d’être à l’aise avec les concepts de bas niveau.

Premier regard sur un binaire

N’ouvrez jamais un binaire à l’aveugle dans un désassembleur. Commencez par l’examiner avec quelques outils rapides en ligne de commande afin d’en déterminer le type, l’architecture et les éventuelles chaînes de caractères évidentes.

# Identify file type and architecture
file ./challenge

# Pull human-readable strings (flags are sometimes left in plaintext)
strings ./challenge

# Check which security mitigations are enabled
checksec --file=./challenge

Analyse statique et dynamique

Vous analysez les binaires de deux manières complémentaires :

  • Analyse statique — lisez le code sans l’exécuter, à l’aide d’un désassembleur ou d’un décompilateur comme Ghidra, ou d’une vue de désassemblage. Vous voyez le flux de contrôle complet, mais devez déduire les valeurs à l’exécution.
  • Analyse dynamique — exécutez le programme sous un débogueur tel que GDB et observez les valeurs réelles dans les registres et la mémoire. Vous voyez exactement ce qui se passe, mais uniquement sur le chemin que vous exécutez.

Les joueurs expérimentés alternent entre les deux : lisez statiquement pour élaborer une théorie, puis confirmez dynamiquement en avançant pas à pas.

Lire le désassemblage

Pour faire de la rétro-ingénierie, vous lisez de l’assembleur. Vous n’avez pas besoin de l’écrire couramment, mais vous devez reconnaître certains schémas :

  • cmp / test suivis d’un saut (je, jne) constituent une comparaison et un branchement — souvent la vérification du mot de passe.
  • call appelle une fonction ; les arguments ont été placés dans des registres ou sur la pile juste avant.
  • mov déplace des données entre les registres, la mémoire et les constantes.

Lorsque vous trouvez un cmp comparé à votre entrée, suivi d’un branchement vers un message de réussite, vous avez trouvé la vérification. Il vous faut maintenant retrouver ou contourner la valeur attendue.

Les décompilateurs vous font gagner du temps

Les décompilateurs modernes reconvertissent l’assembleur en C approximatif, bien plus rapide à lire que les instructions brutes. Une vérification de mot de passe décompilée pourrait ressembler à ceci :

// Decompiler output (approximate)
if (strcmp(user_input, "s3cr3t_p4ss") == 0) {
    puts("Correct! Here is your flag:");
    print_flag();
} else {
    puts("Wrong.");
}

Comment la corruption de mémoire commence

Les défis d’exploitation binaire ciblent des programmes qui lisent une entrée dans un tampon de taille fixe sans en vérifier la longueur. La pile stocke les variables locales ainsi que l’adresse de retour enregistrée, qui indique au CPU où aller lorsqu’une fonction se termine.

Si l’entrée déborde d’un tampon local, elle peut écraser cette adresse de retour enregistrée. Quiconque contrôle l’adresse de retour contrôle l’endroit où l’exécution se poursuit.

// Vulnerable: no bound on how much is read into buf
void vuln() {
    char buf[64];
    gets(buf);   // reads until newline, ignores buf size
}

Le débordement classique de tampon sur la pile

Le cas le plus simple d’exploitation binaire consiste à écraser l’adresse de retour pour sauter vers une fonction que le programme n’était pas censé appeler — une fonction win() cachée qui affiche le drapeau.

Procédure :

  • Trouvez le décalage exact entre le début du tampon et l’adresse de retour (un outil de motif cyclique permet de le déterminer rapidement).
  • Trouvez l’adresse de la fonction cible.
  • Envoyez un remplissage jusqu’au décalage, puis écrasez l’adresse de retour avec la cible.
# Build the input with a Python exploit library
from pwn import *

p = process('./challenge')
offset = 72                 # bytes to reach the return address
win_addr = 0x401176        # address of the win() function
p.sendline(b'A' * offset + p64(win_addr))
p.interactive()

Mécanismes de protection modernes

Les binaires réels activent des défenses qui bloquent les débordements naïfs. Vous devez les identifier avec checksec :

  • Canaris de pile — une valeur secrète placée avant l’adresse de retour ; si elle change, le programme s’interrompt. Vous devez d’abord la divulguer.
  • NX (No-eXecute) — la pile n’est pas exécutable, vous ne pouvez donc pas y exécuter le code d’interpréteur de commandes que vous y placez.
  • ASLR / PIE — les adresses sont choisies aléatoirement à chaque exécution ; vous avez donc besoin d’une fuite d’adresse avant de pouvoir viser.
  • RELRO — protège la table globale des décalages contre les écrasements.

Chaque mécanisme de protection vous pousse vers des techniques plus avancées.

Programmation orientée retour (ROP)

Lorsque NX vous empêche d’exécuter votre propre code, la programmation orientée retour réutilise du code déjà présent dans le binaire.

Vous enchaînez de courtes séquences d’instructions appelées blocs, chacune se terminant par ret, afin d’effectuer des actions étape par étape — par exemple charger un registre et appeler une fonction de bibliothèque pour lancer un interpréteur de commandes. Vous construisez la chaîne sur la pile afin que chaque ret saute vers le bloc suivant.

ROP constitue le pont entre les débordements de débutants et l’exploitation réelle, où le code de l’attaquant est rarement exécutable directement.

Failles de chaîne de format

Une autre primitive classique d’exploitation binaire est la vulnérabilité de chaîne de format, où l’entrée utilisateur est transmise directement comme argument de format à une fonction d’affichage.

// Vulnerable: user controls the format string
printf(user_input);          // dangerous

// Safe: user input is data, not format
printf("%s", user_input);    // correct

Pourquoi les défenseurs apprennent cela

Vous apprenez à exploiter précisément les défauts de mémoire afin de pouvoir les prévenir. Les enseignements défensifs sont concrets :

  • N’utilisez jamais de fonctions d’entrée sans limite comme gets ou strcpy ; utilisez des équivalents qui vérifient la longueur.
  • Gardez les mécanismes de protection activés : canaris, NX, ASLR/PIE complets et RELRO complet par défaut.
  • Privilégiez les langages à sûreté mémoire lorsque le modèle de menace le permet.
  • Considérez toute valeur contrôlée par l’utilisateur qui atteint une chaîne de format ou une copie de tampon comme un problème grave lors d’une revue de code.

Vérification rapide

Évaluez votre compréhension des bases de la rétro-ingénierie et de l’exploitation binaire.

Récapitulatif

Vous disposez maintenant d’une vue d’ensemble de la rétro-ingénierie et de l’exploitation binaire :

  • Examinez chaque binaire avec file, strings et checksec avant toute analyse approfondie.
  • Combinez les analyses statique (désassembleur/décompilateur) et dynamique (débogueur) pour comprendre la logique.
  • L’exploitation binaire commence par le débordement de tampon sur la pile qui écrase une adresse de retour ; les mécanismes de protection (canaris, NX, ASLR/PIE, RELRO) rendent la tâche plus difficile.
  • ROP contourne NX en réutilisant des blocs existants ; les failles de chaîne de format proviennent d’arguments de format non fiables.
  • Chaque technique constitue également une leçon défensive pour écrire et relire du code plus sûr.

Ensuite, vous constituez une boîte à outils et apprenez à rédiger vos solutions.

Questions Fréquemment Posées

La leçon « Bases de l’ingénierie inverse et de l’exploitation binaire » est-elle gratuite ?

Oui — le texte complet de « Bases de l’ingénierie inverse et de l’exploitation binaire » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Cyber Security Academy, passe à CoddyKit PRO. Le cours Cyber Security Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Bases de l’ingénierie inverse et de l’exploitation binaire » ?

Introduction à l’ingénierie inverse et à l’exploitation de binaires. Tu pratiques Cyber Security Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Cyber Security Academy ?

Aucune expérience préalable n'est requise. Cyber Security Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Bases de l’ingénierie inverse et de l’exploitation binaire » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Cyber Security Academy ?

Oui. Chaque leçon Cyber Security Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Catégories et état d’esprit des CTF
  2. Défis Web et de cryptographie
  3. Bases de l’ingénierie inverse et de l’exploitation binaire
  4. Outils et comptes rendus techniques
← Retour à Cyber Security Academy