C’est pas du gâteau : Renforcer la sécurité de la glibc
- View all articles
Sergio Durigan Junior
Senior Software Engineer
Chainguard
Sergio Durigan Junior Senior Software Engineer
La série « This Shit is Hard » de Chainguard met en lumière le travail d’ingénierie complexe que nous avons accompli afin d’offrir les meilleurs résultats possibles aux clients qui utilisent nos produits. Nous avons abordé plusieurs sujets importants, notamment la Chainguard Factory, les bibliothèques Chainguard pour Java, nos intégrations avec plusieurs scanners partenaires et notre mise en œuvre du niveau 3 de SLSA. Aujourd’hui, nous nous intéressons aux options de compilation durcies (hardened flags) et à la bibliothèque GNU C.
Il n’est guère surprenant que nous prenions la sécurité très au sérieux chez Chainguard. Cela se manifeste de différentes manières, comme notre engagement à fournir à nos clients des images de conteneurs sans aucune vulnérabilité (zero-CVE) ou l’automatisation poussée que nous mettons en place pour veiller à ce que nos paquets soient constamment mis à jour avec les derniers correctifs amont. Mais le travail de sécurité ne se limite pas à l’atténuation des risques : il est payant d’être proactif et de prendre des mesures préventives capables d’empêcher les acteurs malveillants de nuire. L’une de ces mesures est l’adoption d’options de compilation durcies lors de la génération de nos paquets.
Dans cet article de blog, je vais vous raconter brièvement nos tentatives pour compiler avec des options de durcissement l’une de nos bibliothèques les plus importantes : la bibliothèque GNU C (glibc). Ce fut une tâche passionnante, semée d’embûches et de subtilités méconnues, qui nous a permis de collaborer avec les projets amont GNU Compiler Collection (GCC) et glibc pour résoudre des problèmes complexes et, à terme, livrer une version durcie de la bibliothèque.
Notre chaîne d’outils et nos options de compilation
Selon Wikipédia, une chaîne d’outils (toolchain) est « un ensemble d’outils de développement logiciel utilisés pour compiler et, plus largement, développer des logiciels ». Dans le contexte des paquets Chainguard, on peut considérer qu’une chaîne d’outils regroupe le compilateur (GCC, par exemple) et les outils qui l’accompagnent comme l’éditeur de liens, le débogueur, etc. Chez Chainguard, nous maintenons des chaînes d’outils pour de nombreux langages (Golang, Rust, Python, C/C++, Java, et bien d’autres), mais dans le cadre spécifique de cet article de blog, nous nous intéressons à la chaîne d’outils C. Et parce que la bibliothèque C standard que nous utilisons, glibc, fait partie intégrante de tout système GNU/Linux, nous considérons qu’elle fait également partie de notre chaîne d’outils.
L’une de nos mesures proactives les plus importantes consiste à compiler nos paquets à l’aide d’options de compilation durcies. Ces options sont généralement issues du guide Compiler Options Hardening Guide for C and C++ de l’OpenSSF, et nous suivons leurs recommandations d’aussi près que possible. Les autres distributions GNU/Linux majeures n’adoptent qu’un sous-ensemble restreint des options suggérées par l’OpenSSF. C’est encore une manière pour Chainguard de rester à la pointe des pratiques de sécurité.
Les options de compilation que nous utilisons pour les programmes en C/C++ sont un mélange de bonnes pratiques générales et d’options de durcissement spécifiques à chaque processeur. Par exemple, l’utilisation de -z noexecstack lors de l’édition de liens d’un programme marque sa mémoire de pile comme non exécutable, ce qui empêche les attaques par exécution de données. Sur les systèmes x86 et ARM64, nous utilisons respectivement -fcf-protection=full et -mbranch-protection=standard, qui activent l’instrumentation du code pour accroître la sécurité des programmes en effectuant des vérifications pour empêcher le détournement du flux de contrôle, une technique utilisée dans la programmation orientée retour (ROP) et la programmation orientée saut (JOP).
Le problème de la glibc
Presque tous les paquets écrits en C ou C++ que nous livrons à nos utilisateurs sont compilés avec nos options de durcissement recommandées. Il n’y a que très peu d’exceptions à cette règle, et elles surviennent généralement parce que nous devons désactiver une option précise pour corriger une incompatibilité avec l’amont. Mais la glibc a toujours constitué une exception à cette règle, et cela n’a rien de surprenant.
La bibliothèque GNU C est un paquet fondamental pour nous. Elle est présente dans quasiment toutes les images que nous proposons et constitue une dépendance pour la grande majorité de nos paquets. Nous lui accordons une attention toute particulière lors de la publication de nouvelles versions ou lorsque nous y apportons des modifications, car un bug dans la glibc peut soudainement devenir un problème dans l’ensemble de nos images.
Lors de notre première tentative de compilation de la glibc avec des options durcies, nous avons découvert que certaines applications se mettaient à planter lorsqu’elles utilisaient cette version renforcée. Nos ingénieurs ont réussi à obtenir une trace d’appels (stack trace) du plantage, mais malheureusement, elle ne fournissait pas beaucoup d’informations sur ce qui se passait. Nous avons donc décidé d’annuler l’introduction des options de durcissement lors de la compilation de la glibc, le temps de comprendre pleinement le problème. Malgré ce revers, nous avions conscience de tout l’intérêt que représentait une glibc durcie pour l’ensemble de nos images, et nous n’étions pas prêts à baisser les bras.
La nouvelle tentative et l’investigation
Après en avoir discuté avec l’équipe, j’ai décidé d’enquêter sur le problème et de comprendre ce qui pouvait être fait pour activer pleinement les options de durcissement sur la glibc. J’adore déboguer des problèmes ardus et j’ai une certaine expérience des chaînes d’outils, j’avais donc hâte de voir jusqu’où je pourrais mener cette mission. Même si l’objectif ultime était d’activer toutes les options durcies, parvenir à en activer ne serait-ce qu’un sous-ensemble constituerait déjà une victoire.
J’ai commencé par tenter de reproduire le problème. Heureusement, je disposais déjà d’un test simple pour déclencher l’erreur. Il suffisait d’installer le paquet py3-matplotlib, puis, au sein d’un système exécutant une glibc durcie, d’exécuter la commande :
$ python3 -c 'import matplotlib'
Cela entraînait une interruption brutale du programme (abort) avec génération d’un fichier de vidage mémoire (coredump). J’ai suivi ces étapes et j’ai constaté que le plantage se produisait comme prévu. Grâce à cela, j’ai pu utiliser GDB pour récupérer la trace d’appels :
#0 0x00007c43afe9972c in __pthread_kill_implementation () from /lib/libc.so.6
#1 0x00007c43afe3d8be in raise () from /lib/libc.so.6
#2 0x00007c43afe2531f in abort () from /lib/libc.so.6
#3 0x00007c43af84f79d in uw_init_context_1[cold] () from /usr/lib/libgcc_s.so.1
#4 0x00007c43af86d4d8 in _Unwind_RaiseException () from /usr/lib/libgcc_s.so.1
#5 0x00007c43acac9014 in __cxxabiv1::__cxa_throw (obj=0x5b7d7f52fab0, tinfo=0x7c429b6fd218 <typeinfo for pybind11::attribute_error>, dest=0x7c429b5f7f70 <pybind11::reference_cast_error::~reference_cast_error() [clone .lto_priv.0]>)
at ../../../../libstdc++-v3/libsupc++/eh_throw.cc:93
#6 0x00007c429b5ec3a7 in ft2font__getattr__(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) [clone .lto_priv.0] [clone .cold] () from /usr/lib/python3.13/site-packages/matplotlib/ft2font.cpython-313-x86_64-linux-gnu.so
#7 0x00007c429b62f086 in pybind11::cpp_function::initialize<pybind11::object (*&)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >), pybind11::object, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, pybind11::name, pybind11::scope, pybind11::sibling>(pybind11::object (*&)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >), pybind11::object (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&)::{lambda(pybind11::detail::function_call&)#1}::_FUN(pybind11::detail::function_call&) [clone .lto_priv.0] ()
from /usr/lib/python3.13/site-packages/matplotlib/ft2font.cpython-313-x86_64-linux-gnu.so
#8 0x00007c429b603886 in pybind11::cpp_function::dispatcher(_object*, _object*, _object*) () from /usr/lib/python3.13/site-packages/matplotlib/ft2font.cpython-313-x86_64-linux-gnu.so
...
C’était la même trace d’appels que celle obtenue par les autres ingénieurs qui s’étaient penchés sur le problème, ce qui était une bonne nouvelle. Cela signifiait que j’étais confronté au même problème, et non à une anomalie différente. Je me souviens m’être dit qu’il était curieux de voir la fonction abort être appelée immédiatement après _Unwind_RaiseException, mais je n’y ai pas prêté plus d’attention que cela sur le moment. Ce que je voulais, c’était trouver un autre paquet qui plantait avec la glibc durcie afin de comparer les traces d’appels, et j’ai rapidement constaté que l’éditeur de texte Emacs rencontrait lui aussi le même problème. Avec Emacs, voici la trace d’appels que j’ai obtenue :
#0 0x00007eede329972c in __pthread_kill_implementation () from /lib/libc.so.6
#1 0x00007eede323d8be in raise () from /lib/libc.so.6
#2 0x00007eede322531f in abort () from /lib/libc.so.6
#3 0x00007eede262879d in uw_init_context_1[cold] () from /usr/lib/libgcc_s.so.1
#4 0x00007eede2646e7c in _Unwind_Backtrace () from /usr/lib/libgcc_s.so.1
#5 0x00007eede3327b11 in backtrace () from /lib/libc.so.6
#6 0x000059535963a8a1 in emacs_backtrace ()
#7 0x000059535956499a in main ()
Cette fois, le plantage se produit dans _Unwind_Backtrace, ce qui indique qu’un schéma récurrent se dessine ! Cela devait avoir un lien avec le déroulement de pile (stack unwinding) — du moins, c’est ce que je pensais… lisez la suite pour découvrir toute la vérité. Voyez-vous, la fonction backtrace (oui, c’est bien une fonction) et le mécanisme de gestion des exceptions en C++ utilisent des techniques similaires pour accomplir leur tâche, ce qui revient concrètement à dérouler les trames de la pile.
Un reproducteur minimal
Reproduire facilement le bug est une excellente chose qui facilite le débogage, mais disposer d’un reproducteur minimal pour le problème, c’est encore mieux.
py3-matplotlib est un paquet volumineux qui entraîne toute une série de dépendances supplémentaires. Il n’est donc pas évident de demander à d’autres personnes : « installez simplement ce gros paquet ainsi que toutes ces autres dépendances, puis lancez cette commande… », en particulier si nous devons signaler un bug en amont et nous adresser à des interlocuteurs qui n’utilisent peut-être même pas la même distribution que nous. J’ai donc entrepris de trouver une recette plus concise pour reproduire le problème, idéalement quelque chose qui ne soit pas lié à un paquet spécifique de la distribution.
Disposant de toutes les informations recueillies lors de la session de débogage initiale, en particulier la trace d'appels d'Emacs, j'ai pensé que je pouvais écrire un programme très simple qui invoquerait simplement la fonction backtrace de la glibc afin de déclencher le chemin de code menant à _Unwind_Backtrace. Voici ce que j'ai écrit :
#include <execinfo.h>
int
main(int argc, char *argv[])
{
void *a[4096];
backtrace (a, 100);
return 0;
}
La bonne nouvelle, c'est que j'arrivais toujours à reproduire le problème avec ce petit programme, ce qui me facilitait grandement la tâche.
GCC entre en jeu
Jusqu'à ce stade, je considérais que ce bogue était causé par la glibc. Dans le même temps, alors que je travaillais à l'intégration de GCC 15 dans Wolfi, j'ai découvert par hasard que le plantage ne se produisait pas en utilisant une version durcie de la glibc compilée avec GCC 15. Je me suis alors focalisé sur GCC et, plus particulièrement, sur libgcc, qui fournit les mécanismes nécessaires pour effectuer le déroulement de pile (entre autres choses).
Grâce à l'aide précieuse d'un ami, j'ai passé plusieurs heures à explorer en profondeur les rouages internes de la logique de déroulement dans libgcc. J'ai beaucoup appris et j'ai fini par découvrir que l'extrait suivant, issu d'une fonction appelée uw_frame_state_for, posait problème :
// ...
fde = _Unwind_Find_FDE (context->ra + _Unwind_IsSignalFrame (context) - 1,
&context->bases);
if (fde == NULL)
{
#ifdef MD_FALLBACK_FRAME_STATE_FOR
/* Couldn't find frame unwind info for this function. Try a
target-specific fallback mechanism. This will necessarily
not provide a personality routine or LSDA. */
return MD_FALLBACK_FRAME_STATE_FOR (context, fs);
#else
return _URC_END_OF_STACK;
#endif
}
// ...
La variable fde ne devrait pas être NULL ici, mais elle l'est. Cela ne se produisait jamais lorsque la glibc était compilée avec GCC 15, mais cela arrivait bien si elle était compilée avec GCC 14. Cette valeur NULL provenait d'une autre fonction appelée find_fde_tail, et il semblait y avoir un problème dans la manière dont la fonction calculait le Frame Description Entry (la signification de FDE) de /lib/ld-linux-x86-64.so.2. Cela signifie que la glibc et le chargeur dynamique sont en effet également impliqués dans le bogue.
J'ai décidé de procéder par dichotomie (bisect) sur GCC pour déterminer exactement ce qui avait changé entre GCC 14 et 15 permettant au code de fonctionner soudainement, mais à ce stade, je n'étais plus certain qu'il s'agissait d'un bogue du compilateur. Ayant atteint les limites de mes connaissances sur GCC/glibc et le déroulement de pile, j'ai décidé de signaler un bogue en amont et de demander de l'aide.
Le projet amont prend le relais
J'ai signalé ce bogue à GCC, et en quelques heures, la communauté a mené une enquête approfondie et en a identifié la cause première. Il s'agissait bien d'un bogue de la glibc après tout. Un nouveau bogue a été ouvert, cette fois à l'encontre de la glibc, et un correctif a rapidement été proposé.
Au final, le problème venait bien de la façon dont l'éditeur de liens définit __ehdr_start, ce qui, d'après le code (issu de elf/dl-support.c) :
if (_dl_phdr == NULL)
{
/* Starting from binutils-2.23, the linker will define the
magic symbol __ehdr_start to point to our own ELF header
if it is visible in a segment that also includes the phdrs.
So we can set up _dl_phdr and _dl_phnum even without any
information from auxv. */
extern const ElfW(Ehdr) __ehdr_start attribute_hidden;
assert (__ehdr_start.e_phentsize == sizeof *GL(dl_phdr));
_dl_phdr = (const void *) &__ehdr_start + __ehdr_start.e_phoff;
_dl_phnum = __ehdr_start.e_phnum;
}
Mais la définition suivante est celle qui pose problème (issue de elf/rtld.c) :
extern const ElfW(Ehdr) __ehdr_start attribute_hidden;
Ce symbole (ainsi que son pendant, __ehdr_end) faisait l'objet d'une réadressage à l'exécution alors qu'il n'aurait pas dû. Le correctif déployé a ajouté des barrières d'optimisation pour empêcher le compilateur d'effectuer ces réadressages.
Épilogue : s'amuser avec l'éditeur de liens ARM64
Vous pensiez que c'était terminé ? Nous le pensions aussi. Mais en réalité, un autre problème rôdait dans l'ombre.
Chainguard prend en charge les paquets et les images ARM64, et l'un des processeurs ARM sur le marché est le processeur Axion de Google. Pour une raison obscure, l'outil ldconfig plantait lors de son exécution sur ces processeurs. Après une enquête bien plus courte, j'ai signalé un autre bogue en amont à la glibc et, là encore, j'ai obtenu une réponse et un correctif approprié en quelques jours. Le problème, cette fois, était lié au fait que, sur ARM64, memcpy et memcmp (entre autres fonctions) sont implémentées à l'aide de fonctions indirectes (ou ifunc). Il s'agit d'une fonctionnalité pratique de la glibc qui permet aux développeurs de proposer différentes implémentations d'une même fonction, puis de choisir entre elles au moment de l'exécution. Pour que cela fonctionne, cependant, du code d'initialisation doit être exécuté. Dans ce bogue précis, les fonctions étaient appelées avant la procédure d'initialisation, ce qui provoquait le plantage.
Conclusion
Ces bogues ont été très intéressants à analyser, et c'était une excellente opportunité de pouvoir aider la communauté en amont à les résoudre. C'est aussi un effet secondaire de l'approche de Chainguard pour assurer la sécurité de nos paquets : comme nous compilons et testons constamment les dernières mises à jour en amont, nous finissons par repérer des bogues complexes dont même les projets d'origine n'ont pas connaissance. Si vous souhaitez en savoir plus sur notre travail lié au durcissement des compilateurs, découvrez comment nous avons atténué une vulnérabilité d'rsync à l'aide de ces options de compilation. Notre équipe DevRel a également mis à disposition un excellent tutoriel pour vous aider à faire vos premiers pas avec les options de compilation afin de sécuriser votre code.
Share this article
Articles connexes
ingénierieHelp! I need somebody! --help, not just anybody! Every tool that never had a manual page
ingénierieCI in 2027: Why the future of coding needs instant back-pressure
ingénierieGitHub Actions down? No problem. Green with Chainguard Checks.
ingénierieIt’s a man’s, man’s, man’s world: Every manual page in Chainguard OS, now readable by your agent
ingénierieThis Shit is Hard: Nobody has ever been pwned by Helvetica…or have they?
ingénierieThis Shit is Hard: Building a vulnerability database from private reports