cuFuzz

Dieses Repository enthält die Artefakte für cuFuzz, einen GPU-orientierten Coverage-geführten Fuzzer für CUDA-Anwendungen im Userspace. cuFuzz kombiniert Host- und Geräteseitige Coverage-Erfassung mit Sanitizern, um effektiv Fehler in CUDA-Programmen zu finden.

Repository-Struktur

cufuzz-artifacts/
├── src/                        # Core cuFuzz components
│   ├── cufuzz_cov_nvbit/       # NVBit-based device-side coverage collection tool
│   └── cufuzz_sand/            # Sanitizer wrappers for SAND integration
├── targets/                    # Example fuzzing targets
│   └── sampleApp/              # Simple CUDA app with intentional bug for testing
├── scripts/                    # Evaluation and analysis scripts
├── Tools/                      # External dependencies
│   ├── AFLplusplus/            # AFL++ fuzzer (git submodule)
│   └── AFLplusplus.patch       # cuFuzz patches for AFL++
├── third-party-licenses/       # Third-party license files
│   ├── LICENSE_from_aflplusplus  # AFL++ Apache 2.0 license
│   └── LICENSE_from_nvbit        # NVBit NVIDIA EULA
├── images/                     # Documentation images
├── build.sh                    # Automated build script
├── verify_build.sh             # Quick verification test
├── Dockerfile                  # Docker container definition
├── LICENSE                     # Apache License 2.0
└── CONTRIBUTING.md             # Contribution guidelines and DCO

Anforderungen

Hardware-Anforderungen

cuFuzz wurde mit der folgenden Hardwarekonfiguration getestet:

Komponente	Spezifikation
GPU	NVIDIA A40 (48GB VRAM, Compute Capability 8.6)
CPU	Intel Xeon Platinum 8362 (64 Kerne, 2 Threads/Kern)
Arbeitsspeicher	120GB+ RAM empfohlen
Speicher	50GB+ freier Speicherplatz für Docker-Image und Fuzzing-Ausgaben

Andere GPUs: cuFuzz sollte auf anderen NVIDIA GPUs mit Compute Capability ≥ 7.0 funktionieren. Passen Sie die Umgebungsvariable GPU_ARCH entsprechend an (siehe GPU-Architektur-Konfiguration).

Software-Anforderungen

Komponente	Version
Ubuntu	22.04 LTS
NVIDIA Treiber	570.144 oder kompatibel
CUDA Toolkit	12.9
Docker	20.10+ (empfohlen)
nvidia-container-toolkit	Erforderlich für --gpus Flag-Unterstützung
clang	14

Schnellstart: Docker-Anweisungen

Der schnellste Weg, cuFuzz auszuprobieren, ist die Verwendung eines Docker-Containers. Unser Dockerfile verwendet das offizielle NVIDIA CUDA 12.9 Entwicklungsimage.

1. Artefakt extrahieren und AFL++ einrichten

tar -xzvf cufuzz-artifacts.tar.gz
cd cufuzz-artifacts

# Clone AFL++ (required dependency)
git clone https://github.com/AFLplusplus/AFLplusplus.git Tools/AFLplusplus
cd Tools/AFLplusplus
git checkout 9cac7ced05eb9f36c1d0b02ad594b3b09cd3938b
cd ../..

2. Docker-Image bauen

Erstellen Sie das Docker-Image mit Angabe Ihrer GPU-Architektur:

sudo docker build --build-arg GPU_ARCH=<your_arch> -t cufuzz .

GPU-Architektur-Referenz:

GPU-Familie	Architektur	Beispiele
Ampere (Rechenzentrum)	sm_80	A100
Ampere (Consumer/Pro)	sm_86	A40, RTX 3090, RTX 3060
Hopper	sm_90	H100
Ada Lovelace	sm_89	RTX 4090, L40
Turing	sm_75	RTX 2080, T4

Eine vollständige Liste finden Sie unter: https://developer.nvidia.com/cuda-gpus

Beispiel für A40/RTX 3090:

sudo docker build --build-arg GPU_ARCH=sm_86 -t cufuzz .

Hinweis: Dieser Schritt kann je nach Maschine und Netzwerkverbindung mehrere Minuten dauern.

3. Docker-Container ausführen

sudo docker run --rm --gpus all -it -v /:/my_workspace cufuzz bash

4. Installation überprüfen

Sobald der Docker-Container läuft, überprüfen Sie den Build:

root@container:~/cufuzz# ./verify_build.sh

Detaillierte Build-Anweisungen (Ohne Docker)

Voraussetzungen

Installieren Sie die erforderlichen Abhängigkeiten unter Ubuntu 22.04:

apt-get update && apt-get install -y build-essential python3-dev automake cmake git flex \
    bison libglib2.0-dev libpixman-1-dev python3-setuptools cargo libgtk-3-dev lld llvm llvm-dev \
    clang ninja-build cpio libcapstone-dev wget curl python3-pip vim less libxxhash-dev bc zlib1g-dev

GPU-Architektur setzen

Setzen Sie die Umgebungsvariable GPU_ARCH für Ihre GPU (siehe Architektur-Tabelle oben):

export GPU_ARCH=sm_86  # An Ihre GPU anpassen

AFL++ bauen

cd Tools/AFLplusplus 
patch -N -p1 < ../AFLplusplus.patch 
export CXX=/usr/bin/clang++-14 
export CC=/usr/bin/clang-14
make -j8 &> build.log

NVBit-Coverage-Tool bauen

Laden Sie NVBit Version 1.7.5 herunter:

mkdir -p Tools/NVBit
wget https://github.com/NVlabs/NVBit/releases/download/v1.7.5/nvbit-Linux-x86_64-1.7.5.tar.bz2
tar -xvf nvbit-Linux-x86_64-1.7.5.tar.bz2 
mv nvbit_release_x86_64/* Tools/NVBit/
rm -rf nvbit_release_x86_64 nvbit-Linux-x86_64-1.7.5.tar.bz2

Bauen Sie unser NVBit-Coverage-Tool:

cd src/cufuzz_cov_nvbit/
export GPU_ARCH=sm_86  # An Ihre GPU anpassen
ARCH=$GPU_ARCH make 

Sanitizer-Wrapper bauen

cd src/cufuzz_sand
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -O2 wrapper_san.c -o wrapper_memcheck.out 
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -DSAN_MODE_INIT -O2 wrapper_san.c -o wrapper_initcheck.out 
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -DSAN_MODE_RACE -O2 wrapper_san.c -o wrapper_racecheck.out
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -DSAN_MODE_ASAN -O2 wrapper_san.c -o wrapper_asan.out

Verwendung

Nachdem Sie cuFuzz gebaut haben, starten Sie das Fuzzing mit folgendem Befehl:

CUFUZZ_MAP_SIZE=65536 AFL_SKIP_CPUFREQ=1 AFL_PRELOAD=/PFAD/ZU/cufuzz_cov.so \
    ./Tools/AFLplusplus/afl-fuzz -x sample.dict -i input_samples/ -o output_dir/ \
    -t 1000000 ./cuda_app.out @@

cuFuzz-Umgebungsvariablen

AFL++ Standardvariablen

Variable	Beschreibung	Beispiel
AFL_SKIP_CPUFREQ	CPU-Skalierungsrichtlinien-Prüfung überspringen	AFL_SKIP_CPUFREQ=1
AFL_PRELOAD	Pfad zum NVBit-Coverage-Tool	AFL_PRELOAD=/pfad/zu/cufuzz_cov.so

cuFuzz Coverage-Variablen

Variable	Beschreibung	Beispiel
CUFUZZ_MAP_SIZE	Größe der Coverage-Karte in Bytes	CUFUZZ_MAP_SIZE=65536
COV_PERSISTENT	Unterstützung für AFL persistenten Modus aktivieren (0=nein, 1=ja)	COV_PERSISTENT=1
GPU_ARCH	Ziel-GPU-Architektur für Builds	GPU_ARCH=sm_86

cuFuzz-Sanitizer-Variablen

Variable	Beschreibung	Beispiel
ORIGINAL_APP	Pfad zur unveränderten (nicht instrumentierten) Anwendung	ORIGINAL_APP=./cuda_app
SANITIZER_PATH	Pfad zur compute-sanitizer-Binärdatei	SANITIZER_PATH=/usr/local/cuda/bin/compute-sanitizer
SANITIZER_ARG	Argumente für den Memcheck-Sanitizer	SANITIZER_ARG="--tool=memcheck --error-exitcode 99"
SANITIZER_ARG_RACE	Argumente für den Racecheck-Sanitizer	SANITIZER_ARG_RACE="--tool=racecheck --error-exitcode 99"
SANITIZER_ARG_INIT	Argumente für den Initcheck-Sanitizer	SANITIZER_ARG_INIT="--tool=initcheck --error-exitcode 99"

AFL_SAN_ABSTRACTION Modi

Die Variable AFL_SAN_ABSTRACTION steuert, welche Eingaben an Sanitizer übergeben werden: