En bref. Le 9 novembre 2026, le FORGE Lab de Microsoft a publié l'analyse de plusieurs bugs de sûreté mémoire trouvés dans std et core, les bibliothèques de base de Rust, dont une partie avec l'aide d'un outil de recherche de vulnérabilités par IA. Certains se déclenchent depuis du code entièrement safe, c'est-à-dire sans aucun bloc unsafe dans votre programme. Microsoft précise qu'aucun de ces bugs n'est automatiquement une vulnérabilité dans les programmes qui utilisent la bibliothèque : il faut un usage précis et inhabituel de l'API (l'interface de programmation). Pour vos équipes, l'intérêt est double : mettre à jour la chaîne d'outils, et relire votre propre code unsafe avec les trois erreurs de confiance que Microsoft décrit.
Ce qui s'est passé
Dans un billet du Microsoft Security Blog daté du 9 novembre 2026, le FORGE Lab, un laboratoire de Microsoft qui étudie les vulnérabilités des logiciels complexes, décrit des bugs signalés au suivi de tickets de Rust. Une partie a été trouvée avec Hyenas, la version de recherche de MDASH, l'outil d'analyse de vulnérabilités par IA de Microsoft. Les chercheurs ont ensuite étudié le code, reproduit les bugs, évalué leur impact et travaillé avec les mainteneurs de Rust pour les corriger. L'équipe compte parmi ses membres les auteurs de Rudra, un analyseur statique publié en 2021 qui cherchait ce type de bugs dans l'écosystème Rust.
Au moment de la publication, deux des tickets ouverts par l'équipe restaient ouverts. Microsoft souligne que les mainteneurs de Rust ont trié et répondu rapidement à ses rapports.
Le périmètre est précis : il s'agit de bugs de soundness dans le code unsafe de la bibliothèque standard. Les bugs du compilateur lui-même sont hors sujet.
Le principe : qu'est-ce qu'un bug de soundness ?
Rust garantit qu'un programme écrit en code safe ne peut pas provoquer de comportement indéfini (undefined behavior), comme une lecture hors des limites d'un tableau ou l'utilisation d'une mémoire déjà libérée. Mais une grande partie de la bibliothèque standard, Vec et String compris, repose sur de petits blocs unsafe enveloppés dans des API sûres. Dans un bloc unsafe, c'est le programmeur, et non le compilateur, qui garantit que les règles sont respectées.
Une API est dite sound si aucun usage en code safe ne peut déclencher de comportement indéfini. Un bug de soundness, c'est une API sûre en apparence que du code safe peut amener à corrompre la mémoire. Microsoft classe les bugs trouvés en trois erreurs de confiance.
1. Supposer que le code ne paniquera pas
Du code unsafe casse souvent un invariant un court instant, par exemple en allouant un tampon non initialisé qu'il remplit ensuite. Si un appel intermédiaire panique, la pile se déroule et les destructeurs s'exécutent alors que l'invariant est cassé.
Exemple signalé : MapWindows::clone (ticket #156501), une API encore réservée à la version nightly. Le clone créait un tampon dont le destructeur était déjà actif, puis appelait le clone de l'utilisateur pour le remplir. Si ce clone panique, le destructeur détruit (drop) des valeurs jamais initialisées. Le correctif garde le tampon dans ManuallyDrop jusqu'à ce qu'il soit complet.
Même famille : l'API Allocator. Plusieurs endroits de la bibliothèque devenaient non sûrs si un allocateur personnalisé déroulait la pile (Microsoft en a signalé un dans BTreeMap::insert, d'autres en ont signalé d'autres). Plutôt que de corriger chaque cas, la stabilisation de l'API, annoncée par Microsoft pour Rust 1.100 le 12 novembre, interdit aux implémentations de dérouler la pile depuis les méthodes du trait ou depuis drop.
2. Faire confiance à une implémentation fournie par l'appelant
Du code unsafe appelle souvent du code fourni par l'utilisateur : un comparateur, une implémentation de trait, une closure. Ce code est safe, mais il peut renvoyer des réponses incohérentes. En Rust, c'est au code unsafe de rester correct quoi qu'il reçoive.
Exemple signalé : str::replace avec un motif personnalisé (ticket #156491). Un raccourci d'optimisation supposait qu'un motif d'un seul octet était forcément un caractère ASCII (le jeu de caractères de base). Un motif personnalisé pouvait déclarer un octet non ASCII, et str::replace produisait alors une String qui n'est pas de l'UTF-8 valide (l'encodage standard des caractères), ce qui mène à un comportement indéfini dans les opérations suivantes. Le correctif change le type pour qu'il garantisse lui-même l'UTF-8.
Microsoft cite aussi join : corrigé en 2020 (identifiant public de vulnérabilité CVE-2020-36323) parce qu'il supposait que Borrow::borrow renvoyait toujours la même chaîne, il a nécessité un nouveau correctif en avril 2026 pour un chemin que le premier n'avait pas couvert. D'autres contributeurs ont signalé cette année des problèmes voisins dans l'API Pattern (#158265, #165076), toujours ouverts au moment de la publication.
3. Faire confiance à l'état du système
La troisième famille se situe à la frontière avec le système d'exploitation et la bibliothèque C : piles de signaux, projections mémoire, variables d'environnement, que d'autres threads ou le noyau peuvent modifier à tout moment. Selon Microsoft, ces bugs étaient difficiles à trouver par analyse statique, et les agents IA rendent leur recherche praticable parce qu'ils connaissent le comportement de ces interfaces.
process::exitet la pile de signaux du thread principal (#161018). Appelé depuis un thread secondaire,process::exitlibérait la pile de signaux alternative du thread principal alors que celui-ci tournait encore. Le bug datait de 2015 et touche Rust stable. Microsoft a étudié une exploitation possible et l'a jugée peu probable dans les conditions testées, en précisant que cette évaluation ne s'applique pas automatiquement aux autres bugs.CommandExt::execet l'environnement global (#156951). Sur Unix,execmodifiait la variable globale d'environnement en ne prenant que le verrou de lecture. Un autre thread pouvait alors voir des variables destinées au nouveau programme, et deux échecs concurrents d'execpouvaient laisser un pointeur vers un tableau libéré. Le comportement existe depuis 2021 ; un correctif est en revue.process::exitet les destructeurs de variables locales de thread (#164243), signalé par une autre personne : une double libération possible en code safe. Un correctif proposé fait passerprocess::exitpar l'appel_exitde POSIX, la norme d'interface des systèmes Unix.
Qui est concerné
- Les équipes qui écrivent du Rust, et surtout celles qui maintiennent du code
unsafe: les trois erreurs de confiance s'appliquent à votre code autant qu'à la bibliothèque standard. - Les programmes multithreadés qui appellent
process::exitdepuis un thread secondaire ouCommandExt::execpendant que d'autres threads lisent l'environnement. - Les projets qui implémentent un allocateur personnalisé, désormais soumis à la règle de non-déroulement.
- Les utilisateurs d'API nightly, où plusieurs de ces bugs ont été trouvés avant stabilisation.
Microsoft rappelle que Rust gagne du terrain : langage interne de premier rang chez Microsoft, runtime de l'agent Copilot réécrit en Rust chez GitHub ; Bun, Android, le noyau Linux et Cloudflare y déplacent aussi du code. Un bug de la bibliothèque standard peut donc avoir des effets bien au-delà du code où il naît.
Comment vous protéger
Le billet ne fournit pas de liste de versions corrigées à installer ; la plupart des points ci-dessous relèvent des bonnes pratiques.
Tenir la chaîne d'outils à jour. Les correctifs arrivent dans les versions successives du compilateur et de la bibliothèque standard. Suivez les notes de version de Rust et les tickets cités (#156951 et #164243 notamment, encore en cours au moment de la publication), et fixez une échéance de montée de version dans votre politique de dépendances.
Repérer les usages à risque dans votre code. Une recherche simple dans vos dépôts suffit à dresser l'inventaire :
- appels à
process::exithors du thread principal ; - appels à
CommandExt::execdans des programmes multithreadés qui lisent aussi l'environnement ; - implémentations du trait
Allocatorou allocateurs globaux personnalisés ; - dépendance à des API nightly comme
Iterator::map_windowsou le traitPattern.
Relire votre propre unsafe avec la grille de Microsoft. Pour chaque bloc unsafe, posez trois questions :
- Un appel à du code que vous ne contrôlez pas (
clone,drop, comparaison, closure, itérateur) peut-il paniquer pendant qu'un invariant est cassé ? Si oui, terminez le travail qui peut paniquer avant de casser l'invariant, ou protégez l'état avecManuallyDropou une garde dont le destructeur restaure l'invariant, comme le faitSetLenOnDropdansVec. - Le code dépend-il d'une propriété d'une implémentation fournie par l'appelant ? Microsoft recommande d'appeler l'implémentation une seule fois et de garder le résultat, de valider ce qu'elle renvoie, ou d'encoder la propriété dans un type que le code safe ne peut pas falsifier. À défaut, rendez le trait
unsafepour que l'implémenteur s'engage explicitement. - Le code suppose-t-il que l'état du processus (environnement, piles de signaux, projections mémoire) ne change pas pendant qu'il travaille ?
Ce que ça dit des outils d'analyse par IA
Le billet suggère deux points utiles pour une équipe DevSecOps. D'abord, la frontière avec le système échappait à l'analyse statique classique, ce qui explique peut-être la durée de vie de ces bugs : celui de la pile de signaux est resté près de 11 ans dans la bibliothèque standard, et Microsoft estime que les agents IA rendent ce terrain praticable. Ensuite, chaque signalement a été reproduit et évalué par des chercheurs avant d'être envoyé, et Microsoft précise que son évaluation d'exploitabilité, faite pour le bug #161018, ne s'applique pas automatiquement aux autres. Microsoft juge que la frontière entre le langage et le système est l'un des terrains les plus prometteurs pour la recherche de vulnérabilités par agents.
FAQ
Rust est-il moins sûr qu'on ne le pensait ?
Microsoft défend l'inverse : Rust impose à ses API sûres une exigence plus stricte que C et C++. En C++, un comparateur incohérent passé à std::sort provoque un comportement indéfini ; en Rust, le tri doit rester sûr quel que soit le comparateur. Cette exigence définit clairement ce qu'est un bug de soundness, ce qui permet de le corriger une fois dans la bibliothèque plutôt que dans chaque programme.
Mon programme est-il vulnérable ?
Pas automatiquement. Selon Microsoft, chaque bug demande une situation inhabituelle : une panique au mauvais moment, une implémentation volontairement incohérente, ou process::exit appelé depuis un thread secondaire. Il ne devient une vulnérabilité grave que si un vrai programme utilise l'API de cette façon.
Qu'est-ce que le code safe et le code unsafe en Rust ?
Le code safe est vérifié par le compilateur, qui empêche les erreurs mémoire. Le code unsafe permet des opérations que le compilateur ne peut pas vérifier, comme manipuler des pointeurs bruts ; c'est alors au développeur de garantir qu'elles sont correctes.
Quels bugs restent ouverts ?
Au moment de la publication, deux tickets signalés par l'équipe de Microsoft restaient ouverts, ainsi que des tickets voisins signalés par d'autres sur l'API Pattern. Le correctif de CommandExt::exec était en revue.
Sources
- Microsoft Security Blog, FORGE Lab uses agentic tools to identify memory safety issues in Rust, 9 novembre 2026 : https://www.microsoft.com/en-us/security/blog/2026/11/09/forge-lab-uses-agentic-tools-to-identify-memory-safety-issues-in-rust
WeeSec aide les équipes de développement à intégrer la revue de code unsafe et les outils d'analyse dans leur démarche DevSecOps.