LibAFL
LibAFL est une bibliothèque de fuzzing modulaire qui implémente les fonctionnalités des fuzzers basés sur AFL comme AFL++. Contrairement aux fuzzers traditionnels, LibAFL fournit toutes ses fonctionnalités de manière modulaire et personnalisable sous forme de bibliothèque Rust. Il peut être utilisé comme un remplacement direct de libFuzzer ou comme une bibliothèque pour construire des fuzzers personnalisés à partir de zéro.
Quand l'utiliser
| Fuzzer | Meilleur pour | Complexité |
|---|---|---|
| libFuzzer | Configuration rapide, monothread | Faible |
| AFL++ | Multi-cœur, usage général | Moyenne |
| LibAFL | Fuzzers personnalisés, fonctionnalités avancées, recherche | Élevée |
Choisissez LibAFL quand :
- Vous avez besoin de stratégies de mutation ou de mécanismes de feedback personnalisés
- Les fuzzers standard ne prennent pas en charge l'architecture de votre cible
- Vous souhaitez implémenter des techniques de fuzzing innovantes
- Vous avez besoin d'un contrôle fin sur les composants du fuzzer
- Vous menez des recherches en fuzzing
Démarrage rapide
LibAFL peut être utilisé comme remplacement direct de libFuzzer avec une configuration minimale :
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// Appelez votre code avec les données fournies par le fuzzer
my_function(data, size);
return 0;
}
Construisez la couche de compatibilité libFuzzer de LibAFL :
git clone https://github.com/AFLplusplus/LibAFL
cd LibAFL/libafl_libfuzzer_runtime
./build.sh
Compilez et exécutez :
clang++ -DNO_MAIN -g -O2 -fsanitize=fuzzer-no-link libFuzzer.a harness.cc main.cc -o fuzz
./fuzz corpus/
Installation
Prérequis
- Clang/LLVM 15-18
- Rust (via rustup)
- Dépendances système supplémentaires
Linux/macOS
Installez Clang :
apt install clang
Ou installez une version spécifique via apt.llvm.org :
wget https://apt.llvm.org/llvm.sh
chmod +x llvm.sh
sudo ./llvm.sh 15
Configurez l'environnement pour Rust :
export RUSTFLAGS="-C linker=/usr/bin/clang-15"
export CC="clang-15"
export CXX="clang++-15"
Installez Rust :
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Installez les dépendances supplémentaires :
apt install libssl-dev pkg-config
Pour le mode de compatibilité libFuzzer, installez la version nightly de Rust :
rustup toolchain install nightly --component llvm-tools
Vérification
Construisez LibAFL pour vérifier l'installation :
cd LibAFL/libafl_libfuzzer_runtime
./build.sh
# Devrait produire libFuzzer.a
Écrire un harnais (Harness)
Les harnais LibAFL suivent le même modèle que libFuzzer lorsqu'on utilise le mode de remplacement direct :
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// Votre code cible de fuzzing ici
return 0;
}
Lors de la construction de fuzzers personnalisés avec LibAFL en tant que bibliothèque Rust, la logique du harnais est intégrée directement dans le fuzzer. Voir la section « Écrire un fuzzer personnalisé » ci-dessous pour le modèle complet.
Voir aussi : Pour des techniques détaillées d'écriture de harnais, consultez la compétence technique harness-writing.
Modes d'utilisation
LibAFL prend en charge deux modes d'utilisation principaux :
1. Remplacement direct de libFuzzer
Utilisez LibAFL comme remplacement de libFuzzer avec des harnais existants.
Compilation :
clang++ -DNO_MAIN -g -O2 -fsanitize=fuzzer-no-link libFuzzer.a harness.cc main.cc -o fuzz
Exécution :
./fuzz corpus/
Recommandé pour les longues campagnes :
./fuzz -fork=1 -ignore_crashes=1 corpus/
2. Fuzzer personnalisé en tant que bibliothèque Rust
Construisez un fuzzer entièrement personnalisé en utilisant les composants LibAFL.
Créez un projet :
cargo init --lib my_fuzzer
cd my_fuzzer
cargo add [email protected] [email protected] [email protected] [email protected] \
--features "[email protected]/libfuzzer,[email protected]/sancov_pcguard_hitcounts"
Configurez Cargo.toml :
[lib]
crate-type = ["staticlib"]
Écrire un fuzzer personnalisé
Voir aussi : Pour des techniques détaillées d'écriture de harnais, des modèles de gestion d'entrées complexes et des stratégies avancées, consultez la compétence technique fuzz-harness-writing.
Composants du fuzzer
Un fuzzer LibAFL se compose de composants modulaires :
- Observateurs - Collectent les retours d'exécution (couverture, timing)
- Feedback - Détermine si les entrées sont intéressantes
- Objectif - Définit les buts du fuzzing (plantages, timeouts)
- État - Maintient le corpus et les métadonnées
- Mutateurs - Génèrent de nouvelles entrées
- Planificateur - Sélectionne les entrées à muter
- Exécuteur - Exécute la cible avec les entrées
Structure de base du fuzzer
use libafl::prelude::*;
use libafl_bolts::prelude::*;
use libafl_targets::{libfuzzer_test_one_input, std_edges_map_observer};
#[no_mangle]
pub extern "C" fn libafl_main() {
let mut run_client = |state: Option<_>, mut restarting_mgr, _core_id| {
// 1. Configurer les observateurs
let edges_observer = HitcountsMapObserver::new(
unsafe { std_edges_map_observer("edges") }
).track_indices();
let time_observer = TimeObserver::new("time");
// 2. Définir le feedback
let mut feedback = feedback_or!(
MaxMapFeedback::new(&edges_observer),
TimeFeedback::new(&time_observer)
);
// 3. Définir l'objectif
let mut objective = feedback_or_fast!(
CrashFeedback::new(),
TimeoutFeedback::new()
);
// 4. Créer ou restaurer l'état
let mut state = state.unwrap_or_else(|| {
StdState::new(
StdRand::new(),
InMemoryCorpus::new(),
OnDiskCorpus::new(&output_dir).unwrap(),
&mut feedback,
&mut objective,
).unwrap()
});
// 5. Configurer le mutateur
let mutator = StdScheduledMutator::new(havoc_mutations());
let mut stages = tuple_list!(StdMutationalStage::new(mutator));
// 6. Configurer le planificateur
let scheduler = IndexesLenTimeMinimizerScheduler::new(
&edges_observer,
QueueScheduler::new()
);
// 7. Créer le fuzzer
let mut fuzzer = StdFuzzer::new(scheduler, feedback, objective);
// 8. Définir le harnais
let mut harness = |input: &BytesInput| {
let buf = input.target_bytes().as_slice();
libfuzzer_test_one_input(buf);
ExitKind::Ok
};
// 9. Configurer l'exécuteur
let mut executor = InProcessExecutor::with_timeout(
&mut harness,
tuple_list!(edges_observer, time_observer),
&mut fuzzer,
&mut state,
&mut restarting_mgr,
timeout,
)?;
// 10. Charger les entrées initiales
if state.must_load_initial_inputs() {
state.load_initial_inputs(
&mut fuzzer,
&mut executor,
&mut restarting_mgr,
&input_dir
)?;
}
// 11. Démarrer le fuzzing
fuzzer.fuzz_loop(&mut stages, &mut executor, &mut state, &mut restarting_mgr)?;
Ok(())
};
// Lancer le fuzzer
Launcher::builder()
.run_client(&mut run_client)
.cores(&cores)
.build()
.launch()
.unwrap();
}
Compilation
Mode verbeux
Spécifiez manuellement tous les drapeaux d'instrumentation :
clang++-15 -DNO_MAIN -g -O2 \
-fsanitize-coverage=trace-pc-guard \
-fsanitize=address \
-Wl,--whole-archive target/release/libmy_fuzzer.a -Wl,--no-whole-archive \
main.cc harness.cc -o fuzz
Wrapper de compilation (Recommandé)
Créez un wrapper de compilation LibAFL pour gérer l'instrumentation automatiquement.
Créez src/bin/libafl_cc.rs :
use libafl_cc::{ClangWrapper, CompilerWrapper, Configuration, ToolWrapper};
pub fn main() {
let args: Vec<String> = env::args().collect();
let mut cc = ClangWrapper::new();
cc.cpp(is_cpp)
.parse_args(&args)
.link_staticlib(&dir, "my_fuzzer")
.add_args(&Configuration::GenerateCoverageMap.to_flags().unwrap())
.add_args(&Configuration::AddressSanitizer.to_flags().unwrap())
.run()
.unwrap();
}
Compilez et utilisez :
cargo build --release
target/release/libafl_cxx -DNO_MAIN -g -O2 main.cc harness.cc -o fuzz
Voir aussi : Pour une configuration détaillée des sanitizers, les problèmes courants et les drapeaux avancés, consultez les compétences techniques address-sanitizer et undefined-behavior-sanitizer.
Exécuter des campagnes
Exécution de base
./fuzz --cores 0 --input corpus/
Fuzzing multi-cœur
./fuzz --cores 0,8-15 --input corpus/
Cela lance 9 clients : un sur le cœur 0, et 8 sur les cœurs 8-15.
Avec options
./fuzz --cores 0-7 --input corpus/ --output crashes/ --timeout 1000
Interface utilisateur textuelle (TUI)
Activez la vue graphique des statistiques :
./fuzz -tui=1 corpus/
Interprétation des résultats
| Sortie | Signification |
|---|---|
corpus: N | Nombre de cas de test intéressants trouvés |
objectives: N | Nombre de plantages/timeouts trouvés |
executions: N | Nombre total d'invocations de la cible |
exec/sec: N | Débit d'exécution actuel |
edges: X% | Pourcentage de couverture de code |
clients: N | Nombre de processus de fuzzing parallèles |
Le fuzzer émet deux principaux types d'événements :
- UserStats - Pulsation régulière avec les statistiques actuelles
- Testcase - Nouvelle entrée intéressante découverte
Utilisation avancée
Astuces et conseils
| Astuce | Pourquoi c'est utile |
|---|---|
Utilisez -fork=1 -ignore_crashes=1 | Continuer le fuzzing après le premier plantage |
Utilisez InMemoryOnDiskCorpus | Persister le corpus entre les redémarrages |
Activez TUI avec -tui=1 | Meilleure visualisation de la progression |
| Utilisez une version spécifique de LLVM | Évitez les problèmes de compatibilité |
Définissez RUSTFLAGS correctement | Évitez les erreurs de linkage |
Déduplication des plantages
Évitez de stocker des plantages en double provenant du même bogue :
Ajoutez un observateur de backtrace :
let backtrace_observer = BacktraceObserver::owned(
"BacktraceObserver",
libafl::observers::HarnessType::InProcess
);
Mettez à jour l'exécuteur :
let mut executor = InProcessExecutor::with_timeout(
&mut harness,
tuple_list!(edges_observer, time_observer, backtrace_observer),
&mut fuzzer,
&mut state,
&mut restarting_mgr,
timeout,
)?;
Mettez à jour l'objectif avec le feedback de hachage :
let mut objective = feedback_and!(
feedback_or_fast!(CrashFeedback::new(), TimeoutFeedback::new()),
NewHashFeedback::new(&backtrace_observer)
);
Cela garantit que seuls les plantages avec des backtraces uniques sont sauvegardés.
Fuzzing par dictionnaire
Utilisez des dictionnaires pour guider le fuzzing vers des jetons spécifiques :
Ajoutez des jetons depuis un fichier :
let mut tokens = Tokens::new();
if let Some(tokenfile) = &tokenfile {
tokens.add_from_file(tokenfile)?;
}
state.add_metadata(tokens);
Mettez à jour le mutateur :
let mutator = StdScheduledMutator::new(
havoc_mutations().merge(tokens_mutations())
);
Exemple de jetons codés en dur (PNG) :
state.add_metadata(Tokens::from([
vec![137, 80, 78, 71, 13, 10, 26, 10], // En-tête PNG
"IHDR".as_bytes().to_vec(),
"IDAT".as_bytes().to_vec(),
"PLTE".as_bytes().to_vec(),
"IEND".as_bytes().to_vec(),
]));
Voir aussi : Pour des stratégies détaillées de création de dictionnaires et des dictionnaires spécifiques aux formats, consultez la compétence technique fuzzing-dictionaries.
Jetons automatiques
Extrayez automatiquement les valeurs magiques et les sommes de contrôle du programme :
Activez dans le wrapper de compilation :
cc.add_pass(LLVMPasses::AutoTokens)
Chargez les jetons automatiques dans le fuzzer :
tokens += libafl_targets::autotokens()?;
Vérifiez la section des jetons :
echo "p (uint8_t *)__token_start" | gdb fuzz
Réglage des performances
| Paramètre | Impact |
|---|---|
| Fuzzing multi-cœur | Accélération linéaire avec le nombre de cœurs |
InMemoryCorpus | Plus rapide mais non persistant |
InMemoryOnDiskCorpus | Vitesse et persistance équilibrées |
| Sanitizers | Ralentissement de 2 à 5 fois, essentiel pour les bogues |
Niveau d'optimisation -O2 | Équilibre entre vitesse et couverture |
Déboguer le fuzzer
Exécutez le fuzzer en mode mono-processus pour un débogage plus facile :
// Remplacez le lanceur par un appel direct
run_client(None, SimpleEventManager::new(monitor), 0).unwrap();
// Commentez :
// Launcher::builder()
// .run_client(&mut run_client)
// ...
// .launch()
Ensuite, déboguez avec GDB :
gdb --args ./fuzz --cores 0 --input corpus/
Exemples concrets
Exemple : libpng
Fuzzing de libpng avec LibAFL :
1. Obtenez le code source :
curl -L -O https://downloads.sourceforge.net/project/libpng/libpng16/1.6.37/libpng-1.6.37.tar.xz
tar xf libpng-1.6.37.tar.xz
cd libpng-1.6.37/
apt install zlib1g-dev
2. Définissez le wrapper de compilation :
export FUZZER_CARGO_DIR="/path/to/libafl/project"
export CC=$FUZZER_CARGO_DIR/target/release/libafl_cc
export CXX=$FUZZER_CARGO_DIR/target/release/libafl_cxx
3. Construisez la bibliothèque statique :
./configure --enable-shared=no
make
4. Obtenez le harnais :
curl -O https://raw.githubusercontent.com/glennrp/libpng/f8e5fa92b0e37ab597616f554bee254157998227/contrib/oss-fuzz/libpng_read_fuzzer.cc
5. Liez le fuzzer :
$CXX libpng_read_fuzzer.cc .libs/libpng16.a -lz -o fuzz
6. Préparez les graines :
mkdir seeds/
curl -o seeds/input.png https://raw.githubusercontent.com/glennrp/libpng/acfd50ae0ba3198ad734e5d4dec2b05341e50924/contrib/pngsuite/iftp1n3p08.png
7. Obtenez le dictionnaire (optionnel) :
curl -O https://raw.githubusercontent.com/glennrp/libpng/2fff013a6935967960a5ae626fc21432807933dd/contrib/oss-fuzz/png.dict
8. Commencez le fuzzing :
./fuzz --input seeds/ --cores 0 -x png.dict
Exemple : Projet CMake
Intégrez LibAFL avec le système de build CMake :
CMakeLists.txt :
project(BuggyProgram)
cmake_minimum_required(VERSION 3.0)
add_executable(buggy_program main.cc)
add_executable(fuzz main.cc harness.cc)
target_compile_definitions(fuzz PRIVATE NO_MAIN=1)
target_compile_options(fuzz PRIVATE -g -O2)
Construisez le binaire non instrumenté :
cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ .
cmake --build . --target buggy_program
Construisez le fuzzer :
export FUZZER_CARGO_DIR="/..."