Que fait AFL++ ?
AFL++ est un fork du fuzzer original AFL qui offre de meilleures performances de fuzzing et des fonctionnalités plus avancées tout en maintenant la stabilité. Un avantage majeur par rapport à libFuzzer est qu'AFL++ prend en charge de manière stable l'exécution de campagnes de fuzzing sur plusieurs cœurs, ce qui le rend idéal pour les efforts de fuzzing à grande échelle.
Quand l'utiliser
| Fuzzer | Idéal pour | Complexité |
|---|---|---|
| AFL++ | Fuzzing multi-cœur, mutations diverses, projets matures | Moyenne |
| libFuzzer | Configuration rapide, mono-thread, harnais simples | Faible |
| LibAFL | Fuzzers personnalisés, recherche, cas d'utilisation avancés | Élevée |
Choisissez AFL++ quand :
- Vous avez besoin de fuzzing multi-cœur pour maximiser le débit
- Votre projet peut être compilé avec Clang ou GCC
- Vous souhaitez des stratégies de mutation diverses et des outils matures
- libFuzzer a atteint un plateau et vous avez besoin de plus de couverture
- Vous fuzzez des codebases de production qui bénéficient de l'exécution parallèle
Démarrage rapide
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// Appelez votre code avec les données fournies par le fuzzer
check_buf((char*)data, size);
return 0;
}
Compilez et exécutez :
# Configurez d'abord le script wrapper AFL++ (voir Installation)
./afl++ docker afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
mkdir seeds && echo "aaaa" > seeds/minimal_seed
./afl++ docker afl-fuzz -i seeds -o out -- ./fuzz
Installation
AFL++ a de nombreuses dépendances, notamment LLVM, Python et Rust. Nous recommandons d'utiliser une distribution Debian ou Ubuntu récente pour le fuzzing avec AFL++.
| Méthode | Quand l'utiliser | Compilateurs supportés |
|---|---|---|
| Dépôts Ubuntu/Debian | Ubuntu récent, fonctionnalités de base seulement | Ubuntu 23.10 : Clang 14 & GCC 13Debian 12 : Clang 14 & GCC 12 |
| Docker (depuis Docker Hub) | Version spécifique d'AFL++, support Apple Silicon | Depuis 4.35c : Clang 19 & GCC 11 |
| Docker (depuis les sources) | Tester des fonctionnalités non publiées, appliquer des correctifs | Configurable dans le Dockerfile |
| Depuis les sources | Éviter Docker, besoin de correctifs spécifiques | Ajustable via la variable d'environnement LLVM_CONFIG |
Ubuntu/Debian
Avant d'installer afl++, vérifiez la dépendance de version de clang du paquet avec apt-cache show afl++, et installez la version correspondante de lld (par exemple, lld-17).
apt install afl++ lld-17
Docker (depuis Docker Hub)
docker pull aflplusplus/aflplusplus:stable
Docker (depuis les sources)
git clone --depth 1 --branch stable https://github.com/AFLplusplus/AFLplusplus
cd AFLplusplus
docker build -t aflplusplus .
Depuis les sources
Référez-vous au Dockerfile pour les prérequis de version Ubuntu et les dépendances. Définissez LLVM_CONFIG pour spécifier la version de Clang (par exemple, llvm-config-18).
Configuration du script wrapper
Créez un script wrapper pour exécuter AFL++ sur l'hôte ou dans Docker :
cat <<'EOF' > ./afl++
#!/bin/sh
AFL_VERSION="${AFL_VERSION:-"stable"}"
case "$1" in
host)
shift
bash -c "$*"
;;
docker)
shift
/usr/bin/env docker run -ti \
--privileged \
-v ./:/src \
--rm \
--name afl_fuzzing \
"aflplusplus/aflplusplus:$AFL_VERSION" \
bash -c "cd /src && bash -c \"$*\""
;;
*)
echo "Usage: $0 {host|docker}"
exit 1
;;
esac
EOF
chmod +x ./afl++
Avertissement de sécurité : Les scripts afl-system-config et afl-persistent-config nécessitent des privilèges root et désactivent les fonctionnalités de sécurité du système d'exploitation. Ne fuzzez pas sur des systèmes de production ou votre environnement de développement. Utilisez plutôt une VM dédiée.
Configuration système
Exécutez après chaque redémarrage pour jusqu'à 15% d'exécutions supplémentaires par seconde :
./afl++ <host/docker> afl-system-config
Pour des performances maximales, désactivez les atténuations de sécurité du noyau (nécessite le chargeur d'amorçage grub, non supporté dans Docker) :
./afl++ host afl-persistent-config
update-grub
reboot
./afl++ <host/docker> afl-system-config
Vérifiez avec cat /proc/cmdline - la sortie doit inclure mitigations=off.
Écrire un harnais
Structure du harnais
AFL++ prend en charge les harnais de style libFuzzer :
#include <stdint.h>
#include <stddef.h>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// 1. Validez la taille d'entrée si nécessaire
if (size < MIN_SIZE || size > MAX_SIZE) return 0;
// 2. Appelez la fonction cible avec les données de fuzz
target_function(data, size);
// 3. Retournez 0 (non nul réservé pour une utilisation future)
return 0;
}
Règles du harnais
| À faire | À ne pas faire |
|---|---|
| Réinitialiser l'état global entre les exécutions | Dépendre de l'état des exécutions précédentes |
| Gérer les cas limites avec élégance | Quitter sur une entrée invalide |
| Garder le harnais déterministe | Utiliser des générateurs de nombres aléatoires |
| Libérer la mémoire allouée | Créer des fuites de mémoire |
| Valider les tailles d'entrée | Traiter des entrées non limitées |
Voir aussi : Pour des techniques détaillées d'écriture de harnais, des motifs pour gérer des entrées complexes, et des stratégies avancées, consultez la compétence technique fuzz-harness-writing.
Compilation
AFL++ offre plusieurs modes de compilation avec différents compromis.
Arbre de décision du mode de compilation
Choisissez votre mode de compilation :
- Mode LTO (
afl-clang-lto) : Meilleures performances et instrumentation. Essayez d'abord. - Mode LLVM (
afl-clang-fast) : Solution de repli si LTO échoue à compiler. - Plugin GCC (
afl-gcc-fast) : Pour les projets nécessitant GCC.
Compilation de base (mode LLVM)
./afl++ <host/docker> afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Compilation avec GCC
./afl++ <host/docker> afl-g++-fast -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Important : La version de GCC doit correspondre à celle utilisée pour compiler le plugin GCC d'AFL++.
Avec des sanitizers
./afl++ <host/docker> AFL_USE_ASAN=1 afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Voir aussi : Pour une configuration détaillée des sanitizers, des problèmes courants et des indicateurs avancés, consultez les compétences techniques address-sanitizer et undefined-behavior-sanitizer.
Indicateurs de compilation
Notez que -g n'est pas nécessaire, il est ajouté par défaut par les compilateurs AFL++.
| Indicateur | Objectif |
|---|---|
-DNO_MAIN=1 | Ignorer la fonction main lors de l'utilisation d'un harnais libFuzzer |
-O2 | Niveau d'optimisation de production (recommandé pour le fuzzing) |
-fsanitize=fuzzer | Activer le mode de compatibilité libFuzzer et ajoute l'exécution du fuzzer lors de la liaison de l'exécutable |
-fsanitize=fuzzer-no-link | Instrumenter sans lier l'exécution du fuzzer (pour les bibliothèques statiques et les fichiers objets) |
Gestion du corpus
Création du corpus initial
AFL++ nécessite au moins un fichier de seed non vide :
mkdir seeds
echo "aaaa" > seeds/minimal_seed
Pour des projets réels, rassemblez des entrées représentatives :
- Téléchargez des exemples de fichiers pour le format que vous fuzzez
- Extrayez des cas de test de la suite de tests du projet
- Utilisez des entrées valides minimales pour votre format de fichier
Minimisation du corpus
Après une campagne, minimisez le corpus pour ne conserver que la couverture unique :
./afl++ <host/docker> afl-cmin -i out/default/queue -o minimized_corpus -- ./fuzz
Voir aussi : Pour des stratégies de création de corpus, des dictionnaires et la sélection de seeds, consultez la compétence technique fuzzing-corpus.
Exécution de campagnes
Exécution de base
./afl++ <host/docker> afl-fuzz -i seeds -o out -- ./fuzz
Définition de variables d'environnement
./afl++ <host/docker> AFL_FAST_CAL=1 afl-fuzz -i seeds -o out -- ./fuzz
Interprétation de la sortie
L'interface AFL++ affiche des statistiques de fuzzing en temps réel :
| Sortie | Signification |
|---|---|
| execs/sec | Vitesse d'exécution - plus élevé est meilleur |
| cycles done | Nombre de passages de file d'attente terminés |
| corpus count | Nombre de cas de test uniques dans la file d'attente |
| saved crashes | Nombre de plantages uniques trouvés |
| stability | % d'arêtes stables (doit être proche de 100%) |
Structure du répertoire de sortie
out/default/
├── cmdline # Comment le SUT a-t-il été invoqué ?
├── crashes/ # Entrées qui plantent le SUT
│ └── id:000000,sig:06,src:000002,time:286,execs:13105,op:havoc,rep:4
├── hangs/ # Entrées qui bloquent le SUT
├── queue/ # Cas de test reproduisant l'état final du fuzzer
│ ├── id:000000,time:0,execs:0,orig:minimal_seed
│ └── id:000001,src:000000,time:0,execs:8,op:havoc,rep:6,+cov
├── fuzzer_stats # Statistiques de la campagne
└── plot_data # Données pour le tracé
Analyse des résultats
Consultez les statistiques de campagne en direct :
./afl++ <host/docker> afl-whatsup out
Créez des graphiques de couverture :
apt install gnuplot
./afl++ <host/docker> afl-plot out/default out_graph/
Ré-exécution de cas de test
./afl++ <host/docker> ./fuzz out/default/crashes/<test_case>
Options du fuzzer
| Option | Objectif |
|---|---|
-G 4000 | Longueur maximale de l'entrée de test (par défaut : 1048576 octets) |
-t 1000 | Délai d'attente en millisecondes pour chaque cas de test (par défaut : 1000ms) |
-m 1000 | Limite de mémoire en mégaoctets (par défaut : 0 = illimité) |
-x ./dict.dict | Utiliser un fichier dictionnaire pour guider les mutations |
Fuzzing multi-cœur
AFL++ excelle dans le fuzzing multi-cœur avec deux avantages majeurs :
- Plus d'exécutions par seconde (évolue linéairement avec les cœurs physiques)
- Fuzzing asymétrique (par exemple, un job ASan, les autres sans sanitizers)
Démarrage d'une campagne
Lancez le fuzzer principal (en arrière-plan) :
./afl++ <host/docker> afl-fuzz -M primary -i seeds -o state -- ./fuzz 1>primary.log 2>primary.error &
Lancez les fuzzers secondaires (autant que de cœurs) :
./afl++ <host/docker> afl-fuzz -S secondary01 -i seeds -o state -- ./fuzz 1>secondary01.log 2>secondary01.error &
./afl++ <host/docker> afl-fuzz -S secondary02 -i seeds -o state -- ./fuzz 1>secondary02.log 2>secondary02.error &
Surveillance des campagnes multi-cœur
Listez tous les jobs en cours :
jobs
Consultez les statistiques en direct (mise à jour chaque seconde) :
./afl++ <host/docker> watch -n1 --color afl-whatsup state/
Arrêt de tous les fuzzers
kill $(jobs -p)
Analyse de couverture
AFL++ suit automatiquement la couverture via une instrumentation des arêtes. Les informations de couverture sont stockées dans fuzzer_stats et plot_data.
Mesure de la couverture
Utilisez afl-plot pour visualiser la couverture au fil du temps :
./afl++ <host/docker> afl-plot out/default out_graph/
Amélioration de la couverture
- Utilisez des dictionnaires pour un fuzzing conscient du format
- Lancez des campagnes plus longues (cycles_wo_finds indique un plateau)
- Essayez différentes stratégies de mutation avec le fuzzing multi-cœur
- Analysez les lacunes de couverture et ajoutez des entrées de seed ciblées
Voir aussi : Pour des techniques détaillées d'analyse de couverture, d'identification des lacunes de couverture, et d'amélioration systématique de la couverture, consultez la compétence technique coverage-analysis.
CMPLOG
CMPLOG/RedQueen est le meilleur mécanisme de résolution de contraintes de chemin disponible dans tout fuzzer. Pour l'activer, la cible de fuzz doit être instrumentée pour cela. Avant de construire la cible de fuzzing, définissez la variable d'environnement :
./afl++ <host/docker> AFL_LLVM_CMPLOG=1 make
Aucune action spéciale n'est nécessaire pour compiler et lier le harnais.
Pour exécuter une instance de fuzzer avec une cible de fuzzing instrumentée CMPLOG, ajoutez -c0 aux arguments de la commande :
./afl++ <host/docker> afl-fuzz -c0 -S cmplog -i seeds -o state -- ./fuzz 1>secondary02.log 2>secondary02.error &
Intégration des sanitizers
Les sanitizers sont essentiels pour trouver des bugs de corruption mémoire qui ne provoquent pas de plantage immédiat.
AddressSanitizer (ASan)
./afl++ <host/docker> AFL_USE_ASAN=1 afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Remarque : La limite de mémoire (-m) n'est pas supportée avec ASan en raison de la réservation de mémoire virtuelle de 20 To.
UndefinedBehaviorSanitizer (UBSan)
./afl++ <host/docker> AFL_USE_UBSAN=1 afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer,undefined harness.cc main.cc -o fuzz
Problèmes courants des sanitizers
| Problème | Solution |
|---|---|
| ASan ralentit le fuzzing | Utilisez seulement 1 job ASan dans une configuration multi-cœur |
| Épuisement de la pile | Augmentez la pile avec ASAN_OPTIONS=stack_size=... |
| Incompatibilité de version GCC | Assurez-vous que le GCC système correspond à la version du plugin AFL++ |
Voir aussi : Pour une configuration complète des sanitizers et le dépannage, consultez la compétence technique address-sanitizer.
Utilisation avancée
Astuces et conseils
| Astuce | Pourquoi ça aide |
|---|---|
| Utilisez des harnais LLVMFuzzerTestOneInput si possible | Si une campagne de fuzzing a au moins 85% de stabilité, c'est le style de fuzzing le plus efficace. Sinon, essayez le fuzzing d'entrée standard ou de fichier |
| Utilisez des dictionnaires | Aide le fuzzer à découvrir des mots-clés spécifiques au format et des octets magiques |
| Définissez des délais d'attente réalistes | Empêche les faux positifs dus à la charge système |
| Limitez la taille d'entrée | Les entrées plus grandes n'explorent pas nécessairement plus d'espace |
| Surveillez la stabilité | Une faible stabilité indique un comportement non déterministe |
Fuzzing d'entrée standard
AFL++ peut fuzzer des programmes lisant depuis stdin sans harnais libFuzzer :
./afl++ <host/docker> afl-clang-fast++ -O2 main_stdin.c -o fuzz_stdin
./afl++ <host/docker> afl-fuzz -i seeds -o out -- ./fuzz_stdin
C'est plus lent que le mode persistant mais ne nécessite aucun code de harnais.
Fuzzing d'entrée fichier
Pour les programmes qui lisent des fichiers, utilisez le paramètre @@ :
./afl++ <host/docker> afl-clang-fast++ -O2 main_file.c -o fuzz_file
./afl++ <host/docker> afl-fuzz -i seeds -o out -- ./fuzz_file @@
Pour de meilleures performances, utilisez fmemopen pour créer des descripteurs de fichier à partir de la mémoire.
Fuzzing d'arguments
Fuzzez les arguments de ligne de commande en utilisant argv-fuzz-inl.h :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef __AFL_COMPILER
#include "argv-fuzz-inl.h"
#endif
void check_buf(char *buf, size_t buf_len) {
if(buf_len > 0 && buf[0] == 'a') {
if(buf_len > 1 && buf[1] == 'b') {
if(buf_len > 2 && buf[2] == 'c') {
abort();
}
...[tronqué pour la traduction]