Sortie de Rust 1.84. Noyaux Tock et Vekos, écrits en Rust. Dialecte Mini-C

La version du langage de programmation polyvalent Rust 1.84, à l'origine développé par le projet Mozilla, est désormais soutenue par l'organisation indépendante à but non lucratif Rust Foundation. Le langage est axé sur la sécurité de la mémoire et fournit des moyens d'atteindre un haut degré de parallélisme dans l'exécution des tâches, tout en évitant l'utilisation d'un ramasse-miettes et d'un environnement d'exécution (l'exécution se limite à l'initialisation de base et à la maintenance de la bibliothèque standard).

Les méthodes de gestion de la mémoire en Rust éliminent les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes liés à la gestion bas niveau de la mémoire, tels que l'accès à une zone mémoire après sa libération, la déréférence de pointeurs nuls, le dépassement de tampon, etc. Pour faciliter la diffusion des bibliothèques, assurer la compilation et gérer les dépendances, un gestionnaire de paquets nommé Cargo est en développement. Un dépôt pour le déploiement des bibliothèques, crates.io, est également supporté.

La sécurité de la mémoire dans Rust est assurée au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, à la prise en compte de la durée de vie des objets (portée) et à l'évaluation de l'accès mémoire pendant l'exécution du code. Rust offre également des outils pour se protéger contre les débordements d'entiers, exige l'initialisation obligatoire des valeurs des variables avant leur utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept d'immuabilité (immutable) pour les références et les variables par défaut, et propose une forte typage statique pour minimiser les erreurs logiques.

Les principales nouveautés :

• Dans le gestionnaire de paquets Cargo, le mécanisme de gestion des dépendances a été stabilisé, sélectionnant les versions des composants dépendants en tenant compte de la compatibilité avec les versions du compilateur Rust déclarées comme minimales prises en charge par le projet (MSRV, Minimum Supported Rust Version). Cette nouvelle fonctionnalité permet de libérer les mainteneurs de la nécessité de choisir manuellement des versions plus anciennes de chaque dépendance dans les projets qui préservent la compatibilité avec les anciennes versions des outils Rust. Un nouveau mode de détermination des dépendances sera activé par défaut dans la version Rust 1.85, mais il est déjà disponible sous forme d'option, à activer en indiquant 'incompatible-rust-versions = "fallback"' dans la section '[resolver]' du fichier '.cargo/config.toml'.
• Le portage du compilateur vers un nouveau gestionnaire de types (trait solver) a été entamé, destiné à vérifier les limites d'applicabilité des traits, à normaliser les types et à évaluer la compatibilité des types. Dans la version 1.84, le nouveau gestionnaire est utilisé pour vérifier la cohérence des implémentations des traits, c'est-à-dire pour évaluer l'existence de plus d'un trait pour le type considéré, en tenant compte du code provenant d'autres crates. Cette vérification a permis de résoudre des problèmes présents dans l'ancienne implémentation du gestionnaire de types, qui pouvaient potentiellement entraîner des conflits dus à la superposition de différentes implémentations de traits.
• Une nouvelle API 'Strict Provenance' a été proposée, qui peut être utilisée pour convertir un pointeur en un entier et vice versa, en tenant compte des métadonnées associées au pointeur concernant son origine et son domaine d'utilisation (en plus de l'adresse, une valeur 'provenance' est attachée au pointeur avec des informations sur le lien avec d'autres pointeurs, permettant de déterminer où et quand le pointeur peut accéder à la mémoire). Lors de la conversion d'un pointeur en un entier et vice versa, un comportement indéfini peut se produire en raison de la difficulté à retracer l'origine du pointeur résultant. La nouvelle API permet d'effectuer des opérations de bas niveau sur les pointeurs, telles que la conservation d'informations supplémentaires dans les bits inférieurs du pointeur, sans avoir à convertir le pointeur en un entier.
• Une nouvelle série d'API a été stabilisée dans la catégorie des API stables, notamment des méthodes et des implémentations de traits stabilisées :
  • Ipv6Addr::is_unique_local
  • Ipv6Addr::is_unicast_link_local
  • core::ptr::with_exposed_provenance
  • core::ptr::with_exposed_provenance_mut
  • ::addr
  • ::expose_provenance
  • ::avec_addr
  • ::map_addr
  • ::isqrt
  • ::checked_isqrt
  • ::isqrt
  • NonZero::isqrt
  • core::ptr::sans_provenance
  • core::ptr::sans_provenance_mut
  • core::ptr::dangling
  • core::ptr::dangling_mut
  • Pin::as_deref_mut
• L'attribut «const» est appliqué dans les fonctions :
  • AtomicBool::from_ptr
  • AtomicPtr::from_ptr
  • AtomicU8::from_ptr
  • AtomicU16::from_ptr
  • AtomicU32::from_ptr
  • AtomicU64::from_ptr
  • AtomicUsize::from_ptr
  • AtomicI8::from_ptr
  • AtomicI16::from_ptr
  • AtomicI32::from_ptr
  • AtomicI64::from_ptr
  • AtomicIsize::from_ptr
  • ::is_null
  • ::as_ref
  • ::as_mut
  • Pin::new
  • Pin::new_unchecked
  • Pin::get_ref
  • Pin::into_ref
  • Pin::get_mut
  • Pin::get_unchecked_mut
  • Pin::static_ref
  • Pin::static_mut
• Le support des insertions inline en assembleur pour les architectures s390x et Arm64EC a été stabilisé.
• Pour la plateforme cible WebAssembly, le support des fonctionnalités multivalue, types de référence et appel de queue a été stabilisé.
• Un deuxième niveau de support pour la plateforme wasm32v1-none a été mis en œuvre. Ce deuxième niveau de support garantit la compilation.

De plus, plusieurs projets liés à Rust peuvent être mentionnés :

• La version 2.2 du système d'exploitation Tock, écrit en Rust et destiné à une utilisation sur des microcontrôleurs, a été publiée. Ce système permet l'exécution simultanée de plusieurs applications non fiables sur des appareils embarqués avec une mémoire RAM limitée, tels que des capteurs, TPM (Trusted Platform Module), clés d'authentification et appareils portables. Il prend en charge des plateformes avec des microcontrôleurs basés sur les architectures ARM Cortex-M et RISC-V. Une caractéristique clé de Tock est l'isolation des niveaux d'application, de noyau et de pilotes, ainsi que l'isolation de chaque application et pilote individuellement. L'isolation utilise à la fois les capacités du langage Rust et la sécurité par la séparation au niveau de la mémoire.
• Le projet VEKOS (Verified Experimental Kernel OS) développe un noyau de système d'exploitation en Rust, garantissant la vérification des composants exécutés. À chaque opération sur le système de fichiers, création de processus et allocation de mémoire, une confirmation cryptographique est générée pour vérifier l'opération en cours d'exécution (la mise en œuvre est comparable à l'utilisation de la blockchain pour vérifier les actions dans un système d'exploitation). Dans le système de fichiers VKFS, pour garantir l'intégrité et la protection contre la falsification rétroactive, une structure d'arbre Merkle est utilisée, où chaque branche vérifie toutes les branches et nœuds sous-jacents, grâce à un hachage arborescent. L'allocation de mémoire se fait en mode COW (Copy-On-Write).
• Un groupe de chercheurs de Microsoft et d'Inria développe un sous-ensemble du langage C — Mini-C, conçu pour la traduction automatique des programmes en C en une représentation en Rust. Contrairement au compilateur c2rust, le nouveau projet permet de générer du code Rust sans utiliser de code non sécurisé, mais est principalement axé sur la conversion de projets C disposant d'une preuve formelle de fiabilité. Il est supposé qu'il sera plus simple de traduire d'abord un projet C en Mini-C, dans lequel les opérations arithmétiques avec des pointeurs ne sont pas autorisées, plutôt que de réécrire des blocs non sécurisés après une compilation directe de C en Rust.

  La mise en œuvre du compilateur est basée sur les outils KaRaMeL. Mini-C a été développé et testé dans le cadre d'un projet de réécriture en Rust de la bibliothèque cryptographique HACL*, pour laquelle une preuve formelle de fiabilité a été fournie. Une telle preuve a été utilisée pour démontrer la capacité à générer un code Rust sûr à partir de Mini-C.

• Daniel Stenberg, l'auteur de l'outil curl, a annoncé l'arrêt du développement et du soutien par le projet Curl d'un backend HTTP alternatif, écrit en Rust en utilisant la bibliothèque Hyper. La raison invoquée est le manque d'intérêt de la part des développeurs et des utilisateurs.
• La version bêta du shell Fish 4.0, réécrit en Rust, a été annoncée. Il est noté qu'après deux ans de développement, la base de code de Fish a été entièrement transférée de C++ à Rust. Le passage à Rust a permis de résoudre des problèmes de multi-threading, d'obtenir des outils modernes révélant des erreurs à l'étape de la compilation, d'améliorer la sécurité de la gestion de la mémoire et de rendre le projet plus attrayant pour de nouveaux développeurs.
• Le projet Tor a publié la version 1.3.2 d'Arti, une implémentation alternative du client Tor en Rust. Arti propose une bibliothèque intégrable que diverses applications peuvent utiliser. Lors de la création d'Arti, l'expérience passée de développement de Tor a été prise en compte pour éviter les problèmes architecturaux connus, rendant le projet plus modulaire et efficace. La branche 1.x est marquée comme adaptée à l'utilisation par des utilisateurs ordinaires, offrant le même niveau de confidentialité, d'utilisabilité et de stabilité que l'implémentation principale en C. La nouvelle version poursuit le développement de RPC, prépare la prise en charge des relais et ajoute une protection contre les attaques par déni de service (DoS) sur les services Onion.
• La version 0.15 du moteur de jeu Bevy, écrite en Rust, a été publiée. Le moteur utilise un modèle axé sur les données (Data Driven) pour définir la logique du jeu, construit sur un ensemble de composants prêts à l'emploi du Bevy ECS (Entity Component System) pouvant être exécutés en parallèle. Le rendu 2D et 3D est supporté, ainsi que l'animation par squelette, la définition du graphe de rendu, un système de formation de scènes, un cadre pour la création d'interfaces utilisateur, et la possibilité de modifier des scènes et des ressources sans avoir besoin de redémarrer.
• Le nouvel éditeur de texte en console Helix 25.01, écrit en Rust, étend les idées de vim et neovim. Il prend en charge l'intégration avec des serveurs LSP et Tree-sitter, la sélection simultanée de plusieurs blocs, l'utilisation de plusieurs curseurs lors de l'édition, des thèmes de mise en forme, et le protocole de débogage DAP (Debug Adapter Protocol).
• Le moteur de navigateur Servo, écrit en Rust, a ajouté la prise en charge du mode sombre. La taille du navigateur ServoShell a été réduite de 20%. La prise en charge des spécifications web a été étendue pour permettre la connexion et la lecture de messages dans Discord (l'envoi de messages reste impossible).
• Mozilla a présenté l'outil Uniffi for React Native pour créer des modules pour React Native en Rust.
• Des tests de performance des encodeurs d'images au format PNG ont été réalisés. Les décodeurs en Rust (png, zune-png, wuffs) se sont révélés plus rapides que ceux en C (libpng, spng, stb_image). Par exemple, le paquet crate png (image-rs) a surpassé libpng de 1,8 fois sur un système x86 et de 1,5 fois sur un système ARM. image-rs : 375,401 MP/s (moyenne) 318,632 MP/s (moyenne géométrique) zune-png : 376,649 MP/s (moyenne) 302,529 MP/s (moyenne géométrique) wuffs : 376,205 MP/s (moyenne) 287,181 MP/s (moyenne géométrique) libpng : 208,906 MP/s (moyenne) 173,034 MP/s (moyenne géométrique) spng : 299,515 MP/s (moyenne) 235,495 MP/s (moyenne géométrique) stb_image : 234,353 MP/s (moyenne) 171,505 MP/s (moyenne géométrique)

Source : opennet.ru