💻 computer science

RustGo: Fairly Directed Greybox Fuzzing for Enforcing Rust Memory Safety

RustGo est un nouveau fuzzer greybox dirigé qui exploite l'analyse statique spécifique à Rust pour identifier automatiquement les cibles potentielles de bogues de mémoire et élaguer les chemins d'exécution non pertinents, améliorant ainsi considérablement l'efficacité du fuzzing et découvrant des vulnérabilités inconnues dans le code Rust unsafe par rapport aux approches existantes.

Auteurs originaux : 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

Publié 2026-08-07

📖 8 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : 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)

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous êtes un détective essayant de trouver une faille minuscule et isolée dans une ville immense et bouillonnante. Dans le monde du logiciel informatique, cette ville est un programme, et la faille est un « bug de mémoire » — une erreur où le programme tente de saisir, d'utiliser ou de jeter des données qu'il ne devrait pas, provoquant ainsi un plantage ou une intrusion. Depuis des décennies, la méthode la plus populaire pour trouver ces bugs est le « fuzzing ». Considérez le fuzzing comme le fait de lancer des millions de boules de neige aléatoires et chaotiques contre les murs de la ville pour voir si l'une d'elles brise une fenêtre. Généralement, cela fonctionne bien pour les langages plus anciens, mais il y a un pièat : c'est incroyablement inefficace. Vous pourriez lancer 99 boules de neige sur la porte d'entrée robuste et incassable juste pour trouver la seule fenêtre fragile dans une ruelle à l'arrière.

Entrez dans l'ère de Rust, un langage de programmation moderne qui agit comme un garde de sécurité ultra-strict. Les règles de Rust sont si bonnes que 90 % de la ville qu'il construit est pratiquement blindée ; le garde s'assure que la plupart des « fenêtres » (zones de mémoire) sont verrouillées par défaut. Cependant, pour construire certaines choses complexes, Rust permet aux développeurs d'ouvrir une petite porte spéciale appelée « code unsafe » (non sécurisé). C'est le seul endroit où les règles strictes sont assouplies, et c'est le seul endroit où un bug de mémoire peut réellement se cacher. Le problème est que les outils de « lancer de boules de neige » existants ne le savent pas. Ils continuent de lancer des boules de neige sur les 90 % de la ville qui sont déjà sûrs, gaspillant temps et énergie, tout en manquant les quelques endroits dangereux derrière la porte spéciale. Ce document présente un nouvel outil de détective appelé RustGo qui change la donne en sachant exactement où lancer les boules de neige.

Le Détective Intelligent : RustGo

Les chercheurs derrière ce document, une équipe de l'Université de Corée et d'autres institutions, ont réalisé que lancer des boules de neige de manière aléatoire sur un programme Rust revient à essayer de trouver une aiguille dans une botte de foin en brûlant toute la botte de foin. Puisque Rust garantit la sécurité pour la majeure partie de son code, ils se sont demandé : Pourquoi tester les parties sûres du tout ? Ils ont construit RustGo, un « fuzzer de boîte grise dirigé » qui agit comme un détective avec une carte et une loupe, plutôt qu'une personne aveugle lançant des pierres.

RustGo fonctionne en trois étapes ingénieuses pour traquer les bugs efficacement :

1. Trouver les bonnes cibles (La Carte)
D'abord, RustGo scanne le code pour trouver les zones « unsafe » où les bugs pourraient se cacher. Mais il ne se contente pas de deviner. Il utilise un type spécial d'analyse pour observer comment les données circulent dans le programme. Imaginez que la ville possède de nombreuses ruelles, mais que certaines mènent à des impasses ou à des boucles qui ne se produisent jamais dans la réalité. RustGo les filtre. Il identifie les points spécifiques où un bug de mémoire pourrait se déclencher et regroupe ensuite les points similaires. Si deux chemins différents dans le code mènent exactement au même résultat dangereux, RustGo les traite comme une seule cible, afin de ne pas perdre de temps à vérifier la même chose deux fois. Dans leurs tests, cette étape les a aidés à réduire le nombre de cibles à vérifier d'environ 84 %, se concentrant uniquement sur les zones véritablement suspectes.

2. Couper les impasses (La Loupe)
Une fois que RustGo sait où regarder, il doit ignorer le reste de la ville. Dans les anciens outils de fuzzing, la « carte » de la ville incluait souvent la bibliothèque standard (les outils pré-construits que Rust utilise), qui est immense et pleine de chemins qui semblent accessibles mais qui ne le sont pas réellement. Cela confondait les outils, les faisant explorer des zones inutiles. RustGo a introduit un nouveau tour appelé « élagage de chemin spécifique à la cible » (target-specific path pruning). C'est comme avoir une clôture magique qui fait instantanément disparaître tout chemin qui ne mène pas à la cible spécifique que vous enquêtez actuellement. Si le détective cherche un bug dans la boulangerie, la clôture bloque les chemins menant à la bibliothèque ou au parc, même si ces chemins existent techniquement dans la ville. Cela a permis à RustGo de couper 78,49 % des chemins non pertinents que d'autres outils perdraient du temps à explorer.

3. Jouer équitablement (La Stratégie Round-Robin)
Voici le dernier tournant crucial. Lorsqu'un détective a plusieurs suspects (cibles) à vérifier, les outils plus anciens deviennent souvent obsédés par le plus facile à atteindre, ignorant les plus difficiles. RustGo utilise un système de « basculement dynamique équitable » (dynamic fair toggling). Imaginez un arbitre qui change l'attention du détective entre les suspects dans une rotation parfaite. Si le détective passe trop de temps sur le Suspect A, l'arbitre le fait immédiatement passer au Suspect B, garantissant que chaque suspect reçoit une part équitable d'attention. RustGo fait cela en donnant à chaque cible sa propre « file d'attente » de boules de neige et son propre « carnet de notes » pour suivre la progression. Cela garantit qu'aucun endroit dangereux n'est laissé sans test simplement parce qu'il est légèrement plus difficile à atteindre.

Les Résultats : Plus Rapides et Plus Intelligents

L'équipe a testé RustGo sur 13 applications Rust réelles, allant des serveurs web aux outils de traitement de données. Ils l'ont comparé aux meilleurs outils existants, y compris le célèbre AFL++ et plusieurs fuzzers « dirigés » spécialisés. Les résultats sont frappants.

Parce que RustGo a cessé de perdre du temps sur les 90 % de code sûrs pour se concentrer uniquement sur les 10 % dangereux, il a trouvé des vulnérabilités 2,09 à 5,08 fois plus vite que les autres outils. Dans certains cas, comme l'application gimli, il était plus de 10 fois plus rapide. Pour mettre cela en perspective, si un ancien outil mettait 10 heures pour trouver un bug, RustGo l'a trouvé en moins d'une heure.

Mais la vitesse n'est pas la seule victoire. L'équipe a utilisé RustGo pour traquer des bugs « dans la nature », et non pas seulement dans leur laboratoire de test. Ils ont découvert 13 bugs de mémoire auparavant inconnus dans des logiciels réels. Sur ceux-ci, 10 ont été confirmés par les développeurs de logiciels, et 8 ont déjà été corrigés. Plus impressionnant encore, 6 de ces bugs ont reçu des identifiants de sécurité officiels (RUSTSEC), et un a reçu un identifiant CVE, qui est la norme mondiale pour le suivi des failles de sécurité graves. Cela prouve que RustGo n'est pas seulement une idée théorique ; c'est un outil pratique qui rend déjà les logiciels plus sûrs.

Pourquoi cela compte

Ce document ne se contente pas de suggérer que RustGo est une bonne idée ; il la mesure, prouve qu'elle fonctionne et montre qu'elle trouve des bugs réels que d'autres ont manqués. Il argumente explicitement contre l'ancienne façon de penser : que nous devons tester chaque ligne de code pour être en sécurité. Au lieu de cela, il montre qu'en comprenant les règles uniques de Rust, nous pouvons être plus intelligents, plus rapides et plus efficaces.

Les chercheurs ont également abordé une préoccupation courante : « Et si nous manquions un bug en ignorant les parties sûres ? » Ils expliquent que les règles de sécurité de Rust sont si strictes que les bugs de mémoire spatiale (comme accéder à la mauvaise adresse mémoire) ne peuvent tout simplement pas se produire dans les parties sûres du code. Par conséquent, les ignorer ne crée pas un angle mort ; cela élimine simplement le bruit. Pour les bugs temporels (utiliser la mémoire après qu'elle a été libérée), RustGo veille à ne pas supprimer accidentellement un chemin qui pourrait mener à un bug, en utilisant une approche « conservatrice » qui maintient le filet de sécurité assez large pour tout attraper.

En fin de compte, RustGo est un témoignage de la puissance de la spécialisation. Tout comme un chef étoilé n'utilise pas un marteau pour casser une noix, un fuzzer moderne ne devrait pas utiliser un instrument contondant sur un langage aussi sophistiqué que Rust. En adaptant l'approche aux forces et faiblesses uniques du langage, les auteurs ont créé un outil qui est non seulement plus rapide, mais aussi plus équitable, garantissant que chaque danger potentiel dans le code reçoive l'attention qu'il mérite.

Résumé Technique : RustGo

Énoncé du Problème

Rust garantit la sécurité de la mémoire grâce à des politiques strictes au moment de la compilation (propriété, emprunt, durées de vie), pourtant des bugs de mémoire persistent dans les régions unsafe où ces politiques sont contournées. Bien que le code unsafe ne constitue qu'une petite fraction des programmes Rust typiques (environ 10 %), les approches de fuzzing existantes traitent l'ensemble du code source comme une source potentielle de bugs. Cela entraîne une allocation inefficace des ressources, car les fuzzer gaspillent des efforts sur des régions sûres pour la mémoire que le compilateur Rust garantit déjà comme étant sécurisées.

De plus, les solutions de Fuzzing Gris de Boîte Dirigé (DGF) existantes, conçues à l'origine pour C/C++, font face à des défis importants lorsqu'elles sont appliquées à Rust :

Identification des Cibles : Les méthodes traditionnelles reposent sur une sélection manuelle ou des critères simples (par exemple, l'emplacement des sanitizers) et ne parviennent pas à identifier automatiquement les cibles propices aux bugs de mémoire spécifiques à l'architecture unique de Rust, telles que les déréférencements de pointeurs bruts dans le code sûr qui sont aliasés à des pointeurs non sûrs.
Élagage de Chemins (Path Pruning) : La bibliothèque standard de Rust est liée statiquement et monomorphisée, créant un binaire unifié complexe. Les analyses de joignabilité existantes sur-approximent souvent, échouant à élaguer les chemins non pertinents car elles ne peuvent pas distinguer efficacement le code utilisateur de la logique de la bibliothèque standard.
Équité dans le Fuzzing Multi-Cibles : Les DGF multi-cibles existants privilégient souvent les cibles « proches », ce qui entraîne la famine des cibles distantes mais vulnérables. Les états de fuzzing partagés (file d'attente d'entrée unique, bitmap de couverture unique) rendent difficile l'allocation équitable de l'énergie entre plusieurs cibles distinctes.

Méthodologie

Le papier propose RustGo, un fuzzer gris de boîte dirigé pour Rust, conçu pour identifier, optimiser et fuzzer de manière équitable les régions propices aux bugs de mémoire. RustGo opère via trois composantes clés :

1. Identification et Optimisation des Cibles

RustGo emploie une analyse statique multi-étapes pour identifier les cibles vulnérables :

Analyse MIR et LLVM IR : Il effectue une analyse de correspondance de types au niveau de la Représentation Intermédiaire de Niveau Moyen (MIR) pour identifier les opérations de pointeurs bruts, qui ne sont pas préservées dans l'IR LLVM. Il utilise ensuite une analyse de propagation de taches basée sur le Graphe de Flux de Valeurs (VFG) au niveau de l'IR LLVM pour suivre la propagation des pointeurs et identifier les sites d'aliasing.
Filtrage de la Bibliothèque Standard : Pour éviter les faux positifs causés par l'analyse insensible au contexte de la bibliothèque standard monomorphisée, RustGo annote les fonctions de la bibliothèque standard. Il utilise les arêtes du Graphe de Flux de Contrôle Inter-procédural (ICFG) pour propager la tache à travers les frontières de la bibliothèque sans traverser la logique interne de la bibliothèque, filtrant ainsi efficacement les chemins inaccessibles.
Optimisation par Post-Dominance : Pour réduire le nombre de cibles et empêcher le fuzzer de se dégrader en un fuzzer générique guidé par la couverture, RustGo effectue une analyse de post-dominance inter-procédurale. Si une cible $t_i$ est post-dominée par $t_j$ (signifiant que tous les chemins vers $t_i$ doivent passer par $t_j$ ), $t_i$ est fusionnée avec $t_j$ . Cela réduit les cibles redondantes en les consolidant en emplacements représentatifs.

2. Élagage de Chemins Spécifique aux Cibles

Une fois les cibles identifiées, RustGo élimine les chemins non pertinents pour maximiser l'efficacité du fuzzing :

Remappage des Sites d'Appel : Les cibles situées dans la bibliothèque standard sont remappées vers leurs sites d'invocation correspondants dans le code utilisateur afin de garantir une analyse de joignabilité précise.
Élagage Sensible aux Préconditions :
- Pour les bugs spatiaux (déréférencements de pointeurs bruts), aucun élagage n'est appliqué car ceux-ci peuvent survenir sans préconditions spécifiques.
- Pour les bugs temporels (ex: Use-After-Free), RustGo exploite les résultats de l'analyse de tache pour vérifier si un chemin contient la séquence d'opérations mémoires nécessaire (ex: alloc $\to$ free $\to$ dereference). Les chemins dépourvus de ces séquences sont élagués.
- Gestion Async/Await : Pour éviter les faux négatifs dans le code concurrent, RustGo désactive conservateurment l'élagage pour les fonctions impliquant async/await et l'aliasing de pointeurs bruts.

3. Fuzzing par Basculement Dynamique Équitable (Dynamic Fair Toggling Fuzzing)

Pour assurer un test équitable entre plusieurs cibles sans interférence, RustGo introduit un mécanisme de basculement dynamique :

Multi-File d'Attente et Multi-Couverture : Contrairement aux fuzzer traditionnels qui utilisent une file d'attente d'entrée et un bitmap de couverture globaux, RustGo maintient des files d'attente d'entrée et des bitmaps de couverture indépendants pour chaque cible.
Basculement Dynamique (Dynamic Toggle) : Le fuzzer bascule entre les cibles selon un mode round-robin. Lorsqu'une cible est active, le système met à jour une « Mémoire Partagée de Basculement » (TSM) pour activer dynamiquement uniquement les blocs de base pertinents pour cette cible spécifique. Cela permet au fuzzer d'élaguer les chemins non pertinents en temps réel pour la cible actuelle tout en maintenant des états de fuzzing indépendants, garantissant qu'aucune cible ne soit affamée de ressources.

Contributions Clés

Framework RustGo : Un nouveau fuzzer gris de boîte dirigé spécifiquement adapté à Rust, capable d'identifier et d'optimiser automatiquement les cibles propices aux bugs de mémoire en utilisant une analyse statique spécifique à Rust (analyse croisée MIR/LLVM IR, suivi de taches et post-dominance).
Élagage Spécifique aux Cibles : Une stratégie d'élagage novatrice qui gère la structure complexe et la monomorphisation de la bibliothèque standard de Rust, atteignant une grande précision dans l'élimination des chemins non pertinents.
Fuzzing Multi-Cibles Équitable : Une approche de basculement dynamique avec des schémas multi-files d'attente et multi-couverture qui assure une allocation d'énergie équilibrée, empêchant le biais vers les cibles facilement atteignables commun aux DGF existants.
Évaluation et Découverte : Une évaluation complète sur des applications Rust réelles, démontrant des améliorations de performance significatives par rapport aux fuzzers de pointe et la découverte de 13 bugs de mémoire auparavant inconnus.

Résultats

Les auteurs ont évalué RustGo sur un benchmark personnalisé de 13 applications Rust réelles et sur le benchmark deepSURF (26 bugs réels).

Optimisation des Cibles : RustGo a réduit le nombre de cibles initiales de 84,13 % en moyenne grâce à la consolidation par post-dominance.
Élagage de Chemins : RustGo a élagué en moyenne 78,49 % des chemins non pertinents par cible, surpassant nettement les approches de référence (ex: RG-base à 51,11 %).
Accélération : RustGo a atteint les cibles 2,09x à 5,08x plus vite que les DGF existants (incluant AFLGo, WindRanger, FishFuzz et PanicKiller) et 2,85x à 3,45x plus vite que les fuzzer guidés par la couverture (AFL, AFL++).
Découverte de Vulnérabilités : RustGo a identifié 13 bugs de mémoire auparavant inconnus dans des projets Rust réels. Parmi ceux-ci, 10 ont été confirmés, 8 ont été corrigés, 6 ont reçu des identifiants RUSTSEC et 1 a reçu un identifiant CVE.
Comparaison avec les Générateurs de Drivers de Fuzz : Comparé aux générateurs de drivers de fuzz (RPG, RUG, deepSURF), RustGo a réussi à détecter les 13 nouveaux bugs, tandis que les générateurs ont échoué à détecter la majorité en raison des difficultés à construire des types d'arguments complexes et des contextes d'exécution.

Signification

Le papier affirme que RustGo répond à l'inefficacité critique de l'application de stratégies de fuzzing centrées sur C/C++ à Rust. En exploitant les caractéristiques uniques du langage Rust (propriété, monomorphisation et distinction entre code sûr et non sûr), RustGo parvient à un processus de fuzzing « équitable » et « dirigé » qui évite de gaspiller des ressources sur le code sûr pour la mémoire. Les résultats démontrent que le fuzzing ciblé et conscient de Rust est non seulement plus efficace mais aussi plus performant pour découvrir des vulnérabilités profondes de sécurité de la mémoire que le fuzzing générique guidé par la couverture et les approches dirigées existantes. La découverte de 13 nouveaux bugs, dont certains ont reçu des identifiants CVE et RUSTSEC, valide l'utilité pratique du framework pour renforcer la sécurité de l'écosystème Rust.