Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Rust

Partie 4 sur 4

Niveau de lecture :

9Le code « unsafe »Approfondir

Certaines opérations ne peuvent pas être vérifiées par le compilateur : manipuler directement des adresses de mémoire, dialoguer avec du matériel, appeler une bibliothèque écrite en C. Rust les autorise, mais seulement dans un bloc marqué unsafe (« non sûr »), où le programmeur s’engage à respecter lui-même les règles :

let x = 5;
let p = &x as *const i32;    // pointeur brut, comme en C
unsafe {
    println!("{}", *p);      // lecture permise seulement ici
}

Le mot unsafe ne désactive pas toutes les vérifications : il permet seulement cinq opérations supplémentaires, comme suivre un pointeur brut ou appeler une fonction externe. Son intérêt est de concentrer le risque : au lieu d’un programme entier où chaque ligne peut corrompre la mémoire, on obtient quelques blocs bien délimités, faciles à repérer, à relire et à tester en priorité. La bibliothèque standard elle-même en contient, enveloppés dans des fonctions sûres. Dans le noyau Linux, les pilotes en Rust s’appuient sur des couches d’abstraction qui isolent le code unsafe nécessaire au dialogue avec le reste du noyau, écrit en C.

Rust sait appeler du C et être appelé par lui, grâce à une interface pour les fonctions étrangères (en anglais Foreign Function Interface, FFI). C’est ce qui permet de l’introduire progressivement dans un projet existant : on réécrit d’abord les composants les plus exposés, comme ceux qui analysent des données venues d’Internet, en gardant le reste en C ou en C++.

10L’écosystème

10.1Les outils

Rust doit une partie de son succès à ses outils, livrés avec le langage et utilisés par tous : Cargo pour construire et gérer les dépendances, rustfmt pour mettre en forme le code de façon uniforme, clippy, qui signale des centaines d’erreurs courantes et de maladresses, cargo test pour les tests, cargo doc pour produire la documentation, et rust-analyzer, qui apporte l’aide à la saisie dans les éditeurs de code. Le compilateur s’appuie sur LLVM, une infrastructure de compilation libre partagée avec d’autres langages comme Swift, qui produit du code machine très optimisé pour de nombreux processeurs.

10.2Les domaines

  • Systèmes : composants de noyaux, pilotes, micrologiciels, hyperviseurs comme Firecracker, utilisé par Amazon pour isoler les fonctions de ses clients (voir la virtualisation) ;
  • Réseau et serveurs : relais et équilibreurs de charge, serveurs Web, avec des cadriciels comme Axum ou Actix ;
  • Outils en ligne de commande : des réécritures rapides d’outils classiques, comme ripgrep pour la recherche de texte, très appréciées ;
  • WebAssembly : Rust est l’un des langages les plus utilisés pour produire ce code rapide qui s’exécute dans les navigateurs (voir WebAssembly) ;
  • Embarqué : microcontrôleurs, automobile, aéronautique, où une version certifiée du compilateur, Ferrocene, est apparue en 2023 ;
  • Outils pour d’autres langages : de nombreux outils de l’écosystème Python ou JavaScript, comme le gestionnaire de paquets uv ou l’outil de vérification Ruff pour Python, sont écrits en Rust pour leur vitesse.

11Forces et limites

Forces

  • Sûreté de la mémoire et absence de courses de données, vérifiées à la compilation.
  • Performances comparables au C et au C++, sans ramasse-miettes.
  • Système de types riche : Option, Result, énumérations, filtrage exhaustif.
  • Outils excellents et uniformes ; messages d’erreur clairs.

Limites

  • Courbe d’apprentissage raide : les premières semaines, on « se bat » avec le vérificateur d’emprunts.
  • Compilation lente sur les gros projets.
  • Écosystème plus jeune que celui de Java ou de C++, et dépendance fréquente à de nombreuses petites bibliothèques.
  • Interopérabilité avec le C++ encore délicate.

Rust convient particulièrement aux composants où la sécurité et la performance comptent toutes les deux. Pour un script rapide ou une petite application de gestion, un langage plus simple, comme Python ou Go, reste souvent plus productif (voir Python et Go).

Sécurité de l’information

Le coin cyber

Rust est aujourd’hui au cœur des politiques de sécurité logicielle : supprimer la principale cause de failles graves est un enjeu de sécurité nationale. Mais un langage sûr ne fait pas un programme sûr. Les attaques sont décrites ici dans leur principe seulement.

C.1Les langages sûrs, une recommandation officielle

Depuis 2022, les agences de cybersécurité poussent les éditeurs à abandonner progressivement le C et le C++ pour les nouveaux développements : la NSA (National Security Agency, l’agence américaine du renseignement technique) en 2022 ; la CISA (Cybersecurity and Infrastructure Security Agency, l’agence américaine de cybersécurité) et ses homologues de plusieurs pays, qui demandent en 2023 aux éditeurs de publier une feuille de route vers des langages sûrs pour la mémoire ; la Maison-Blanche en 2024. En France, l’ANSSI (Agence nationale de la sécurité des systèmes d’information) publie depuis 2020 des règles de programmation sécurisée en Rust. Les résultats d’Android (figure 3) montrent l’effet de cette stratégie : on n’a pas réécrit l’ancien code, on a écrit le nouveau en langages sûrs, et les failles de mémoire ont fondu, parce que les failles se concentrent dans le code récent.

PART DES FAILLES D’ANDROID DUES À LA GESTION DE LA MÉMOIRE 0 % 20 % 40 % 60 % 80 % 76 % 2019 35 % 2022 24 % 2024 moins de 20 % 2025 Le nouveau code est écrit en Rust ou en Kotlin ; l’ancien code en C et C++ vieillit et se stabilise. Source : Google, blogs de sécurité d’Android (2022, 2024, 2025).
Figure 3. L’effet des langages sûrs sur les failles d’Android.

C.2Ce que Rust ne protège pas

  • Les erreurs de logique : un contrôle d’accès oublié, une injection SQL, un mot de passe mal vérifié sont tout aussi possibles en Rust qu’ailleurs (voir le développement sécurisé).
  • Les paniques : un unwrap sur une donnée inattendue arrête le traitement. Le 18 novembre 2025, une grande partie du Web a été inaccessible pendant plusieurs heures : chez Cloudflare, un fichier de configuration avait doublé de taille à la suite d’un changement de droits dans une base de données, dépassant une limite fixée dans le code ; le logiciel, écrit en Rust, a rencontré l’erreur et appelé unwrap, qui l’a arrêté sur des milliers de serveurs.
  • Les dépassements d’entiers : en mode optimisé, un calcul qui dépasse la capacité d’un entier « fait le tour » sans erreur, sauf si l’on utilise les fonctions de calcul vérifié.
  • Le code unsafe et les bibliothèques en C appelées par Rust, où toutes les erreurs classiques restent possibles.

C.3La chaîne d’approvisionnement

Un projet Rust dépend souvent de dizaines, voire de centaines de bibliothèques téléchargées sur crates.io. Des attaquants y publient des paquets piégés aux noms proches de bibliothèques connues, une technique appelée typosquatting. Le risque est aggravé par deux mécanismes : les scripts de construction (build.rs) et certaines macros s’exécutent pendant la compilation, sur la machine du développeur ou du serveur d’intégration, avant même que le programme ne soit lancé. Les parades : vérifier les noms et la réputation des dépendances, les figer avec le fichier Cargo.lock, consulter la base d’alertes RustSec avec cargo audit, et filtrer les dépendances autorisées avec des outils comme cargo deny ou cargo vet.

C.4Idée reçue

« C’est écrit en Rust, donc c’est sûr. » Faux. Rust élimine une grande famille de failles, celles de la mémoire, qui sont parmi les plus graves. Il ne garantit ni l’absence d’erreurs de logique, ni la résistance aux arrêts brutaux, ni la fiabilité des bibliothèques utilisées. Un logiciel en Rust se conçoit, se relit, se teste et se maintient avec la même rigueur que les autres.

C.5Bonnes pratiques

Développeur

  • Traiter toutes les erreurs avec Result et ? ; bannir unwrap et expect du code exposé à des données extérieures.
  • Réduire le code unsafe au strict nécessaire, le documenter et le faire relire en priorité.
  • Utiliser clippy et les fonctions de calcul vérifié pour les données venues de l’extérieur.

Organisation

  • Écrire en langage sûr les nouveaux composants exposés, en commençant par ceux qui analysent des données venues d’Internet.
  • Surveiller les dépendances : cargo audit dans l’intégration continue, liste de bibliothèques autorisées.
  • Former les équipes : la courbe d’apprentissage est réelle, et un code Rust mal compris est un code Rust mal relu.

Référentiels : ANSSI, Règles de programmation pour le développement d’applications sécurisées en Rust (2020) · CISA et partenaires internationaux, The Case for Memory Safe Roadmaps (2023) · NSA, Software Memory Safety (2022).

Références

  1. S. Klabnik, C. Nichols, The Rust Programming Language, 2e éd., No Starch Press, 2023 ; traduction française en ligne.
  2. J. Blandy, J. Orendorff, L. Tindall, Programming Rust, 2e éd., O’Reilly, 2021.
  3. R. Jung, J.-H. Jourdan, R. Krebbers, D. Dreyer, « RustBelt: Securing the Foundations of the Rust Programming Language », POPL, 2018.
  4. J. Vander Stoep, « Eliminating Memory Safety Vulnerabilities at the Source », Google Security Blog, 2024.
  5. CISA, NSA, FBI et agences partenaires, The Case for Memory Safe Roadmaps, 2023.

Voir aussi

Citer cet article

« Le langage Rust », Encyclopédie informatique, révision du 26 octobre 2026.