SAFuzz: Semantic-Guided Adaptive Fuzzing for LLM-Generated Code

1. O Problema

A ascensão de assistentes de codificação baseados em Grandes Modelos de Linguagem (LLMs), como o GitHub Copilot e o Cursor, acelerou o desenvolvimento de software, mas criou um desafio crítico de segurança: a quantidade massiva de código gerado por IA supera a capacidade das estruturas de teste tradicionais.

As abordagens de teste existentes apresentam limitações significativas ao lidar com código gerado por IA:

• Testes de Unidade Baseados em LLM: (ex: ChatUniTest) focam na correção funcional e cobertura de código, mas falham em detectar falhas em tempo de execução como timeouts, estouro de memória (overflow) e inconsistências lógicas complexas.
• Verificação Formal: Embora ofereçam garantias fortes, são difíceis de escalar, exigem especialistas humanos e dependem da geração de invariantes que os LLMs ainda não dominam com precisão.
• Fuzzing Tradicional: Atribui orçamentos de tempo uniformes a todos os programas, desperdiçando recursos em código seguro e ignorando alvos de alto risco. Além disso, os harnesses (ambientes de teste) gerados automaticamente muitas vezes são genéricos, falhando em capturar restrições específicas do problema e gerando muitos falsos positivos ou falhas superficiais.

O resultado é que o código gerado por IA, embora pareça correto, pode conter vulnerabilidades algorítmicas (como complexidade inadequada ou estouro de inteiros) que só aparecem sob condições adversas.

2. Metodologia: O Framework SAFUZZ

O SAFUZZ é um framework híbrido de teste que combina análise semântica guiada por LLMs com técnicas tradicionais de fuzzing para uma alocação adaptativa de recursos. O sistema opera em três etapas principais:

A. Geração de Variantes de Prompt (Stage 1)

Para simular interações reais de usuários e explorar a variabilidade comportamental dos LLMs, o sistema gera múltiplas variações de prompt para cada problema algorítmico.

• Inclui variações semânticas (reordenação de restrições, foco em casos de borda) e variações "bugadas" (instruções intencionais para induzir erros, como uso de int em vez de long).
• Isso expõe uma maior variedade de vulnerabilidades algorítmicas e relacionadas a recursos.

B. Geração de Harness de Fuzzing Guiada por LLM (Stage 2)

Um agente LLM gera harnesses de teste específicos para cada problema, superando a limitação de drivers genéricos.

• Extração de Restrições: O LLM analisa a descrição do problema para extrair limites numéricos e tipos de dados, evitando a geração de entradas inválidas que explodiriam o espaço de busca.
• Geração de Oráculos Semânticos: Em vez de apenas verificar crashes, o sistema implementa oráculos específicos:
  1. Timeout: Detecta loops infinitos ou complexidade excessiva.
  2. Crash: Verifica violações de memória (ponteiros nulos, índices fora dos limites).
  3. Determinismo: Garante saídas consistentes para as mesmas entradas.
  4. Overflow: Detecta erros de tipo (ex: soma de grandes números em int).
• Loop de Validação: Um mecanismo de retry com feedback de compilação corrige erros de sintaxe ou API no harness gerado, garantindo escalabilidade.

C. Predição de Vulnerabilidade e Alocação Adaptativa (Stage 3)

Esta é a inovação central para eficiência. O sistema não trata todos os programas igualmente.

• Extração de Recursos Híbridos: Combina 6 métricas de análise estática (ex: complexidade ciclomática, linhas de código) com 8 recursos semânticos derivados de LLM (ex: risco de estouro de inteiro, risco de timeout baseado na complexidade do algoritmo vs. restrições do problema).
• Modelo de Predição: Um classificador Random Forest prevê a probabilidade de um programa conter vulnerabilidades ($p_i$).
• Alocação Adaptativa:
  1. Filtragem por Limiar: Programas com probabilidade abaixo de um limiar ($\theta$) são descartados imediatamente.
  2. Alocação Proporcional: O tempo de fuzzing restante é distribuído proporcionalmente à probabilidade de vulnerabilidade ($t_i \propto p_i$). Programas de alto risco recebem mais tempo.
  3. Parada Antecipada Dinâmica: O scheduler monitora a cobertura em tempo real. Se a cobertura estagnar (saturação), o teste é interrompido para realocar recursos a outros alvos.

3. Contribuições Principais

1. Framework Híbrido SAFUZZ: Integra geração de harnesses semânticos, oráculos específicos de domínio e alocação adaptativa de recursos.
2. Recursos Semânticos Guiados por LLM: Demonstra que métricas estáticas são insuficientes para detectar erros algorítmicos (como complexidade $O(n^2)$ em problemas que exigem $O(n)$) e propõe o uso de LLMs para pontuar riscos específicos (estouro, timeout, lógica).
3. Mecanismo de Alocação Adaptativa: Substitui a alocação uniforme de tempo por uma estratégia baseada em risco, filtrando código seguro e focando esforços nos alvos mais perigosos.
4. Geração de Harnesses Robusta: Um agente com loop de validação que gera harnesses compiláveis e semanticamente corretos, escalando linearmente com a complexidade do problema.

4. Resultados Experimentais

O sistema foi avaliado em um conjunto de dados de 96 problemas algorítmicos do CSES (gerando 1.152 variantes de código).

• Precisão na Discriminação de Vulnerabilidades: O SAFUZZ aumentou a precisão na filtragem de código seguro de 77,9% (GreenFuzz) para 85,7%, permitindo descartar mais código limpo sem perder bugs reais.
• Eficiência de Tempo: Redução de 1,71x no custo total de tempo de fuzzing em comparação com o estado da arte (GreenFuzz), mantendo um recall (taxa de detecção) comparável.
  • SAFUZZ: 141,3 minutos (detectou 226 bugs).
  • GreenFuzz: 242,9 minutos (detectou 232 bugs).
• Combinação com Testes de Unidade: Ao combinar SAFUZZ com geradores de testes de unidade (ChatUniTest), o recall de detecção de bugs aumentou de 67,3% para 79,5%, demonstrando que as duas abordagens detectam classes complementares de falhas.
• Escalabilidade: O agente de geração de harnesses manteve um crescimento linear no tempo de execução, mesmo com problemas complexos que exigiam tentativas de recriação (retry).

5. Significância

O SAFUZZ representa um avanço crucial na segurança do software gerado por IA. Ele demonstra que:

• A consciência semântica é essencial para testar código algorítmico, pois métricas estáticas tradicionais não conseguem capturar a lógica subjacente ou a adequação do algoritmo às restrições do problema.
• A alocação inteligente de recursos é viável e necessária para escalar o teste de milhões de linhas de código geradas por IA, permitindo que as equipes de segurança foquem apenas no que é realmente perigoso.
• A combinação de técnicas (fuzzing adaptativo + testes de unidade) oferece uma cobertura de segurança superior à soma das partes, abordando tanto falhas funcionais quanto falhas de tempo de execução e recursos.

Em resumo, o SAFUZZ oferece um caminho escalável para garantir a confiabilidade do código produzido por assistentes de IA, transformando o teste de uma tarefa uniforme e custosa em um processo dinâmico, orientado por risco e semanticamente consciente.