💻 computer science

RustGo: Fairly Directed Greybox Fuzzing for Enforcing Rust Memory Safety

RustGo es un nuevo fuzzer de caja gris dirigido que aprovecha el análisis estático específico de Rust para identificar automáticamente posibles objetivos de errores de memoria y podar rutas de ejecución irrelevantes, mejorando así significativamente la eficiencia del fuzzing y descubriendo vulnerabilidades desconocidas en código Rust inseguro en comparación con los enfoques existentes.

Autores originales: Dongyeon Yu (Korea University), Jiun Min (Korea University), Yewan Na (Ulsan National Institute of Science and Technology), Mijung Kim (Ulsan National Institute of Science and Technology), Taegyu Kim

Publicado 2026-08-07

📖 7 min de lectura🧠 Análisis profundo

CC BY 4.0

Autores originales: Dongyeon Yu (Korea University), Jiun Min (Korea University), Yewan Na (Ulsan National Institute of Science and Technology), Mijung Kim (Ulsan National Institute of Science and Technology), Taegyu Kim (The Pennsylvania State University), Yuseok Jeon (Korea University)

Artículo original bajo licencia CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta es una explicación generada por IA del artículo a continuación. No ha sido escrita ni avalada por los autores. Para mayor precisión técnica, consulte el artículo original. Leer descargo de responsabilidad completo

Imagina que eres un detective intentando encontrar un fallo diminuto y único en una ciudad enorme y bulliciosa. En el mundo del software informático, este programa es una ciudad, y el fallo es un "error de memoria" (memory bug): un error donde el programa intenta tomar, usar o desechar datos que no debería, provocando que se bloquee o sea hackeado. Durante décadas, la forma más popular de encontrar estos errores ha sido el "fuzzing". Piensa en el fuzzing como lanzar millones de bolas de nieve aleatorias y caóticas contra las murallas de la ciudad para ver si alguna rompe una ventana. Normalmente, esto funciona bien para los lenguajes antiguos, pero hay un inconveniente: es increíblemente ineficiente. Podrías lanzar 99 bolas de nieve contra la puerta principal, robusta e inquebrantable, solo para encontrar la única ventana débil en un callejón trasero.

Entra Rust, un lenguaje de programación moderno que actúa como un guardia de seguridad súper estricto. Las reglas de Rust son tan buenas que el 90% de la ciudad que construye es prácticamente a prueba de balas; el guardia asegura que la mayoría de las "ventanas" (áreas de memoria) estén cerradas con llave por defecto. Sin embargo, para construir ciertas cosas complejas, Rust permite a los desarrolladores abrir una pequeña y especial puerta llamada "código inseguro" (unsafe code). Este es el único lugar donde las reglas estrictas se relajan, y es el único lugar donde un error de memoria puede esconderse. El problema es que las herramientas de "lanzamiento de bolas de nieve" existentes no saben esto. Siguen lanzando bolas de nieve al 90% de la ciudad que ya es segura, desperdiciando tiempo y energía, mientras pasan por alto los pocos puntos peligrosos detrás de la puerta especial. Este artículo presenta una nueva herramienta de detective llamada RustGo que cambia las reglas del juego al saber exactamente dónde lanzar las bolas de nieve.

El Detective Inteligente: RustGo

Los investigadores detrás de este artículo, un equipo de la Universidad de Corea y otras instituciones, se dieron cuenta de que lanzar bolas de nieve aleatoriamente a un programa de Rust es como intentar encontrar una aguja en un pajar quemando todo el pajar. Dado que Rust garantiza la seguridad de la mayor parte de su código, se preguntaron: ¿Por qué probar las partes seguras? Construyeron RustGo, un "fuzzer de caja gris dirigido" (directed greybox fuzzer) que actúa como un detective con un mapa y una lupa, en lugar de una persona con los ojos vendados lanzando piedras.

RustGo funciona en tres pasos ingeniosos para cazar errores de manera eficiente:

1. Encontrar los Objetivos Adecuados (El Mapa)
Primero, RustGo escanea el código para encontrar las zonas "inseguras" donde podrían esconderse los errores. Pero no solo adivina. Utiliza un tipo especial de análisis para observar cómo fluyen los datos a través del programa. Imagina que la ciudad tiene muchos callejones, pero algunos conducen a callejones sin salida o bucles que nunca ocurren en la vida real. RustGo los filtra. Identifica los puntos específicos donde un error de memoria podría activarse y luego fusiona los puntos similares. Si dos caminos diferentes en el código conducen exactamente al mismo resultado peligroso, RustGo los trata como uno solo, para no perder tiempo comprobando lo mismo dos veces. En sus pruebas, este paso les ayudó a reducir el número de objetivos que necesitaban comprobar en aproximadamente un 84%, centrándose solo en las áreas verdaderamente sospechosas.

2. Cortar los Callejones sin Salida (La Lupa)
Una vez que RustGo sabe dónde mirar, debe ignorar el resto de la ciudad. En las herramientas de fuzzing antiguas, el "mapo" de la ciudad a menudo incluía la biblioteca estándar (las herramientas preconstruidas que usa Rust), que es enorme y está llena de rutas que parecen alcanzables pero que en realidad no lo son. Esto confundía a las herramientas, haciendo que exploraran áreas inútiles. RustGo introdujo un nuevo truco llamado "poda de rutas específica del objetivo" (target-specific path pruning). Es como tener una valla mágica que hace desaparecer instantáneamente cualquier camino que no conduzca al objetivo específico que estás investigando en ese momento. Si el detective está buscando un error en la panadería, la valla bloquea los caminos hacia la biblioteca o el parque, incluso si esos caminos técnicamente existen en la ciudad. Esto permitió a RustGo cortar el 78.49% de las rutas irrelevantes que otras herramientas perderían tiempo explorando.

3. Jugar Limpio (La Estrategia Round-Robin)
Aquí llega el giro final y crucial. Cuando un detective tiene múltiples sospechosos (objetivos) que revisar, las herramientas antiguas a menudo se obsesionan con el más fácil de alcanzar, ignorando los más difíciles. RustGo utiliza un sistema de "conmutación dinámica justa" (dynamic fair toggling). Imagina a un árbitro que cambia la atención del detective entre los sospechosos en una rotación perfecta. Si el detective pasa demasiado tiempo con el Sospechoso A, el árbitro inmediatamente lo cambia al Sospechoso B, asegurando que cada sospechoso reciba una cantidad justa de atención. RustGo hace esto asignando a cada objetivo su propia "cola" de bolas de nieve y su propio "tarjetero de puntuación" para rastrear el progreso. Esto asegura que ningún punto peligroso quede sin probar solo por ser ligeramente más difícil de alcanzar.

Los Resultados: Más Rápido y Más Inteligente

El equipo probó RustGo en 13 aplicaciones de Rust del mundo real, que van desde servidores web hasta herramientas de procesamiento de datos. Compararon RustGo con las mejores herramientas existentes, incluyendo la famosa AFL++ y varios fuzzers "dirigidos" especializados. Los resultados fueron impactantes.

Debido a que RustGo dejó de perder el tiempo en el 90% de código seguro y se centró puramente en el 10% peligroso, encontró vulnerabilidades de 2.09 a 5.08 veces más rápido que las otras herramientas. En algunos casos, como en la aplicación gimli, fue más de 10 veces más rápido. Para poner esto en perspectiva, si una herramienta antigua tardara 10 horas en encontrar un error, RustGo lo encontró en menos de una hora.

Pero la velocidad no es la única victoria. El equipo utilizó RustGo para cazar errores en el mundo real, no solo en su laboratorio de pruebas. Descubrieron 13 errores de memoria previamente desconocidos en software del mundo real. De estos, 10 fueron confirmados por los desarrolladores del software, y 8 ya han sido corregidos. Aún más impresionante, 6 de estos errores recibieron IDs de seguridad oficiales (RUSTSEC), y uno recibió un ID CVE, que es el estándar global para rastrear fallos de seguridad graves. Esto demuestra que RustGo no es solo una idea teórica; es una herramienta práctica que ya está haciendo el software más seguro.

Por Qué Esto Importa

Este artículo no solo sugiere que RustGo es una buena idea; lo mide, lo demuestra y muestra cómo encuentra errores reales que otros pasaron por alto. Argumenta explícitamente en contra de la vieja forma de pensar: que debemos probar cada línea de código para estar seguros. En su lugar, muestra que, al comprender las reglas únicas de Rust, podemos ser más inteligentes, más rápidos y más efectivos.

Los investigadores también abordaron una preocupación común: "¿Qué pasa si nos perdemos un error al ignorar las partes seguras?". Explican que las reglas de seguridad de Rust son tan estrictas que los errores de memoria espacial (como acceder a la dirección de memoria incorrecta) simplemente no pueden ocurrir en las partes seguras del código. Por lo tanto, ignorarlas no crea un punto ciego; simplemente elimina el ruido. Para los errores temporales (usar la memoria después de haber sido liberada), RustGo es cuidadoso para asegurar que no poda accidentalmente un camino que podría conducir a un error, utilizando un enfoque "conservador" que mantiene la red de seguridad lo suficientemente amplia como para atraparlo todo.

Al final, RustGo es un testimonio del poder de la especialización. Así como un maestro chef no usa un martillo para romper una nuez, un fuzzer moderno no debería usar un instrumento romo en un lenguaje tan sofisticado como Rust. Al adaptar el enfoque a las fortalezas y debilidades únicas del lenguaje, los autores han creado una herramienta que no solo es más rápida, sino también más justa, asegurando que cada peligro potencial en el código reciba la atención que merece.

Resumen Técnico: RustGo

Planteamiento del Problema

Rust garantiza la seguridad de la memoria mediante políticas estrictas en tiempo de compilación (propiedad, préstamo, tiempos de vida), sin embargo, los errores de memoria persisten en las regiones unsafe donde estas políticas se omiten. Aunque el código unsafe constituye una fracción pequeña de los programas típicos de Rust (aproximadamente el 10%), los enfoques de fuzzing existentes tratan a todo el código base como una fuente potencial de errores. Esto resulta en una asignación ineficiente de recursos, ya que los fuzzers desperdician esfuerzos en regiones de memoria segura que el propio compilador de Rust ya garantiza como seguras.

Además, las soluciones de Fuzzing de Caja Gris Dirigido (DGF) existentes, diseñadas originalmente para C/C++, enfrentan desafíos significativos al aplicarse a Rust:

Identificación de Objetivos: Los métodos tradicionales dependen de la selección manual o de criterios simples (por ejemplo, ubicaciones de sanitizers) y no logran identificar automáticamente objetivos propensos a errores de memoria específicos de la arquitectura única de Rust, como las desreferencias de punteros crudos en código seguro que están aliasadas a punteros inseguros.
Poda de Rutas (Path Pruning): La biblioteca estándar de Rust está vinculada estáticamente y monomorfizada, lo que crea un binario complejo y unificado. Los análisis de alcanzabilidad existentes suelen sobreaproximar, fallando al podar rutas irrelevantes porque no pueden distinguir eficazmente entre el código del usuario y la lógica de la biblioteca estándar.
Equidad en el Fuzzing de Múltiples Objetivos: Los DGF de múltiples objetivos existentes suelen priorizar los objetivos más "cercanos", lo que provoca la inanición de objetivos distantes pero vulnerables. El estado compartido de fuzzing (una única cola de entrada, un único bitmap de cobertura) dificulta la asignación equitativa de energía entre múltiples objetivos distintos.

Metodología

El artículo propone RustGo, un fuzzer de caja gris dirigido para Rust diseñado para identificar, optimizar y realizar fuzzing de manera justa de las regiones propensas a errores de memoria. RustGo opera a través de tres componentes principales:

1. Identificación y Optimización de Objetivos

RustGo emplea un análisis estático de múltiples etapas para identificar objetivos vulnerables:

Análisis de MIR e IR de LLVM: Realiza un análisis de coincidencia de tipos al nivel de la Representación Intermedia de Nivel Medio (MIR) para identificar operaciones de punteros crudos, que no se preservan en el IR de LLVM. Luego, utiliza un análisis de trazado basado en el Grafo de Flujo de Valores (VFG) al nivel de IR de LLVM para rastrear la propagación de punteros e identificar sitios de alias.
Filtrado de la Biblioteca Estándar: Para evitar falsos positivos causados por un análisis insensible al contexto de la biblioteca estándar monomorfizada, RustGo anota las funciones de la biblioteca estándar. Utiliza aristas del Grafo de Flujo de Control Interprocedural (ICFG) para propagar el rastro a través de los límites de la biblioteca sin atravesar la lógica interna de la misma, filtrando eficazmente las rutas inalcanzables.
Optimización de Post-dominancia: Para reducir el número de objetivos y evitar que el fuzzer degrade a un fuzzer de cobertura guiada genérico, RustGo realiza un análisis de post-dominancia interprocedural. Si un objetivo $t_i$ está post-dominado por $t_j$ (lo que significa que todos los caminos hacia $t_i$ deben pasar por $t_j$ ), $t_i$ se fusiona con $t_j$ . Esto reduce los objetivos redundantes al consolidarlos en ubicaciones representativas.

2. Poda de Rutas Específica del Objetivo

Una vez identificados los objetivos, RustGo elimina las rutas irrelevantes para maximizar la eficiencia del fuzzing:

Remapeo de Sitios de Llamada: Los objetivos ubicados dentro de la biblioteca estándar se remapean a sus correspondientes sitios de invocación en el código del usuario para asegurar un análisis de alcanzabilidad preciso.
Poda Consciente de Precondiciones:
- Para errores espaciales (desreferencias de punteros crudos), no se aplica poda, ya que estos pueden ocurrir sin precondiciones específicas.
- Para errores temporales (por ejemplo, Uso-Después-Liberación/Use-After-Free), RustGo aprovecha los resultados del análisis de trazado para verificar si una ruta contiene la secuencia de operaciones de memoria necesaria (por ejemplo, alloc $\to$ free $\to$ dereference). Las rutas que carecen de estas secuencias son podadas.
- Manejo de Async/Await: Para evitar falsos negativos en código concurrente, RustGo deshabilita conservadoramente la poda para funciones que involucran async/await y alias de punteros crudos.

3. Fuzzing de Conmutación Justa Dinámica (Dynamic Fair Toggling Fuzzing)

Para asegurar una prueba equitativa entre múltiples objetivos sin interferencias, RustGo introduce un mecanismo de conmutación dinámica:

Multi-Cola y Multi-Cobertura: A diferencia de los fuzzers tradicionales que utilizan una única cola de entrada y un bitmap de cobertura global, RustGo mantiene colas de entrada y bitmaps de cobertura independientes para cada objetivo.
Conmutación Dinámica (Dynamic Toggle): El fuzzer cambia entre objetivos en un orden circular (round-robin). Cuando un objetivo está activo, el sistema actualiza una "Memoria Compartida de Conmutación" (TSM) para habilitar dinámicamente solo los bloques básicos relevantes para ese objetivo específico. Esto permite al fuzzer podar rutas irrelevantes en tiempo real para el objetivo actual mientras mantiene estados de fuzzing independientes, asegurando que ningún objetivo sufra de inanición de recursos.

Contribuciones Clave

Marco de Trabajo RustGo: Un nuevo fuzzer de caja gris dirigido diseñado específicamente para Rust, capaz de identificar y optimizar automáticamente objetivos propensos a errores de memoria utilizando análisis estático específico de Rust (análisis cruzado MIR/IR de LLVM, rastreo de trazado y post-dominancia).
Poda Específica del Objetivo: Una estrategia de poda novedosa que maneja la compleja estructura y monomorfización de la biblioteca estándar de Rust, logrando una alta precisión en la eliminación de rutas irrelevantes.
Fuzzing de Múltiples Objetivos Justo: Un enfoque de conmutación dinámica con esquemas de multi-cola y multi-cobertura que asegura una asignación equilibrada de energía entre múltiples objetivos, evitando el sesgo hacia objetivos fácilmente alcanzables común en los DGF existentes.
Evaluación y Descubrimiento: Evaluación exhaustiva en aplicaciones reales de Rust, demostrando mejoras significativas de rendimiento sobre los fuzzers de vanguardia y el descubrimiento de 13 errores de memoria previamente desconocidos.

Resultados

Los autores evaluaron RustGo en un benchmark personalizado de 13 aplicaciones reales de Rust y el benchmark deepSURF (26 errores reales).

Optimización de Objetivos: RustGo redujo el número de objetivos iniciales en un promedio del 84.13% mediante la consolidación por post-dominancia.
Poda de Rutas: RustGo podó un promedio del 78.49% de las rutas irrelevantes por objetivo, superando significativamente a los enfoques base (por ejemplo, RG-base con un 51.11%).
Aceleración (Speedup): RustGo alcanzó los objetivos de 2.09x a 5.08x más rápido que los DGF existentes (incluyendo AFLGo, WindRanger, FishFuzz y PanicKiller) y de 2.85x a 3.45x más rápido que los fuzzers guiados por cobertura (AFL, AFL++).
Descubrimiento de Vulnerabilidades: RustGo identificó 13 errores de memoria previamente desconocidos en proyectos reales de Rust. De estos, 10 fueron confirmados, 8 fueron parcheados, 6 recibieron IDs de RUSTSEC y 1 recibió un ID de CVE.
Comparación con Generadores de Fuzz Drivers: Al compararse contra generadores de fuzz drivers (RPG, RUG, deepSURF), RustGo detectó con éxito todos los 13 nuevos errores, mientras que los generadores fallaron en detectar la mayoría debido a las dificultades para construir tipos de argumentos complejos y contextos de ejecución.

Significado

El artículo afirma que RustGo aborda la ineficiencia crítica de aplicar estrategias de fuzzing centradas en C/C++ a Rust. Al aprovechar las características únicas del lenguaje Rust (propiedad, monomorfización y la distinción entre código seguro e inseguro), RustGo logra un proceso de fuzzing "justo" y "dirigido" que evita desperdiciar recursos en código de memoria segura. Los resultados demuestran que el fuzzing dirigido y consciente de Rust no solo es más eficiente, sino también más efectivo para descubrir vulnerabilidades profundas de seguridad de memoria que tanto el fuzzing de cobertura guiada genérica como los enfoques dirigidos existentes. El descubrimiento de 13 nuevos errores, incluyendo aquellos con IDs de CVE y RUSTSEC asignados, valida la utilidad práctica del marco para mejorar la seguridad del ecosistema de Rust.