Miri : Votre détective personnel pour le comportement indéfini en Rust

Vous codez en Rust et êtes confiant dans la sécurité de votre code ? Bien sûr, car Rust est célèbre pour son système de types et ses garanties de sécurité mémoire. Mais que diriez-vous si je vous disais que même en Rust, vous pouvez rencontrer un comportement indéfini (UB), qui peut entraîner des plantages imprévisibles, des vulnérabilités ou un comportement de programme très étrange ? Oui, les blocs unsafe sont un outil puissant qui offre une flexibilité et des performances incroyables, mais cela implique une grande responsabilité. C'est exactement là qu'intervient Miri — un assistant indispensable pour chaque développeur Rust.

Qu'est-ce que Miri et pourquoi en avez-vous besoin ?

Imaginez que vous avez un super détective qui peut regarder à l'intérieur de votre programme et trouver tous les pièges cachés qui peuvent conduire à un comportement indéfini. Miri est exactement ce détective. C'est un outil de détection du comportement indéfini en Rust qui fonctionne comme un interpréteur pour la représentation intermédiaire de Rust (MIR). Il exécute les binaires et les suites de tests de votre projet cargo et identifie le code unsafe qui ne respecte pas les exigences de sécurité de Rust.

Qui en a besoin ? Si vous travaillez avec du code unsafe, que vous écrivez des abstractions de bas niveau, que vous créez des bibliothèques qui doivent être aussi fiables que possible, ou que vous voulez simplement être absolument confiant dans votre application Rust, Miri deviendra votre meilleur ami. Il aide à détecter ces erreurs que le compilateur ne verra pas et que les tests réguliers ne couvriront pas, car elles peuvent ne se manifester que sous certaines conditions ou sur certaines plateformes.

Miri en action : quels problèmes détecte-t-il ?

Miri ne se contente pas de chercher des erreurs, il identifie spécifiquement des types concrets de comportement indéfini qui peuvent compromettre la stabilité de votre application. En voici quelques-uns :

• Erreurs d'accès mémoire : C'est un classique. Miri détectera si vous sortez des limites de la mémoire allouée (accès hors limites) ou si vous essayez d'utiliser de la mémoire après qu'elle ait été libérée (utilisation après libération). Situation familière quand le programme plante aux endroits les plus inattendus ? Miri vous aidera à trouver la racine du problème.
• Utilisation incorrecte de données non initialisées : Tenter de lire des données de la mémoire qui n'a pas été initialisée est un chemin direct vers l'UB. Miri garde un œil vigilant sur cela.
• Violations des invariants de type : Rust surveille strictement les types, mais dans les blocs unsafe, vous pouvez violer même les invariants de base, par exemple créer un bool qui n'est pas 0 ou 1, ou un enum avec un discriminant invalide. Miri détectera également cela.
• Problèmes d'alignement mémoire : Accéder à la mémoire avec un alignement insuffisant peut entraîner des échecs sur certaines architectures. Miri vérifiera que tous vos pointeurs sont correctement alignés.
• Conditions de course et modèle mémoire faible : La concurrence est difficile. Miri peut émuler certains effets de mémoire faible et détecter les conditions de course qui sont extrêmement difficiles à reproduire sur du matériel réel. C'est particulièrement précieux pour les applications multithread.
• Fuites mémoire : À la fin de l'exécution du programme, Miri vérifiera s'il y a de la mémoire allouée qui n'est plus accessible. C'est un excellent moyen de trouver des fuites qui peuvent lentement mais sûrement « manger » les ressources de votre serveur.
• Vérifications d'aliasing expérimentales : Miri inclut également des vérifications expérimentales pour les règles Stacked Borrows et Tree Borrows, qui aident à identifier les violations plus subtiles des règles d'aliasing pour les types de référence. Ce sont des efforts de recherche de pointe qui aident déjà à rendre Rust encore plus sûr.

Comment Miri fonctionne : un approfondissement de l'interpréteur

Contrairement aux analyseurs statiques, Miri ne se contente pas de scanner votre code. Il l'exécute dans son propre « bac à sable » — en tant qu'interpréteur pour la représentation intermédiaire de Rust (MIR). Cela lui permet d'observer le comportement du programme en temps réel et d'identifier les problèmes qui ne se manifestent que pendant l'exécution.

Exécution déterministe : Par défaut, Miri assure une exécution entièrement déterministe. Cela signifie que si vous exécutez le programme avec les mêmes données d'entrée, le résultat sera toujours identique. Comment est-ce réalisé ? Miri remplace de nombreuses API système (par exemple, les générateurs de nombres aléatoires, les variables d'environnement, les horloges) par ses propres implémentations « fictives ». C'est particulièrement important pour reproduire et déboguer les bugs qui pourraient otherwise se manifester de manière aléatoire.

Interprétation croisée : Il est intéressant de noter que Miri peut exécuter votre code pour différentes plateformes cibles même si votre système hôte est différent. Par exemple, vous pouvez exécuter des tests sur Windows, mais Miri les interprétera comme s'ils s'exécutaient sur Linux (--target x86_64-unknown-linux-gnu). C'est particulièrement utile pour tester du code dépendant de la plateforme, par exemple pour vérifier la correction des manipulations d'octets sur les systèmes little-endian et big-endian.

Premiers pas avec Miri : plus facile qu'il n'y paraît

Intégrer Miri dans votre flux de travail est assez simple, surtout si vous utilisez déjà rustup et cargo.

Installation

Pour installer Miri, vous aurez besoin d'une version nightly de Rust. Exécutez simplement :

rustup +nightly component add miri

Exécuter les tests et les binaires

Après l'installation, vous pouvez exécuter vos projets via Miri en utilisant les commandes familières cargo :

• Pour exécuter tous les tests du projet via Miri : cargo miri test
• Si vous avez un projet binaire, exécutez-le via Miri : cargo miri run

Lors de la première exécution, Miri effectuera une configuration supplémentaire et installera les dépendances nécessaires, en demandant votre confirmation.

Au fait, cargo miri run/test supporte les mêmes drapeaux que cargo run/test常规. Par exemple, cargo miri test filter n'exécutera que les tests contenant filter dans le nom.

Fonctionnalités avancées avec les drapeaux Miri

Vous pouvez passer des drapeaux Miri spéciaux via la variable d'environnement MIRIFLAGS. Par exemple, pour désactiver l'isolation de l'hôte (et obtenir l'accès aux vraies API système, mais perdre le déterminisme) :

RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-disable-isolation" cargo miri test

Ou, pour tester différents scénarios de comportement non déterministe (par exemple, différents entrelacements de threads ou adresses d'allocation) :

MIRIFLAGS="-Zmiri-many-seeds=0..16" cargo miri test

C'est une fonctionnalité très puissante pour identifier les bugs difficiles à attraper qui ne se manifestent que sous certaines conditions.

Intégration CI/CD

Miri est excellent pour les vérifications automatisées dans CI. Voici un exemple de configuration d'un job pour GitHub Actions :

  miri:
    name: "Miri"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Miri
        run: |
          rustup toolchain install nightly --component miri
          rustup override set nightly
          cargo miri setup
      - name: Test with Miri
        run: cargo miri test

Ignorer les tests incompatibles avec Miri

Parfois, votre code peut utiliser des API que Miri ne supporte pas encore (par exemple, les opérations réseau). Dans ce cas, vous pouvez simplement ignorer ces tests pour Miri :

#[test]
#[cfg_attr(miri, ignore)]
fn does_not_work_on_miri() {
    // Ваш код, который Miri не поддерживает
}

Miri sauve déjà le monde (et votre code)

La chose la plus impressionnante à propos de Miri est son efficacité prouvée. Il a déjà découvert de nombreux bugs réels dans la bibliothèque standard Rust et les crates populaires. Parmi eux figuraient des erreurs liées à l'accès à la mémoire non initialisée dans VecDeque, un alignement incorrect dans Vec, des fuites mémoire dans BTreeMap, et même des conditions de course dans les canaux std::mpsc. Ce n'est pas qu'un outil académique, mais un assistant éprouvé qui est activement utilisé pour améliorer la fiabilité de l'écosystème Rust.

Conclusions : Miri vaut-il la peine d'être essayé ?

Absolument ! Miri n'est pas une solution miracle, et il ne détectera pas tous les violations possibles de la spécification Rust (parce qu'une telle spécification unifiée n'existe essentiellement pas). Cependant, c'est un outil indispensable pour améliorer la fiabilité du code Rust, en particulier dans les sections unsafe et lors du travail avec la concurrence.

Si vous prenez la qualité de votre code Rust au sérieux, si vous voulez minimiser les risques liés au comportement indéfini, et si vous voulez être confiant dans la stabilité de vos applications, Miri devrait faire partie de votre arsenal. Il vous aidera à trouver et corriger ces bugs insidieux qui peuvent se cacher profondément dans votre code, avant qu'ils ne deviennent un problème pour vos utilisateurs. Essayez Miri, et vous serez surpris de tout ce qu'il peut trouver dans votre code apparemment parfait !