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

1. El Problema

La seguridad de la memoria es un desafío crítico en la ingeniería de software, especialmente en sistemas heredados escritos en C y C++. Se estima que el 70% de las vulnerabilidades de seguridad provienen de problemas de seguridad de la memoria (desbordamientos de búfer, punteros colgantes, condiciones de carrera). Aunque Rust ofrece garantías de seguridad de memoria en tiempo de compilación mediante su modelo de propiedad y préstamo, migrar manualmente grandes bases de código C/C++ a Rust es costoso, lento y propenso a errores.

Las soluciones automáticas existentes presentan limitaciones:

• Enfoques basados en reglas: A menudo generan código Rust no idiomático que conserva bloques unsafe y patrones de bajo nivel, limitando los beneficios de seguridad.
• Modelos de Lenguaje Grande (LLM) puros: Aunque pueden generar código más idiomático, sufren de alucinaciones (generar información falsa o incorrecta) y carecen de garantías semánticas, lo que puede resultar en código que no compila o que viola la seguridad de la memoria.

2. Metodología Propuesta

Los autores proponen un marco de trabajo híbrido que integra Modelos de Lenguaje Grande (LLM) con un pipeline de Generación Aumentada por Recuperación (RAG) para transpilar código C/C++ a Rust seguro.

Arquitectura del Sistema

El enfoque se divide en tres componentes principales:

1. Segmentación y Transpilación:

   • El código fuente C/C++ se divide en bloques equilibrados (basados en el conteo de llaves {} y longitud de caracteres, mínimo 500 caracteres) para mantener el contexto funcional sin exceder los límites de tokens.
   • Se genera un resumen natural del propósito del programa para mantener la intención global.
   • Fase 1 (Transpilación Inicial): El LLM convierte los segmentos a Rust, permitiendo el uso de constructos unsafe para preservar el comportamiento original.
   • Fase 2 (Refinamiento): El código Rust inicial se vuelve a procesar con instrucciones explícitas para eliminar punteros crudos (Raw Pointer Dereferences - RPDs) y conversiones de tipo inseguras (Unsafe Type Casts - UTCs), buscando maximizar la seguridad.

2. Pipeline RAG (Recuperación Aumentada):

   • Para mitigar las alucinaciones, el sistema recupera contexto relevante de documentación de Rust, mejores prácticas de seguridad y patrones de código antes de generar la respuesta.
   • Se utiliza una estrategia de fragmentación (chunking) optimizada para documentos externos y archivos generados, asegurando que el LLM tenga acceso a conocimiento específico sobre manejo seguro de punteros y casting.

3. Capa de Verificación:

   • Autoevaluación del LLM: El modelo estima la reducción de constructos inseguros.
   • Verificación del Compilador: Se utiliza rustc y scripts personalizados para contar errores reales de compilación relacionados con RPDs (códigos E0133, E0392, E0793) y UTCs (E0604–E0607), así como líneas de código inseguras (ULoCs) y bloques unsafe.

Configuración Experimental

• Modelos evaluados: GPT-4o, GPT-4-Turbo (LLMs) y o3-mini (SLM - Small Language Model).
• Dataset: Siete programas de GNU Coreutils (uniq, cat, pwd, truncate, head, split, tail) escritos en C.
• Parámetros: Temperatura = 0 para garantizar reproducibilidad.

3. Contribuciones Clave

1. Nuevo Marco de Transpilación: Propuesta de un pipeline que combina LLMs con RAG específicamente diseñado para mejorar la seguridad de la memoria en la transpilación C/C++ a Rust, no solo la corrección funcional.
2. Evaluación Rigurosa: Análisis de la capacidad de los LLMs de última generación para generar código seguro manteniendo la equivalencia funcional, utilizando métricas cuantitativas verificadas por compilador.
3. Mitigación de Alucinaciones: Demostración de que el enriquecimiento de prompts con recuperación de contexto (RAG) reduce significativamente las alucinaciones y mejora la precisión factual en la generación de código.
4. Comparativa de Modelos: Evaluación comparativa entre modelos grandes (GPT-4) y modelos pequeños (o3-mini), revelando diferencias en la comprensión semántica de la seguridad.

4. Resultados Principales

Los experimentos se centraron en la reducción de RPDs (Desreferencias de Punteros Crudos), UTCs (Conversiones de Tipo Inseguras) y ULoCs (Líneas de Código Inseguras).

• Rendimiento de GPT-4o y GPT-4-Turbo:
  • Ambos modelos lograron reducciones significativas en constructos inseguros.
  • GPT-4-Turbo obtuvo los mejores resultados generales, eliminando casi todos los RPDs y UTCs en 5 de los 7 programas (ej. uniq, cat, head, split). En muchos casos, el código final compiló sin errores de seguridad.
  • Ambos modelos mostraron una alta correlación entre sus estimaciones auto-reportadas y la verificación del compilador, indicando una menor tasa de alucinación en comparación con modelos más pequeños.
• Rendimiento de o3-mini (SLM):
  • Aunque generó código sintácticamente correcto, mostró una tasa de alucinación mucho más alta.
  • A menudo sobreestimó las mejoras de seguridad (ej. reportó reducciones drásticas que el compilador no confirmó).
  • En algunos casos (como cat y tail), el código final generó más constructos inseguros que la versión original, a pesar de la inserción de directivas de seguridad declarativas (#![forbid(unsafe_code)]).
• Comparación con el Estado del Arte:
  • El enfoque RAG-LLM superó a métodos anteriores como C2SaferRust y LAC2R, logrando reducciones de constructos inseguros mucho mayores (en algunos casos del 100% en RPDs y UTCs).

5. Significado e Impacto

Este trabajo demuestra que la combinación de LLMs avanzados con pipelines RAG es una vía viable y superior para la modernización automática de software legado.

• Seguridad: Permite transformar sistemas críticos escritos en C en Rust con garantías de seguridad de memoria, reduciendo la superficie de ataque.
• Eficiencia: Automatiza un proceso que antes requería meses de trabajo manual, haciendo factible la migración de infraestructura crítica.
• Fiabilidad: La integración de RAG mitiga el problema de las alucinaciones, un obstáculo principal para la adopción de IA en tareas de ingeniería de software de alta precisión.
• Futuro: El marco sienta las bases para agentes de IA capaces de gestionar migraciones de código a gran escala, con aplicaciones potenciales en sistemas operativos, controladores y software embebido.

En conclusión, el estudio valida que los LLMs asistidos por RAG no solo pueden transpilar código, sino hacerlo de manera segura, idiomática y verificable, superando las limitaciones de las herramientas de transpilación tradicionales y de los modelos de IA sin contexto.