Crackme pour débutants : votre premier crackme résolu (2026)

Qu'est-ce qu'un crackme ?

Qu'est-ce qu'un crackme ? Un crackme est un petit programme écrit spécialement pour être rétro-ingénié, à titre d'exercice. Il vérifie généralement un mot de passe, un numéro de série ou une clé de licence, et le but est de comprendre cette vérification assez bien pour la passer. Comme l'auteur l'a conçu pour être cassé, le résoudre est légal et ne viole aucune licence.

La tradition remonte à plusieurs décennies. L'ancien site communautaire crackmes.de en a hébergé des milliers jusqu'à sa fermeture, et son successeur spirituel, crackmes.one, a été créé pour que les débutants aient toujours un endroit où apprendre. La plupart des crackmes appartiennent à l'un de ces trois types :

• Crackme : trouver le mot de passe ou le flag caché. Le plus simple, et le meilleur point de départ.
• Keygenme : comprendre l'algorithme qui transforme un nom en numéro de série valide, puis écrire un petit programme (un keygen) qui produit un numéro de série pour n'importe quel nom.
• Patchme : modifier le binaire lui-même pour qu'il accepte n'importe quelle entrée. Valable uniquement quand l'auteur l'autorise.

Ce dernier point piège beaucoup de débutants. Modifier un saut conditionnel pour que le programme affiche toujours « Access granted » donne l'impression d'avoir gagné, mais les règles de crackmes.one considèrent le patch comme une solution invalide, sauf si le défi est explicitement un patchme. La raison est pratique : un patch vous apprend où se trouve la vérification, alors qu'un keygen prouve que vous avez compris ce qu'elle fait.

Pourquoi les crackmes sont la meilleure porte d'entrée vers la rétro-ingénierie

La rétro-ingénierie est la catégorie de CTF que les débutants évitent le plus longtemps. On vous remet un fichier compilé sans code source, et la première fois que vous l'ouvrez dans un désassembleur, le mur d'instructions semble insurmontable. Si vous découvrez encore les catégories de CTF, notre guide des six catégories de CTF montre où se situe le reversing à côté du web, de la crypto et du pwn.

Les crackmes règlent ce problème de « mur insurmontable » de trois façons :

• Ils sont petits. Un crackme pour débutants n'a souvent qu'une seule fonction qui compte. Vous apprenez à ignorer le code généré par le compilateur et à zoomer sur la vérification.
• Ils sont classés par difficulté. crackmes.one note chaque crackme de 1 (chaînes en clair, comparaisons simples) à 6 (machines virtuelles maison et forte obfuscation), ce qui vous permet de monter une marche à la fois.
• Ils forgent directement vos réflexes de CTF. Un défi de reversing typique en CTF, c'est un crackme avec un flag au bout. La démarche est la même, seul le chrono tourne.

Notre avis franc : si vous voulez faire de l'exploitation de binaires un jour, vous ne pouvez pas sauter cette étape. Tout buffer overflow commence par la lecture du programme que vous allez casser.

Préparer un espace de travail sûr pour les crackmes

Les crackmes des sites communautaires sont vérifiés avant d'être publiés, mais il s'agit toujours d'exécutables écrits par des inconnus. Lancez-les dans une machine virtuelle, jamais sur l'ordinateur qui contient vos mots de passe et vos photos. Une VM Kali Linux ou Ubuntu suffit largement, et prendre un instantané (snapshot) avant chaque session vous permet d'annuler en quelques secondes tout comportement étrange. Les crackmes Windows vont dans une VM Windows séparée.

Il faut étonnamment peu d'outils pour démarrer. Voici ceux que nous installerions dès le premier jour :

Quel désassembleur choisir ? Prenez Ghidra. Il est gratuit, open source, maintenu par la NSA, et son décompilateur transforme la plupart des crackmes pour débutants en pseudo-C lisible. IDA Free et Binary Ninja sont excellents, mais inutile de dépenser de l'argent ou d'apprendre une deuxième interface tant que les bases sont encore fraîches. Pour une visite guidée de l'interface, le chapitre Ghidra du cours de rétro-ingénierie de HackerDNA présente les panneaux que vous utiliserez vraiment.

Comment résoudre un crackme : la méthode en 5 étapes

Presque tous les crackmes pour débutants cèdent à la même routine. Suivez-la dans l'ordre, et ne passez à l'étape suivante que lorsque l'étape en cours ne vous apprend plus rien.

1. Lancez-le. Tapez exprès une mauvaise réponse et notez chaque message. « Wrong password. » est une chaîne que vous pourrez rechercher plus tard.
2. Identifiez-le. Lancez file pour connaître le format (ELF pour Linux, PE pour Windows), l'architecture (x86-64, ARM64) et savoir si les symboles ont été supprimés.
3. Lisez les chaînes. Lancez strings et cherchez les messages que vous avez vus, ainsi que tout ce qui ressemble à un mot de passe, une chaîne de format ou un flag.
4. Trouvez la vérification. Ouvrez le binaire dans Ghidra ou avec objdump, allez au code qui affiche le message de succès et remontez jusqu'à la comparaison qui en décide.
5. Confirmez en direct, puis résolvez proprement. Posez un point d'arrêt sur cette comparaison dans GDB et observez les vraies valeurs. Notez ensuite la réponse ou, pour un keygenme, réécrivez l'algorithme en Python.

L'étape 4 est celle qui fait peur, et c'est là que l'astuce « remonter depuis le message de succès » prend tout son sens. Vous n'avez jamais besoin de comprendre tout le programme. Il suffit de comprendre la vingtaine d'instructions qui choisissent entre deux messages.

Exemple pratique : trois crackmes d'entraînement à compiler vous-même

Le crackme le plus sûr est celui que vous avez compilé. Voici trois courts programmes en C, chacun un cran plus difficile que le précédent. Enregistrez-les dans votre VM, compilez-les, puis essayez d'oublier le code source et de les résoudre comme si vous ne l'aviez jamais vu. Nous avons tout exécuté sur Ubuntu 24.04 avec GCC 13.3, GNU objdump 2.42 et GDB 15.1 en x86-64 : vos adresses peuvent donc légèrement différer sur une autre configuration.

// level1.c - the password is in plain sight
#include <stdio.h>
#include <string.h>
int main(void) {
    char input[64];
    printf("Password: ");
    if (!fgets(input, sizeof input, stdin)) return 1;
    input[strcspn(input, "\n")] = 0;
    if (strcmp(input, "s3cr3t_b4nana") == 0) puts("Access granted.");
    else puts("Wrong password.");
    return 0;
}

// level2.c - the password is XOR-encoded
#include <stdio.h>
#include <string.h>
static const unsigned char enc[] = {0x2e,0x70,0x34,0x1f,0x29,0x2e,0x1f,
    0x33,0x34,0x32,0x29,0x2e,0x27,0x33,0x00};
int main(void) {
    char input[64], key[16];
    printf("Password: ");
    if (!fgets(input, sizeof input, stdin)) return 1;
    input[strcspn(input, "\n")] = 0;
    for (int i = 0; enc[i]; i++) key[i] = enc[i] ^ 0x40;
    key[sizeof enc - 1] = 0;
    if (strcmp(input, key) == 0) puts("Access granted.");
    else puts("Wrong password.");
    return 0;
}

// level3.c - a keygenme: the serial depends on your name
#include <stdio.h>
#include <string.h>
int main(void) {
    char name[32], serial[32], want[32];
    unsigned int sum = 0;
    printf("Name: ");   if (!fgets(name, sizeof name, stdin)) return 1;
    printf("Serial: "); if (!fgets(serial, sizeof serial, stdin)) return 1;
    name[strcspn(name, "\n")] = 0; serial[strcspn(serial, "\n")] = 0;
    if (strlen(name) < 4) { puts("Name too short."); return 1; }
    for (size_t i = 0; i < strlen(name); i++) sum += (unsigned char)name[i] * (i + 1);
    snprintf(want, sizeof want, "KEY-%04X", (sum ^ 0x1337) & 0xFFFF);
    if (strcmp(serial, want) == 0) puts("Valid serial. Well done.");
    else puts("Invalid serial.");
    return 0;
}

gcc -O0 -o level1 level1.c
gcc -O0 -o level2 level2.c
gcc -O0 -o level3 level3.c

Niveau 1 : le mot de passe bien en vue

Lancez-le, échouez, puis identifiez-le :

$ ./level1
Password: test
Wrong password.
$ file level1
level1: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked,
interpreter /lib64/ld-linux-x86-64.so.2, ..., for GNU/Linux 3.2.0, not stripped

« Not stripped » signifie que les noms de fonctions comme main sont toujours présents, ce qui facilite la suite. Passons aux chaînes. La sortie complète fait environ 90 lignes de noms de bibliothèques et de restes du compilateur, mais regardez ce qui se trouve juste entre les deux messages que vous avez déjà vus :

$ strings level1
...
Password:
s3cr3t_b4nana
Access granted.
Wrong password.
...

Et c'est résolu. Le compilateur range les chaînes littérales ensemble dans une section en lecture seule, si bien qu'un mot de passe codé en dur atterrit souvent juste à côté des messages de succès et d'échec. C'est exactement ce que signifie le niveau 1 sur crackmes.one, et vous serez surpris de voir combien de fois cela marche encore dans les défis d'échauffement des CTF.

Niveau 2 : le mot de passe caché

Mêmes messages, mais cette fois strings n'affiche rien qui ressemble à un mot de passe. Il est temps de trouver la vérification. Désassemblez main en syntaxe Intel, celle qu'utilisent la plupart des tutoriels :

$ objdump -d -M intel --no-show-raw-insn level2 | awk '/<main>:/,/^$/'
    ...
    1263:  mov    eax,DWORD PTR [rbp-0x64]
    1266:  cdqe
    1268:  lea    rdx,[rip+0xd99]        # 2008 <enc>
    126f:  movzx  eax,BYTE PTR [rax+rdx*1]
    1273:  xor    eax,0x40
    1276:  mov    edx,eax
    ...
    1297:  jne    1263 <main+0x7a>
    ...
    12ab:  call   10f0 <strcmp@plt>
    12b0:  test   eax,eax
    12b2:  jne    12c5 <main+0xdc>

Lisez-le à l'envers. En 12ab, le programme appelle strcmp, et le saut juste après choisit le message de succès ou d'échec. Au-dessus se trouve une boucle : charger un octet depuis quelque chose qui s'appelle enc, lui appliquer un XOR avec 0x40, le stocker, recommencer jusqu'à un octet nul. Le vrai mot de passe est donc construit à l'exécution à partir d'octets encodés.

Vous pourriez décoder ces octets à la main. Il est plus rapide de laisser le programme travailler et de lire le résultat dans GDB. Poser un point d'arrêt sur le symbole strcmp en général est un piège ici, car le chargeur dynamique l'appelle aussi avant que main ne démarre : arrêtez-vous plutôt sur l'appel exact. 0x12ab - 0x11e9 (le début de main) donne 194 :

$ echo AAAA > in.txt
$ gdb -q ./level2
(gdb) break *main+194
(gdb) run < in.txt
Breakpoint 1, 0x00005555555552ab in main ()
(gdb) x/s $rdi
0x7fffffffc400: "AAAA"
(gdb) x/s $rsi
0x7fffffffc3f0: "n0t_in_strings"

Sous Linux x86-64, les deux premiers arguments d'une fonction passent par les registres rdi et rsi. L'un contient votre saisie, l'autre le mot de passe décodé. L'auteur l'a même nommé pour vous (« pas dans strings »).

Niveau 3 : votre premier keygen

Le niveau 3 demande un nom et un numéro de série. Il n'y a pas une seule bonne réponse, donc un débogueur seul ne vous donnerait que le numéro de série d'un seul nom. Le but d'un keygenme est de reconstruire l'algorithme. strings donne un premier indice :

$ strings level3 | grep KEY
KEY-%04X

C'est un format de type printf : le numéro de série est « KEY- » suivi de quatre chiffres hexadécimaux en majuscules. Voici maintenant la boucle qui calcule ces chiffres :

    132c:  lea    rdx,[rbp-0x70]
    1330:  mov    rax,QWORD PTR [rbp-0x78]
    1334:  add    rax,rdx
    1337:  movzx  eax,BYTE PTR [rax]       ; c = name[i]
    133a:  movzx  eax,al
    133d:  mov    rdx,QWORD PTR [rbp-0x78]
    1341:  add    rdx,0x1                  ; i + 1
    1345:  imul   eax,edx                  ; c * (i + 1)
    1348:  add    DWORD PTR [rbp-0x7c],eax ; sum += ...
    134b:  add    QWORD PTR [rbp-0x78],0x1 ; i++
    ...
    1362:  mov    eax,DWORD PTR [rbp-0x7c]
    1365:  xor    eax,0x1337               ; sum ^ 0x1337
    136a:  movzx  edx,ax                   ; keep the low 16 bits

Chaque caractère est multiplié par sa position (en commençant à 1), les produits sont additionnés, la somme subit un XOR avec 0x1337, et seuls les 16 bits de poids faible sont conservés. Réécrivez cela en Python et vous avez un keygen :

import sys

name = sys.argv[1]
total = sum(ord(c) * (i + 1) for i, c in enumerate(name))
print(f"KEY-{(total ^ 0x1337) & 0xFFFF:04X}")

$ python3 keygen.py dana
KEY-10C3
$ ./level3
Name: dana
Serial: KEY-10C3
Valid serial. Well done.

En pratique, c'est à ce moment que les crackmes font tilt pour la plupart des gens. Vous n'avez rien deviné. Vous avez lu la logique, vous l'avez réécrite dans un langage que vous connaissez, et le programme vous a donné raison. Ghidra aurait affiché la même boucle en pseudo-C, et c'est pourquoi il devient votre outil principal dès que les programmes dépassent quelques dizaines de lignes. Ouvrez level3 dedans et comparez la vue du décompilateur avec l'assembleur ci-dessus.

Où trouver des crackmes

crackmes.one

crackmes.one est la grande bibliothèque communautaire, et l'endroit où aller après vos propres binaires d'entraînement. Lors de notre vérification en novembre 2026, sa page d'accueil affichait 100 861 utilisateurs, 4 834 crackmes et 6 846 writeups. Quelques points à connaître avant votre premier téléchargement :

• Chaque téléchargement est une archive ZIP protégée par mot de passe. Le mot de passe est toujours crackmes.one. L'archive évite d'ouvrir l'exécutable par accident avant qu'il n'arrive dans votre VM.
• Utilisez les filtres de recherche. Vous pouvez filtrer par difficulté (de 1 à 6), note de qualité, langage, plateforme et nombre de writeups. Commencez par les niveaux 1 et 2, sous Linux ou Windows selon votre VM, avec au moins un writeup pour vérifier votre raisonnement ensuite.
• Certains crackmes rapportent désormais des points. Les crackmes à validation automatique affichent un flag au format CMO{...}. Le soumettre enregistre votre résolution et rapporte entre 100 et 600 points au classement.
• Les writeups sont des explications, pas des réponses. Un writeup qui ne contient que le mot de passe est refusé. En rédiger un pour chaque crackme résolu est la meilleure habitude d'étude que vous puissiez prendre, et cela vous constitue un portfolio. Notez que le site demande des writeups en anglais.

Archives de CTF et labs guidés

Les CTF pour débutants et les plateformes d'entraînement proposent presque toujours une catégorie reversing, et ces défis sont des crackmes avec un flag de CTF au bout. pwn.college va plus loin et enseigne l'assembleur et la rétro-ingénierie depuis zéro. Notre guide pwn.college pour débutants indique quels dojos faire en premier.

Comme livre gratuit à garder ouvert à côté de Ghidra, Reverse Engineering for Beginners de Dennis Yurichev reste la recommandation de référence, et il existe en français. Il montre le même code C compilé par différents compilateurs et pour différents processeurs, exactement la compétence qu'un crackme entraîne.

Les erreurs classiques des débutants

• Lancer des crackmes sur sa machine principale. Vérifié ne veut pas dire audité. Utilisez une VM avec des instantanés, et désactivez ses dossiers partagés.
• Sauter directement au niveau 4. Un crackme bourré d'astuces anti-débogage vous fera abandonner. Résolvez dix crackmes de niveau 1 et 2 avant de monter.
• Lire chaque instruction. Partez de la chaîne de succès et remontez. La majeure partie d'un binaire est du code d'initialisation du compilateur que vous pouvez ignorer sans risque.
• Patcher au lieu de comprendre. Transformer un jne en je fonctionne sur votre copie et ne vous apprend presque rien. Visez le mot de passe ou un keygen.
• Ouvrir le writeup au bout de cinq minutes. Fixez-vous un budget, environ une heure pour un crackme facile, puis lisez un writeup et réécrivez la solution vous-même sans regarder.

Considérations légales et éthiques

Les crackmes sont légaux parce que leurs auteurs les ont conçus pour être cassés et les ont publiés dans ce but. Les compétences que vous développez sont celles qu'utilisent chaque jour les analystes de malwares et les chercheurs en vulnérabilités. Cela ne fait pas pour autant de chaque binaire une cible légitime.

• crackmes.one interdit lui-même les triches de jeux, les cracks de logiciels commerciaux et les vrais malwares.
• Ne publiez pas le crackme ou le writeup de quelqu'un d'autre comme votre propre travail.
• Respectez les règles de chaque plateforme sur la publication des solutions, surtout pendant un CTF en cours.

Questions fréquentes