Principaux enseignements
- Lorsqu'un correctif n'est disponible que dans une version plus récente, la mise à jour nécessaire pour l'obtenir entraîne l'installation de toutes les autres modifications.
- Le « backporting » consiste à transposer uniquement le correctif vers la version que vous utilisez, ce qui vous évite souvent d'avoir à effectuer la migration.
- Le « pinning » permet de garantir la prévisibilité des modifications et reste valable tant que la version « pinée » continue de bénéficier de correctifs.
- La prise en charge ne devrait pas prendre fin lorsqu'un paquet arrive en fin de vie, car les vulnérabilités (CVE) signalées à son sujet ne disparaissent pas pour autant.
Tous les développeurs connaissent ce ticket. Le scanner passe au rouge un mardi, l'avis indique que le correctif a été intégré à la version 5.0.0, et vous utilisez la version 3.8. La solution proposée tient en une seule ligne. Le travail à effectuer, lui, nécessite un sprint.
Les équipes perdent des semaines à cause de cela, et ce qui est frustrant, c’est que la vulnérabilité n’est souvent pas le plus difficile. De nombreux correctifs CVE ne représentent que quelques lignes de code. Ce qui rend leur mise en œuvre coûteuse, c’est tout ce qui va de pair avec ces quelques lignes, alors que la seule façon officielle de les obtenir est de procéder à une mise à jour.
Alors, est-il possible de corriger une faille de sécurité sans passer à une nouvelle version majeure ? Souvent, oui. Mais il est utile de comprendre pourquoi « il suffit de mettre à jour » est devenu la réponse par défaut, et dans quels cas cela ne fonctionne plus.
Pourquoi la mise à niveau est-elle devenue la réponse par défaut ?
Pendant la majeure partie de l’histoire de l’open source, la correction des failles a toujours suivi le même cycle. Quelqu’un signale une vulnérabilité, un responsable de maintenance la corrige sur la branche principale, une nouvelle version est publiée, et tous les utilisateurs en aval mettent à jour leur version. De nombreux outils de scan des dépendances s’articulent autour de ce cycle. Ils comparent la version dont vous disposez aux versions dont on sait qu’elles contiennent le correctif et vous invitent à effectuer la mise à jour.
Cela fonctionne bien lorsque l'écart est faible. Passer de la version 2.4.1 à la 2.4.2 ne pose généralement aucun problème. Le hic, c'est que les responsables de maintenance corrigent les problèmes sur les branches sur lesquelles ils travaillent activement, c'est-à-dire généralement la branche principale la plus récente et peut-être une ou deux branches LTS. Très peu de projets disposent du temps ou des ressources humaines nécessaires pour revenir en arrière et corriger une version datant de deux ans, et personne ne peut raisonnablement attendre des bénévoles qu’ils le fassent. Ainsi, plus vous êtes en retard par rapport à la version actuelle, plus une « simple mise à jour » se transforme en une véritable migration.
Lorsque le correctif est fourni avec tout le reste
J'appelle cela un correctif lié à une version. Il s'agit d'un correctif de sécurité que le développeur en amont ne fournit que dans le cadre d'une nouvelle version ; par conséquent, la seule façon officielle d'obtenir ce correctif est d'accepter toutes les autres modifications apportées par cette version.
C’est dans ces autres changements que réside le véritable coût. Une nouvelle version majeure peut cesser de prendre en charge l’environnement d’exécution que vous utilisez, renommer une API que votre code appelle à quarante endroits, modifier un paramètre par défaut sur lequel vous comptiez, ou apporter son propre ensemble de dépendances transitives. La version sémantique est censée vous avertir de tout cela, et elle le fait lorsque les responsables de maintenance s’y tiennent. Mais les changements de comportement apparaissent suffisamment souvent dans les versions mineures pour que personne ne doive considérer un numéro de version comme une promesse. Et même une version majeure parfaitement documentée doit tout de même être lue, testée et déployée par quelqu’un, généralement une personne qui avait d’autres projets cette semaine-là.
npm est très clair à ce sujet. Lorsque npm audit fix Si le système ne parvient pas à résoudre un élément dans les plages de versions que vous avez déclarées, il vous redirigera généralement vers npm audit fix --force, ce qui la documentation de npm On peut dire que cela autorise des installations en dehors de la plage que vous avez définie, y compris les changements majeurs selon la norme SemVer. Le système ne vous demandera pas non plus pour laquelle de ces mises à jour majeures vous êtes réellement prêt. C'est tout à fait raisonnable dans le cadre d'un projet de week-end. Sur un service de production, c'est le point de départ d'une chasse aux régressions.
Trois domaines où la mise à niveau échoue
Le premier cas est évident dès qu’on y est confronté. Parfois, il n’existe tout simplement pas de version de remplacement. Le package a été déprécié ou la branche de version est arrivée en fin de vie, et personne ne reviendra vers elle. Le request Le module `package` est l'exemple classique de Node. Bien qu'il ait été déprécié début 2020, on le retrouve encore dans de nombreuses arborescences de dépendances, et lorsque 28155, une faille permettant à des redirections inter-protocoles de contourner les protections SSRF, a été révélée en 2023, mais le paquet d'origine n'a jamais fait l'objet d'une version corrigée. Ce n'est toujours pas le cas aujourd'hui. Une version dérivée maintenue, @cypress/request, a bien publié un correctif, mais celui-ci a été intégré à la version 3.0.0 sous un nom de paquet différent, et changer de paquet implique une migration à part entière.
Le deuxième problème est le saut de version majeur. Le correctif existe, mais il se trouve dans la version 6.x alors que vous êtes en 4.x, et passer de l’une à l’autre implique de modifier du code d’application qui n’a rien à voir avec la vulnérabilité. Votre équipe de sécurité souhaite que le CVE soit résolu cette semaine. Votre responsable technique sait que la migration pourrait prendre tout un trimestre. Ils ont tous les deux raison, et c’est précisément pour cette raison que ces tickets restent ouverts si longtemps, et qu’un ticket qui a commencé par un correctif de sécurité finit parfois par donner lieu à son propre cahier des charges.
Le troisième prend les gens au dépourvu : il s’agit de la dépendance transitive. Le paquet vulnérable ne se trouve pas dans votre package.json du tout. Elle se trouve quatre niveaux plus bas, intégrée par un composant parent dont la plage de versions n’autorise pas la version corrigée. La solution la plus propre consiste à mettre à jour le composant parent, si une version plus récente de celui-ci autorise la version corrigée, puisque vous restez ainsi dans la plage choisie par les responsables du composant parent. Si cette version est elle-même à une version majeure de distance, vous vous retrouvez toutefois face au deuxième problème. L’autre solution consiste à forcer la version avec Remplacements npm. Yarn les appelle resolutions, et les versions actuelles de pnpm définies overrides dans pnpm-workspace.yaml. Les remplacements fonctionnent, mais ils vous obligent à utiliser une combinaison que les responsables du projet parent n’ont jamais testée, ce qui fait que c’est à vous qu’incombe cette tâche. Et si la version corrigée est d’une version majeure supérieure à celle prévue par le projet parent, le remplacement fournit à ce dernier une API pour laquelle il n’a jamais été conçu.
Le « pinning » n'a jamais été le problème
Il existe un conseil qui circule beaucoup, selon lequel le fait de « fixer » les dépendances revient à « geler » les vulnérabilités. Techniquement, c'est vrai. Si vous fixez une version et que vous ne la modifiez plus jamais, toutes les vulnérabilités CVE signalées pour cette version vous resteront sur les bras.
Je pense toutefois que cette approche met la faute sur la mauvaise cible. Le « pinning », associé à un fichier de verrouillage (lockfile) figé et à des installations qui le respectent, garantit que l’environnement de production utilise bien l’arborescence des dépendances que vous avez réellement testée. Cela empêche également une version récemment piratée de se glisser dans votre build lors de la prochaine installation, ce qui est crucial au vu des nombreux cas de comptes de mainteneurs compromis ces dernières années. En septembre 2025, un compte de mainteneur piraté par hameçonnage a été utilisé pour publier des versions malveillantes de chalk et debug vers npm. Les équipes qui effectuent l'installation à l'aide de npm ci à partir d'un fichier de verrouillage vierge validé avant l'attaque, elles ont continué à compiler les versions qu'elles avaient déjà validées. Les équipes qui laissent tout passer à la version la plus récente troquent un type de risque contre un autre.
Le véritable problème, c'est ce qu'il advient de la version que vous avez épinglée. Une version épinglée n'intègre jamais automatiquement les correctifs ; vous dépendez donc de quelqu'un qui publie une version corrigée pour cette branche. Dès que l'amont cesse de le faire, il ne vous reste généralement plus qu'à choisir entre vivre avec la vulnérabilité CVE, éventuellement en y appliquant une mesure d'atténuation, et procéder à la migration. Corrigez cela, et l'épinglage redeviendra ce qu'il était censé être : un moyen de contrôler le changement plutôt qu'un moyen d'accumuler des risques.
En quoi consiste réellement le « backporting » ?
Le « backport » consiste à adapter un correctif de sécurité provenant d’une version plus récente d’un paquet à une version plus ancienne, afin que la version que vous utilisez déjà bénéficie de ce correctif sans les autres modifications apportées en amont. Les distributions Linux pratiquent cette méthode depuis des décennies. Lorsque Red Hat propose un correctif pour une ancienne version d’OpenSSL, il s’agit d’un « backport », et personne ne s’attend à ce que les clients RHEL passent à la dernière version en amont à chaque fois qu’un CVE est publié.
Faire la même chose pour les dépendances de l’application semble assez simple. Trouver le commit en amont, l’appliquer à l’ancienne balise, publier. En pratique, le commit ne s’applique souvent pas sans problème. Le code environnant a été déplacé, les signatures de fonctions ont changé, et parfois le correctif s’appuie sur une refactorisation qui a eu lieu trois versions après celle que vous corrigez. Le correctif peut appeler une fonction d’aide qui n’existe pas encore dans l’ancienne version, ou valider des données d’entrée à un niveau que l’ancien code n’a jamais connu. Ainsi, la personne chargée du backport doit comprendre en quoi consiste réellement la vulnérabilité, et pas seulement l’aspect du diff, puis écrire un correctif qui comble la même faille dans l’ancien code.
Il faut ensuite le vérifier. Un bon backport est recompilé à partir du code source, testé à l’aide de la suite de tests du projet (le cas échéant) et vérifié par rapport à la vulnérabilité elle-même afin de s’assurer que la faille est bien comblée. L’objectif est que rien ne change, à l’exception de ce que le correctif est censé modifier. Il arrive parfois qu’un correctif de sécurité rende plus stricte une fonctionnalité sur laquelle votre code s’appuyait, par exemple en rejetant des entrées que l’ancienne version acceptait sans rien signaler ; lorsque cela se produit, il convient de le signaler clairement, et non de l’introduire subrepticement. Tout le reste doit se comporter exactement comme hier.
Je ne vais pas prétendre que cela fonctionne pour toutes les vulnérabilités CVE. Certains correctifs sont liés à des changements architecturaux qui n’existent tout simplement pas dans l’ancien code, et c’est vrai pour tous ceux qui font ce travail. Cependant, beaucoup de vulnérabilités sont bien plus localisées que cela. Une vérification de limites manquante, une expression régulière qui effectue une remontée de pile incorrecte, des données d’entrée qui n’ont jamais été validées. Ces problèmes peuvent souvent être corrigés dans l’ancien code sans avoir à modifier la nouvelle architecture, et c’est grâce à eux que la correction des vulnérabilités sans mise à niveau fonctionne aussi souvent.
Comment SecureChain corrige les vulnérabilités sans mise à jour
C'est le problème que nous avons créé SecureChain partout. SecureChain met à disposition des versions corrigées à partir d'un registre npm géré par TuxCare. Une version corrigée part de la même version en amont, intègre le correctif et obtient un -tuxcare.N suffixe à la fin, donc 3.8.0 devient 3.8.0-tuxcare.1. Un projet sous la version 3.8 reste sous la version 3.8, mais intègre désormais le correctif.
Ce suffixe en fait effectivement une chaîne de version différente, et une plage telle que ^3.8.0 Il ne le détectera pas automatiquement. C'est donc l'interface CLI de SecureChain qui se charge de l'association. securechain sca analyse votre arborescence de dépendances résolues et recense les vulnérabilités, y compris les paquets pouvant être corrigés par une version patchée. securechain harden puis il fixe ces versions, en écrasant les règles de substitution (ou les résolutions Yarn) pour les paquets transitifs, actualise le fichier de verrouillage, puis réinstalle les paquets. Avant de terminer, il vérifie que l'arborescence installée contient bien les nouvelles versions ; s'il ne parvient pas à le confirmer, il rétablit vos fichiers dans leur état initial. Ajouter --dry-run si vous souhaitez voir la modification avant que quoi que ce soit ne soit écrit.
Votre fichier de verrouillage change, tout comme le paquet corrigé, mais le code de votre application n'a généralement pas besoin d'être modifié, et vous n'êtes pas passé à une nouvelle version majeure. Vous devriez tout de même exécuter vos tests avant la mise en production, comme pour toute mise à jour de dépendance. En CI, securechain check la tâche échoue s'il existe une version corrigée et que le projet ne l'utilise pas, afin que personne ne retombe accidentellement sur la version vulnérable. L'interface en ligne de commande fonctionne avec npm, pnpm et Yarn.
Que se passe-t-il lorsque l'amont cesse de fournir des correctifs ?
Le « backporting » permet de corriger les problèmes liés à une version spécifique. À lui seul, cependant, il ne résout pas le problème posé par l'abandon du paquet par le développeur en amont. De nombreux paquets tombent dans l'oubli bien avant que leur fin de vie ne soit officiellement annoncée.
SecureChain gère cela par étapes, qui sont décrites dans la documentation SecureChain. Tant que le projet en amont continue de publier des correctifs, le délai de réponse est calculé à partir de la publication de ces correctifs. Si le projet en amont cesse de les publier et que le paquet entre dans une phase appelée « Sustained », TuxCare prend directement en charge sa maintenance, et les délais de réponse sont calculés à partir du jour de la publication du CVE, et non à partir d’un correctif en amont qui pourrait ne jamais voir le jour. Pour un CVE critique, TuxCare vise à fournir une version corrigée dans les 7 jours suivant le correctif en amont lors de la première étape, et dans les 14 jours suivant la publication une fois qu’il a pris le relais. Par la suite, le paquet passe en mode « Endless Lifecycle Support » (ELS) et, si vous avez souscrit à l’ELS en plus de SecureChain, les correctifs continuent d’être fournis aussi longtemps que vous avez besoin du paquet.
N'oublie pas request? Upstream n'a jamais publié de correctif pour la vulnérabilité CVE-2023-28155, mais les données VEX publiées par TuxCare indiquent qu'elle est considérée comme résolue dans request 2.88.2-tuxcare.2 et toutes les versions suivantes. La ligne de version reste la même, vous n'avez donc rien à renommer dans votre package.json, et aucune branche vers laquelle migrer.
Ce que j’apprécie dans cette configuration, c’est qu’une fois ces deux éléments en place, il n’y a pas de rupture brutale. Personne dans votre équipe n’a à remarquer qu’un responsable de maintenance s’est fait discret, et personne n’a à se mettre en quête d’un nouveau fournisseur à la hâte. Vous continuez à récupérer une nouvelle version corrigée de la même manière que vous le feriez pour n’importe quelle mise à jour, et le registre d’où elle provient reste le même, que le responsable de maintenance d’origine soit occupé à livrer des versions, qu’il se soit fait discret ou qu’il ait complètement quitté le projet.
Quand faut-il tout de même effectuer une mise à niveau ?
Rien de tout cela ne constitue un argument contre la mise à niveau. Les nouvelles versions majeures apportent des améliorations en termes de performances, de meilleures API et des corrections pour de nombreux bugs pour lesquels personne n'a jamais signalé de CVE. Prévoyez ces mises à niveau et effectuez-les.
Le débat porte sur la question de savoir qui définit le calendrier. Lorsque la seule façon de corriger une vulnérabilité CVE consiste à effectuer une mise à niveau, c’est cette vulnérabilité qui dicte votre feuille de route. En revanche, lorsque vous pouvez appliquer un correctif à la version que vous utilisez, vous effectuez la mise à niveau parce que la nouvelle version en vaut la peine, vous la testez correctement et vous le faites selon un calendrier défini par votre équipe. C’est une bien meilleure raison de modifier une dépendance qu’un badge rouge affiché par un scanner.
Foire aux questions
Est-il possible de corriger une faille de sécurité sans mettre à jour le paquet ?
Souvent, oui. Lorsque le code vulnérable est relativement autonome, le correctif peut être rétroporté vers la version que vous utilisez déjà, ce qui permet de corriger la vulnérabilité sans les changements incompatibles, les nouvelles dépendances ou le travail de migration qui accompagnent généralement une nouvelle version majeure.
Comment appliquer un correctif rétroporté dans npm, pnpm ou Yarn ?
Installez la version corrigée de celle que vous utilisez déjà. Pour les paquets transitifs, fixez-la à l'aide de règles de remplacement dans npm ou pnpm, ou de résolutions dans Yarn. Les versions corrigées portent généralement un suffixe tel que -tuxcare.1, ce à quoi vos plages de versions existantes ne correspondent pas d'elles-mêmes ; c'est donc la redéfinition qui permet d'intégrer la version dans l'arborescence, tandis que la version parente reste sur la ligne de version prévue.
Est-il sans risque de forcer l'exécution de la commande « npm audit fix » ?
Course à pied npm audit fix --force Cette commande permet de supprimer les avertissements, mais pour ce faire, elle autorise npm à installer des versions en dehors des plages que vous avez définies, y compris les versions majeures selon la norme SemVer, dont certaines peuvent comporter des modifications incompatibles. Considérez cela comme une mise à jour imprévue. Vérifiez les modifications apportées au fichier lockfile et exécutez l'intégralité de votre suite de tests avant que ces changements ne soient déployés en production.
Qu'est-ce qu'un correctif de sécurité rétroactif ?
Un correctif de sécurité rétroporté est un correctif adapté à partir d'une version plus récente d'un paquet et appliqué à une version plus ancienne. Son champ d'application se limite à la vulnérabilité et exclut les modifications sans rapport avec celle-ci ; ainsi, le code écrit pour la version plus ancienne devrait continuer à fonctionner, même s'il est recommandé de le tester comme pour toute autre mise à jour de dépendance.
Que signifie le fait qu'un correctif de sécurité soit lié à une version plus récente ?
Cela signifie que le correctif est lié à une version spécifique. Un correctif lié à une version spécifique est un correctif de sécurité que le développeur en amont ne fournit que dans le cadre d'une nouvelle version ; ainsi, pour l'appliquer via une mise à jour, il faut également accepter toutes les autres modifications de cette version, ce qui explique pourquoi la résolution d'un CVE se transforme en une migration complète.
Est-il sûr de fixer les versions des dépendances ?
Le « pinning », associé à un fichier de verrouillage dédié et à des installations qui le respectent, telles que npm ci, est une bonne pratique car elle vous permet de reproduire l'arborescence des dépendances que vous avez testée et d'exclure de vos builds les versions non validées. Le risque réside dans le fait de laisser la version « épinglée » sans correctifs ; le « pinning » fonctionne donc mieux lorsque cette version continue de bénéficier de correctifs de sécurité.
Comment corriger une vulnérabilité dans une dépendance transitive ?
Les options habituelles consistent soit à mettre à jour le paquet parent, si une version plus récente prend en charge la version corrigée, soit à forcer l'utilisation de la version corrigée à l'aide de remplacements, ce qui peut entraîner des dysfonctionnements du paquet parent. Une version rétroportée vous offre une troisième option, car le remplacement peut pointer vers une version corrigée basée sur la même version en amont que celle déjà utilisée par le paquet parent.
Qu'advient-il de la sécurité d'un paquet une fois qu'il a atteint sa fin de vie ?
Upstream cesse de publier des correctifs, mais de nouvelles vulnérabilités (CVE) continuent d'être signalées. À moins que quelqu'un ne continue à y apporter des correctifs, il ne vous reste plus que des mesures d'atténuation, une branche dérivée ou une migration, et les vulnérabilités restent exposées entre-temps.
