PCTAMALOU

🔬 Mission pratique – Laboratoire (2 heures)

Architecture du Lab Fuzzing

⚠️ Environnement de Test Sécurisé

Étapes Détaillées de Fuzzing

Étape 1 : Préparation du Programme Vulnérable

/* vuln_fuzz.c - Programme vulnérable pour fuzzing */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void vulnerable_function(char *input) {
    char buffer[64];
    // Vulnérabilités intentionnelles
    strcpy(buffer, input);               // 1. Buffer overflow classique
    
    printf("Buffer content: %s\n", buffer);
    
    // 2. Use-After-Free potentiel
    char *dynamic = malloc(32);
    strcpy(dynamic, "safe");
    free(dynamic);
    
    // 3. Integer overflow/underflow
    int size = strlen(input);
    if (size < 0) {                     // Condition impossible normalement
        printf("Negative size detected!\n");
    }
}

int main(int argc, char **argv) {
    if (argc < 2) {
        printf("Usage: %s <input>\n", argv[0]);
        return 1;
    }
    
    printf("[*] Processing input: %s\n", argv[1]);
    vulnerable_function(argv[1]);
    
    return 0;
}Copier

# Compilation pour fuzzing et débogage
gcc -g -O0 -fno-stack-protector -z execstack -o vuln_fuzz vuln_fuzz.c
# -g : Symboles de débogage
# -O0 : Pas d'optimisation (pour débogage facile)
# -fno-stack-protector : Désactive canary
# -z execstack : Stack exécutable (pour démonstration)

# Vérification des protections
checksec --file=./vuln_fuzz

# Compilation avec AddressSanitizer (recommandé)
gcc -g -fsanitize=address -fno-omit-frame-pointer -o vuln_fuzz_asan vuln_fuzz.cCopier

Étape 2 : Fuzzing Dumb avec Radamsa

# Installation
sudo apt install radamsa -y

# Création d'un corpus initial (seeds)
mkdir -p ~/mon_lab/fuzzing/corpus
echo "test" > ~/mon_lab/fuzzing/corpus/seed1.txt
echo "A" > ~/mon_lab/fuzzing/corpus/seed2.txt
echo "1234567890" > ~/mon_lab/fuzzing/corpus/seed3.txt

# Script de fuzzing basique
#!/bin/bash
# fuzz_basic.sh
CORPUS_DIR="~/mon_lab/fuzzing/corpus"
CRASH_DIR="~/mon_lab/fuzzing/crashes"
mkdir -p "$CRASH_DIR"

echo "[*] Starting dumb fuzzing with radamsa"
for i in {1..1000}; do
    # Génération d'input muté
    INPUT=$(radamsa "$CORPUS_DIR"/*.txt 2>/dev/null)
    
    # Exécution avec timeout
    timeout 1 ./vuln_fuzz "$INPUT" 2>&1
    
    # Vérification du code de retour
    RET=$?
    if [[ $RET -eq 139 ]] || [[ $RET -eq 11 ]]; then  # SIGSEGV
        echo "[!] CRASH detected on iteration $i"
        echo "$INPUT" > "$CRASH_DIR/crash_${i}.txt"
    elif [[ $RET -eq 124 ]]; then  # Timeout
        echo "[*] Timeout on iteration $i"
    fi
    
    # Status toutes les 100 itérations
    if (( $i % 100 == 0 )); then
        echo "[*] Progress: $i/1000 iterations"
    fi
done

echo "[*] Fuzzing complete. Check $CRASH_DIR for crashes."Copier

Étape 3 : Fuzzing Intelligent avec boofuzz

#!/usr/bin/env python3
"""
fuzz_advanced.py - Fuzzing avancé avec boofuzz
"""

import sys
import subprocess
import time
from boofuzz import *

class ProcessMonitor:
    """Moniteur personnalisé pour programmes locaux"""
    def __init__(self, program_path):
        self.program_path = program_path
        self.crash_count = 0
        
    def pre_send(self, target=None, fuzz_data_logger=None, session=None):
        """Hook avant envoi"""
        pass
        
    def post_send(self, target=None, fuzz_data_logger=None, session=None):
        """Hook après envoi"""
        pass
        
    def retrieve_data(self):
        """Récupération des données (non utilisé ici)"""
        return b""
        
    def close(self):
        """Nettoyage"""
        pass

def fuzz_local_program():
    """Fuzzing d'un programme local via arguments"""
    
    # Configuration du fuzzer
    session = Session(
        target=Target(
            connection=ProcessMonitor("./vuln_fuzz")
        ),
        crash_threshold=10,  # Arrêt après 10 crashes
        sleep_time=0.01      # Délai entre tests
    )
    
    # Définition du schéma de fuzzing
    s_initialize("argument_fuzz")
    
    # Chaîne de base avec mutations
    s_string("FUZZ", fuzzable=True)
    
    # Ajout de patterns spécifiques
    s_static(" ")
    s_size("FUZZ", output_format="ascii", fuzzable=True)
    
    # Connexion et démarrage
    session.connect(s_get("argument_fuzz"))
    
    print("[*] Démarrage du fuzzing intelligent avec boofuzz")
    print("[*] Programme cible: ./vuln_fuzz")
    print("[*] Appuyez sur Ctrl+C pour arrêter")
    
    try:
        session.fuzz()
    except KeyboardInterrupt:
        print("\n[*] Fuzzing interrompu par l'utilisateur")
    
    print(f"[*] Total de crashes détectés: {session.crash_count}")

def simple_process_fuzzer():
    """Fuzzer plus simple pour débuter"""
    
    # Listes de valeurs à tester
    patterns = [
        "A" * 100,           # Buffer overflow simple
        "%s" * 50,           # Format string
        "\x00" * 80,         # Null bytes
        "../../etc/passwd",  # Path traversal
        "<script>",          # XSS-like
        "1; DROP TABLE",     # SQL-like
        "A" * 500,           # Overflow massif
    ]
    
    print("[*] Testing predefined patterns")
    
    for i, pattern in enumerate(patterns):
        print(f"[*] Test {i+1}/{len(patterns)}: {pattern[:50]}...")
        
        try:
            # Exécution avec timeout
            result = subprocess.run(
                ["./vuln_fuzz", pattern],
                timeout=2,
                capture_output=True,
                text=True
            )
            
            if result.returncode != 0:
                print(f"[!] Crash avec pattern {i}: {result.returncode}")
                with open(f"crash_pattern_{i}.txt", "w") as f:
                    f.write(pattern)
                    
        except subprocess.TimeoutExpired:
            print(f"[*] Timeout avec pattern {i}")
        except Exception as e:
            print(f"[!] Erreur: {e}")

if __name__ == "__main__":
    print("=== PCTAMALOU Fuzzing Lab ===")
    print("1. Fuzzing avancé avec boofuzz")
    print("2. Fuzzing simple avec patterns prédéfinis")
    
    choice = input("Choix [1/2]: ").strip()
    
    if choice == "1":
        fuzz_local_program()
    else:
        simple_process_fuzzer()Copier

Étape 4 : Analyse des Crashes

# 1. Reproduire le crash avec le même input
cat crash_123.txt
./vuln_fuzz "$(cat crash_123.txt)"

# 2. Analyse avec GDB
gdb -q ./vuln_fuzz
(gdb) run "$(cat crash_123.txt)"
(gdb) backtrace full     # Affiche la pile d'appel
(gdb) info registers     # Registres au moment du crash
(gdb) x/20x $rsp        # Examine la stack
(gdb) disas              # Désassemble autour de EIP/RIP

# 3. Analyse avec ASAN (si compilé avec)
./vuln_fuzz_asan "$(cat crash_123.txt)"

# 4. Minification de l'input (trouver le minimum qui crash)
python3 -c "
input_data = open('crash_123.txt', 'r').read()
for i in range(len(input_data), 0, -1):
    test = input_data[:i]
    # Tester si ça crash toujours
    # (implémenter la logique de test)
"Copier

Étape 5 : Fuzzing Coverage-Guided avec AFL++

# Installation AFL++
sudo apt install afl++ -y

# Compilation avec instrumentation AFL
afl-gcc -g -o vuln_fuzz_afl vuln_fuzz.c

# Création du corpus initial
mkdir -p afl_inputs afl_outputs
echo "test" > afl_inputs/seed1.txt
echo "A"*100 > afl_inputs/seed2.txt

# Lancement du fuzzer
afl-fuzz -i afl_inputs -o afl_outputs -- ./vuln_fuzz_afl @@

# @@ sera remplacé par le fichier d'input

Exercice Pratique : Challenge de Fuzzing

// challenge.c - Programme avec bugs cachés
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct User {
    char name[50];
    int id;
    void (*print)(struct User*);
};

void print_user(struct User *u) {
    printf("User: %s (ID: %d)\n", u->name, u->id);
}

void bug1(char *input) {
    // TODO: Implémenter buffer overflow
}

void bug2(int count) {
    // TODO: Implémenter integer overflow
}

void bug3(char *format) {
    // TODO: Implémenter format string vulnérabilité
}

int main(int argc, char **argv) {
    // Appeler différentes fonctions basées sur l'input
    // Votre mission: trouver les 3 bugs via fuzzing
    return 0;
}