💻 computer science

RustGo: Fairly Directed Greybox Fuzzing for Enforcing Rust Memory Safety

O RustGo é um novo fuzzer greybox direcionado que aproveita a análise estática específica de Rust para identificar automaticamente potenciais alvos de bugs de memória e podar caminhos de execução irrelevantes, aumentando assim significativamente a eficiência de fuzzing e descobrindo vulnerabilidades desconhecidas em código Rust unsafe em comparação com abordagens existentes.

Autores originais: Dongyeon Yu (Korea University), Jiun Min (Korea University), Yewan Na (Ulsan National Institute of Science and Technology), Mijung Kim (Ulsan National Institute of Science and Technology), Taegyu Kim

Publicado 2026-08-07

📖 7 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Dongyeon Yu (Korea University), Jiun Min (Korea University), Yewan Na (Ulsan National Institute of Science and Technology), Mijung Kim (Ulsan National Institute of Science and Technology), Taegyu Kim (The Pennsylvania State University), Yuseok Jeon (Korea University)

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 uma falha única e minúscula em uma cidade enorme e movimentada. No mundo do software de computador, este cidade é um programa, e a falha é um "bug de memória" — um erro onde o programa tenta pegar, usar ou descartar dados que não deveria, fazendo com que ele trave ou seja hackeado. Por décadas, a maneira mais popular de encontrar esses bugs tem sido o "fuzzing". Pense no fuzzing como jogar milhões de bolas de neve aleatórias e caóticas contra as muralhas da cidade para ver se alguma delas quebra uma janela. Geralmente, isso funciona bem para linguagens mais antigas, mas há um porém: é incrivelmente ineficiente. Você pode jogar 99 bolas de neve na porta da frente, que é robusta e inquebrável, apenas para encontrar a única janela frágil em um beco nos fundos.

Apresentamos o Rust, uma linguagem de programação moderna que atua como um segurança super rigoroso. As regras do Rust são tão boas que 90% da cidade que ele constrói é praticamente à prova de balas; o segurança garante que a maioria das "janelas" (áreas de memória) esteja trancada por padrão. No entanto, para construir certas coisas complexas, o Rust permite que os desenvolvedores abram um pequeno portão especial chamado "código unsafe" (não seguro). Este é o único lugar onde as regras estritas são relaxadas, e é o único lugar onde um bug de memória pode se esconder. O problema é que as ferramentas de "lançamento de bolas de neve" existentes não sabem disso. Elas continuam jogando bolas de neve nos 90% da cidade que já são seguros, desperdiçando tempo e energia, enquanto perdem os poucos pontos perigosos atrás do portão especial. Este artigo apresenta uma nova ferramenta de detetive chamada RustGo que muda o jogo ao saber exatamente onde jogar as bolas de neve.

O Detetive Inteligente: RustGo

Os pesquisadores por trás deste artigo, uma equipe da Universidade da Coreia e outras instituições, perceberam que jogar bolas de neve aleatoriamente em um programa Rust é como tentar encontrar uma agulha em um palheiro queimando todo o palheiro. Como o Rust garante a segurança para a maior parte de seu código, eles perguntaram: Por que testar as partes seguras? Eles construíram o RustGo, um "fuzzer greybox direcionado" que atua como um detetive com um mapa e uma lupa, em vez de uma pessoa vendada jogando pedras.

O RustGo trabalha em três etapas inteligentes para caçar bugs de forma eficiente:

1. Encontrando os Alvos Certos (O Mapa)
Primeiro, o RustGo varre o código para encontrar as zonas "unsafe" onde os bugs podem se esconder. Mas ele não apenas adivinha. Ele usa um tipo especial de análise para observar como os dados fluem através do programa. Imagine que a cidade tem muitos becos, mas alguns levam a becos sem saída ou loops que nunca acontecem na vida real. O RustGo filtra esses casos. Ele identifica os pontos específicos onde um bug de memória poderia ser acionado e, em seguida, agrupa pontos semelhantes. Se dois caminhos diferentes no código levam exatamente ao mesmo resultado perigoso, o RustGo os trata como um único alvo, para não perder tempo verificando a mesma coisa duas vezes. Em seus testes, esta etapa os ajudou a reduzir o número de alvos que precisavam verificar em cerca de 84%, focando apenas nas áreas verdadeiramente suspeitas.

2. Cortando os Caminhos Sem Saída (A Lupa)
Uma vez que o RustGo sabe onde olhar, ele precisa ignorar o resto da cidade. Em ferramentas de fuzzing mais antigas, o "mapa" da cidade frequentemente incluía a biblioteca padrão (as ferramentas pré-construídas que o Rust usa), que é enorme e cheia de caminhos que parecem alcançáveis, mas que na verdade não são. Isso confundia as ferramentas, fazendo-as explorar áreas inúteis. O RustGo introduziu um novo truque chamado "poda de caminho específica do alvo" (target-specific path pruning). É como ter uma cerca mágica que faz desaparecer instantaneamente qualquer caminho que não leve ao alvo específico que você está investigando no momento. Se o detetive estiver procurando um bug na padaria, a cerca bloqueia os caminhos para a biblioteca ou o parque, mesmo que esses caminhos tecnicamente existam na cidade. Isso permitiu que o RustGo cortasse 78,49% dos caminhos irrelevantes que outras ferramentas perderiam tempo explorando.

3. Jogando Limpo (A Estratégia Round-Robin)
Aqui está a reviravolta final e crucial. Quando um detetive tem múltiplos suspeitos (alvos) para verificar, as ferramentas antigas muitas vezes ficam obcecadas com o mais fácil de alcançar, ignorando os mais difíceis. O RustGo usa um sistema de "alternância dinâmica justa" (dynamic fair toggling). Imagine um árbitro que alterna a atenção do detetive entre os suspeitos em uma rotação perfeita. Se o detetive passar muito tempo no Suspeito A, o árbitro imediatamente o muda para o Suspeito B, garantindo que cada suspeito receba uma quantidade justa de atenção. O RustGo faz isso dando a cada alvo sua própria "fila" de bolas de neve e sua própria "planilha de pontuação" para rastrear o progresso. Isso garante que nenhum ponto perigoso seja deixado sem teste apenas por ser um pouco mais difícil de alcançar.

Os Resultados: Mais Rápidos e Mais Inteligentes

A equipe testou o RustGo em 13 aplicações Rust do mundo real, variando de servidores web a ferramentas de processamento de dados. Eles compararam o RustGo com as melhores ferramentas existentes, incluindo o famoso AFL++ e vários fuzzers "direcionados" especializados. Os resultados foram impressionantes.

Como o RustGo parou de perder tempo nos 90% de código seguro e focou puramente nos 10% perigosos, ele encontrou vulnerabilidades de 2,09 a 5,08 vezes mais rápido do que as outras ferramentas. Em alguns casos, como na aplicação gimli, foi mais de 10 vezes mais rápido. Para colocar em perspectiva, se uma ferramenta antiga levasse 10 horas para encontrar um bug, o RustGo o encontrou em menos de uma hora.

Mas a velocidade não é a única vitória. A equipe usou o RustGo para caçar bugs no mundo real, não apenas em seu laboratório de testes. Eles descobriram 13 bugs de memória anteriormente desconhecidos em softwares do mundo real. Destes, 10 foram confirmados pelos desenvolvedores do software e 8 já foram corrigidos. Mais impressionante ainda, 6 desses bugs receberam IDs de segurança oficiais (RUSTSEC), e um recebeu um ID CVE, que é o padrão global para rastrear falhas de segurança graves. Isso prova que o RustGo não é apenas uma ideia teórica; é uma ferramenta prática que já está tornando o software mais seguro.

Por Que Isso Importa

Este artigo não apenas sugere que o RustGo é uma boa ideia; ele a mede, prova que funciona e mostra encontrando bugs reais que outros perderam. Ele argumenta explicitamente contra a antiga forma de pensar: a de que devemos testar cada linha de código para estarmos seguros. Em vez disso, mostra que, ao compreender as regras únicas do Rust, podemos ser mais inteligentes, rápidos e eficazes.

Os pesquisadores também abordaram uma preocupação comum: "E se perdermos um bug ao ignorar as partes seguras?". Eles explicam que as regras de segurança do Rust são tão estritas que bugs de memória espacial (como acessar o endereço de memória errado) simplesmente não podem acontecer nas partes seguras do código. Portanto, ignorá-las não cria um ponto cego; apenas remove o ruído. Para bugs temporais (usar memória após ela ter sido liberada), o RustGo é cuidadoso para garantir que não descarte acidentalmente um caminho que poderia levar a um bug, usando uma abordagem "conservadora" que mantém a rede de segurança larga o suficiente para capturar tudo.

No fim, o RustGo é um testemunho do poder da especialização. Assim como um mestre chef não usa um martelo para quebrar uma noz, um fuzzer moderno não deve usar um instrumento bruto em uma linguagem tão sofisticada quanto o Rust. Ao adaptar a abordagem às forças e fraquezas únicas da linguagem, os autores criaram uma ferramenta que é não apenas mais rápida, mas também mais justa, garantindo que cada perigo potencial no código receba a atenção que merece.

Resumo Técnico: RustGo

Declaração do Problema

O Rust garante a segurança de memória por meio de políticas rigorosas de tempo de compilação (propriedade, empréstimo, tempos de vida), contudo, bugs de memória persistem em regiões unsafe onde essas políticas são ignoradas. Embora o código unsafe constitua uma fração pequena dos programas Rust típicos (aproximadamente 10%), as abordagens de fuzzing existentes tratam todo o código-fonte como uma fonte potencial de bugs. Isso resulta em uma alocação ineficiente de recursos, pois os fuzzers desperdiçam esforço em regiões de segurança de memória que o próprio compilador Rust já garante serem seguras.

Além disso, as soluções de Fuzzing Cinza Direcionado (DGF) existentes, originalmente projetadas para C/C++, enfrentam desafios significativos quando aplicadas ao Rust:

Identificação de Alvos: Métodos tradicionais dependem de seleção manual ou critérios simples (ex: localizações de sanitizers) e falham em identificar automaticamente alvos propensos a bugs de memória específicos da arquitetura única do Rust, como desreferências de ponteiros brutos em código seguro que são aliases de ponteiros inseguros.
Poda de Caminhos (Path Pruning): A biblioteca padrão do Rust é vinculada estaticamente e monomorfizada, criando um binário complexo e unificado. As análises de alcançabilidade existentes costumam superestimar, falhando em podar caminhos irrelevantes por não conseguirem distinguir efetivamente entre o código do usuário e a lógica da biblioteca padrão.
Justiça em Fuzzing Multi-Alvo: Os DGFs multi-alvo existentes frequentemente priorizam alvos "próximos", levando à inanição (starvation) de alvos distantes, porém vulneráveis. Estados de fuzzing compartilhados (fila de entrada única, bitmap de cobertura único) tornam difícil alocar energia de forma justa entre múltiplos alvos distintos.

Metodologia

O artigo propõe o RustGo, um fuzzer cinza direcionado para Rust projetado para identificar, otimizar e realizar o fuzzing de forma justa em regiões propensas a bugs de memória. O RustGo opera através de três componentes principais:

1. Identificação e Otimização de Alvos

O RustGo emprega uma análise estática de múltiplos estágios para identificar alvos vulneráveis:

Análise de MIR e LLVM IR: Realiza uma análise de correspondência de tipos no nível de Representação Intermediária de Médio Nível (MIR) para identificar operações de ponteiro bruto, que não são preservadas no LLVM IR. Em seguida, utiliza análise de taint baseada em Grafo de Fluxo de Valor (VFG) no nível de LLVM IR para rastrear a propagação de ponteiros e identificar sites de aliasing.
Filtragem da Biblioteca Padrão: Para evitar falsos positivos causados pela análise insensível ao contexto da biblioteca padrão monomorfizada, o RustGo anota as funções da biblioteca padrão. Ele utiliza arestas de Grafo de Fluxo de Controle Interprocedural (ICFG) para propagar o taint através das fronteiras da biblioteca sem atravessar a lógica interna da biblioteca, filtrando efetivamente caminhos inalcançáveis.
Otimização de Pós-Dominância: Para reduzir o número de alvos e evitar que o fuzzer degrade para um fuzzer genérico guiado por cobertura, o RustGo realiza uma análise de pós-dominância interprocedural. Se um alvo $t_i$ é pós-dominado por $t_j$ (significando que todos os caminhos para $t_i$ devem passar por $t_j$ ), $t_i$ é mesclado em $t_j$ . Isso reduz alvos redundantes ao consolidá-los em locais representativos.

2. Poda de Caminho Específica de Alvo

Uma vez identificados os alvos, o RustGo elimina caminhos irrelevantes para maximizar a eficiência do fuzzing:

Remapeamento de Call-Site: Alvos localizados dentro da biblioteca padrão são remapeados para seus respectivos sites de invocação no código do usuário para garantir uma análise de alcançabilidade precisa.
Poda Consciente de Precondição:
- Para bugs espaciais (desreferências de ponteiro bruto), nenhuma poda é aplicada, pois estes podem ocorrer sem precondições específicas.
- Para bugs temporais (ex: Use-After-Free), o RustGo utiliza os resultados da análise de taint para verificar se um caminho contém a sequência necessária de operações de memória (ex: alloc $\to$ free $\to$ dereference). Caminhos que carecem dessas sequências são podados.
- Tratamento de Async/Await: Para evitar falsos negativos em código concorrente, o RustGo desabilita conservadoramente a poda para funções que envolvem async/await e aliasing de ponteiro bruto.

3. Fuzzing de Alternância Justa Dinâmica (Dynamic Fair Toggling Fuzzing)

Para garantir testes equitativos entre múltiplos alvos sem interferência, o RustGo introduz um mecanismo de alternância dinâmica:

Multi-Fila e Multi-Cobertura: Ao contrário dos fuzzers tradicionais que usam uma única fila de entrada e um bitmap de cobertura global, o RustGo mantém filas de entrada e bitmaps de cobertura independentes para cada alvo.
Alternância Dinâmica (Dynamic Toggle): O fuzzer alterna entre alvos em regime round-robin. Quando um alvo está ativo, o sistema atualiza uma "Memória Compartilhada de Alternância" (TSM) para habilitar dinamicamente apenas os blocos básicos relevantes para aquele alvo específico. Isso permite que o fuzzer podar caminhos irrelevantes em tempo real para o alvo atual enquanto mantém estados de fuzzing independentes, garantindo que nenhum alvo sofra inanição de recursos.

Principais Contribuições

Framework RustGo: Um novo fuzzer cinza direcionado adaptado especificamente para Rust, capaz de identificar e otimizar automaticamente alvos propensos a bugs de memória usando análise estática específica de Rust (análise cruzada MIR/LLVM IR, rastreamento de taint e pós-dominância).
Poda Específica de Alvo: Uma estratégia de poda inovadora que lida com a estrutura complexa e a monomorfização da biblioteca padrão do Rust, alcançando alta precisão na eliminação de caminhos irrelevantes.
Fuzzing Multi-Alvo Justo: Uma abordagem de alternância dinâmica com esquemas de multi-fila e multi-cobertura que garante uma alocação de energia equilibrada entre múltiplos alvos, evitando o viés em direção a alvos facilmente alcançáveis comuns em DGFs existentes.
Avaliação e Descoberta: Avaliação abrangente em aplicações Rust do mundo real, demonstrando melhorias significativas de desempenho sobre fuzzers de última geração e a descoberta de 13 bugs de memória anteriormente desconhecidos.

Resultados

Os autores avaliaram o RustGo em um benchmark customizado de 13 aplicações Rust do mundo real e no benchmark deepSURF (26 bugs do mundo real).

Otimização de Alvo: O RustGo reduziu o número de alvos iniciais em uma média de 84,13% através da consolidação por pós-dominância.
Poda de Caminho: O RustGo podou uma média de 78,49% de caminhos irrelevantes por alvo, superando significativamente as abordagens de linha de base (ex: RG-base com 51,11%).
Aceleração (Speedup): O RustGo atingiu alvos de 2,09x a 5,08x mais rápido que DGFs existentes (incluindo AFLGo, WindRanger, FishFuzz e PanicKiller) e de 2,85x a 3,45x mais rápido que fuzzers guiados por cobertura (AFL, AFL++).
Descoberta de Vulnerabilidades: O RustGo identificou 13 bugs de memória anteriormente desconhecidos em projetos Rust do mundo real. Destes, 10 foram confirmados, 8 foram corrigidos, 6 receberam IDs RUSTSEC e 1 recebeu um ID CVE.
Comparação com Fuzz Drivers: Quando comparado contra geradores de fuzz drivers (RPG, RUG, deepSURF), o RustGo detectou com sucesso todos os 13 novos bugs, enquanto os geradores falharam em detectar a maioria devido às dificuldades em construir tipos de argumentos complexos e contextos de execução.

Significância

O artigo afirma que o RustGo aborda a ineficiência crítica de aplicar estratégias de fuzzing centradas em C/C++ ao Rust. Ao aproveitar as características únicas da linguagem Rust (propriedade, monomorfização e a distinção entre código seguro e inseguro), o RustGo alcança um processo de fuzzing "justo" e "direcionado" que evita o desperdício de recursos em código de memória segura. Os resultados demonstram que o fuzzing direcionado e consciente de Rust não é apenas mais eficiente, mas também mais eficaz na descoberta de vulnerabilidades profundas de segurança de memória do que tanto o fuzzing genérico guiado por cobertura quanto as abordagens direcionadas existentes. A descoberta de 13 novos bugs, incluindo aqueles atribuídos aos IDs CVE e RUSTSEC, valida a utilidade prática do framework para aumentar a segurança do ecossistema Rust.