« La sécurisation des logiciels via le langage Rust n'est pas supérieure à celle offerte par le C++ », d'après Bjarne Stroustrup

Contre une sortie de la NSA qui exclut le C++ des langages sécurisés

« La sécurisation des logiciels par le langage Rust n’est pas supérieure à celle offerte par le C++ », d’après Bjarne Stroustrup
qui réagit à une sortie de la NSA qui exclut le C++ des langages sécurisés

Mark Russinovich de Microsoft a déclaré au troisième trimestre de l’année précédente que « c’est le moment d’arrêter d’initier de nouveaux projets en langages C ou C++ et de passer à Rust. » Motif : le Rust offre de meilleures garanties de sécurisation des logiciels que les langages C ou C++. La position reprise quelques mois plus tard par la NSA trouve désormais contradicteur et pas des moindres. Sans détour, le créateur du langage C++ déclare : « la sécurisation des logiciels par le langage Rust n’est pas supérieure à celle offerte par le C++. »

En effet, Bjarne Stroustrup s’inscrit en faux avec le fait que la publication de la NSA limite la notion de sécurisation des logiciels à celle de sécurisation de la mémoire. En réalité, cet aspect est un dénominateur commun de toutes les publications qui conseillent de mettre le C ou le C++ au rebut au profit du langage Rust en raison des garanties de sécurisation des logiciels que plusieurs grandes entreprises (Microsoft, Amazon, etc.) lui reconnaissent.

« 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 », indique-t-il. 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.

https://www.youtube.com/watch?v=t3Qf96V5WWg

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.

#include
#include
#include
#include
enum NoRefs {};
enum HasMutRef {};
enum HasRefs {};
template
class Own;
template
class MutRef;
template
class Ref;
template
inline Own make(Args... args) {
return Own(std::forward(args)...);
}
template
inline Own consume(Own own, MutRef ref) {
return Own(std::move(own));
}
template
inline Own consume(Own own) {
return Own(std::move(own));
}
template
std::pair, MutRef> mut(Own own) {
T* t = own.t_;
own.t_ = nullptr;
return std::make_pair(Own(t), MutRef(t));
}
template
std::pair, MutRef> ref(Own own) {
T* t = own.t_;
own.t_ = nullptr;
return std::make_pair(Own(t), Ref(t));
}
// No refs exist.
template
class [[clang::trivial_abi]] Own {
public:
template
Own(Args... args) : t_(new T(std::forward(args)...)) {}
~Own() { delete t_; }
Own(Own&& other) : t_(other.t_) { other.t_ = nullptr; }
T& operator*() const noexcept { return *t_; }
T* operator->() const noexcept { return t_; }
private:
friend Own consume(Own own, MutRef ref);
friend Own consume(Own own);
friend std::pair, MutRef> mut(Own own);
friend std::pair, Ref> ref(Own own);
Own(Own&& own) : t_(own.t_) {}
Own(Own&& own) : t_(own.t_) {}
T* t_;
};
// A mut ref exists.
template
class [[clang::trivial_abi]] Own {
public:
T& operator*() const noexcept { return *t_; }
T* operator->() const noexcept { return t_; }
private:
friend class Own;
Own(T* t) : t_(t) {}
~Own() {}
T* t_;
};
// Non-mut refs exist.
template
class [[clang::trivial_abi]] Own {
public:
T& operator*() const noexcept { return *t_; }
T* operator->() const noexcept { return t_; }
Ref ref() { return Ref(t_, &count_); }
private:
friend std::pair, Ref> ref(Own own);
explicit Own(T* t) : t_(t) {}
~Own() { assert(count_ == 0u); }
T* t_;
uint32_t count_;
};
template
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, MutRef> mut(Own own);
MutRef(T* t) : t_(t) {}
T* t_;
};
template
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, Ref> ref(Own own);
Ref(T* t, uint32_t* count) : t_(t), count_(count) { ++(*count); }
T* t_;
uint32_t* count_;
};
MutRef Borrows(MutRef 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 i = make(5);
auto& hasmut = mut(std::move(i));
MutRef ref = Borrows(std::move(hasmut.second));
Own i2 = consume(std::move(hasmut.first), std::move(ref));
}

La sortie de Bjarne Stroustrup 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 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++.

Sources : Bjarne, Google

Et vous ?

:fleche: Ê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 ?
:fleche: Le C et le C++ ont-ils vraiment besoin de remplaçants surtout en matière de programmation système ?
:fleche: Votre entreprise a-t-elle adopté le langage Rust ? Si oui, pour quelles raisons ?

Voir aussi :

:fleche: L'équipe Microsoft Security Response Center recommande l'utilisation de Rust comme approche proactive pour un code plus sécurisé
:fleche: Quel langage pourrait remplacer C ? Après avoir comparé Go, Rust et D, le choix d'Andrei Alexandrescu se porte sur D
:fleche: C2Rust : un outil qui permet de faire la traduction et la refactorisation de votre code écrit en langage C vers le langage Rust