bg-szy/TOP-SKILLS

AFL++

AFL++ é um fork do fuzzer AFL original que oferece melhor desempenho de fuzzing e recursos mais avançados, mantendo a estabilidade. Uma grande vantagem sobre o libFuzzer é que o AFL++ tem suporte estável para execução de campanhas de fuzzing em múltiplos núcleos, tornando-o ideal para esforços de fuzzing em larga escala.

Quando Usar

Fuzzer	Melhor Para	Complexidade
AFL++	Fuzzing multicore, mutações diversas, projetos maduros	Média
libFuzzer	Configuração rápida, single-thread, harnesses simples	Baixa
LibAFL	Fuzzers customizados, pesquisa, casos de uso avançados	Alta

Escolha AFL++ quando:

• Você precisar de fuzzing multicore para maximizar a taxa de execução
• Seu projeto puder ser compilado com Clang ou GCC
• Você quiser estratégias de mutação diversas e ferramentas maduras
• O libFuzzer estagnou e você precisar de mais cobertura
• Você estiver fazendo fuzzing de bases de código de produção que se beneficiam de execução paralela

Início Rápido

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    // Chame seu código com os dados fornecidos pelo fuzzer
    check_buf((char*)data, size);
    return 0;
}

Compile e execute:

# Configure o script wrapper do AFL++ primeiro (veja Instalação)
./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

Instalação

O AFL++ tem muitas dependências, incluindo LLVM, Python e Rust. Recomendamos usar uma distribuição Debian ou Ubuntu atual para fuzzing com AFL++.

Método	Quando Usar	Compiladores Suportados
Repositórios Ubuntu/Debian	Ubuntu recente, apenas recursos básicos	Ubuntu 23.10: Clang 14 e GCC 13Debian 12: Clang 14 e GCC 12
Docker (do Docker Hub)	Versão específica do AFL++, suporte Apple Silicon	A partir de 4.35c: Clang 19 e GCC 11
Docker (a partir do código-fonte)	Testar recursos não lançados, aplicar patches	Configurável no Dockerfile
A partir do código-fonte	Evitar Docker, precisar de patches específicos	Ajustável via variável de ambiente LLVM_CONFIG

Ubuntu/Debian

Antes de instalar o afl++, verifique a dependência de versão do clang do pacote com apt-cache show afl++ e instale a versão correspondente do lld (por exemplo, lld-17).

apt install afl++ lld-17

Docker (do Docker Hub)

docker pull aflplusplus/aflplusplus:stable

Docker (a partir do código-fonte)

git clone --depth 1 --branch stable https://github.com/AFLplusplus/AFLplusplus
cd AFLplusplus
docker build -t aflplusplus .

A partir do código-fonte

Consulte o Dockerfile para requisitos de versão do Ubuntu e dependências. Defina LLVM_CONFIG para especificar a versão do Clang (por exemplo, llvm-config-18).

Configuração do Script Wrapper

Crie um script wrapper para executar o AFL++ no host ou no Docker:

cat <<'EOF' > ./afl++
#!/bin/sh
AFL_VERSION="${AFL_VERSION:-"stable"}"
case "$1" in
   host)
        shift
        bash -c "$*"
        ;;
    docker)
        shift
        /usr/bin/env docker run -i \
            --privileged \
            -v ./:/src \
            --rm \
            --name "afl_fuzzing_$$" \
            "aflplusplus/aflplusplus:$AFL_VERSION" \
            bash -c "cd /src && bash -c \"$*\""
        ;;
    *)
        echo "Usage: $0 {host|docker}"
        exit 1
        ;;
esac
EOF
chmod +x ./afl++

Os exemplos abaixo usam o modo docker, exceto pelos comandos de configuração do sistema que precisam alcançar o kernel do host. Substitua por host para executar qualquer um deles contra um AFL++ instalado na própria máquina. O wrapper une tudo após o argumento de modo em uma única string de shell, então a formatação de citações não sobrevive: um argumento contendo um espaço (-x "my dict.dict") chega dividido em palavras. Renomeie esses arquivos sem espaços ou edite o wrapper para essa execução.

A ausência de -t é intencional. docker run -ti aborta com the input device is not a TTY sempre que a entrada padrão não é um terminal, o que cobre trabalhos de CI e qualquer coisa que um agente ou script acione. afl-fuzz percebe que não há terminal e imprime linhas de status simples no lugar da interface de tela cheia. Um programa que insiste em um terminal, como watch, deve ser executado no lado do host do wrapper. $$ expande para o PID do wrapper, então instâncias paralelas obtêm nomes de contêiner distintos, em vez de colidir em um único afl_fuzzing. docker ps trunca a coluna COMMAND, então todas as linhas parecem iguais; use docker ps --no-trunc para diferenciar as instâncias antes de parar uma.

Aviso de Segurança: Os scripts afl-system-config e afl-persistent-config exigem privilégios de root e desativam recursos de segurança do sistema operacional. Não faça fuzzing em sistemas de produção ou em seu ambiente de desenvolvimento. Use uma VM dedicada.

Configuração do Sistema

Execute após cada reinicialização para obter até 15% mais execuções por segundo:

./afl++ host afl-system-config

afl-system-config ajusta o kernel no qual é executado, então execute-o na máquina que hospeda a campanha. ./afl++ docker afl-system-config atinge as mesmas configurações através do contêiner --privileged do wrapper, que é a única rota quando o AFL++ está instalado apenas via Docker.

Para desempenho máximo, desative as mitigações de segurança do kernel (requer bootloader grub, não suportado no Docker):

./afl++ host afl-persistent-config
update-grub
reboot
./afl++ host afl-system-config

Verifique com cat /proc/cmdline - a saída deve incluir mitigations=off.

Escrevendo um Harness

Estrutura do Harness

O AFL++ suporta harnesses estilo libFuzzer:

#include <stdint.h>
#include <stddef.h>

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    // 1. Valide o tamanho da entrada, se necessário
    if (size < MIN_SIZE || size > MAX_SIZE) return 0;

    // 2. Chame a função alvo com os dados do fuzzer
    target_function(data, size);

    // 3. Retorne 0 (diferente de zero reservado para uso futuro)
    return 0;
}

Regras do Harness

Faça	Não Faça
Redefina o estado global entre execuções	Dependa do estado de execuções anteriores
Trate casos extremos graciosamente	Saia em entrada inválida
Mantenha o harness determinístico	Use geradores de números aleatórios
Libere memória alocada	Crie vazamentos de memória
Valide tamanhos de entrada	Processe entrada ilimitada

Veja Também: Para técnicas detalhadas de escrita de harness, padrões para lidar com entradas complexas e estratégias avançadas, consulte a habilidade técnica fuzz-harness-writing.

Compilação

O AFL++ oferece vários modos de compilação com diferentes compromissos.

Árvore de Decisão do Modo de Compilação

Escolha seu modo de compilação:

• Modo LTO (afl-clang-lto): Melhor desempenho e instrumentação. Tente este primeiro.
• Modo LLVM (afl-clang-fast): Recorra se o LTO falhar ao compilar.
• Plugin GCC (afl-gcc-fast): Para projetos que exigem GCC.

Compilação Básica (Modo LLVM)

./afl++ docker afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz

Compilação com GCC

./afl++ docker afl-g++-fast -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz

Importante: A versão do GCC deve corresponder à versão usada para compilar o plugin GCC do AFL++.

Com Sanitizers

./afl++ docker AFL_USE_ASAN=1 afl-clang-fast++ -DNO_MAIN=1 -O2 -fsanitize=fuzzer harness.cc main.cc -o fuzz

Veja Também: Para configuração detalhada de sanitizers, problemas comuns e sinalizadores avançados, consulte as habilidades técnicas address-sanitizer e undefined-behavior-sanitizer.

Sinalizadores de Build

Observe que -g não é necessário, é adicionado por padrão pelos compiladores do AFL++.

Sinalizador	Propósito
-DNO_MAIN=1	Pular a função main ao usar o harness libFuzzer
-O2	Nível de otimização de produção (recomendado para fuzzing)
-fsanitize=fuzzer	Ativar modo de compatibilidade libFuzzer e adicionar o runtime do fuzzer ao vincular o executável
-fsanitize=fuzzer-no-link	Instrumentar sem vincular o runtime do fuzzer (para bibliotecas estáticas e arquivos objeto)

Gerenciamento de Corpus

Criando Corpus Inicial

O AFL++ requer pelo menos um arquivo de semente não vazio:

mkdir seeds
echo "aaaa" > seeds/minimal_seed

Para projetos reais, reúna entradas representativas:

• Baixe arquivos de exemplo para o formato que você está fuzzeando
• Extraia casos de teste do conjunto de testes do projeto
• Use entradas válidas mínimas para seu formato de arquivo

Minimização de Corpus

Após uma campanha, minimize o corpus para manter apenas a cobertura única:

./afl++ docker afl-cmin -i out/default/queue -o minimized_corpus -- ./fuzz

Veja Também: Para estratégias de criação de corpus, dicionários e seleção de sementes, consulte a habilidade técnica fuzzing-corpus.

Executando Campanhas

Execução Básica

./afl++ docker afl-fuzz -i seeds -o out -- ./fuzz

Configurando Variáveis de Ambiente

./afl++ docker AFL_FAST_CAL=1 afl-fuzz -i seeds -o out -- ./fuzz

Interpretando a Saída

O AFL++ relata essas estatísticas de qualquer maneira, mas como você as lê depende do modo. O docker run -i do wrapper dá ao contêiner nenhum TTY, então afl-fuzz remove a interface de tela cheia e escreve linhas de status simples no log — os campos abaixo aparecem lá e em state/<instância>/fuzzer_stats. Para obter a interface interativa, execute o modo host em um terminal ou adicione -t ao wrapper para uma execução que você está acompanhando manualmente.

Saída	Significado
execs/sec	Velocidade de execução - quanto mais alto, melhor
cycles done	Número de passagens de fila concluídas
corpus count	Número de casos de teste únicos na fila
saved crashes	Número de crashes únicos encontrados
stability	% de arestas estáveis (deve estar próximo de 100%)

Estrutura do Diretório de Saída

out/default/
├── cmdline          # Como o SUT foi invocado?
├── crashes/         # Entradas que crasham o SUT
│   └── id:000000,sig:06,src:000002,time:286,execs:13105,op:havoc,rep:4
├── hangs/           # Entradas que travam o SUT
├── queue/           # Casos de teste reproduzindo o estado final do fuzzer
│   ├── id:000000,time:0,execs:0,orig:minimal_seed
│   └── id:000001,src:000000,time:0,execs:8,op:havoc,rep:6,+cov
├── fuzzer_stats     # Estatísticas da campanha
└── plot_data        # Dados para plotagem

Analisando Resultados

Visualize estatísticas de campanha ao vivo:

./afl++ docker afl-whatsup out

Crie gráficos de cobertura. A imagem aflplusplus já inclui gnuplot-nox; no modo host, instale o gnuplot primeiro com apt install gnuplot.

./afl++ docker afl-plot out/default out_graph/

Reexecutando Casos de Teste

Passe um dos nomes de arquivo de out/default/crashes/:

./afl++ docker ./fuzz out/default/crashes/id:000000,sig:06,src:000002,time:286,execs:13105,op:havoc,rep:4

Opções do Fuzzer

Opção	Propósito
-G 4000	Tamanho máximo de entrada de teste (padrão: 1048576 bytes)
-t 1000	Tempo limite em milissegundos para cada caso de teste (padrão: 1000ms)
-m 1000	Limite de memória em megabytes (padrão: 0 = ilimitado)
-x ./dict.dict	Usar arquivo de dicionário para guiar mutações

Variáveis de Ambiente Que Importam

O AFL++ tem muitas variáveis de ambiente, mas a maioria é de nicho. Estas são as que importam na prática.

Sempre Defina Estas

# Toda campanha deve usar tmpfs — seu SSD agradecerá, e é mais rápido
AFL_TMPDIR=/dev/shm

AFL_TMPDIR é um ganho de desempenho gratuito, sem desvantagens — não configurá-lo desgasta seu SSD e diminui o fuzzing.

Alvos Lentos

# Acelera a calibração em ~2,5x — use quando os alvos são lentos (por exemplo, >10 ms/exec)
AFL_FAST_CAL=1

AFL_FAST_CAL reduz o tempo de calibração com perda de precisão insignificante. Recomendado especificamente para alvos lentos onde a calibração, de outra forma, levaria muito tempo.

Campanhas Multicore

# Na instância principal (-M) apenas — necessário para afl-cmin, não para o fuzzing em si
AFL_FINAL_SYNC=1

# Em todas as instâncias — armazenar casos de teste em cache na memória (padrão: 50 MB, boa faixa: 50-250 MB)
AFL_TESTCACHE_SIZE=100

AFL_FINAL_SYNC diz à instância principal para fazer uma importação final de todas as secundárias ao parar. Isso não afeta o processo de fuzzing em si — só importa quando você executa afl-cmin posteriormente para minimização de corpus, garantindo que a fila da instância principal tenha o corpus combinado completo. AFL_TESTCACHE_SIZE armazena casos de teste em cache na memória para reduzir E/S de disco; o padrão é 50 MB e valores entre 50-250 MB funcionam bem para a maioria das campanhas.

Fuzzing CI/Automatizado

# Falhe rápido se o fuzzing não estiver encontrando nada
AFL_EXIT_ON_TIME=3600  # 1 hora sem novos caminhos = parar

# Ou execute até "concluído" (todas as entradas da fila processadas)
AFL_EXIT_WHEN_DONE=1

# Ambientes headless
AFL_NO_UI=1

Fuzzing ilimitado em CI desperdiça recursos. Defina limites de tempo ou use condições de saída.

Variáveis a Evitar

Variável	Por Que Pular
AFL_NO_ARITH	Pode prejudicar a cobertura em formatos binários, mas pode ser útil para alvos baseados em texto
AFL_SHUFFLE_QUEUE	Apenas para configurações exóticas, geralmente prejudicial
AFL_DISABLE_TRIM	Aparação é valiosa, não desabilite sem motivo

Fuzzing Multicore

O AFL++ se destaca no fuzzing multicore com duas grandes vantagens:

1. Mais execuções por segundo (escala linearmente com núcleos físicos)
2. Fuzzing assimétrico (por exemplo, um job com ASan, o resto sem sanitizers)

Iniciando uma Campanha

Inicie o fuzzer principal (em segundo plano):

./afl++ docker afl-fuzz -M primary -i seeds -o state -- ./fuzz 1>primary.log 2>primary.error </dev/null &

Inicie os fuzzers secundários (quantos núcleos você tiver):

./afl++ docker afl-fuzz -S secondary01 -i seeds -o state -- ./fuzz 1>secondary01.log 2>secondary01.error </dev/null &
./afl++ docker afl-fuzz -S secondary02 -i seeds -o state -- ./fuzz 1>secondary02.log 2>secondary02.error </dev/null &

O </dev/null é obrigatório, não decorativo. docker run -i mantém o cliente lendo sua própria entrada padrão, e um processo em segundo plano que lê o terminal recebe SIGTTOP, fazendo com que ele pare. Redirecionar stdin de /dev/null previne isso.

Monitorando o Progresso

Veja todas as instâncias de uma vez:

./afl++ docker afl-whatsup state

Pare todas as instâncias (enquanto espera que cada uma salve seu estado):

kill %1 %2 %3       # ou
pkill -f "afl-fuzz"  # ou
docker ps --no-trunc | grep afl_fuzzing | cut -d' ' -f1 | xargs docker stop

Verifique se as instâncias secundárias estão encontrando caminhos que a principal perdeu. Execute afl-whatsup periodicamente e verifique se a contagem da fila da instância principal está crescendo. Se as secundárias param de importar novos caminhos que acrescentam cobertura, a campanha atingiu um platô.

Solução de Problemas

Problemas Comuns e Soluções

Problema	Solução
"Qemu mode not available"	Use um modo de compilação diferente, não QEMU
"Fuzzing is slow (< 1 execs/sec)"	Verifique as configurações -t e -m; tente AFL_FAST_CAL=1
"Fork server crashed"	Não use o modo -n (sem instrumentação)
"LTO mode compilation fails"	Caindo de volta para o modo LLVM (afl-clang-fast++)
"GCC plugin not found"	Certifique-se de que a versão do GCC corresponde
"System configuration not applied"	Execute afl-system-config como root
"Docker: permission denied"	Instale o Docker e adicione seu usuário ao grupo docker

Erro: ``