cuFuzz

Este repositório contém os artefatos do cuFuzz, um fuzzer orientado a GPU para aplicações CUDA no espaço do usuário, baseado em cobertura. O cuFuzz combina a coleta de cobertura do lado do host e do dispositivo com sanitização para descobrir bugs em programas CUDA de forma eficaz.

Overview

Estrutura do Repositório

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

Requisitos

Requisitos de Hardware

O cuFuzz foi testado na seguinte configuração de hardware:

Componente	Especificação
GPU	NVIDIA A40 (48GB VRAM, Compute Capability 8.6)
CPU

Outras GPUs: o cuFuzz deve funcionar em outras GPUs NVIDIA com Compute Capability ≥ 7.0. Ajuste a variável de ambiente GPU_ARCH de acordo (veja Configuração da Arquitetura da GPU).

Requisitos de Software

Início Rápido: Instruções com Docker

A maneira mais rápida de experimentar o cuFuzz é usar um contêiner Docker. Nosso Dockerfile utiliza a imagem de desenvolvimento oficial NVIDIA CUDA 12.9.

1. Extrair o Artefato e Configurar AFL++

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. Construir a Imagem Docker

Construa a imagem Docker, especificando a arquitetura da sua GPU:

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

Referência de arquitetura de GPU:

Para uma lista completa, veja: https://developer.nvidia.com/cuda-gpus

Exemplo para A40/RTX 3090:

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

Nota: Esta etapa pode levar vários minutos, dependendo da sua máquina e conexão de rede.

3. Executar o Contêiner Docker

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

4. Verificar a Instalação

Assim que o contêiner Docker estiver em execução, verifique a construção:

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

Instruções Detalhadas de Construção (Sem Docker)

Pré-requisitos

Instale as dependências necessárias no 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

Definir a Arquitetura da GPU

Defina a variável de ambiente GPU_ARCH para sua GPU (veja a tabela de arquiteturas acima):

export GPU_ARCH=sm_86  # Altere para corresponder à sua GPU

Construir o AFL++

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

Construir a Ferramenta de Cobertura NVBit

Baixe o NVBit versão 1.7.5:

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

Construa nossa ferramenta de cobertura NVBit:

cd src/cufuzz_cov_nvbit/
export GPU_ARCH=sm_86  # Ajuste para sua GPU
ARCH=$GPU_ARCH make

Construir Wrappers de Sanitizador

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

Uso

Após construir o cuFuzz, invoque o fuzzing usando o seguinte comando:

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

Variáveis de Ambiente do cuFuzz

Variáveis Padrão do AFL++

Variável	Descrição	Exemplo
`AFL_SKIP_CPUFREQ`	Ignorar verificação de política de escalonamento de CPU	`AFL_SKIP_CPUFREQ=1`
`AFL_PRELOAD`	Caminho para a ferramenta de cobertura NVBit	`AFL_PRELOAD=/path/to/cufuzz_cov.so`

Variáveis de Cobertura do cuFuzz

Variáveis de Sanitização do cuFuzz

Modos do AFL_SAN_ABSTRACTION

A variável AFL_SAN_ABSTRACTION controla quais entradas são alimentadas aos sanitizadores:

Recomendado: AFL_SAN_ABSTRACTION=simplify_trace (padrão)

Exemplos

Modo Básico

Neste modo, o cuFuzz utiliza cobertura do lado do dispositivo e executa o compute sanitizer em um subconjunto de entradas (entradas com traços únicos). Este modo aproveita o recurso SAND do AFL++ para desacoplar a coleta de cobertura da sanitização.

cd src/cufuzz_sand

# Build sanitizer wrappers
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

cd ../../targets/sampleApp/

export PATH=/usr/local/cuda/bin/:$PATH
export GPU_ARCH=sm_86  # Adjust for your GPU

# Build vanilla version (for sanitizer)
nvcc sampleApp.cu -I/usr/local/cuda/include/ -O2 --ptxas-options "-v" \
    --gpu-architecture=$GPU_ARCH -o sampleApp-vanilla.out

# Build instrumented version (for fuzzing)
nvcc sampleApp.cu -I/usr/local/cuda/include/ -O2 --ptxas-options "-v" \
    --gpu-architecture=$GPU_ARCH --compiler-bindir ../../Tools/AFLplusplus/afl-clang-fast++ \
    -o sampleApp.out

# Run cuFuzz
ORIGINAL_APP=./sampleApp-vanilla.out \
SANITIZER_PATH=/usr/local/cuda/bin/compute-sanitizer \
SANITIZER_ARG="--tool=memcheck --report-api-errors=no --error-exitcode 99" \
SANITIZER_ARG_RACE="--tool=racecheck --report-api-errors=no --error-exitcode 99" \
SANITIZER_ARG_INIT="--tool=initcheck --report-api-errors=no --error-exitcode 99" \
CUFUZZ_MAP_SIZE=65536 \
AFL_SKIP_CPUFREQ=1 \
AFL_PRELOAD=../../src/cufuzz_cov_nvbit/cufuzz_cov.so \
../../Tools/AFLplusplus/afl-fuzz -x sample.dict -i in/ -o out/ \
    -w ../../src/cufuzz_sand/wrapper_memcheck.out \
    -w ../../src/cufuzz_sand/wrapper_racecheck.out \
    -w ../../src/cufuzz_sand/wrapper_initcheck.out \
    -t 1000000 ./sampleApp.out @@

Saída de exemplo do modo sanitizador

Executando sem sanitizadores (não recomendado): remova os argumentos -w e as variáveis SANITIZER_*.

Executando sem cobertura do lado do dispositivo (opcional): remova AFL_PRELOAD=...cufuzz_cov.so.

Modo Persistente

Neste modo, o cuFuzz aproveita o modo persistente do AFL++, onde múltiplas entradas são testadas em um único processo. Isso melhora significativamente a vazão ao amortizar o custo de inicialização do CUDA.

O modo persistente requer modificações no código-fonte do harness de fuzzing. Veja a documentação do modo persistente do AFL++ para detalhes.

cd targets/sampleApp/

export PATH=/usr/local/cuda/bin/:$PATH
export GPU_ARCH=sm_86  # Adjust for your GPU

# Build persistent mode binary
nvcc sampleApp_persistent.cu -I/usr/local/cuda/include/ -O2 --ptxas-options "-v" \
    --gpu-architecture=$GPU_ARCH --compiler-bindir ../../Tools/AFLplusplus/afl-clang-fast++ \
    -o sampleApp_persistent.out

# Run cuFuzz in persistent mode
COV_PERSISTENT=1 \
CUFUZZ_MAP_SIZE=65536 \
AFL_SKIP_CPUFREQ=1 \
AFL_PRELOAD=../../src/cufuzz_cov_nvbit/cufuzz_cov.so \
./../../Tools/AFLplusplus/afl-fuzz -x sample.dict -i in/ -o out/ \
    -t 1000000 ./sampleApp_persistent.out @@

Saída de exemplo do modo persistente

O modo persistente também suporta opções de sanitizador usando: src/cufuzz_sand/wrapper_persistent_san.c

Solução de Problemas

Problemas Comuns

GPU não detectada: certifique-se de que os drivers NVIDIA estão instalados e que nvidia-smi funciona
Incompatibilidade de arquitetura: defina GPU_ARCH para corresponder à capacidade de computação da sua GPU
Fuzzing lento: ative o modo persistente para melhor vazão

Contribuindo

Aceitamos contribuições! Por favor, veja CONTRIBUTING.md para diretrizes sobre como contribuir, incluindo:

Reportar problemas
Enviar pull requests
Requisitos do Developer Certificate of Origin (DCO)
Diretrizes de estilo de código

Citação

Se você usar cuFuzz em sua pesquisa, por favor, cite nosso artigo do OOPSLA 2026:

@article{cufuzz2026,
  title={Hunting CUDA Bugs at Scale with cuFuzz},
  author={Mohamed Tarek Ibn Ziad and Christos Kozyrakis},
  journal={Proceedings of the ACM on Programming Languages},
  volume={10},
  number={OOPSLA1},
  article={123},
  month={4},
  year={2026},
  doi={10.1145/3798231}
}

Licença

Este projeto está licenciado sob a Apache License 2.0 - veja o arquivo LICENSE para detalhes.

Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Componentes de Terceiros

Este projeto utiliza os seguintes componentes de terceiros:

Componente	Licença	Arquivo de Licença
AFL++	Apache License 2.0	third-party-licenses/LICENSE_from_aflplusplus
NVBit	NVIDIA EULA	third-party-licenses/LICENSE_from_nvbit

Ubuntu	22.04 LTS
NVIDIA Driver	570.144 ou compatível
CUDA Toolkit	12.9
Docker	20.10+ (recomendado)
nvidia-container-toolkit	Necessário para suporte à flag `--gpus`
clang	14

Ampere (Data Center)	`sm_80`	A100
Ampere (Consumidor/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

`CUFUZZ_MAP_SIZE`	Tamanho do mapa de cobertura em bytes	`CUFUZZ_MAP_SIZE=65536`
`COV_PERSISTENT`	Ativar suporte a modo persistente do AFL++ (0=não, 1=sim)	`COV_PERSISTENT=1`
`GPU_ARCH`	Arquitetura de GPU alvo para construções	`GPU_ARCH=sm_86`

`ORIGINAL_APP`	Caminho para a aplicação vanilla (não instrumentada)	`ORIGINAL_APP=./cuda_app`
`SANITIZER_PATH`	Caminho para o binário compute-sanitizer	`SANITIZER_PATH=/usr/local/cuda/bin/compute-sanitizer`
`SANITIZER_ARG`	Argumentos para o sanitizador memcheck	`SANITIZER_ARG="--tool=memcheck --error-exitcode 99"`
`SANITIZER_ARG_RACE`	Argumentos para o sanitizador racecheck	`SANITIZER_ARG_RACE="--tool=racecheck --error-exitcode 99"`
`SANITIZER_ARG_INIT`	Argumentos para o sanitizador initcheck	`SANITIZER_ARG_INIT="--tool=initcheck --error-exitcode 99"`

`all_trace`	Alimenta todas as entradas aos sanitizadores	Mais alta	Mais lento
`simplify_trace`	Alimenta entradas com caminhos de execução únicos	Alta	Equilibrado
`unique_trace`	Alimenta entradas com assinaturas de cobertura únicas	Médio	Mais rápido
`coverage_increase`	Alimenta apenas entradas que causam aumento de cobertura	Mais baixa	Mais rápido

cuFuzz

Mais Populares

cuFuzz

Estrutura do Repositório

Requisitos

Requisitos de Hardware

Requisitos de Software

Início Rápido: Instruções com Docker

1. Extrair o Artefato e Configurar AFL++

2. Construir a Imagem Docker

3. Executar o Contêiner Docker

4. Verificar a Instalação

Instruções Detalhadas de Construção (Sem Docker)

Pré-requisitos

Definir a Arquitetura da GPU

Construir o AFL++

Construir a Ferramenta de Cobertura NVBit

Construir Wrappers de Sanitizador

Uso

Variáveis de Ambiente do cuFuzz

Variáveis Padrão do AFL++

Variáveis de Cobertura do cuFuzz

Variáveis de Sanitização do cuFuzz

Modos do AFL_SAN_ABSTRACTION

Exemplos

Modo Básico

Modo Persistente

Solução de Problemas

Problemas Comuns

Contribuindo

Citação

Licença

Componentes de Terceiros