Communitygithub.com

AFL++

AFL++ est un fork d'AFL offrant de meilleures performances de fuzzing et des fonctionnalités avancées pour le fuzzing multi-cœur de projets C/C++.

Qu'est-ce que AFL++ ?

AFL++ est un fuzzer puissant, fork d'AFL, conçu pour le fuzzing de code C/C++ avec des performances améliorées et des fonctionnalités avancées. Il se distingue par sa prise en charge stable et efficace du fuzzing multi-cœur, permettant de maximiser le débit sur les projets à grande échelle. Le skill couvre l'installation via Docker, les dépôts Ubuntu/Debian ou la compilation depuis les sources, avec un script wrapper facilitant l'exécution en environnement hôte ou conteneurisé. Il propose des modes de compilation LTO, LLVM et GCC, l'intégration de sanitizers (ASan, UBSan), la gestion de corpus, l'analyse de couverture, et le mécanisme CMPLOG/RedQueen pour la résolution de contraintes. Ce skill est idéal pour les développeurs cherchant à sécuriser leurs codebases en production grâce à un fuzzing robuste et parallélisable.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/SamuelChien/mega-skills-collection/tree/HEAD/aflpp

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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

FuzzerIdéal pourComplexité
AFL++Fuzzing multi-cœur, mutations diverses, projets maturesMoyenne
libFuzzerConfiguration rapide, mono-thread, harnais simplesFaible
LibAFLFuzzers 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éthodeQuand l'utiliserCompilateurs supportés
Dépôts Ubuntu/DebianUbuntu récent, fonctionnalités de base seulementUbuntu 23.10 : Clang 14 & GCC 13Debian 12 : Clang 14 & GCC 12
Docker (depuis Docker Hub)Version spécifique d'AFL++, support Apple SiliconDepuis 4.35c : Clang 19 & GCC 11
Docker (depuis les sources)Tester des fonctionnalités non publiées, appliquer des correctifsConfigurable dans le Dockerfile
Depuis les sourcesÉviter Docker, besoin de correctifs spécifiquesAjustable 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écutionsDépendre de l'état des exécutions précédentes
Gérer les cas limites avec éléganceQuitter sur une entrée invalide
Garder le harnais déterministeUtiliser des générateurs de nombres aléatoires
Libérer la mémoire allouéeCréer des fuites de mémoire
Valider les tailles d'entréeTraiter 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++.

IndicateurObjectif
-DNO_MAIN=1Ignorer la fonction main lors de l'utilisation d'un harnais libFuzzer
-O2Niveau d'optimisation de production (recommandé pour le fuzzing)
-fsanitize=fuzzerActiver le mode de compatibilité libFuzzer et ajoute l'exécution du fuzzer lors de la liaison de l'exécutable
-fsanitize=fuzzer-no-linkInstrumenter 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 :

SortieSignification
execs/secVitesse d'exécution - plus élevé est meilleur
cycles doneNombre de passages de file d'attente terminés
corpus countNombre de cas de test uniques dans la file d'attente
saved crashesNombre 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

OptionObjectif
-G 4000Longueur maximale de l'entrée de test (par défaut : 1048576 octets)
-t 1000Délai d'attente en millisecondes pour chaque cas de test (par défaut : 1000ms)
-m 1000Limite de mémoire en mégaoctets (par défaut : 0 = illimité)
-x ./dict.dictUtiliser un fichier dictionnaire pour guider les mutations

Fuzzing multi-cœur

AFL++ excelle dans le fuzzing multi-cœur avec deux avantages majeurs :

  1. Plus d'exécutions par seconde (évolue linéairement avec les cœurs physiques)
  2. 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èmeSolution
ASan ralentit le fuzzingUtilisez seulement 1 job ASan dans une configuration multi-cœur
Épuisement de la pileAugmentez la pile avec ASAN_OPTIONS=stack_size=...
Incompatibilité de version GCCAssurez-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

AstucePourquoi ça aide
Utilisez des harnais LLVMFuzzerTestOneInput si possibleSi 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 dictionnairesAide le fuzzer à découvrir des mots-clés spécifiques au format et des octets magiques
Définissez des délais d'attente réalistesEmpêche les faux positifs dus à la charge système
Limitez la taille d'entréeLes 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]

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

SamuelChien/mega-skills-collection

Security audit, hardening, threat modeling (STRIDE/PASTA), Red/Blue Team, OWASP checks, code review, incident response, and infrastructure security for any project.

SamuelChien/mega-skills-collection

Arquitecto de Soluciones Principal y Consultor Tecnológico de Andru.ia. Diagnostica y traza la hoja de ruta óptima para proyectos de IA en español.

SamuelChien/mega-skills-collection

Ingeniero de Sistemas de Andru.ia. Diseña, redacta y despliega nuevas habilidades (skills) dentro del repositorio siguiendo el Estándar de Diamante.

SamuelChien/mega-skills-collection

Estratega de Inteligencia de Dominio de Andru.ia. Analiza el nicho específico de un proyecto para inyectar conocimientos, regulaciones y estándares únicos del sector. Actívalo tras definir el nicho.

SamuelChien/mega-skills-collection

2D game development principles. Sprites, tilemaps, physics, camera.

SamuelChien/mega-skills-collection

3D game development principles. Rendering, shaders, physics, cameras.

SamuelChien/mega-skills-collection

Expert in building 3D experiences for the web - Three.js, React Three Fiber, Spline, WebGL, and interactive 3D scenes. Covers product configurators, 3D portfolios, immersive websites, and bringing depth to web experiences.

SamuelChien/mega-skills-collection

Accessibility audit skill for scanning, fixing, and verifying WCAG 2.2 Level A and AA compliance across React, Next.js, Vue, Angular, Svelte, and plain HTML codebases. Use when auditing accessibility, fixing a11y violations, checking color contrast, generating compliance reports, or integrating accessibility checks into CI/CD pipelines.

SamuelChien/mega-skills-collection

Ab Test Analyzer - Auto-activating skill for Data Analytics. Triggers on: ab test analyzer, ab test analyzer Part of the Data Analytics skill category.

SamuelChien/mega-skills-collection

A B Test Config Creator - Auto-activating skill for ML Deployment. Triggers on: a b test config creator, a b test config creator Part of the ML Deployment skill category.

SamuelChien/mega-skills-collection

When the user wants to plan, design, or implement an A/B test or experiment. Also use when the user mentions "A/B test," "split test," "experiment," "test this change," "variant copy," "multivariate test," "hypothesis," "conversion experiment," "statistical significance," or "test this." For tracking implementation, see analytics-tracking.

SamuelChien/mega-skills-collection

Acceptance Criteria Creator - Auto-activating skill for Enterprise Workflows. Triggers on: acceptance criteria creator, acceptance criteria creator Part of the Enterprise Workflows skill category.

SamuelChien/mega-skills-collection

Use when a coding task should be driven end-to-end from issue intake through implementation, review, deployment, and acceptance verification with minimal human re-intervention.

SamuelChien/mega-skills-collection

Accessibility Audit Runner - Auto-activating skill for Frontend Development. Triggers on: accessibility audit runner, accessibility audit runner Part of the Frontend Development skill category.

SamuelChien/mega-skills-collection

You are an accessibility expert specializing in WCAG compliance, inclusive design, and assistive technology compatibility. Conduct audits, identify barriers, and provide remediation guidance.

SamuelChien/mega-skills-collection

Web accessibility patterns for WCAG 2.2 compliance including ARIA, keyboard navigation, screen readers, and testing

SamuelChien/mega-skills-collection

Manage Discord channel access — approve pairings, edit allowlists, set DM/group policy. Use when the user asks to pair, approve someone, check who's allowed, or change policy for the Discord channel.

SamuelChien/mega-skills-collection

Create unified specification packages across Business, Development, and Design teams. Staged elaboration (L0 Vision → L1 Requirements → L2 Team Detail → L3 Acceptance Criteria) to build shared understanding. Does not write code.

SamuelChien/mega-skills-collection

Research a company or person and get actionable sales intel. Works standalone with web search, supercharged when you connect enrichment tools or your CRM. Trigger with "research [company]", "look up [person]", "intel on [prospect]", "who is [name] at [company]", or "tell me about [company]".

SamuelChien/mega-skills-collection

Validate messaging consistency across website, GitHub repos, and local documentation generating read-only discrepancy reports. Use when checking content alignment or finding mixed messaging. Trigger with phrases like "check consistency", "validate documentation", or "audit messaging".

Skills associés