PCTAMALOU

🔬 Atelier pratique — La Forge (2 heures)

⚠️ Préparation de l'environnement

mkdir -p ~/maestro/forge_binaire/{src,build,notes}
cd ~/maestro/forge_binaire

sudo apt update
sudo apt install -y gcc clang make binutils file

gcc --version
objdump --version | head -1Copier

Niveau 1 Comparaison simple

/* crackme01.c — Niveau 1 : comparaison simple */
#include <stdio.h>
#include <string.h>

#define SECRET "pctamalou2026"

int main(void) {
    char input[64];

    printf("Mot de passe : ");
    if (!fgets(input, sizeof(input), stdin)) {
        return 1;
    }
    input[strcspn(input, "\n")] = '\0';

    if (strcmp(input, SECRET) == 0) {
        puts("Correct ! Accès accordé.");
        return 0;
    } else {
        puts("Incorrect. Réessayez.");
        return 1;
    }
}Copier

gcc -O0 -g -no-pie -fno-stack-protector -o build/crackme01-O0 src/crackme01.c
gcc -O2 -g -no-pie -fno-stack-protector -o build/crackme01-O2 src/crackme01.c
gcc -O2 -no-pie -fno-stack-protector -o build/crackme01-O2s src/crackme01.c
strip -s build/crackme01-O2s

ls -lh build/Copier

🔍 Motif -O0 — le binaire transparent

objdump -d -M intel build/crackme01-O0 | sed -n '/<main>:/,/^$/p'Copier

À observer : le prompt et le secret sont visibles en clair dans .rodata, strcmp@plt est appelé explicitement, input vit à [rbp-0x50].

strings build/crackme01-O0 | grep -E "Mot de passe|Correct|pctamalou"Copier

🔍 -O2 — sortie réelle gcc 12.2

objdump -d -M intel build/crackme01-O2 | sed -n '/<main>:/,/^$/p'Copier

Le motif exact produit par gcc 12.2 :

• strcmp a disparu — plus aucun appel dans cette zone.
• La comparaison est faite par deux movabs/cmp sur des qwords qui se chevauchent : le premier qword couvre les octets [0..7] de la chaîne ("pctamalo"), le second couvre les octets [6..13] ("lou2026\0", avec \0 intégré pour valider aussi la fin).
• Le chevauchement (offset 6 pour le second) est délibéré : il garantit que la chaîne fait exactement 13 caractères en comparant 8 + 8 avec 6 octets en commun.
• strcspn n'est pas inliné — c'est encore un appel à strcspn@plt (ligne 4010d2).

undefined8 main(void) {
  char input[64];
  printf("Mot de passe : ");
  fgets(input, 0x40, stdin);
  input[strcspn(input, "\n")] = 0;
  if (strcmp(input, "pctamalou2026") == 0) {
    puts("Correct !");
    return 0;
  }
  puts("Incorrect.");
  return 1;
}

undefined8 main(void) {
  char input[80];
  printf("Mot de passe : ");
  fgets(input, 0x40, stdin);
  input[strcspn(input, "\n")] = 0;
  if ((*(long *)input == 0x6f6c616d61746370) &&
      (*(long *)(input + 6) == 0x36323032756f6c)) {
    puts("Correct !");
    return 0;
  }
  puts("Incorrect.");
  return 1;
}

Chemin intellectuel : pour reconstruire la chaîne, on décode chaque qword en little-endian :

• 0x6f6c616d61746370 → octets 70 63 74 61 6d 61 6c 6f → "pctamalo"
• 0x36323032756f6c → octets 6c 6f 75 32 30 32 36 00 → "lou2026\0"

Le second qword chevauche le premier à partir de l'offset 6 : il fournit les 2 derniers caractères de "pctamalo" ('l', 'o') en plus des caractères suivants jusqu'au \0. En concaténant : "pctamalo" + "u2026" (le reste du second, moins le chevauchement) = "pctamalou2026".

Niveau 2 XOR obfusqué

/* crackme02.c — Niveau 2 : XOR obfusqué */
#include <stdio.h>
#include <string.h>

/* "pctamalou2026" XOR 0x42 */
static const unsigned char secret_xor[] = {
    0x32, 0x21, 0x36, 0x23, 0x2F, 0x23, 0x2E, 0x2D,
    0x37, 0x70, 0x72, 0x70, 0x74
};

static int check(const char *input) {
    size_t len = strlen(input);
    if (len != sizeof(secret_xor)) return 0;
    for (size_t i = 0; i < len; i++) {
        if ((unsigned char)(input[i] ^ 0x42) != secret_xor[i]) {
            return 0;
        }
    }
    return 1;
}

int main(void) {
    char input[64];
    printf("Mot de passe : ");
    if (!fgets(input, sizeof(input), stdin)) return 1;
    input[strcspn(input, "\n")] = '\0';
    if (check(input)) { puts("Correct !"); return 0; }
    puts("Incorrect."); return 1;
}Copier

🔍 Motif à reconnaître

Trois instructions suffisent pour reconnaître le motif : movzx (chargement byte) → xor al, imm → cmp. La constante 0x42 est directement lisible dans l'instruction. Une fois repérée, on sait que chaque byte de secret_xor est le caractère original XOR 0x42.

Niveau 3 Détection de debugger (ptrace)

/* crackme03.c — Niveau 3 : anti-debug basique */
#include <stdio.h>
#include <string.h>
#include <sys/ptrace.h>

#define SECRET "forgebinaire2026"

static int is_being_debugged(void) {
    if (ptrace(PTRACE_TRACEME, 0, 0, 0) == -1) {
        return 1;
    }
    return 0;
}

int main(void) {
    char input[64];
    if (is_being_debugged()) {
        puts("Debugger détecté. Sortie.");
        return 2;
    }
    printf("Mot de passe : ");
    if (!fgets(input, sizeof(input), stdin)) return 1;
    input[strcspn(input, "\n")] = '\0';
    if (strcmp(input, SECRET) == 0) { puts("Correct !"); return 0; }
    puts("Incorrect."); return 1;
}Copier

🔍 Contournement GDB — correctement

Méthode recommandée — avec symboles :

gdb -q ./build/crackme03-O0

(gdb) break is_being_debugged
Breakpoint 1 at 0x4011a9

(gdb) commands
> return 0
> continue
> end

(gdb) runCopier

Cette méthode est robuste : elle force le retour de la fonction de check à 0, avant même que ptrace ne soit appelé.

Méthode alternative — binaire strippé :

# 1. Trouver l'adresse du call ptrace
objdump -d -M intel ./build/crackme03-O2s | grep -B1 "ptrace"

# Exemple de sortie :
#   4011c5: call 401030 <ptrace@plt>
# → on se positionne juste APRÈS le call, à 0x4011ca

# 2. Dans GDB
gdb -q ./build/crackme03-O2s
(gdb) break *0x4011ca
(gdb) commands
> set $rax = 0
> continue
> end
(gdb) runCopier

Niveau 4 Comparaison custom

/* crackme04.c — Niveau 4 : comparaison custom */
#include <stdio.h>
#include <string.h>

/* "pctamalou2026" + 3 sur chaque caractère */
static const char secret_shifted[] = {
    's','f','w','d','p','d','o','r','x','5','3','5','9','\0'
};

static int custom_check(const char *input) {
    size_t i = 0;
    while (input[i] != '\0' && secret_shifted[i] != '\0') {
        if ((char)(input[i] + 3) != secret_shifted[i]) return 0;
        i++;
    }
    return input[i] == '\0' && secret_shifted[i] == '\0';
}

int main(void) {
    char input[64];
    printf("Mot de passe : ");
    if (!fgets(input, sizeof(input), stdin)) return 1;
    input[strcspn(input, "\n")] = '\0';
    if (custom_check(input)) { puts("Correct !"); return 0; }
    puts("Incorrect."); return 1;
}Copier

🔍 Motif de la boucle custom

Le motif est immédiatement identifiable : un movzx suivi d'un add reg, 0x3 dans une boucle. La transformation +3 est lisible. Même sans symbole, même strippé, cette boucle reste reconnaissable à sa structure.

Niveau 5 La Chambre Rose

Le niveau 5 combine quatre anti-debugs, deux chaînes obfusquées, une validation en cinq étapes et une comparaison par hash FNV-1a.

Les défenses combinées

/* crackme05.c — Niveau 5 : La Chambre Rose
 * Usage strictement pédagogique en laboratoire isolé.
 * Aucun réseau, aucune persistance, aucune exfiltration.
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>

static int check_tracer_pid(void) {
    FILE *f = fopen("/proc/self/status", "r");
    if (!f) return 0;
    char line[256];
    int traced = 0;
    while (fgets(line, sizeof(line), f)) {
        if (strncmp(line, "TracerPid:", 10) == 0) {
            if (atoi(line + 10) != 0) traced = 1;
            break;
        }
    }
    fclose(f);
    return traced;
}

static int check_ptrace_fork(void) {
    pid_t pid = fork();
    if (pid < 0) return 0;
    if (pid == 0) {
        if (ptrace(PTRACE_TRACEME, 0, 0, 0) == -1) _exit(1);
        _exit(0);
    }
    int status;
    if (waitpid(pid, &status, 0) < 0) return 0;
    return WIFEXITED(status) && WEXITSTATUS(status) == 1;
}

/* Scan int3 limité à 32 octets (fragile, best-effort) */
static int check_int3(const void *addr, size_t len) {
    const unsigned char *p = (const unsigned char *)addr;
    for (size_t i = 0; i < len; i++) {
        if (p[i] == 0xCC) return 1;
    }
    return 0;
}

static int check_timing(void) {
    struct timespec t0, t1;
    clock_gettime(CLOCK_MONOTONIC, &t0);
    volatile unsigned long x = 0;
    for (unsigned long i = 0; i < 200000; i++) x += i;
    clock_gettime(CLOCK_MONOTONIC, &t1);
    long long ns = (t1.tv_sec - t0.tv_sec) * 1000000000LL
                 + (t1.tv_nsec - t0.tv_nsec);
    return ns > 50000000LL;
}

static int in_vm_cpuid(void) {
#if defined(__x86_64__) || defined(__i386__)
    unsigned int eax, ebx, ecx, edx;
    __asm__ __volatile__("cpuid" : "=a"(eax), "=b"(ebx),
                         "=c"(ecx), "=d"(edx) : "a"(1));
    return (ecx >> 31) & 1;
#else
    return 0;
#endif
}

static int in_vm_dmi(void) {
    const char *files[] = {
        "/sys/class/dmi/id/product_name",
        "/sys/class/dmi/id/sys_vendor",
        "/sys/class/dmi/id/board_vendor",
        NULL
    };
    const char *keys[] = {
        "QEMU", "VMware", "VirtualBox", "KVM",
        "Microsoft Corporation", "innotek", NULL
    };
    char buf[256];
    for (int i = 0; files[i]; i++) {
        FILE *f = fopen(files[i], "r");
        if (!f) continue;
        if (fgets(buf, sizeof(buf), f)) {
            for (int j = 0; keys[j]; j++) {
                if (strstr(buf, keys[j])) { fclose(f); return 1; }
            }
        }
        fclose(f);
    }
    return 0;
}

/* ÉTAPE 1 — "rose2026" XOR 0x37 */
static const unsigned char s1_enc[] = {
    0x45, 0x58, 0x44, 0x52, 0x05, 0x07, 0x05, 0x01, 0x00
};

__attribute__((noinline))
static int stage1(const char *in) {
    char decoded[16];
    for (int i = 0; i < 8; i++) decoded[i] = s1_enc[i] ^ 0x37;
    decoded[8] = '\0';
    return strcmp(in, decoded) == 0;
}

/* ÉTAPE 2 — code magique */
#define STAGE2_MAGIC 0xC0FFEEu

__attribute__((noinline))
static int stage2(unsigned int n) {
    return n == STAGE2_MAGIC;
}

/* ÉTAPE 3 — "forge-hero" XOR 0x5A + hash FNV-1a
 * NOTE : le hash n'est PAS une protection ici. La chaîne reste
 * récupérable par XOR. Le hash introduit le concept de
 * comparaison non-littérale. */
static unsigned int fnv1a(const char *s) {
    unsigned int h = 2166136261u;
    while (*s) {
        h ^= (unsigned char)*s++;
        h *= 16777619u;
    }
    return h;
}

static const unsigned char s3_enc[] = {
    0x3C, 0x35, 0x28, 0x3D, 0x3F, 0x77, 0x32, 0x3F, 0x28, 0x35, 0x00
};

__attribute__((noinline))
static int stage3(const char *in) {
    char decoded[16];
    for (int i = 0; i < 10; i++) decoded[i] = s3_enc[i] ^ 0x5A;
    decoded[10] = '\0';
    return fnv1a(in) == fnv1a(decoded);
}

/* ÉTAPE 4 — (17 * 23) + 42 = 433 */
__attribute__((noinline))
static int stage4(unsigned long n) {
    return n == (17UL * 23UL + 42UL);
}

/* ÉTAPE 5 — somme ASCII de "forge-hero" = 1006 */
__attribute__((noinline))
static int stage5(unsigned long n) {
    return n == 1006UL;
}

int main(void) {
    puts("=== LA CHAMBRE ROSE — 5 ÉTAPES ===");
    puts("");

    if (check_tracer_pid()) {
        puts("[!] TracerPid actif. Sortie propre.");
        return 2;
    }
    if (check_ptrace_fork()) {
        puts("[!] ptrace refusé. Sortie propre.");
        return 2;
    }
    if (check_int3((const void *)stage1, 32) ||
        check_int3((const void *)stage3, 32) ||
        check_int3((const void *)stage5, 32)) {
        puts("[!] Breakpoint int3 détecté. Sortie propre.");
        return 2;
    }
    if (check_timing()) {
        puts("[!] Timing anormal. Sortie propre.");
        return 2;
    }

    if (in_vm_cpuid() || in_vm_dmi()) {
        puts("[i] Environnement virtualisé détecté. Normal en lab.");
        puts("");
    }

    char s1[64], s3[64];
    unsigned int n2;
    unsigned long n4, n5;

    printf("[1/5] Password             : ");
    fflush(stdout);
    if (!fgets(s1, sizeof(s1), stdin)) return 1;
    s1[strcspn(s1, "\n")] = '\0';
    if (!stage1(s1)) { puts("  x Étape 1 échouée."); return 1; }
    puts("  + Étape 1 validée.");

    printf("[2/5] Code (hex)           : ");
    fflush(stdout);
    if (scanf("%x", &n2) != 1) return 1;
    getchar();
    if (!stage2(n2)) { puts("  x Étape 2 échouée."); return 1; }
    puts("  + Étape 2 validée.");

    printf("[3/5] Clé finale           : ");
    fflush(stdout);
    if (!fgets(s3, sizeof(s3), stdin)) return 1;
    s3[strcspn(s3, "\n")] = '\0';
    if (!stage3(s3)) { puts("  x Étape 3 échouée."); return 1; }
    puts("  + Étape 3 validée.");

    printf("[4/5] (17 * 23) + 42       : ");
    fflush(stdout);
    if (scanf("%lu", &n4) != 1) return 1;
    getchar();
    if (!stage4(n4)) { puts("  x Étape 4 échouée."); return 1; }
    puts("  + Étape 4 validée.");

    printf("[5/5] Somme ASCII de la clé : ");
    fflush(stdout);
    if (scanf("%lu", &n5) != 1) return 1;
    getchar();
    if (!stage5(n5)) { puts("  x Étape 5 échouée."); return 1; }
    puts("  + Étape 5 validée.");

    puts("");
    puts("Bravo, Maestro. Vous avez ouvert la Chambre Rose.");
    puts("Cinq étapes. Quatre anti-debugs. Une obfuscation.");
    puts("Aucune magie. Juste de la lecture.");
    return 0;
}Copier

🔍 Points d'entrée d'analyse sur le binaire strippé

# 1. Chaînes qui survivent au strip
strings build/crackme05-O2s | grep -E "Étape|Debugger|Chambre"

# 2. Chercher les appels d'imports critiques + l'instruction cpuid
#    (cpuid est une instruction, pas un call — grep direct)
objdump -d -M intel build/crackme05-O2s | grep -E "call.*(ptrace|fork|fopen)|cpuid"

# 3. Repérer les constantes d'étape
objdump -d -M intel build/crackme05-O2s | grep -iE "0xc0ffee|0x3ee|0x1b1"Copier

Ce motif — movzx + xor imm + cmp — est la signature du décodage XOR. Repérez-le dans stage1 (clé 0x37) et stage3 (clé 0x5A).

🔍 Contournement GDB — méthode correcte

Sur la variante -O2s, break check_tracer_pid ne fonctionnera pas — les symboles sont absents. Il faut s'appuyer sur les appels d'imports.

# Trouver les adresses des appels critiques
objdump -d -M intel build/crackme05-O2s | grep -E "call.*(ptrace|fopen|fork)"

# Dans GDB, breakpoint APRÈS le call, forcer $rax = 0
gdb -q ./build/crackme05-O2s
(gdb) break *0x401234       # adresse trouvée via objdump
(gdb) commands
> set $rax = 0
> continue
> end
(gdb) runCopier

Password             : rose2026
Code (hex)           : C0FFEE
Clé finale           : forge-hero
(17 * 23) + 42       : 433
Somme ASCII de la clé: 1006

Étape finale — Makefile

Un seul pattern rule suffit pour les 15 binaires. On utilise -no-pie pour la lisibilité des adresses dans les désassemblages pédagogiques.

CC      = gcc
CFLAGS  = -fno-stack-protector -no-pie -Wall
BUILD   = build
SRC     = src
LEVELS  = 01 02 03 04 05

$(BUILD)/crackme%-O0: $(SRC)/crackme%.c | $(BUILD)
	$(CC) -O0 -g $(CFLAGS) -o $@ $<

$(BUILD)/crackme%-O2: $(SRC)/crackme%.c | $(BUILD)
	$(CC) -O2 -g $(CFLAGS) -o $@ $<

$(BUILD)/crackme%-O2s: $(SRC)/crackme%.c | $(BUILD)
	$(CC) -O2 $(CFLAGS) -o $@ $<
	strip -s $@

ALL = $(foreach lvl,$(LEVELS),\
        $(BUILD)/crackme$(lvl)-O0 \
        $(BUILD)/crackme$(lvl)-O2 \
        $(BUILD)/crackme$(lvl)-O2s)

all: $(ALL)

$(BUILD):
	mkdir -p $(BUILD)

clean:
	rm -f $(BUILD)/*

.PHONY: all cleanCopier

make
ls -lh build/    # 15 binairesCopier

Le pont source ↔ binaire — récapitulatif