Mejorando las técnicas de fuzzing con LLMs

Los Modelos de Lenguaje Grande (LLMs) se han vuelto una herramienta clave para muchas tareas, incluido el código. Sin embargo, cuando se trata de bibliotecas de aprendizaje profundo, pueden haber errores que afectan no solo a las bibliotecas mismas, sino también a cualquier aplicación construida sobre ellas. Es crucial mantener la calidad de estas bibliotecas ya que se utilizan en áreas críticas como la salud y las finanzas.

Un método común para encontrar errores en el software se llama Fuzzing. Este método genera entradas aleatorias para probar el software y buscar errores. En el caso de las bibliotecas de aprendizaje profundo, crear programas de entrada válidos es un desafío. Estos programas deben seguir reglas específicas relacionadas con su lenguaje de programación y los tipos de cálculos que se están realizando.

Investigaciones recientes sugieren que los LLMs pueden utilizarse para ayudar a generar estos programas de entrada. Han sido entrenados con grandes cantidades de código y datos, lo que les da la capacidad de entender la sintaxis y la semántica de los lenguajes de programación. A pesar de esto, los LLMs a menudo crean programas que siguen patrones comunes similares a los que vieron en sus datos de entrenamiento, lo que puede no ser efectivo para el fuzzing.

#La Necesidad de Probar Casos Extremos

El fuzzing es más efectivo cuando puede generar casos de entrada inusuales o raros. Estos casos extremos pueden revelar errores que entradas normales no detectarían. Los métodos existentes que usan LLMs no siempre priorizan los casos extremos, limitándose en cambio a patrones de código más comunes. Por lo tanto, se necesita un nuevo enfoque para utilizar los LLMs para generar programas que puedan fuzzear efectivamente bibliotecas de aprendizaje profundo.

Este artículo presenta una técnica que guía a los LLMs para crear programas de entrada que se centran en casos extremos para el fuzzing. La base de esta técnica es la idea de que los programas históricos que desencadenaron errores pueden proporcionar segmentos de código útiles que pueden ayudar a descubrir nuevos errores.

#Enfoques Actuales de Fuzzing

Históricamente, las técnicas de fuzzing se pueden clasificar en dos categorías principales: fuzzing a nivel de modelo y fuzzing a nivel de API. El fuzzing a nivel de modelo funciona reutilizando modelos existentes o creando nuevos desde cero, pero a menudo tiene dificultades para cumplir con los requisitos complejos de las API de aprendizaje profundo. Por otro lado, el fuzzing a nivel de API se enfoca en APIs individuales, lo que puede limitar la capacidad de encontrar errores que surgen de la interacción de múltiples APIs.

Ambos métodos tienen sus limitaciones, lo que lleva a los investigadores a explorar alternativas que aprovechen las capacidades de los LLMs. La idea clave es que estos modelos están entrenados en un gran volumen de código, lo que los hace capaces de producir programas de entrada válidos. Sin embargo, su tendencia a generar código que sigue patrones típicos puede limitar su efectividad para identificar errores.

#Nuestra Técnica Propuesta

La técnica propuesta busca equipar a los LLMs para generar programas de entrada centrados en casos extremos para un fuzzing efectivo. Este enfoque se basa en la idea de que los programas históricos que desencadenaron errores contienen ingredientes valiosos para descubrir errores. Estudios previos han demostrado que usar información histórica puede ayudar a generar casos de prueba efectivos, pero los métodos tradicionales requieren un esfuerzo manual extenso.

Nuestro enfoque automatiza este proceso utilizando LLMs, que pueden aprender de los programas históricos que desencadenaron errores y producir nuevos ejemplos que sean similares en naturaleza. Esto elimina la necesidad de una anotación manual intensiva de fragmentos de código y permite la generación de casos de prueba más diversos y útiles.

#Construcción del Conjunto de Datos

Para implementar la técnica, comenzamos creando un conjunto de datos de fragmentos de código que desencadenan errores. Esto se puede lograr minando informes de errores de repositorios de código abierto relacionados con bibliotecas de aprendizaje profundo. El conjunto de datos incluye dos componentes críticos: el código que desencadena el error y la API problemática correspondiente.

#Minando la Historia de Errores

Para recopilar los datos necesarios, utilizamos un rastreador web para recolectar problemas y solicitudes de extracción de GitHub. Buscamos fragmentos de código dentro de estos informes que ilustren los errores. Estos fragmentos son esenciales para entrenar a los LLMs para replicar los patrones de código asociados con errores pasados.

A menudo, determinar la API problemática exacta a partir del fragmento de código no es sencillo. Para abordar esto, implementamos un proceso de etiquetado automatizado que utiliza LLMs para anotar los fragmentos de código con la API problemática correspondiente. Esto minimiza las anotaciones necesarias de expertos humanos y permite un enfoque más escalable.

#Estrategias de Aprendizaje

Una vez que tenemos nuestro conjunto de datos, podemos centrarnos en generar programas de entrada utilizando diferentes estrategias de aprendizaje. Consideramos dos métodos principales: aprendizaje en contexto y ajuste fino.

#Aprendizaje en Contexto

El aprendizaje en contexto implica proporcionar a los LLMs ejemplos de código que desencadenen errores ya sea a través de aprendizaje de pocos ejemplos o suministrando programas parciales que desencadenen errores. Esto permite que el modelo aprenda a generar nuevos fragmentos de código que puedan invocar errores similares.

La idea es presentar al LLM ejemplos relevantes y dejar que prediga nuevos segmentos de código basándose en lo que ha aprendido. Al diseñar cuidadosamente los mensajes de entrada, guiamos al LLM para que entienda los patrones asociados con los errores y use ese conocimiento para crear código nuevo, potencialmente problemático.

#Ajuste Fino

Además del aprendizaje en contexto, podemos ajustar finamente el LLM en el conjunto de datos de fragmentos de código que desencadenan errores. El ajuste fino modifica los pesos del modelo en función de los ejemplos específicos en nuestro conjunto de datos, haciéndolo más hábil para generar fragmentos de código que reflejen errores históricos.

Al entrenar al modelo en un conjunto de datos que incluye varios patrones que desencadenan errores, mejoramos su capacidad para generar nuevos programas que retengan las características necesarias para un fuzzing efectivo. Este método puede mejorar significativamente el rendimiento del modelo en la identificación de errores.

#Evaluación de la Técnica

Evaluamos la efectividad de nuestra técnica propuesta aplicándola a dos bibliotecas populares de aprendizaje profundo y comparando los resultados con los fuzzers existentes.

#Detección de Errores

Una de las métricas principales para evaluar la efectividad es el número de errores únicos detectados a través del fuzzing. La capacidad de nuestra técnica para generar entradas de casos extremos puede llevar a la identificación de nuevos errores que podrían pasarse por alto con métodos tradicionales. Utilizamos múltiples métodos oráculo para verificar los errores encontrados, incluyendo chequeos de fallos y inconsistencias en varios entornos de ejecución.

#Métricas de Cobertura

Además de detectar errores, medimos la cobertura de los programas generados. Esto implica evaluar cuántas APIs diferentes se probaron y cuánto del código se ejecutó durante el proceso de fuzzing. Alta cobertura indica una mayor probabilidad de descubrir errores ocultos.

#Comparaciones con Otros Fuzzers

Para entender mejor la efectividad de nuestro enfoque, lo comparamos con fuzzers existentes, tanto a nivel de modelo como a nivel de API. Al analizar el rendimiento en métricas como tasas de detección de errores y cobertura de código, podemos demostrar las ventajas que ofrece nuestra técnica.

#Resultados y Hallazgos

Nuestra evaluación revela que la técnica propuesta supera significativamente a los fuzzers existentes en la detección de errores y en lograr una mayor cobertura de código. Nuestro enfoque basado en LLM conduce al descubrimiento de nuevos errores en ambas bibliotecas, muchos de los cuales son de alta prioridad o están relacionados con la seguridad.

Los hallazgos también destacan la efectividad de la generación de programas de casos extremos. Al guiar estructuralmente al LLM para que se enfoque en patrones históricos que desencadenan errores, podemos facilitar la identificación de errores sutiles que tienden a permanecer ocultos durante pruebas rutinarias.

#Conclusión

En resumen, la técnica propuesta muestra el potencial de usar código histórico que desencadena errores para guiar a los LLMs en el fuzzing de bibliotecas de aprendizaje profundo. Este método totalmente automatizado mejora la capacidad de generar entradas de casos extremos, mejorando significativamente la detección de errores y la cobertura de código en comparación con los enfoques tradicionales de fuzzing.

El éxito de este método no solo indica el valor de los datos históricos en las pruebas de software, sino que también proporciona un marco escalable que puede adaptarse a varios lenguajes de programación y bibliotecas. En general, aprovechar los LLMs para el fuzzing abre nuevas avenidas para mejorar la calidad y confiabilidad del software, especialmente en dominios de aplicación críticos.