» Faut-il arrêter d’initier de nouveaux projets en C++ et passer à Rust ? La question divise dans la communauté des développeurs dont certains recommandent le langage Rust plutôt que le C ou le C++. Les raisons : la parité du Rust en termes de vitesse d’exécution en comparaison avec le C ; la sécurisation et la fiabilité du Rust en comparaison avec C ou C++. La comparaison entre Rust et C++ vient de prendre un coup de neuf avec une sortie des agences de l’alliance Five Eyes. Elles insistent pour que les organisations abandonnent C++ pour le langage Rust, ce, après que la prise de position du créateur du langage C++ selon laquelle : « la sécurisation des logiciels par le Rust n’est pas supérieure à celle offerte par le C++. »
Les comparatifs des langages Rust et C++ ont un dénominateur commun : la mise en avant de la supériorité de Rust à C++ en matière de sécurisation de la mémoire.
La publication des Five Eyes ne s’en écarte pas : « Les langages de programmation tels que C et C++ sont des exemples de langages de programmation qui peuvent conduire à un code non sûr pour la mémoire et qui sont encore parmi les langages les plus utilisés aujourd'hui. Pour tenter d'atténuer les dangers du code à mémoire non sécurisée obtenu en C et C++, de nombreux fabricants de logiciels investissent dans des programmes de formation à l'intention de leurs développeurs.
Nombre de ces programmes de formation comprennent des tactiques conçues pour réduire la prévalence des vulnérabilités de sécurité de la mémoire produites par ces langages. En outre, il existe de nombreux programmes de formation organisés par des associations commerciales et industrielles. En outre, diverses organisations et universités proposent des formations et un certificat professionnel pour démontrer la connaissance des pratiques de codage sécurisé en C et en C++.
Bien que la formation puisse réduire le nombre de vulnérabilités qu'un codeur peut introduire, étant donné l'omniprésence des défauts de sécurité de la mémoire, il est presque inévitable que des vulnérabilités de sécurité de la mémoire se produisent encore. Même les développeurs les plus expérimentés introduisent des bogues desquels peuvent résulter des vulnérabilités importantes. La formation doit servir de transition pendant qu'une organisation met en œuvre des contrôles techniques plus robustes, tels que des langages à sécurité mémoire. »
« Rust garantit la sécurisation de la mémoire et des threads au moment de la compilation en introduisant des règles de propriété. Il va au-delà du RAII, un mécanisme de gestion de la mémoire couramment utilisé en C++. Il présente deux avantages. Le premier est évident : une fois que le compilateur Rust a validé notre programme, nous n'aurons pas de défauts de segmentation ou de conditions de concurrence lors de l'exécution, ce qui nécessiterait des dizaines d'heures de débogage, en particulier dans une base de code hautement concurrente et principalement asynchrone. La seconde est plus subtile : le compilateur Rust restreint simplement les types de fautes, ce qui réduit les fragments de code étroitement imbriqués qui peuvent causer un tel comportement bogué. La réplication des bogues est considérablement améliorée avec l'aide de l'exécution déterministe », indique l'éditeur RisingWave à propos de la réécriture de son SGBD Cloud natif depuis zéro en Rust après abandon du projet en C++.
C’est une sortie qui fait suite à celle d’Amazon qui est d’avis que « choisir Rust c’est opter pour une meilleure sécurisation des logiciels qu’avec le C, mais une efficacité énergétique et une performance d’exécution que seul le C offre. » En effet, certains benchmarks suggèrent que les applications Rust sont plus rapides que leurs équivalents en langage C. Et c’est justement pour ces atouts que sont la parité en termes de vitesse d’exécution en comparaison avec le C, mais surtout pour la sécurisation et la fiabilité que Mark Russinovich recommande le Rust plutôt que le C ou le C++.
Néanmoins, Bjarne Stroustrup s’inscrit en faux avec le fait que les comparatifs entre Rust et C++ limitent la notion de sécurisation des logiciels à celle de sécurisation de la mémoire : « Il n'y a pas qu'une seule définition de la notion de "sécurité" et nous pouvons réaliser une variété de types de sécurité par une combinaison de styles de programmation, de bibliothèques de support et grâce à la mise à profit de l'analyse statique. » Bjarne Stroustrup suggère ainsi que ce qu’il est possible d’obtenir du C++ en matière de sécurisation des logiciels dépend entre autres du développeur et notamment de la connaissance des outils que lui offre le langage, de sa maîtrise du compilateur, etc.
Des ingénieurs de Google au fait de ce que le C++ leur offre comme possibilités se sont donc lancés dans la mise sur pied dans ce langage d’un borrow-checker. C’est une fonctionnalité du compilateur Rust qui
garantit la sécurisation de la mémoire grâce à une gestion des allocations en mémoire des pointeurs.
L’équipe de Google dont la publication est parue au troisième trimestre de l’année précédente est parvenue à la conclusion que le système de types du C++ ne se prête pas à un tel exercice. Et donc que la sécurisation de la mémoire en C++ est réalisable avec des vérifications lors de l’exécution du programme. En d’autres termes, c’est avec du code C++ lent qu’il est possible d’atteindre un niveau de sécurisation équivalent à celui du Rust.
| Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | #include <type_traits> #include <utility> #include <assert.h> #include <stddef.h> enum NoRefs {}; enum HasMutRef {}; enum HasRefs {}; template <class T, typename Mode> class Own; template <class T> class MutRef; template <class T> class Ref; template <class T, typename... Args> inline Own<T, NoRefs> make(Args... args) { return Own<T, NoRefs>(std::forward<Args>(args)...); } template <class T> inline Own<T, NoRefs> consume(Own<T, HasMutRef> own, MutRef<T> ref) { return Own<T, NoRefs>(std::move(own)); } template <class T> inline Own<T, NoRefs> consume(Own<T, HasRefs> own) { return Own<T, NoRefs>(std::move(own)); } template <class T> std::pair<Own<T, HasMutRef>, MutRef<T>> mut(Own<T, NoRefs> own) { T* t = own.t_; own.t_ = nullptr; return std::make_pair(Own<T, HasMutRef>(t), MutRef<T>(t)); } template <class T> std::pair<Own<T, HasRefs>, MutRef<T>> ref(Own<T, NoRefs> own) { T* t = own.t_; own.t_ = nullptr; return std::make_pair(Own<T, HasRefs>(t), Ref<T>(t)); } // No refs exist. template <class T> class [[clang::trivial_abi]] Own<T, NoRefs> { public: template <typename... Args> Own(Args... args) : t_(new T(std::forward<Args>(args)...)) {} ~Own() { delete t_; } Own(Own<T, NoRefs>&& other) : t_(other.t_) { other.t_ = nullptr; } T& operator*() const noexcept { return *t_; } T* operator->() const noexcept { return t_; } private: friend Own<T, NoRefs> consume<T>(Own<T, HasMutRef> own, MutRef<T> ref); friend Own<T, NoRefs> consume<T>(Own<T, HasRefs> own); friend std::pair<Own<T, HasMutRef>, MutRef<T>> mut(Own<T, NoRefs> own); friend std::pair<Own<T, HasRefs>, Ref<T>> ref(Own<T, NoRefs> own); Own(Own<T, HasMutRef>&& own) : t_(own.t_) {} Own(Own<T, HasRefs>&& own) : t_(own.t_) {} T* t_; }; // A mut ref exists. template <class T> class [[clang::trivial_abi]] Own<T, HasMutRef> { public: T& operator*() const noexcept { return *t_; } T* operator->() const noexcept { return t_; } private: friend class Own<T, NoRefs>; Own(T* t) : t_(t) {} ~Own() {} T* t_; }; // Non-mut refs exist. template <class T> class [[clang::trivial_abi]] Own<T, HasRefs> { public: T& operator*() const noexcept { return *t_; } T* operator->() const noexcept { return t_; } Ref<T> ref() { return Ref<T>(t_, &count_); } private: friend std::pair<Own<T, HasRefs>, Ref<T>> ref(Own<T, NoRefs> own); explicit Own(T* t) : t_(t) {} ~Own() { assert(count_ == 0u); } T* t_; uint32_t count_; }; template <class T> class MutRef { public: T& operator*() const noexcept { return *t_; } T* operator->() const noexcept { return t_; } ~MutRef() = default; MutRef(MutRef&& other) : t_(other.t_) {} private: friend std::pair<Own<T, HasMutRef>, MutRef<T>> mut(Own<T, NoRefs> own); MutRef(T* t) : t_(t) {} T* t_; }; template <class T> class Ref { public: T& operator*() const noexcept { return *t_; } T* operator->() const noexcept { return t_; } ~Ref() { --(*count_); } Ref(const Ref& other) : t_(other.t_), count_(other.count_) { ++(*count_); } Ref(Ref&& other) : t_(other.t_), count_(other.count_) {} private: friend std::pair<Own<T, HasRefs>, Ref<T>> ref(Own<T, NoRefs> own); Ref(T* t, uint32_t* count) : t_(t), count_(count) { ++(*count); } T* t_; uint32_t* count_; }; MutRef<int> Borrows(MutRef<int> i) { (*i)++; return i; } TEST(Borrow, HelloWorld) { // Can't do this. The HasMutRefs type is not destructible outside of // consume()in order to have compiler check it is re-owned, but it won't // compile. To pass the HasMutRefs to consume() it has to be destroyed both // inside and outside of consume(). This is true even if trivial_abi is // used and only one destructor would actually run. Own<int, NoRefs> i = make<int>(5); auto& hasmut = mut(std::move(i)); MutRef<int> ref = Borrows(std::move(hasmut.second)); Own<int, NoRefs> i2 = consume(std::move(hasmut.first), std::move(ref)); |
La sortie des agences Five Eyes intervient dans un contexte où Rust se démarque des autres langages présentés depuis des années comme des alternatives au C et au C++. En effet, le noyau Linux s’ouvre de plus en plus au langage de programmation système de Mozilla.
Après 31 ans, un deuxième langage a fait son entrée pour le développement du noyau Linux : c’est le Rust. La prise en charge de Rust pour le développement du noyau Linux est vue comme une « une étape importante vers la capacité d'écrire les pilotes dans un langage plus sûr. » Rust de Mozilla Research est le type de langage de programmation auquel ceux qui écrivent du code pour des systèmes d’entrée/sortie de base (BIOS), des chargeurs d’amorce, des systèmes d’exploitation, etc. portent un intérêt. D’avis d’observateurs avertis, c’est le futur de la programmation système en lieu et place de langages comme le C ou le C++.
Source : Five Eyes
Et vous ?
Êtes-vous en accord avec les griefs portés à l'endroit de C/C++ en matière de sécurité ? Le problème n'est-il pas plutôt celui de la qualité des développeurs ? Le C et le C++ ont-ils vraiment besoin de remplaçants surtout en matière de programmation système ? Votre entreprise a-t-elle adopté le langage Rust ? Si oui, pour quelles raisons ?Voir aussi :
L'équipe Microsoft Security Response Center recommande l'utilisation de Rust comme approche proactive pour un code plus sécurisé Quel langage pourrait remplacer C ? Après avoir comparé Go, Rust et D, le choix d'Andrei Alexandrescu se porte sur D C2Rust : un outil qui permet de faire la traduction et la refactorisation de votre code écrit en langage C vers le langage Rust 
Envoyé par commandantFred
