ClozeMaster: Fuzzing Rust Compiler by Harnessing LLMs for Infilling Masked Real Programs

1. Declaração do Problema

A linguagem de programação Rust está sendo cada vez mais adotada para sistemas críticos devido às suas garantias de segurança de memória e de threads. No entanto, o próprio compilador Rust é complexo, e bugs dentro dele podem levar a comportamentos indefinidos ou falhas em sistemas de produção.

• Desafio 1: Complexidade Sintática. Rust possui uma curva de aprendizado íngreme e regras sintáticas estritas (propriedade, empréstimo, tempos de vida), tornando difícil gerar programas de teste válidos usando geração aleatória tradicional ou fuzzing baseado em mutação.
• Desafio 2: Limitações dos LLMs. Embora os Modelos de Linguagem de Grande Escala (LLMs) mostrem promessa em testes de software, solicitá-los diretamente para gerar casos de teste em Rust frequentemente resulta em código inválido ou em código que não consegue acionar bugs do compilador. Isso é devido ao problema da "cauda longa": o Rust constitui uma pequena fração dos dados de treinamento dos LLMs, e os modelos existentes lutam com os casos de borda específicos e em evolução do compilador Rust.
• Desafio 3: Falta de Contexto. Fuzzers baseados em LLMs existentes frequentemente dependem de geração zero-shot ou ajuste fino sem aproveitar as características estruturais específicas de códigos históricos que acionaram bugs.

2. Metodologia: ClozeMaster

Os autores propõem o ClozeMaster, um framework de fuzzing que combina dados históricos de bugs com capacidades de LLMs usando uma estratégia inovadora de ClozeMask. O fluxo de trabalho consiste em quatro etapas principais:

A. Construção e Aumento do Conjunto de Dados

• Fonte: O sistema coleta trechos de código de relatórios históricos de bugs do compilador Rust (especificamente issues do rustc rotuladas como "C-bug" e "T-compiler"), do conjunto de testes oficial do Rust e do repositório Glacier (contendo gatilhos de Erro Interno do Compilador).
• Aumento: Para aumentar o tamanho do conjunto de dados para ajuste fino, os autores aplicam técnicas de aumento de dados:
  • Deleção Aleatória (RD): Remoção aleatória de tokens de código (probabilidade $p=0,2$).
  • Troca Aleatória (RS): Troca das posições de duas instruções dentro de um programa.
  • Isso expandiu o conjunto de dados de ~25 mil para 100 mil trechos.

B. Ajuste Fino do LLM

• Modelo: O modelo de código aberto Incoder é selecionado por sua capacidade de lidar com tarefas de preenchimento de código.
• Treinamento: O modelo é ajustado finamente no conjunto de dados curado de código histórico que acionou bugs. Isso ensina ao LLM os padrões sintáticos e semânticos específicos associados a vulnerabilidades do compilador Rust.

C. A Estratégia ClozeMask (Inovação Central)

Em vez de gerar código do zero, o ClozeMaster usa uma abordagem de "preencher as lacunas":

1. Mascaramento: Um trecho de código do conjunto de dados é selecionado. Uma Busca em Profundidade (DFS) identifica estruturas de colchetes ((), {}, [], <>). O conteúdo dentro desses colchetes é substituído por um token [mask].
   • Racional: Colchetes definem a sintaxe e a semântica do Rust. Preservar a estrutura externa garante que o código gerado permaneça sintaticamente válido, enquanto o conteúdo interno mascarado permite que o LLM explore casos de borda.
2. Preenchimento: O LLM ajustado finamente é solicitado a preencher as partes mascaradas.
   • Tratamento especial é aplicado a blocos de "recursos" (por exemplo, #![feature(...)]) para incentivar a geração de recursos experimentais conhecidos por serem instáveis.
   • Se o código preenchido for idêntico ao original, ele é descartado para garantir novidade.

D. Oráculo e Filtragem

• Oráculos: O sistema compila o código gerado usando rustc e mrustc.
  • ICE (Erro Interno do Compilador): Detectado via falha ou mensagens de "internal compiler error".
  • Travamento (Hang): Detectado se a compilação exceder um tempo limite de 180 segundos.
• Deduplicação: Rastros de pilha e informações de "time-passes" são armazenados para filtrar bugs duplicados.

3. Principais Contribuições

1. Estratégia ClozeMask: Uma abordagem inovadora que mascara segmentos de código delimitados por colchetes em relatórios históricos de bugs e usa LLMs para preenchê-los. Isso preserva a integridade estrutural necessária para o Rust, enquanto aproveita os LLMs para gerar variações novas e potencialmente com bugs.
2. Framework CLOZEMASTER: A primeira ferramenta de fuzzing especificamente projetada para compiladores Rust que integra dados históricos de bugs, aumento de dados e ajuste fino de LLMs.
3. Validação Empírica: Avaliação extensa em dois compiladores (rustc e mrustc) demonstrando desempenho superior em relação às bases de comparação existentes.

4. Resultados Experimentais

Os autores avaliaram o ClozeMaster contra três bases de comparação: RustSmith (generativo), Rustlantis (generativo) e SPE (baseado em mutação).

• Detecção de Bugs:
  • Total Reportado: 37 bugs.
  • Confirmados: 27 bugs (10 corrigidos pelos desenvolvedores).
  • Comparação: O ClozeMaster encontrou 11 bugs únicos no rustc v1.73, enquanto as bases de comparação encontraram 0–1.
  • Novidade: Muitos bugs estavam latentes em versões tão antigas quanto v1.56 (mais de 2 anos de idade), escapando da detecção por outras ferramentas.
• Cobertura de Código:
  • O ClozeMaster alcançou 64,34% de cobertura de código.
  • Isso representa um aumento relativo de 95,92% sobre o RustSmith (32,84%) e 117,73% sobre o Rustlantis (29,55%).
  • Também superou o SPE (62,02%).
• Cobertura de Componentes: Bugs foram encontrados em diversos componentes do compilador, incluindo analisadores sintáticos, macros, traits, tempos de vida e genéricos constantes. Notavelmente, o recurso "generic const exprs" foi uma grande fonte de ICEs.

5. Significado e Discussão

• Eficácia de Dados Históricos: O estudo confirma que trechos de código que historicamente acionaram bugs contêm conhecimento valioso específico de domínio. Usá-los como base para mascaramento/preenchimento é mais eficaz do que geração aleatória ou geração pura por LLM.
• Importância do Contexto: Estudos de ablação mostraram que remover dados históricos de bugs ou usar um modelo não ajustado finamente degradou significativamente o desempenho. Além disso, usar um LLM sem o contexto "cloze" (gerando do zero) resultou principalmente em sintaxe inválida.
• Seleção de Modelo: O artigo destaca que LLMs de propósito geral (como GPT-4o) ou modelos treinados em código geral (StarCoder) performam mal no preenchimento de Rust devido a erros de sintaxe. O Incoder, treinado com estratégias de mascaramento aleatório, provou-se superior para esta tarefa específica.
• Impacto: O ClozeMaster demonstra que combinar padrões históricos de bugs com preenchimento por LLM é uma estratégia viável e poderosa para testar compiladores complexos e críticos para a segurança, como o do Rust, descobrindo casos de borda profundos que fuzzers tradicionais perdem.

Disponibilidade do Artefato: A implementação e a lista de bugs estão publicamente disponíveis em https://github.com/clozeMasterPro/clozeMaster.