Le sel du fournisseur et la planche mal lavée
Une cuisine n'écrase pas ses propres tomates pour faire son concentré. Elle achète sa farine, son beurre, ses épices, ses fonds parfois. Personne ne lui reproche : refaire tout soi-même serait plus cher et moins sûr. Mais chaque produit acheté entre en cuisine avec ses propres risques, et le chef répond de l'assiette, quel que soit le fournisseur du sel.
Il y a un second sujet, plus discret. Les produits de qualité ne suffisent pas si la cuisine elle-même est contaminée. Une planche mal lavée, un thermomètre faux, un four qui ne chauffe pas à la température affichée : le meilleur produit en sortira abîmé, et personne ne le verra dans l'assiette.
Ce billet ferme le domaine Implémentation avec ces deux sujets. Les composants qu'on intègre, d'abord : comment les choisir, les fixer et les suivre. La chaîne de fabrication, ensuite : comment s'assurer que ce qui sort du build est bien ce qui y est entré. Le cas réel est celui d'une cuisine contaminée de l'intérieur, dont les plats sont partis chez dix-huit mille clients.
Le palier 3 reprendra le sujet côté fournisseurs, avec les billets P22 et P23. Celui-ci reste du côté de l'équipe qui construit.
Ce que contient vraiment ton logiciel
Une application Java moderne de taille moyenne déclare quelques dizaines de dépendances. Chacune en déclare d'autres. Au bout de la chaîne, le livrable contient souvent plusieurs centaines de bibliothèques, dont la grande majorité n'a été choisie par personne dans l'équipe. On les appelle les dépendances transitives.
La figure 1 montre le mécanisme sur un petit exemple.
- Dépendances déclarées
Ce que le cas Heartbleed du billet P14 a montré, c'est que beaucoup d'organisations ont d'abord dû découvrir qu'elles utilisaient OpenSSL. Savoir ce que contient son logiciel est la condition de tout le reste : on ne corrige pas une faille dans un composant qu'on ne sait pas avoir.
Cet inventaire porte un nom, la nomenclature logicielle, et un format standard. Le billet P23 lui est consacré. Retiens ici qu'elle se produit automatiquement, au moment du build, à partir de ce qui a réellement été résolu, pas à partir de ce qu'on croit avoir déclaré.
Choisir un composant
Le billet P10 donnait six critères pour choisir une brique de sécurité. Les mêmes s'appliquent à n'importe quelle dépendance, avec quelques questions en plus.
| Question | Pourquoi elle compte | Le signal d'alerte |
|---|---|---|
| Est-il entretenu ? | Une faille découverte demain doit être corrigée | Dernière version il y a trois ans, questions sans réponse |
| Par combien de personnes ? | Un projet tenu par une seule personne dépend de sa disponibilité | Un seul mainteneur, aucune relecture visible |
| Comment gère-t-il les failles ? | Une politique de divulgation dit qu'il y a quelqu'un pour écouter | Aucun canal de signalement |
| Quelle licence ? | Certaines licences imposent des obligations sur ton propre code | Licence absente, ou incompatible avec ton usage |
| Combien de dépendances tire-t-il ? | Chaque dépendance transitive est un fournisseur de plus | Une petite fonction qui en tire trente |
| En as-tu vraiment besoin ? | Le composant le plus sûr est celui qu'on n'ajoute pas | Trois lignes de code évitées au prix d'une dépendance |
La ligne sur la licence surprend parfois les équipes techniques. Elle relève pourtant du plan d'examen, et le programme du cours y consacre une leçon. Une licence copyleft intégrée dans un produit distribué peut obliger à publier le code source de ce produit. Une bibliothèque sans licence n'est, en droit, pas utilisable du tout. Le juridique doit pouvoir lire la liste des licences, et elle se génère avec l'inventaire.
La dernière ligne est un rappel du billet P10 sur la surface d'attaque. Ajouter une dépendance, c'est faire entrer un fournisseur dans sa cuisine. On le fait quand le gain le justifie, pas pour gagner dix minutes.
Fixer, vérifier, suivre
Une fois choisi, un composant doit être intégré de façon à ce qu'on sache toujours exactement quelle version tourne, et qu'on soit prévenu quand elle devient dangereuse.
Fixer les versions. Une dépendance déclarée « dernière version disponible » donne un build différent chaque jour. On fixe des versions précises, y compris pour les dépendances transitives, avec le mécanisme de verrouillage de l'outil de build.
Vérifier ce qu'on télécharge. Un numéro de version ne prouve pas qu'on a reçu le bon fichier. Une empreinte, enregistrée une fois puis vérifiée à chaque build, le prouve. Gradle sait générer et contrôler ces empreintes.
# Génère gradle/verification-metadata.xml avec l'empreinte de chaque dépendance
./gradlew --write-verification-metadata sha256 help
Le fichier produit se versionne. Tout build ultérieur échoue si une dépendance téléchargée ne correspond pas à son empreinte.
Passer par un dépôt interne. Les builds ne téléchargent pas directement depuis Internet. Ils passent par un dépôt d'artefacts interne, qui garde une copie de chaque version utilisée. On sait ce qui est entré, on peut bloquer une version, et le build ne dépend pas de la disponibilité d'un service externe.
Ce dépôt ferme aussi une attaque connue : la confusion de dépendances. Un attaquant publie sur un dépôt public un paquet qui porte le nom d'une bibliothèque interne de ta société, avec un numéro de version plus élevé. Un outil de build mal réglé préfère la version la plus récente, et télécharge le paquet piégé.
La figure 2 déroule cette attaque.
- Un attaquant publie sur un dépôt public un paquet au nom d'une bibliothèque interne, en version plus élevée
- L'outil de build, mal réglé, préfère la version la plus récente
- Il télécharge le paquet piégé
Suivre en continu. Un composant sans faille connue aujourd'hui en aura une demain. L'analyse des dépendances compare l'inventaire aux bases de vulnérabilités publiques à chaque build, et aussi entre deux builds, pour les applications qui ne changent pas souvent. Le tri suit les règles du billet P15 : une faille dans un composant qu'on embarque n'est pas forcément atteignable depuis ton code.
Mettre à jour souvent, en petites doses. Une dépendance qu'on met à jour chaque mois se met à jour sans drame. Une dépendance qu'on n'a pas touchée depuis quatre ans demande un projet, et le jour de la faille critique, il n'y a pas le temps pour un projet. Des outils proposent automatiquement les mises à jour sous forme de demandes de fusion ; la suite de tests dit si elles cassent quelque chose.
| Pratique | Ce qu'elle empêche | En cuisine |
|---|---|---|
| Versions fixées | Un build différent chaque jour sans que personne l'ait décidé | La fiche technique qui précise la référence exacte du produit |
| Empreintes vérifiées | Un fichier remplacé en route | Le bon de livraison comparé au colis |
| Dépôt interne | Un paquet piégé venu d'ailleurs, une dépendance qui disparaît | La réserve, alimentée par des fournisseurs agréés |
| Suivi continu | Une faille découverte après la livraison et ignorée | Le rappel de lot du fournisseur, lu le jour même |
| Mises à jour régulières | Une dette qui devient un projet | La rotation du stock |
La chaîne de fabrication est un système de production
Un serveur de build compile le code, exécute les tests, assemble le livrable et, souvent, le déploie. Il a donc accès au code source, aux secrets de déploiement et à la production. Le billet P13 le classait dans l'architecture d'exploitation. Il en est l'une des cibles les plus rentables : compromettre le build, c'est compromettre tout ce qui en sort, signé et livré par le canal officiel.
On peut décrire une chaîne de fabrication comme une suite d'étapes, chacune avec sa menace. La figure 3 la dessine.
dépôt de code"] e1@-->|"code source"| B["Build
compilation, tests"] D["Dépendances
dépôt d'artefacts"] e2@-->|"composants"| B B e3@-->|"livrable"| P["Paquet
livrable signé"] P --> R["Registre
stockage des livrables"] R --> X["Déploiement
vérification à l'admission"] e1@{ animate: true } e2@{ animate: true } e3@{ animate: true }
- Ce qui entre dans le build et ce qui en sort
| Étape | La menace | Le contrôle |
|---|---|---|
| Source | Un changement non relu, un compte de développeur volé | Branches protégées, relecture obligatoire par une autre personne, authentification forte |
| Dépendances | Un composant piégé, une confusion de noms | Empreintes vérifiées, dépôt interne, analyse continue |
| Build | Un serveur compromis qui modifie le code pendant la compilation | Environnements de build éphémères et isolés, définis comme du code |
| Paquet | Un livrable remplacé après le build | Signature du livrable, attestation de provenance |
| Registre | Une image modifiée dans le stockage | Accès en écriture réservé au build, référence par empreinte plutôt que par étiquette |
| Déploiement | Un livrable non conforme mis en production | Contrôle d'admission : seuls les livrables signés par la chaîne officielle passent |
Trois principes s'en dégagent.
Le build est éphémère. Un serveur de build permanent accumule l'état de tous les builds précédents, et un intrus peut s'y installer durablement. Un environnement créé pour un build et détruit après ne garde rien, et ne laisse rien à un intrus.
Le build a le minimum de droits. Le travail qui compile n'a pas besoin des secrets de production. Le travail qui déploie n'a pas besoin d'écrire dans le dépôt de code. On sépare les étapes, avec des identités distinctes, comme au billet P2.
Le build se définit comme du code. La configuration de la chaîne vit dans le dépôt, relue comme le reste. Un changement dans le pipeline est un changement dans ce qui part en production.
Signer, attester, reproduire
Une fois le livrable produit, deux questions se posent à celui qui va le déployer. Vient-il de notre chaîne ? Et contient-il ce que notre code source prétend ?
La signature répond à la première. Le build signe le livrable avec une clé qui n'appartient qu'à lui. Le déploiement vérifie la signature. Un livrable remplacé entre les deux est rejeté. Les principes du billet P3 s'appliquent : la clé de signature ne quitte pas un module protégé, et elle a un seul usage.
L'attestation de provenance va plus loin. Elle décrit comment le livrable a été produit : quel dépôt, quelle révision du code, quel environnement, quelles dépendances. Elle est signée par la plateforme de build elle-même, pas par le développeur. Le cadre SLSA, détaillé au billet P23, gradue les garanties qu'une telle attestation peut offrir.
La reproductibilité répond à la seconde. Un build est reproductible si le même code source, compilé deux fois dans deux environnements différents, donne un livrable identique à l'octet près. On peut alors vérifier un livrable en le recompilant ailleurs et en comparant les empreintes. Si elles diffèrent, quelque chose s'est glissé en route.
La figure 4 suit cette vérification.
- Un premier environnement compile le code source et produit un livrable
- Un second environnement, différent du premier, compile le même code source
- On relève l'empreinte du premier livrable
- On relève celle du livrable recompilé ailleurs
- Si les deux empreintes diffèrent, quelque chose s'est glissé en route
La reproductibilité demande d'éliminer tout ce qui varie d'un build à l'autre : dates de compilation, ordre des fichiers dans l'archive, chemins absolus. Avec Maven, une propriété fixe l'horodatage écrit dans les archives produites.
<properties>
<!-- Horodatage fixe : deux builds du même code donnent la même archive -->
<project.build.outputTimestamp>2026-11-16T00:00:00Z</project.build.outputTimestamp>
</properties>
La figure 5 rattache chaque mécanisme à ce qu'il dit du livrable.
Les trois mécanismes ne disent pas la même chose, et il faut savoir ce que chacun prouve.
| Mécanisme | Ce qu'il prouve | Ce qu'il ne prouve pas |
|---|---|---|
| Signature | Le livrable vient de la clé de notre build, et n'a pas été modifié depuis | Que le build lui-même n'était pas compromis |
| Attestation de provenance | Le livrable vient de telle révision, par tel environnement | Que l'environnement était sain pendant la compilation |
| Build reproductible | Un second environnement indépendant obtient le même résultat | Que le code source est exempt de faille |
La colonne de droite est la plus importante. Une signature prouve d'où vient un binaire. Elle ne dit rien de ce qu'il contient.
Seule la troisième ligne, en confrontant deux builds indépendants, peut révéler qu'un environnement a modifié ce qu'il compilait.
En cuisine, c'est la différence entre le cachet du restaurant sur la boîte, la fiche qui dit quel cuisinier a préparé le plat et à quelle heure, et un second cuisinier qui refait la recette dans une autre cuisine pour comparer le goût.
Scénario : SolarWinds, ou la cuisine contaminée
Le 14 décembre 2020, l'éditeur américain SolarWinds annonce avoir été victime d'une cyberattaque visant sa plateforme de supervision réseau, Orion. Un code malveillant, nommé Sunburst, a été inséré dans des versions d'Orion publiées entre mars et juin 2020. Installé et activé chez un client, il pouvait permettre à l'attaquant de prendre le contrôle du serveur qui l'hébergeait.
L'éditeur estime à dix-huit mille le nombre de clients qui ont téléchargé les versions concernées. Il précise que ce chiffre est un maximum. Il inclut des clients qui n'ont pas installé la mise à jour, et d'autres qui l'ont installée sur un serveur sans accès à Internet, où le code malveillant ne pouvait pas joindre ses commanditaires. Parmi ceux qui restent, une très petite partie seulement a vu une activité de l'attaquant.
Le point qui intéresse ce billet est la manière dont le code est entré. D'après l'enquête de l'éditeur, l'attaquant n'a pas modifié le dépôt de code source. L'activité malveillante a eu lieu dans l'environnement de build automatisé.
L'outil utilisé a été analysé par la société CrowdStrike, qui l'a nommé Sunspot. Installé sur le serveur de build à partir du 20 février 2020, il surveillait en permanence les processus en cours. Dès qu'il détectait la compilation d'Orion, il remplaçait un fichier source par une version contenant Sunburst, le temps de la compilation, puis remettait l'original. Le dépôt restait propre. Le livrable ne l'était pas. L'éditeur indique que les attaquants ont retiré eux-mêmes Sunburst de son environnement en juin 2020.
Le livrable produit sortait de la chaîne officielle. Il était distribué par le canal officiel de mise à jour, à des clients qui faisaient confiance à ce canal, et qui avaient raison de le faire selon toutes les règles qu'ils connaissaient.
La figure 6 reprend ce trajet, du serveur de build aux clients.
- À partir du 20 février 2020, Sunspot est installé sur le serveur de build et surveille les processus
- Le dépôt de code source n'est pas modifié : il reste propre
- Dès qu'il détecte la compilation d'Orion, Sunspot remplace un fichier source par une version avec Sunburst
- La compilation finie, il remet l'original : le dépôt reste propre, le livrable ne l'est pas
- Le livrable sort de la chaîne officielle
- Les versions publiées entre mars et juin 2020 partent vers les clients par le canal officiel de mise à jour
Relisons l'attaque avec la chaîne de fabrication.
| Étape | Ce que montre l'enquête | Le contrôle qui aurait pu l'arrêter ou la révéler |
|---|---|---|
| Source | Le dépôt n'a pas été modifié | Aucun : la relecture du code ne pouvait rien voir |
| Build | Un implant sur le serveur de build, actif pendant des mois | Un environnement éphémère, recréé à chaque build, n'aurait pas gardé l'implant |
| Build | Un fichier remplacé pendant la compilation | Un build reproductible, refait ailleurs, aurait donné une empreinte différente |
| Paquet | Un livrable produit par la chaîne officielle | La signature ne pouvait rien révéler : elle certifiait ce que le build avait produit |
| Déploiement chez le client | Une mise à jour installée par confiance dans l'éditeur | Un serveur de supervision sans accès sortant vers Internet limitait la portée |
La figure 7 replace ce tableau sur la chaîne.
dépôt non modifié"]:::sain --> B["Build
implant, fichier remplacé pendant la compilation"]:::risque B e1@-->|"livrable contenant Sunburst"| P["Paquet
produit par la chaîne officielle"] P e2@-->|"mise à jour"| X["Déploiement chez le client
installée par confiance dans l'éditeur"] e1@{ animate: true } e2@{ animate: true }
- Étape non modifiée
- Étape où l'implant agit
- Trajet du livrable contenant Sunburst
La première ligne est déroutante, et c'est elle qui fait la valeur du cas. Toutes les pratiques des billets P14 et P15 étaient impuissantes : il n'y avait rien à relire. Le code source était juste. La faute se trouvait entre le code et le livrable, dans un endroit que la plupart des organisations ne surveillent pas.
Les deuxième et troisième lignes donnent les deux parades. L'une empêche l'implant de survivre d'un build à l'autre. L'autre révèle la modification en confrontant deux compilations indépendantes. Ni l'une ni l'autre n'est simple à mettre en place. Ce sont pourtant les seules qui répondent à cette attaque-là.
La quatrième ligne est celle du tableau précédent, colonne de droite. Une signature prouve l'origine, pas l'innocuité. Quand l'origine est compromise, elle devient un argument de l'attaquant.
La dernière ligne regarde du côté des clients, et annonce le palier 3. Un outil de supervision a, par nature, une vue sur tout le réseau. C'est un fournisseur dont le compte, au sens du billet P9, peut atteindre beaucoup de choses. Les clients dont le serveur Orion ne pouvait pas sortir vers Internet ont été protégés par une règle d'architecture, pas par une signature.
Testez-vous
Pourquoi un numéro de version ne suffit-il pas à savoir ce qu'on a téléchargé ?
Un numéro de version ne prouve pas qu'on a reçu le bon fichier. Une empreinte, enregistrée une fois puis vérifiée à chaque build, le prouve.
Que prouve la signature d'un livrable, et que ne prouve-t-elle pas ?
Elle prouve que le livrable vient de la clé de notre build et n'a pas été modifié depuis. Elle ne prouve pas que le build lui-même n'était pas compromis.
Dans l'attaque de SolarWinds, pourquoi la relecture du code ne pouvait-elle rien voir ?
D'après l'enquête de l'éditeur, le dépôt de code source n'a pas été modifié. Sunspot remplaçait un fichier source sur le serveur de build, le temps de la compilation, puis remettait l'original.
Points clés
- Un logiciel contient bien plus de composants que ceux qu'on a déclarés. L'inventaire se génère au build, à partir de ce qui a réellement été résolu.
- Une dépendance se choisit comme un fournisseur : entretien, mainteneurs, gestion des failles, licence, dépendances tirées, besoin réel.
- On fixe les versions, on vérifie les empreintes, on passe par un dépôt interne, on suit en continu et on met à jour par petites doses.
- La chaîne de fabrication est un système de production : builds éphémères, droits minimaux par étape, configuration versionnée.
- La signature prouve l'origine, l'attestation décrit la fabrication, la reproductibilité révèle une modification. Aucune ne prouve l'innocuité.
- Quand le build est compromis, la relecture du code ne voit rien. Seuls l'isolement et la reproduction indépendante répondent.
Dans la série
Palier 2 : Tenir les fourneaux. Domaine : Implémentation.
- Précédent : Revue de code sécurité : analyse statique, CWE, CVSS, remédiation
- Suivant : Tests de sécurité : stratégie, cas de test, fonctions non documentées
- Vue d'ensemble : Sécurité du cycle de vie logiciel : par où commencer dans La Brigade
Pour aller plus loin
- CSSLP Certification Exam Outline, ISC2 : objectifs 5.5 et 5.6.
- SolarWinds, rapport annuel 2020 (formulaire 10-K), section sur l'incident.
- An Investigative Update of the Cyberattack, SolarWinds.
- SUNSPOT Malware Used to Insert Backdoor Into SolarWinds Product, SecurityWeek, sur l'analyse de CrowdStrike.
- SLSA, Supply-chain Levels for Software Artifacts.