Communitygithub.com

AFL++

AFL++ ist ein Fork des ursprünglichen AFL-Fuzzers mit besserer Fuzzing-Leistung und erweiterten Funktionen, ideal für Multi-Core-Fuzzing von C/C++-Projekten.

Was ist AFL++?

AFL++ ist ein leistungsstarker Fork des AFL-Fuzzers (American Fuzzy Lop), der für seine hervorragende Fuzzing-Leistung, erweiterte Funktionen und stabile Multi-Core-Unterstützung bekannt ist. Entwickler wählen AFL++, wenn sie große Codebasen fuzzen müssen, die von paralleler Ausführung profitieren, oder wenn libFuzzer keine ausreichende Abdeckung mehr bietet. Es unterstützt mehrere Kompilierungsmodi (LTO, LLVM, GCC) und kann mit Clang oder GCC verwendet werden. AFL++ integriert sich nahtlos mit Sanitizern wie AddressSanitizer (ASan) und UndefinedBehaviorSanitizer (UBSan). Das Tool ist plattformübergreifend einsetzbar: nativ auf Debian/Ubuntu, per Docker (mit Apple-Silicon-Unterstützung), aus dem Quellcode oder mit einem benutzerdefinierten Wrapper-Skript. Es bietet fortschrittliche Funktionen wie CMPLOG (RedQueen) zur Pfadbeschränkungslösung, Wörterbücher für formatbewusstes Fuzzing und umfassende Überwachungs- und Coverage-Analyse-Tools. AFL++ eignet sich besonders für die Aufdeckung von Speicherfehlern und Sicherheitslücken in Produktionscodebasen.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

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

FuzzerAm besten geeignet fürKomplexität
AFL++Multi-Core-Fuzzing, vielfältige Mutationen, ausgereifte ProjekteMittel
libFuzzerSchnelle Einrichtung, Single-Threaded, einfache HarnesseNiedrig
LibAFLBenutzerdefinierte Fuzzer, Forschung, fortgeschrittene AnwendungsfälleHoch

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++.

MethodeWann verwendenUnterstützte Compiler
Ubuntu/Debian-ReposAktuelles Ubuntu, nur grundlegende FunktionenUbuntu 23.10: Clang 14 & GCC 13Debian 12: Clang 14 & GCC 12
Docker (von Docker Hub)Bestimmte AFL++-Version, Apple-Silicon-UnterstützungAb 4.35c: Clang 19 & GCC 11
Docker (aus dem Quellcode)Unveröffentlichte Funktionen testen, Patches anwendenKonfigurierbar im Dockerfile
Aus dem QuellcodeDocker vermeiden, bestimmte Patches benötigenEinstellbar ü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

TunNicht tun
Globalen Zustand zwischen den Läufen zurücksetzenSich auf Zustand aus vorherigen Läufen verlassen
Randfälle elegant behandelnBei ungültiger Eingabe beenden
Harness deterministisch haltenZufallszahlengeneratoren verwenden
Zugewiesenen Speicher freigebenSpeicherlecks erzeugen
Eingabegrößen validierenUnbegrenzte 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.

FlagZweck
-DNO_MAIN=1Hauptfunktion überspringen bei Verwendung des libFuzzer-Harness
-O2Optimierungsstufe für die Produktion (für Fuzzing empfohlen)
-fsanitize=fuzzerlibFuzzer-Kompatibilitätsmodus aktivieren und Fuzzer-Laufzeit beim Linken der ausführbaren Datei hinzufügen
-fsanitize=fuzzer-no-linkInstrumentieren 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:

AusgabeBedeutung
execs/secAusführungsgeschwindigkeit – höher ist besser
cycles doneAnzahl der abgeschlossenen Warteschlangendurchläufe
corpus countAnzahl der eindeutigen Testfälle in der Warteschlange
saved crashesAnzahl 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

OptionZweck
-G 4000Maximale Testeingabelänge (Standard: 1048576 Bytes)
-t 1000Timeout in Millisekunden für jeden Testfall (Standard: 1000ms)
-m 1000Speicherlimit in Megabyte (Standard: 0 = unbegrenzt)
-x ./dict.dictWörterbuchdatei verwenden, um Mutationen zu lenken

Multi-Core-Fuzzing

AFL++ zeichnet sich durch Multi-Core-Fuzzing mit zwei Hauptvorteilen aus:

  1. Mehr Ausführungen pro Sekunde (skaliert linear mit physischen Kernen)
  2. 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

ProblemLösung
ASan verlangsamt FuzzingNur 1 ASan-Job in Multi-Core-Konfiguration verwenden
Stack-ErschöpfungStack mit ASAN_OPTIONS=stack_size=... erhöhen
GCC-VersionskonfliktSicherstellen, 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

TippWarum es hilft
Verwenden Sie nach Möglichkeit LLVMFuzzerTestOneInput-HarnesseWenn 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ücherHilft dem Fuzzer, formatspezifische Schlüsselwörter und Magic Bytes zu entdecken
Setzen Sie realistische TimeoutsVerhindert Fehlalarme durch Systemlast
Beschränken Sie die EingabegrößeGrößere Eingaben erkunden nicht unbedingt mehr Raum
Überwachen Sie die StabilitätNiedrige 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]

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".

Verwandte Skills