💻 computer science

On Interaction Effects in Greybox Fuzzing

O artigo propõe o MuoFuzz, um fuzzer cinza que aprende e seleciona sequências de mutadores com base em seus efeitos interativos, demonstrando desempenho superior ao AFL++ e ao MOPT em benchmarks como FuzzBench e MAGMA ao encontrar bugs adicionais e alcançar maior cobertura de código.

Autores originais: Konstantinos Kitsios, Marcel Böhme, Alberto Bacchelli

Publicado 2026-04-24

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Konstantinos Kitsios, Marcel Böhme, Alberto Bacchelli

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você é um detetive tentando encontrar um segredo escondido dentro de uma máquina complexa (um software). Para achar o segredo, você precisa tentar abrir a máquina de milhões de maneiras diferentes, como se estivesse batendo em todas as portas, girando todas as maçanetas e apertando todos os botões.

No mundo da segurança de computadores, isso é chamado de "Fuzzing" (ou "testes de fuzz"). O objetivo é encontrar bugs (erros) que fazem a máquina quebrar ou travar, revelando falhas de segurança.

Aqui está a história do que os autores descobriram e como eles criaram uma nova ferramenta chamada MuoFuzz, explicada de forma simples:

1. O Problema: O Caos Aleatório

Imagine que você tem uma caixa de ferramentas com 32 tipos diferentes de martelos, chaves de fenda e alicates (os "mutadores"). Para testar a máquina, você pega um objeto (um "semente" ou seed) e começa a bater nele com essas ferramentas.

O jeito antigo (AFL++): O fuzzer escolhe as ferramentas aleatoriamente. Ele pode pegar um martelo, depois um alicate, depois um martelo de novo. É como tentar abrir um cadeado girando as rodas de números completamente ao acaso. Funciona, mas é lento e ineficiente.
O jeito intermediário (MOPT): Eles tentaram aprender quais martelos funcionam melhor sozinhos. Se o martelo "A" abre muitas portas, eles usam mais o martelo "A". Mas eles ainda tratavam cada martelo como se estivesse sozinho, sem considerar o que veio antes.

2. A Grande Descoberta: A Dança das Ferramentas

Os autores do artigo notaram algo interessante: a ordem importa.

Eles descobriram que certas ferramentas funcionam muito melhor quando usadas em uma sequência específica.

Analogia: Pense em cozinhar. Se você colocar o sal na água antes de ferver, é ótimo. Se você colocar o sal depois de colocar o macarrão, pode não ficar tão bom. O efeito do sal depende do que veio antes.
No software, eles viram que, por exemplo, se você primeiro "deletar um pedaço" de um arquivo e depois "inverter um bit", você tem uma chance muito maior de encontrar um erro do que se fizer o contrário ou usar essas ferramentas aleatoriamente.

Existe uma "interação" entre as ferramentas. O sucesso de uma depende da outra.

3. A Solução: MuoFuzz (O Chef Inteligente)

Para aproveitar essa descoberta, eles criaram o MuoFuzz. Pense nele como um chef de cozinha que aprendeu a receita perfeita, em vez de apenas jogar ingredientes na panela.

O MuoFuzz funciona em duas fases:

Fase de Treinamento (Aprendizado):
- O fuzzer começa a testar o software de forma "caótica" (como os outros) por algumas horas.
- Durante esse tempo, ele anota em um caderno: "Quando usei a ferramenta X e depois a ferramenta Y, conseguimos abrir uma porta nova!".
- Ele cria um mapa de probabilidades: "Se eu usei a ferramenta X, qual é a chance de a ferramenta Y funcionar bem em seguida?".
Fase Guiada (A Execução):
- Agora que ele aprendeu o mapa, ele para de chutar.
- Quando ele escolhe uma ferramenta, ele olha para o caderno e pergunta: "Ok, acabei de usar o martelo. Qual é a próxima ferramenta que tem mais chance de funcionar bem depois do martelo?".
- Ele segue essa "dança" de ferramentas, criando sequências muito mais inteligentes e eficientes.

4. Os Resultados: Quem Ganhou?

Eles testaram o MuoFuzz contra os campeões atuais (AFL++ e MOPT) em vários programas reais.

Cobertura de Código: O MuoFuzz conseguiu explorar mais partes do software (achou mais "caminhos" dentro da máquina) do que os outros em 9 de 13 programas testados.
Velocidade: Para chegar ao mesmo nível de descoberta que os outros levavam 24 horas para atingir, o MuoFuzz fez isso em média em 15 horas. Ele é mais rápido porque não perde tempo tentando combinações que não funcionam.
Bugs Encontrados: O MuoFuzz encontrou 4 bugs que o AFL++ não viu e 1 bug que nem o AFL++ nem o MOPT viram.

5. Conclusão Simples

A lição principal é: Não basta apenas escolher as melhores ferramentas; é preciso saber a ordem certa de usá-las.

Assim como um músico não toca notas aleatórias, mas segue uma melodia onde cada nota prepara a próxima, o MuoFuzz aprende a "melodia" das ferramentas de teste. Ao entender que uma ferramenta influencia a próxima, ele se torna um detetive muito mais esperto, encontrando falhas de segurança mais rápido e com menos esforço.

Em resumo: O MuoFuzz transformou o teste de software de um "jogo de sorte" em um "jogo de estratégia", usando a inteligência das interações entre as ferramentas para vencer.

Título: Efeitos de Interação em Fuzzing Greybox

Autores: Konstantinos Kitsios, Marcel Böhme e Alberto Bacchelli.
Conferência: ICSE 2026 (48ª Conferência Internacional IEEE/ACM sobre Engenharia de Software).

1. O Problema

O fuzzing baseado em mutação (greybox) é uma técnica de teste automatizado que gera novos inputs mutando seeds (entradas iniciais) para descobrir comportamentos inesperados, como falhas de segurança. Ferramentas modernas, como o AFL++, utilizam uma estratégia de mutação que aplica uma sequência de mutadores (ex: inverter bits, deletar bytes) a um seed.

O problema central identificado pelos autores é que as estratégias atuais de seleção de mutadores tratam cada mutador como independente dos outros.

AFL++: Usa probabilidades fixas para selecionar cada um dos 32 mutadores disponíveis.
MOPT (State-of-the-Art): Otimiza a probabilidade de seleção de cada mutador individualmente, mas ainda assume que a escolha do próximo mutador não depende do anterior.

Os autores hipotetizam que existe um efeito de interação entre mutadores: a eficácia de um mutador específico pode ser significativamente aumentada ou diminuída dependendo de qual mutador foi aplicado imediatamente antes dele. Ignorar essa dependência sequencial limita a eficiência do fuzzer.

2. Metodologia

A pesquisa foi conduzida em três etapas principais:

A. Investigação Empírica do Efeito de Interação (RQ1)

Para validar a hipótese de que mutadores interagem, os autores:

Coleta de Dados: Executaram o AFL++ em 13 programas alvo (do benchmark FuzzBench) com modificações específicas:
- Limitaram o comprimento da sequência de mutadores para $l=2$ (pares).
- Amostrar mutadores uniformemente ao acaso (para evitar viés das probabilidades padrão).
- Contabilizaram o número de inputs "interessantes" (que aumentam a cobertura de código) gerados por cada par de mutadores $\langle i, j \rangle$ .
Modelagem Estatística: Ajustaram um modelo linear com um termo de interação ( $\gamma_{ij}$ $γ_{ij}$ ) e realizaram uma ANOVA de dois fatores.
- Hipótese Nula: O termo de interação é zero (não há efeito combinatório).
- Resultado: Rejeitaram a hipótese nula ( $p < 0.0001$ ) para todos os programas, provando estatisticamente que a combinação de mutadores afeta o resultado.

B. Proposta de Solução: MuoFuzz

Com base na descoberta, propuseram o MuoFuzz (Mut + Duo + Fuzz), um fuzzer que aprende e utiliza a probabilidade condicional de selecionar o próximo mutador dado o anterior.

Fase de Treinamento: O fuzzer executa uma fase inicial (ex: 1 hora) onde coleta dados sobre quais pares de mutadores geram mais inputs interessantes. Ele constrói uma matriz de probabilidade condicional $Pr(m_n = j | m_{n-1} = i)$ .
Fase de Mutação Guiada: Após o treinamento, o fuzzer gera sequências de mutadores utilizando uma Caminhada Aleatória (Random Walk) sobre a cadeia de Markov aprendida. O próximo mutador é amostrado com base na probabilidade condicional do mutador anterior, em vez de uma probabilidade fixa ou isolada.

C. Avaliação Experimental

Compararam o MuoFuzz contra:

AFL++: O estado da arte padrão (probabilidades fixas).
MOPT: Otimiza mutadores individualmente (sem considerar interações).
Benchmarks: FuzzBench (cobertura de código) e MAGMA (bugs reais).
Métricas: Cobertura de código mediana após 24h, tempo para atingir a cobertura final, e número de bugs encontrados.
Estudo de Ablação: Testaram variações do MuoFuzz (ex: usar 2 mutadores anteriores como contexto, seleção ponderada do primeiro mutador, diferentes tempos de treinamento) para validar o design.

3. Contribuições Principais

Evidência Empírica de Interação: Demonstraram, através de análise estatística rigorosa, que a ordem e a combinação de mutadores têm um impacto significativo na geração de inputs interessantes, algo que as ferramentas atuais ignoram.
Nova Estratégia de Mutação (MuoFuzz): Desenvolveram um algoritmo que aprende a probabilidade condicional $Pr(next | current)$ e utiliza essa distribuição para guiar a geração de sequências de mutação, superando a abordagem de "mutador isolado".
Desempenho Superior: Validaram que considerar a interação entre mutadores resulta em maior cobertura de código e descoberta de bugs que outras ferramentas não encontraram.

4. Resultados

Cobertura de Código (FuzzBench):
- O MuoFuzz alcançou a maior cobertura mediana em 10 de 13 programas.
- Superou o AFL++ em 9/13 programas e o MOPT em 8/13 programas com significância estatística.
- Eficiência Temporal: O MuoFuzz alcançou a cobertura de 24h do AFL++ em apenas 15 horas (em média) e a do MOPT em 16,5 horas, demonstrando uma aceleração significativa na exploração.
Descoberta de Bugs (MAGMA):
- O MuoFuzz encontrou 4 bugs que o AFL++ não encontrou.
- Encontrou 1 bug que nem o AFL++ nem o MOPT encontraram.
- Encontrou o mesmo número total de bugs que o MOPT, mas descobriu bugs distintos (o MuoFuzz encontrou o bug SQL010 que o MOPT perdeu, e vice-versa), indicando que a estratégia de interação explora caminhos de execução únicos.
Estudo de Ablação:
- Confirmou que usar apenas o mutador anterior (ordem 1) é mais eficaz do que usar 2 anteriores (ordem 2), devido à "maldição da dimensionalidade" (espaço de estados muito esparsos).
- A seleção aleatória do primeiro mutador funcionou melhor do que uma seleção ponderada, sugerindo que manter a aleatoriedade inicial é crucial para a exploração.

5. Significado e Implicações

Mudança de Paradigma: O trabalho desafia a suposição de independência dos mutadores no fuzzing, propondo que a estratégia de mutação deve ser vista como um processo sequencial dependente (similar a modelos de linguagem bigram em processamento de texto).
Eficiência: Ao aprender quais combinações funcionam bem para um programa específico, o MuoFuzz reduz o tempo necessário para atingir coberturas profundas, otimizando o uso de recursos computacionais.
Generalização: A abordagem é leve e pode ser integrada a qualquer fuzzer baseado em mutação (como AFL++ ou libFuzzer) sem necessidade de modelos complexos de aprendizado de máquina (como redes neurais profundas), focando apenas na estatística de pares de mutadores.
Futuro: Abre caminho para o uso de técnicas mais avançadas de geração de sequências (como Transformers ou RNNs) aplicadas à seleção de mutadores e posições de mutação.

Em resumo, o artigo demonstra que a inteligência na seleção de mutadores, baseada na interação histórica entre eles, é um fator crítico e subutilizado para melhorar a eficácia do fuzzing automatizado.