Un vrai casse-tête : la complexité de corriger à grande échelle les failles de sécurité des bibliothèques Python
- View all articles
Wesley Wiedenmeier
Staff Software Engineer
Chainguard
Wesley Wiedenmeier Staff Software Engineer
Nous savons tous que nous devrions maintenir nos dépendances à jour. Nous savons tous que nous devrions utiliser des outils automatisés pour nous assurer que les versions soient mises à niveau dès qu'un correctif de sécurité est publié pour l'une des centaines de milliers de dépendances qu'utilisent nos applications.
Malheureusement, nous nous sommes tous déjà retrouvés dans des situations où la mise à jour d'une dépendance n'est tout simplement pas envisageable. Avec la recrudescence des attaques par logiciels malveillants, de nombreuses entreprises choisissent de ne pas mettre à niveau leurs dépendances dès leur sortie.
Les développeurs Python ne connaissent que trop bien cette douleur. Si Python possède de nombreux atouts, la rétrocompatibilité n'en fait pas partie. Les développeurs Python sont parfois confrontés à des choix très cornéliens :
S'engager dans une longue migration vers une nouvelle version d'une dépendance
Laisser des failles de sécurité sans correctif
Tenter de rétro-porter (backporter) les correctifs eux-mêmes
Ne pas mettre à jour immédiatement signifie que vous restez exposé à des vulnérabilités connues. Mettre à jour dès la sortie des nouvelles versions de paquets augmente votre exposition potentielle aux logiciels malveillants. Rétro-porter les correctifs soi-même prend du temps, s'avère complexe, et peu d'équipes disposent de la capacité d'ingénierie supplémentaire pour s'y atteler.
Chez Chainguard, notre mission est d'être la source de confiance pour l'open source. Bien que nous vous encouragions à maintenir vos dépendances à jour comme suggéré dans la première option, nous avons conscience que les clients de nos Chainguard Libraries souhaitent sécuriser leurs applications, même lorsque la mise à niveau n'est pas possible. Si vous avez l'habitude de rétro-porter des correctifs vous-même, cet article pourrait vous aider à comprendre pourquoi cette approche n'est pas viable à long terme et pourquoi vous devriez laisser mon équipe et moi-même nous en charger pour vous.
Quels correctifs devrions-nous utiliser, de toute façon ?
Beaucoup de gens écrivent des correctifs de sécurité : les mainteneurs du projet en amont (upstream), les distributions Linux, ou encore un développeur lambda sur un forum. Si vous recherchez <cve_id> patch sur Google, vous obtiendrez probablement pas mal de résultats.
Malheureusement, tout le monde sur Internet n'est pas digne d'une confiance absolue, et les correctifs ne sont donc pas tous d'égale qualité. L'erreur est humaine, et certaines personnes cherchent délibérément à induire les autres en erreur. Si vous téléchargez et exécutez du code provenant d'une source inconnue sur Internet, vous ne savez pas si vous recevez du code provenant d'un ingénieur hautement compétent et intègre, de quelqu'un qui ignore comment écrire du code sécurisé, ou d'un acteur malveillant motivé à accéder aux secrets de votre entreprise et de vos clients.
Nous ne voulons absolument pas mettre nos clients en danger en fournissant un correctif qui, soit ne résout pas le problème de sécurité, soit, pire encore, introduit une nouvelle vulnérabilité. Même si un correctif trouvé sur un forum quelconque a pu être parfaitement rédigé, l'outillage actuel ne permet pas de vérifier cet espoir.
Chez Chainguard, nous adoptons une approche prudente pour sélectionner les correctifs que nous rétro-portons. Nous acceptons uniquement les correctifs que les développeurs légitimes du projet en amont ont validés dans la branche principale du dépôt du projet.
Personne ne connaît les rouages d'un projet mieux que ses auteurs et mainteneurs d'origine. Nous nous appuyons sur leur connaissance approfondie de leur projet pour évaluer correctement les correctifs qu'ils intègrent dans leur base de code.
Générer des correctifs est facile. Leur faire confiance est difficile.
Il est vraiment, vraiment facile de demander à une IA : « Prends ce fichier de patch et rétro-porte-le sur cette version de la base de code ». N'importe qui peut taper cette commande dans son assistant de codage IA préféré, aller se chercher un café, et revenir devant un message indiquant que le rétro-portage est terminé. Sans surprise, l'agent IA sera fier et sûr de son travail.
Chez Chainguard, nous utilisons l'IA. Cependant, la véritable valeur de notre travail réside dans la mise en place de garde-fous et de tests qui nous garantissent que ce que nous livrons est correct.
Nous devons répondre à plusieurs questions cruciales lors du rétro-portage d'un correctif :
Le rétro-portage de ce correctif est-il seulement faisable ?
Cela va-t-il provoquer une régression ?
Cela corrige-t-il réellement la vulnérabilité ?
Les tests de non-régression sont difficiles
Notre processus de tests de non-régression pour les rétro-portages de CVE est conceptuellement simple. Nous vérifions que le projet dispose d'une suite de tests complète avant d'effectuer un rétro-portage, et nous ne poursuivons pas à moins d'être certains que le projet dispose d'une couverture de tests suffisante. Nous exécutons les tests avant d'appliquer les correctifs rétro-portés afin d'établir un décompte de référence des réussites, des échecs et des tests ignorés. Nous appliquons ensuite nos correctifs rétro-portés et réexécutons les tests. Si de nouveaux tests échouent, nous ne livrons pas les correctifs. Bien que le concept soit simple, la mise en pratique s'avère particulièrement ardue.
Avant de pouvoir lancer les tests, nous devons trouver un ensemble compatible de dépendances d'exécution pour la version cible du paquet sur lequel nous tentons de rétro-porter un correctif. Comme toute personne de la communauté Python le sait, ce n'est pas toujours la tâche la plus aisée.
Dès lors que vous prenez en compte les dépendances transitives, un simple paquet Python peut compter de quelques dizaines à plusieurs centaines de dépendances d'exécution. De nombreux paquets définissent des plages de versions très ouvertes pour leurs dépendances. Même le plus intelligent des résolveurs de dépendances ne peut déterminer un ensemble compatible si les métadonnées d'un paquet n'indiquent pas exactement quelles versions de chaque dépendance sont compatibles.
Naturellement, de nombreux paquets ne fixent pas de limites supérieures de version pour leurs prérequis. En tant que mainteneur de paquet, il est difficile, voire impossible, de prédire quand les mainteneurs de l'une de vos dépendances apporteront une modification qui rompra la compatibilité. En tant que mainteneur de paquet, vous pourriez compter sur le respect du versionnage sémantique (semver) par les autres mainteneurs, mais tout le monde ne le fait pas.
Malheureusement, cela signifie que si vous créez un environnement virtuel et installez une version d'un paquet datant d'il y a cinq ans, les chances sont minces pour que les dépendances d'exécution résolues automatiquement soient toutes compatibles avec le paquet installé et entre elles. Il faut se livrer à un véritable travail d'archéologie pour déterminer quel ensemble de dépendances d'exécution fonctionne de concert. C'est un peu comme faire un saut dans le passé, à l'époque où le paquet a été initialement publié.
Une fois que vous disposez enfin d'un ensemble compatible de dépendances d'exécution, vous devez comprendre comment compiler le projet et lancer la suite de tests.
Python est un écosystème logiciel diversifié, couvrant une grande variété d'applications. Sans surprise, il existe une multitude d'outils de test et de processus de compilation différents.
Nombre des paquets les plus essentiels de l'écosystème sont aussi les plus difficiles à compiler. Et souvent, les paquets les plus demandés pour la remédiation de CVE ont des dépendances C/C++/Rust complexes qui nécessitent des processus de compilation très élaborés.
Il faut des heures, tant pour les agents IA que pour les humains, pour parvenir à exécuter sans erreur une suite de tests pour une version donnée d'un paquet. Et vous devez répéter ce travail pour chaque version individuelle d'un paquet pour laquelle vous souhaitez livrer des correctifs, car rien ne reste immuable dans le temps.
Savoir quand une CVE est corrigée est difficile
Pour chaque CVE Python que nous corrigeons, nous confirmons d'abord l'existence d'une réelle vulnérabilité en l'exploitant dans un environnement contrôlé et reproductible. Ensuite, nous essayons d'exploiter la vulnérabilité d'origine dans le même environnement sur notre wheel corrigé, afin de vérifier l'efficacité de notre correctif. La seule variable modifiée entre les sessions de test est le wheel utilisé : la version d'origine non corrigée ou notre version remédiée.
Mais comment obtenons-nous les exploits ?
Il serait appréciable que chaque rapport de CVE inclue une preuve de concept simple et facilement reproductible de la vulnérabilité — un schéma démontrant son fonctionnement. Nous utilisons les étapes de reproduction d'origine lorsqu'elles existent. Malheureusement, c'est rarement le cas.
Bien plus souvent, nous devons comprendre le correctif et concevoir nous-mêmes les exploits. Lorsque nous avons lancé cette initiative de remédiation des CVE, nous doutions de notre capacité à générer de manière fiable des exploits fonctionnels. De façon surprenante et tout aussi inquiétante, les agents IA s'avèrent très doués pour concevoir des exploits ciblant des vulnérabilités connues.
Nous sommes parvenus à utiliser des agents IA pour générer des exploits, allant du contournement d'authentification HTTP aux attaques temporelles par canal auxiliaire dans des bibliothèques cryptographiques.
Nous n'entrerons pas trop dans les détails de notre méthode de génération d'exploits, mais il suffit de dire qu'à mesure que les agents IA gagnent en intelligence et deviennent plus abordables, chacun doit redoubler d'efforts pour préserver ses environnements de toute vulnérabilité de sécurité connue.
Utiliser l'IA de manière sûre est également difficile
Nous faisons appel à des agents IA pour ce travail, mais ces derniers peuvent facilement être induits en erreur. Comment protéger nos systèmes d'IA contre les attaques par injection de prompt ?
La véritable valeur de notre utilisation de l'IA ne réside pas dans les invites ou le contexte employés, mais dans les garde-fous que nous mettons en place autour des modèles. Nos efforts de remédiation des CVE reposent en grande partie sur une logique de validation implémentée sous forme de code conventionnel. Nous comptons sur les agents IA pour déterminer comment rétro-porter les correctifs, mais nous utilisons du bon vieux code Python et Go pour valider les résultats produits par ces agents.
Le processus de remédiation des CVE est découpé en plusieurs étapes, chacune générant un fichier de métadonnées YAML conforme à un schéma fixe. À l'issue de chaque étape, nous combinons validation par le code et examen humain pour vérifier la sortie de l'étape avant de transmettre ces données aux phases suivantes du processus de remédiation.
Nous avons mentionné plus tôt que nous ne faisons confiance qu'aux correctifs provenant du véritable dépôt amont d'un paquet. Mais comment faire appliquer cette règle ?
Chainguard dispose déjà d'un code conventionnel éprouvé pour résoudre le dépôt amont d'un projet Python. Ce code fait partie de notre « reconstructeur de wheels », qui recompile des centaines de milliers d'artefacts à partir de sources vérifiées pour Chainguard Libraries for Python. Nous réutilisons ce code pour déterminer à partir de quel dépôt extraire les correctifs nécessaires à la remédiation des CVE. Lorsque le reconstructeur ne parvient pas à trouver le dépôt source par lui-même, nous nous appuyons sur des fichiers de configuration vérifiés par des humains qui spécifient le véritable dépôt amont du projet.
Dès qu'un agent IA affirme avoir trouvé le véritable correctif amont d'une CVE, un code de validation automatisé s'assure que le dépôt où le correctif a été découvert correspond bien au véritable dépôt amont identifié par la logique de découverte du dépôt source du reconstructeur de wheels. La validation automatisée vérifie ensuite si les commits découverts par l'agent IA ont été fusionnés dans la branche principale de ce dépôt. Ce code de validation effectue quelques contrôles de cohérence supplémentaires sur la sortie de l'agent IA. Si l'un de ces contrôles échoue, le résultat fourni par l'agent IA est immédiatement rejeté.
Le jugement humain a toute son importance
Les agents IA sont des outils formidables, mais le discernement humain prime. Parfois, lors du rétro-portage d'un correctif, des arbitrages s'imposent pour préserver le comportement du correctif amont tout en réduisant au minimum le risque de régression.
Chaque correctif est examiné par l'ingénieur supervisant le processus de rétro-portage ainsi que par un autre ingénieur possédant une connaissance approfondie de l'écosystème Python. Nous ne nous contentons pas d'examiner les fichiers de correctifs en eux-mêmes ; nous passons en revue tout ce qui a été produit lors du rétro-portage, y compris les métadonnées sur le correctif amont, les instructions d'exécution de la suite de tests amont, les résultats des tests de régression et d'exploitabilité, ainsi que les notes sur la manière dont le rétro-portage a été exécuté.
Les fichiers de correctifs sont difficiles à examiner
Mais comment examinons-nous ces fichiers de correctifs, au juste ?
Supposons que vous ayez terminé le rétro-portage d'un correctif. Vous disposez maintenant d'un commit provenant du dépôt d'un projet et d'un fichier de correctif s'appliquant à une version plus ancienne du paquet. Comment les comparer ?
Cela semble simple au premier abord : il suffit d'un diff montrant les modifications entre le correctif initial de la CVE et le correctif rétro-porté. Pourquoi ne pas simplement exécuter git format-patch -1 <commit_id> pour transformer le commit d'origine en correctif, puis utiliser un simple diff pour comparer le correctif d'origine avec le correctif rétro-porté ?
Avez-vous déjà pris deux fichiers de correctifs s'appliquant à différentes versions d'une même base de code pour lancer un diff entre eux ? Le résultat est illisible et certainement pas adapté à un examen par un être humain.
Les fichiers de correctifs fonctionnent bien parce qu'ils contiennent une foule d'informations (numéros de ligne, lignes de contexte, etc.) permettant aux outils de localiser les lignes précises où appliquer les modifications. Malheureusement, toutes ces données varient, parfois considérablement, d'une version à l'autre d'une même base de code. Par conséquent, exécuter un diff entre un correctif original et sa version rétro-portée produit un résultat illisible et inutile.
Comment comparons-nous les correctifs rétro-portés au correctif d'origine ? Nous avons développé notre propre outil de « diff de diffs ».
Au début de ce projet, nous avons été surpris de constater qu'il existait très peu d'outils open source de « diff de diffs ». Il existe d'innombrables outils pour manipuler les fichiers diff et les correctifs. Mais nous n'en avons trouvé aucun qui soit véritablement adapté pour comparer les modifications de code introduites par un correctif rétro-porté à celles du commit amont d'origine.
L'outil de « diff de diffs » est conçu pour comparer un correctif de sécurité rétro-porté avec le correctif de CVE amont d'origine, en acceptant en entrée des chemins de fichiers locaux ou des URL de commits GitHub. Pour parvenir à une comparaison précise, il commence par normaliser les différents formats de correctifs et supprime les métadonnées non essentielles, telles que les en-têtes et le formatage des e-mails.
Surtout, il remplace les éléments variables comme les en-têtes de section (@@ -53,7 +54,12 @@ class FormData:) et les lignes d'index Git (index 0303f547ec..2f702d6480 100644) par des espaces réservés, ce qui garantit que l'outil ne compare que les modifications de code réelles. Pour les correctifs complexes impliquant plusieurs commits amont, il les fusionne automatiquement. Le résultat obtenu met en évidence la différence entre les modifications de code du correctif original et celles du correctif rétro-porté. Il devient alors aisé de repérer la moindre erreur dans le processus de rétro-portage ou d'examiner les adaptations requises pour assurer la compatibilité avec des versions plus anciennes de Python.
Comment nos bibliothèques remédiées sont-elles utilisées ?
Les produits de sécurité ne vous protègent pas si vous ne les utilisez pas. Dans cette optique, l'ergonomie est primordiale. Lorsque nous avons intégré la remédiation de CVE à notre offre Chainguard Libraries for Python, nous devions trouver un moyen de rendre l'utilisation de ces bibliothèques corrigées totalement fluide pour nos clients.
Compte tenu de notre engagement absolu consistant à empêcher l'introduction de logiciels malveillants dans nos bibliothèques Python, nous devions recompiler chaque bibliothèque corrigée à partir des sources au lieu de proposer un simple fichier de correctif.
Cela nous permet de proposer des solutions de remplacement directes pour PyPI qui fournissent automatiquement les versions corrigées des bibliothèques. De cette façon, il vous suffit de faire pointer votre gestionnaire de dépôts ou votre système de compilation vers notre index, de recompiler votre application, et vous voilà protégé.
Nous rendons cela possible grâce aux numéros de version locale. Les versions des paquets Python respectent la PEP-440, qui permet de séparer les numéros de version locale du numéro de version principal à l'aide d'un caractère +. Lors de la résolution des dépendances, les gestionnaires de paquets considèrent qu'une spécification de version telle que 1.2.3+local.1 respecte les mêmes contraintes de version que la version 1.2.3. Toutefois, le numéro de version locale prévaut sur le numéro de version de base. Par conséquent, si vous exécutez pip install “package==1.2.3” et que la version 1.2.3+local.1 est disponible dans votre index, les outils de compilation Python installent automatiquement la version corrigée 1.2.3+local.1.
Chainguard utilise des numéros de version locale au format +cgr.N, où N s'incrémente au fur et à mesure que nous corrigeons des CVE supplémentaires pour une version de paquet donnée. Lorsque vous installez une version d'un paquet depuis notre index remédié, elle reçoit automatiquement la version locale +cgr.N la plus récente disponible, vous garantissant une protection contre le plus grand nombre de CVE possible.
Cela ne serait pas possible sans notre approche automatisée de la compilation sécurisée des wheels Python. En plus des bibliothèques Python avec remédiation de CVE, nous fournissons des dizaines de milliers de bibliothèques Python compilées à partir des sources dans un environnement sécurisé et conforme à la norme SLSA L2. Nous fournissons des attestations signées conformes à la PEP-740 ainsi que des SBOM pour les wheels compilés, conformément à la PEP-770, afin de vous aider à comprendre et auditer votre chaîne d'approvisionnement logicielle.
Notre automatisation garantit la fiabilité des wheels que vous téléchargez et exécutez, qu'ils proviennent de notre index de paquets principal ou de notre index Python remédié.
Mais qu'en est-il des scanners ?
Nos bibliothèques remédiées doivent fonctionner de manière transparente avec les scanners. Lorsqu'un client installe des bibliothèques remédiées +cgr.N depuis notre index et analyse son application pour y détecter d'éventuelles vulnérabilités, son scanner doit comprendre que même si le paquet package==1.2.3 est vulnérable à une CVE, ce n'est pas le cas de package==1.2.3+cgr.1.
Nous rendons cela possible en publiant un flux VEX qui précise exactement quelles CVE sont corrigées dans chaque version de bibliothèque +cgr.N. Le flux VEX est alimenté automatiquement avec les données de notre infrastructure de remédiation des CVE, et de nouvelles entrées sont ajoutées dès que des paquets fraîchement remédiés sont publiés sur notre index.
Nous prenons actuellement en charge l'intégration avec Trivy, Grype, Anchore Enterprise et AWS Inspector. Ainsi, si vous utilisez l'un de ces scanners avec nos bibliothèques corrigées, les vulnérabilités disparaîtront instantanément de vos rapports de vulnérabilité. Nous prévoyons d'ajouter d'autres intégrations de scanners cette année.
Conclusion
La pratique actuelle consistant à chercher un correctif au hasard sur Internet, à l'appliquer à sa bibliothèque et à croiser les doigts ne fonctionne plus face à la multiplication et à l'ampleur croissante des attaques visant l'écosystème Python. Cela signifie-t-il que nous ne pouvons pas corriger certaines CVE ? Absolument. Il se peut que quelqu'un ait conçu un correctif pour une CVE que les responsables amont n'ont pas encore traitée. Un correctif peut être en cours d'examen dans le projet amont sans avoir encore été déployé. Ou les responsables initiaux peuvent simplement avoir choisi de ne pas corriger une CVE.
Notre approche évolue constamment ; néanmoins, notre philosophie générale consiste à livrer moins de correctifs de haute qualité et hautement fiables, plutôt qu'un plus grand nombre de correctifs en lesquels nous avons moins confiance.
Ce qui est difficile, et virtuellement impossible à réussir convenablement, c'est de bâtir un index fiable et de haute qualité de bibliothèques Python corrigées pour votre environnement de production. Il s'agit d'un combat complexe, aux enjeux considérables, que vous n'avez pas à mener seul.
Si vous souhaitez en savoir plus sur Chainguard Libraries for Python, consultez notre page d'accueil ou contactez notre équipe commerciale.
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