LLM4C2Rust: Large Language Models for Automated Memory-Safe Code Transpilation

1. Problema e Motivação

A segurança de memória é um desafio crítico na engenharia de software, especialmente em sistemas legados escritos em C e C++, onde a gestão manual de memória frequentemente leva a vulnerabilidades como estouro de buffer, ponteiros pendentes e condições de corrida. Estima-se que cerca de 70% das vulnerabilidades de segurança derivem desses problemas.

Embora a linguagem Rust ofereça garantias de segurança de memória em tempo de compilação (através de seu modelo de propriedade e empréstimo), a migração manual de grandes bases de código C/C++ para Rust é custosa, demorada e propensa a erros. As abordagens automatizadas existentes baseadas em regras (como o C2Rust) tendem a gerar código Rust "não idiomático" que ainda contém blocos unsafe e mantém padrões de baixo nível do C. Por outro lado, os Modelos de Linguagem de Grande Escala (LLMs) mostram-se promissores para gerar código mais idiomático, mas sofrem com alucinações (geração de informações falsas) e falta de garantias semânticas, o que pode comprometer a segurança do código transpilado.

2. Metodologia Proposta

Os autores propõem um framework híbrido que integra LLMs com Retrieval-Augmented Generation (RAG) para automatizar a transpilação de C/C++ para Rust, com foco explícito na eliminação de práticas inseguras.

Arquitetura do Framework

O processo segue um pipeline de duas etapas principais, auxiliado por uma estratégia de segmentação e verificação:

1. Segmentação do Código:

   • O código fonte C/C++ não é processado inteiro, mas dividido em blocos equilibrados.
   • A segmentação é baseada no balanceamento de chaves {} e no tamanho (mínimo de 500 caracteres), garantindo que funções não sejam cortadas ao meio. Isso permite que o LLM tenha contexto suficiente sem exceder os limites de tokens.

2. Pipeline de Transpilação em Duas Etapas:

   • Etapa 1 (Transpilação Inicial): O LLM converte cada segmento para Rust, permitindo o uso de construções unsafe para preservar o comportamento funcional original.
   • Etapa 2 (Refinamento para Segurança): O código Rust inicial é reprocessado pelo LLM com instruções explícitas para melhorar a segurança, eliminando ponteiros brutos (Raw Pointer Dereferences - RPDs) e conversões de tipo inseguras (Unsafe Type Casts - UTCs).

3. Integração RAG (Geração Aumentada por Recuperação):

   • Durante o refinamento, o prompt do LLM é enriquecido com contexto recuperado de fontes externas, como documentação oficial do Rust, melhores práticas de segurança e exemplos de padrões de ponteiros seguros.
   • Isso visa reduzir alucinações e guiar o modelo para soluções idiomáticas e seguras.

4. Camada de Verificação:

   • O sistema utiliza o compilador Rust (rustc) e scripts personalizados para verificar o código gerado.
   • Métricas de segurança são extraídas diretamente dos erros de compilação (códigos de erro específicos para RPDs e UTCs) e da contagem de linhas/blocos unsafe.
   • O sistema compara as contagens "auto-relatadas" pelo LLM com as contagens verificadas pelo compilador para medir a taxa de alucinação.

Modelos Utilizados

O estudo avaliou três modelos da OpenAI:

• GPT-4o e GPT-4-Turbo (LLMs grandes).
• o3-mini (Small Language Model - SLM).

3. Contribuições Principais

1. Framework de Transpilação Híbrido: Proposição de uma nova arquitetura que combina a fluidez dos LLMs com a precisão determinística de ferramentas estáticas (RAG e compilador) para transpilar C/C++ para Rust seguro.
2. Avaliação de Segurança e Corretude: Análise empírica da capacidade de LLMs de gerar código Rust que mantém a equivalência funcional, mas elimina violações de segurança de memória.
3. Mitigação de Alucinações via RAG: Investigação e demonstração de que o enriquecimento de prompts com contexto recuperado (documentação e exemplos) reduz significativamente as alucinações e melhora a precisão das métricas de segurança reportadas pelo modelo.
4. Benchmarking Comparativo: Comparação direta com abordagens anteriores (C2SaferRust e LAC2R), demonstrando superioridade na redução de construções inseguras.

4. Resultados Experimentais

O estudo foi realizado em sete programas do pacote GNU Coreutils (como cat, uniq, head, tail, etc.).

• Desempenho dos Modelos Grandes (GPT-4o e GPT-4-Turbo):

  • Ambos os modelos demonstraram alta eficácia na redução de RPDs e UTCs.
  • O GPT-4-Turbo obteve os melhores resultados, eliminando quase todos os RPDs e UTCs em 5 dos 7 programas, alcançando código totalmente seguro em vários casos.
  • Houve uma forte correlação entre as estimativas de segurança do modelo e a verificação do compilador, indicando baixa taxa de alucinação quando auxiliado pelo RAG.
  • Reduções drásticas foram observadas em Linhas de Código Inseguras (ULoCs), com alguns programas caindo de centenas para apenas 1 ou 0 linha insegura.

• Desempenho do Modelo Pequeno (o3-mini):

  • Embora produzisse código sintaticamente correto, o o3-mini apresentou alta taxa de alucinação.
  • O modelo frequentemente superestimava as melhorias de segurança (ex: relatava redução de ponteiros que o compilador ainda detectava).
  • Em alguns casos, o código final gerado pelo o3-mini era menos seguro que o original, apesar de inserir diretivas de segurança (#![forbid(unsafe_code)]) que não eliminavam efetivamente os blocos inseguros existentes.

• Comparação com Baselines:

  • A abordagem proposta superou consistentemente métodos anteriores como C2SaferRust e LAC2R, especialmente na eliminação de ponteiros brutos e conversões de tipo inseguras.

5. Significado e Conclusão

O artigo conclui que a transpilação automatizada de C/C++ para Rust seguro é viável e altamente eficaz quando se utiliza LLMs aprimorados por RAG.

• Impacto na Segurança: A abordagem permite a modernização de sistemas legados críticos, reduzindo drasticamente a superfície de ataque associada a erros de memória.
• Confiabilidade: A integração de RAG não apenas melhora a qualidade do código, mas também aumenta a confiabilidade do LLM ao fornecer contexto factual, reduzindo a discrepância entre o que o modelo "pensa" que fez e o que o compilador verifica.
• Futuro: Os autores planejam escalar o método para bases de código maiores (como o conjunto de dados LAERTES) e explorar a reconfiguração de Rust para Rust, visando a adoção industrial em larga escala.

Em suma, o trabalho valida que a combinação de inteligência artificial generativa com recuperação de conhecimento especializado é uma via promissora para resolver o desafio da segurança de memória em sistemas legados.