Was macht AFL++?
AFL++ ist ein Fork des ursprünglichen AFL-Fuzzers, der eine bessere Fuzzing-Leistung und erweiterte Funktionen bei gleichbleibender Stabilität bietet. Ein großer Vorteil gegenüber libFuzzer ist die stabile Unterstützung für Fuzzing-Kampagnen auf mehreren Kernen, was AFL++ ideal für groß angelegte Fuzzing-Bemühungen macht.
Wann verwenden
| Fuzzer | Am besten geeignet für | Komplexität |
|---|---|---|
| AFL++ | Multi-Core-Fuzzing, vielfältige Mutationen, ausgereifte Projekte | Mittel |
| libFuzzer | Schnelle Einrichtung, Single-Threaded, einfache Harnesse | Niedrig |
| LibAFL | Benutzerdefinierte Fuzzer, Forschung, fortgeschrittene Anwendungsfälle | Hoch |
Wählen Sie AFL++, wenn:
- Sie Multi-Core-Fuzzing benötigen, um den Durchsatz zu maximieren
- Ihr Projekt mit Clang oder GCC kompiliert werden kann
- Sie vielfältige Mutationsstrategien und ausgereifte Werkzeuge wünschen
- libFuzzer kein Plateau erreicht hat und Sie mehr Abdeckung benötigen
- Sie Produktionscodebasen fuzzen, die von paralleler Ausführung profitieren
Schnellstart
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// Rufen Sie Ihren Code mit den vom Fuzzer bereitgestellten Daten auf
check_buf((char*)data, size);
return 0;
}
Kompilieren und ausführen:
# Zuerst das AFL++-Wrapper-Skript einrichten (siehe 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++ hat viele Abhängigkeiten, darunter LLVM, Python und Rust. Wir empfehlen die Verwendung einer aktuellen Debian- oder Ubuntu-Distribution für das Fuzzing mit AFL++.
| Methode | Wann verwenden | Unterstützte Compiler |
|---|---|---|
| Ubuntu/Debian-Repos | Aktuelles Ubuntu, nur grundlegende Funktionen | Ubuntu 23.10: Clang 14 & GCC 13Debian 12: Clang 14 & GCC 12 |
| Docker (von Docker Hub) | Bestimmte AFL++-Version, Apple-Silicon-Unterstützung | Ab 4.35c: Clang 19 & GCC 11 |
| Docker (aus dem Quellcode) | Unveröffentlichte Funktionen testen, Patches anwenden | Konfigurierbar im Dockerfile |
| Aus dem Quellcode | Docker vermeiden, bestimmte Patches benötigen | Einstellbar über Umgebungsvariable LLVM_CONFIG |
Ubuntu/Debian
Überprüfen Sie vor der Installation von afl++ die Clang-Versionsabhängigkeit des Pakets mit apt-cache show afl++ und installieren Sie die passende lld-Version (z. B. lld-17).
apt install afl++ lld-17
Docker (von Docker Hub)
docker pull aflplusplus/aflplusplus:stable
Docker (aus dem Quellcode)
git clone --depth 1 --branch stable https://github.com/AFLplusplus/AFLplusplus
cd AFLplusplus
docker build -t aflplusplus .
Aus dem Quellcode
Lesen Sie das Dockerfile für die Ubuntu-Versionsanforderungen und Abhängigkeiten. Setzen Sie LLVM_CONFIG, um die Clang-Version anzugeben (z. B. llvm-config-18).
Einrichtung des Wrapper-Skripts
Erstellen Sie ein Wrapper-Skript, um AFL++ auf dem Host oder in Docker auszuführen:
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 "Verwendung: $0 {host|docker}"
exit 1
;;
esac
EOF
chmod +x ./afl++
Sicherheitswarnung: Die Skripte afl-system-config und afl-persistent-config benötigen Root-Rechte und deaktivieren Betriebssystem-Sicherheitsfunktionen. Verwenden Sie zum Fuzzing keine Produktionssysteme oder Ihre Entwicklungsumgebung. Verwenden Sie stattdessen eine dedizierte VM.
Systemkonfiguration
Führen Sie nach jedem Neustart Folgendes aus, um bis zu 15 % mehr Ausführungen pro Sekunde zu erzielen:
./afl++ <host/docker> afl-system-config
Für maximale Leistung deaktivieren Sie Kernel-Sicherheitsminderungen (erfordert GRUB-Bootloader, nicht in Docker unterstützt):
./afl++ host afl-persistent-config
update-grub
reboot
./afl++ <host/docker> afl-system-config
Überprüfen Sie mit cat /proc/cmdline – die Ausgabe sollte mitigations=off enthalten.
Schreiben eines Harness
Harness-Struktur
AFL++ unterstützt Harnesse im libFuzzer-Stil:
#include <stdint.h>
#include <stddef.h>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// 1. Eingabegröße ggf. validieren
if (size < MIN_SIZE || size > MAX_SIZE) return 0;
// 2. Zielfunktion mit Fuzz-Daten aufrufen
target_function(data, size);
// 3. 0 zurückgeben (ungleich Null für zukünftige Verwendung reserviert)
return 0;
}
Harness-Regeln
| Tun | Nicht tun |
|---|---|
| Globalen Zustand zwischen den Läufen zurücksetzen | Sich auf Zustand aus vorherigen Läufen verlassen |
| Randfälle elegant behandeln | Bei ungültiger Eingabe beenden |
| Harness deterministisch halten | Zufallszahlengeneratoren verwenden |
| Zugewiesenen Speicher freigeben | Speicherlecks erzeugen |
| Eingabegrößen validieren | Unbegrenzte Eingaben verarbeiten |
Siehe auch: Ausführliche Techniken zum Schreiben von Harnessen, Muster für die Verarbeitung komplexer Eingaben und fortgeschrittene Strategien finden Sie in der Technik-Fertigkeit fuzz-harness-writing.
Kompilierung
AFL++ bietet mehrere Kompilierungsmodi mit unterschiedlichen Kompromissen.
Entscheidungsbaum für den Kompilierungsmodus
Wählen Sie Ihren Kompilierungsmodus:
- LTO-Modus (
afl-clang-lto): Beste Leistung und Instrumentierung. Versuchen Sie dies zuerst. - LLVM-Modus (
afl-clang-fast): Fallback, wenn LTO nicht kompiliert werden kann. - GCC-Plugin (
afl-gcc-fast): Für Projekte, die GCC benötigen.
Grundlegende Kompilierung (LLVM-Modus)
./afl++ <host/docker> afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
GCC-Kompilierung
./afl++ <host/docker> afl-g++-fast -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Wichtig: Die GCC-Version muss mit der Version übereinstimmen, die zum Kompilieren des AFL++-GCC-Plugins verwendet wurde.
Mit Sanitizern
./afl++ <host/docker> AFL_USE_ASAN=1 afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Siehe auch: Ausführliche Sanitizer-Konfiguration, häufige Probleme und erweiterte Flags finden Sie in den Technik-Fertigkeiten address-sanitizer und undefined-behavior-sanitizer.
Build-Flags
Beachten Sie, dass -g nicht notwendig ist, da es von den AFL++-Compilern standardmäßig hinzugefügt wird.
| Flag | Zweck |
|---|---|
-DNO_MAIN=1 | Hauptfunktion überspringen bei Verwendung des libFuzzer-Harness |
-O2 | Optimierungsstufe für die Produktion (für Fuzzing empfohlen) |
-fsanitize=fuzzer | libFuzzer-Kompatibilitätsmodus aktivieren und Fuzzer-Laufzeit beim Linken der ausführbaren Datei hinzufügen |
-fsanitize=fuzzer-no-link | Instrumentieren ohne Verlinkung der Fuzzer-Laufzeit (für statische Bibliotheken und Objektdateien) |
Korpusverwaltung
Erstellen eines initialen Korpus
AFL++ benötigt mindestens eine nicht leere Seed-Datei:
mkdir seeds
echo "aaaa" > seeds/minimal_seed
Sammeln Sie für reale Projekte repräsentative Eingaben:
- Laden Sie Beispieldateien für das Format herunter, das Sie fuzzen
- Entpacken Sie Testfälle aus der Testsuite des Projekts
- Verwenden Sie minimale gültige Eingaben für Ihr Dateiformat
Korpus-Minimierung
Minimieren Sie nach einer Kampagne den Korpus, um nur eindeutige Abdeckungen zu behalten:
./afl++ <host/docker> afl-cmin -i out/default/queue -o minimized_corpus -- ./fuzz
Siehe auch: Strategien zur Korpus-Erstellung, Wörterbücher und Seed-Auswahl finden Sie in der Technik-Fertigkeit fuzzing-corpus.
Durchführen von Kampagnen
Grundlegender Durchlauf
./afl++ <host/docker> afl-fuzz -i seeds -o out -- ./fuzz
Setzen von Umgebungsvariablen
./afl++ <host/docker> AFL_FAST_CAL=1 afl-fuzz -i seeds -o out -- ./fuzz
Interpretieren der Ausgabe
Die AFL++-Benutzeroberfläche zeigt Echtzeit-Fuzzing-Statistiken an:
| Ausgabe | Bedeutung |
|---|---|
| execs/sec | Ausführungsgeschwindigkeit – höher ist besser |
| cycles done | Anzahl der abgeschlossenen Warteschlangendurchläufe |
| corpus count | Anzahl der eindeutigen Testfälle in der Warteschlange |
| saved crashes | Anzahl der gefundenen eindeutigen Abstürze |
| stability | % der stabilen Kanten (sollte nahe 100 % sein) |
Verzeichnisstruktur der Ausgabe
out/default/
├── cmdline # Wie wurde das SUT aufgerufen?
├── crashes/ # Eingaben, die das SUT zum Absturz bringen
│ └── id:000000,sig:06,src:000002,time:286,execs:13105,op:havoc,rep:4
├── hangs/ # Eingaben, die das SUT aufhängen
├── queue/ # Testfälle, die den endgültigen Fuzzer-Zustand reproduzieren
│ ├── id:000000,time:0,execs:0,orig:minimal_seed
│ └── id:000001,src:000000,time:0,execs:8,op:havoc,rep:6,+cov
├── fuzzer_stats # Kampagnenstatistiken
└── plot_data # Daten für Diagramme
Analysieren von Ergebnissen
Live-Kampagnenstatistiken anzeigen:
./afl++ <host/docker> afl-whatsup out
Coverage-Diagramme erstellen:
apt install gnuplot
./afl++ <host/docker> afl-plot out/default out_graph/
Erneutes Ausführen von Testfällen
./afl++ <host/docker> ./fuzz out/default/crashes/<test_case>
Fuzzer-Optionen
| Option | Zweck |
|---|---|
-G 4000 | Maximale Testeingabelänge (Standard: 1048576 Bytes) |
-t 1000 | Timeout in Millisekunden für jeden Testfall (Standard: 1000ms) |
-m 1000 | Speicherlimit in Megabyte (Standard: 0 = unbegrenzt) |
-x ./dict.dict | Wörterbuchdatei verwenden, um Mutationen zu lenken |
Multi-Core-Fuzzing
AFL++ zeichnet sich durch Multi-Core-Fuzzing mit zwei Hauptvorteilen aus:
- Mehr Ausführungen pro Sekunde (skaliert linear mit physischen Kernen)
- Asymmetrisches Fuzzing (z. B. ein ASan-Job, Rest ohne Sanitizer)
Starten einer Kampagne
Start des primären Fuzzers (im Hintergrund):
./afl++ <host/docker> afl-fuzz -M primary -i seeds -o state -- ./fuzz 1>primary.log 2>primary.error &
Sekundäre Fuzzer starten (so viele, wie Sie Kerne haben):
./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 &
Überwachen von Multi-Core-Kampagnen
Alle laufenden Jobs auflisten:
jobs
Live-Statistiken anzeigen (wird jede Sekunde aktualisiert):
./afl++ <host/docker> watch -n1 --color afl-whatsup state/
Alle Fuzzer stoppen
kill $(jobs -p)
Coverage-Analyse
AFL++ verfolgt automatisch die Coverage durch Kanteninstrumentierung. Coverage-Informationen werden in fuzzer_stats und plot_data gespeichert.
Coverage messen
Verwenden Sie afl-plot, um die Coverage im Zeitverlauf zu visualisieren:
./afl++ <host/docker> afl-plot out/default out_graph/
Coverage verbessern
- Verwenden Sie Wörterbücher für formatbewusstes Fuzzing
- Führen Sie längere Kampagnen durch (cycles_wo_finds zeigt ein Plateau an)
- Probieren Sie verschiedene Mutationsstrategien mit Multi-Core-Fuzzing aus
- Analysieren Sie Coverage-Lücken und fügen Sie gezielte Seed-Eingaben hinzu
Siehe auch: Ausführliche Coverage-Analyse-Techniken, Identifizierung von Coverage-Lücken und systematische Coverage-Verbesserung finden Sie in der Technik-Fertigkeit coverage-analysis.
CMPLOG
CMPLOG/RedQueen ist der beste Mechanismus zur Lösung von Pfadeinschränkungen, der in einem Fuzzer verfügbar ist. Um ihn zu aktivieren, muss das Fuzz-Ziel dafür instrumentiert werden. Setzen Sie vor dem Erstellen des Fuzz-Ziels die Umgebungsvariable:
./afl++ <host/docker> AFL_LLVM_CMPLOG=1 make
Für das Kompilieren und Linken des Harness sind keine besonderen Aktionen erforderlich.
Um eine Fuzzer-Instanz mit einem CMPLOG-instrumentierten Fuzz-Ziel auszuführen, fügen Sie -c0 zu den Befehlszeilenargumenten hinzu:
./afl++ <host/docker> afl-fuzz -c0 -S cmplog -i seeds -o state -- ./fuzz 1>secondary02.log 2>secondary02.error &
Sanitizer-Integration
Sanitizer sind unerlässlich, um Speicherkorruptionsfehler zu finden, die keine sofortigen Abstürze verursachen.
AddressSanitizer (ASan)
./afl++ <host/docker> AFL_USE_ASAN=1 afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz
Hinweis: Der Speichergrenzwert (-m) wird mit ASan aufgrund der 20-TB-Reservierung des virtuellen Speichers nicht unterstützt.
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
Häufige Sanitizer-Probleme
| Problem | Lösung |
|---|---|
| ASan verlangsamt Fuzzing | Nur 1 ASan-Job in Multi-Core-Konfiguration verwenden |
| Stack-Erschöpfung | Stack mit ASAN_OPTIONS=stack_size=... erhöhen |
| GCC-Versionskonflikt | Sicherstellen, dass System-GCC mit der AFL++-Plugin-Version übereinstimmt |
Siehe auch: Für eine umfassende Sanitizer-Konfiguration und Fehlerbehebung siehe die Technik-Fertigkeit address-sanitizer.
Fortgeschrittene Verwendung
Tipps und Tricks
| Tipp | Warum es hilft |
|---|---|
| Verwenden Sie nach Möglichkeit LLVMFuzzerTestOneInput-Harnesse | Wenn eine Fuzzing-Kampagne mindestens 85 % Stabilität aufweist, ist dies der effizienteste Fuzzing-Stil. Wenn nicht, versuchen Sie Standardeingabe- oder Dateieingabe-Fuzzing |
| Verwenden Sie Wörterbücher | Hilft dem Fuzzer, formatspezifische Schlüsselwörter und Magic Bytes zu entdecken |
| Setzen Sie realistische Timeouts | Verhindert Fehlalarme durch Systemlast |
| Beschränken Sie die Eingabegröße | Größere Eingaben erkunden nicht unbedingt mehr Raum |
| Überwachen Sie die Stabilität | Niedrige Stabilität weist auf nicht-deterministisches Verhalten hin |
Fuzzing mit Standardeingabe
AFL++ kann Programme fuzzen, die von stdin lesen, ohne einen libFuzzer-Harness:
./afl++ <host/docker> afl-clang-fast++ -O2 main_stdin.c -o fuzz_stdin
./afl++ <host/docker> afl-fuzz -i seeds -o out -- ./fuzz_stdin
Dies ist langsamer als der persistente Modus, erfordert aber keinen Harness-Code.
Fuzzing mit Dateieingabe
Verwenden Sie für Programme, die Dateien lesen, den Platzhalter @@:
./afl++ <host/docker> afl-clang-fast++ -O2 main_file.c -o fuzz_file
./afl++ <host/docker> afl-fuzz -i seeds -o out -- ./fuzz_file @@
Für eine bessere Leistung verwenden Sie fmemopen, um Dateideskriptoren aus dem Speicher zu erstellen.
Fuzzing von Argumenten
Fuzzen Sie Befehlszeilenargumente mit 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();
}
…
[gekürzt für die Übersetzung]