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.

En bref. Ce billet suit les composants qu'une équipe intègre, puis la chaîne de fabrication qui produit le livrable : signature, attestation de provenance, build reproductible. Il relit l'attaque de SolarWinds en 2020 : d'après l'enquête de l'éditeur, le code malveillant est entré par l'environnement de build, sans modification du dépôt de code source.

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
Figure 1 : trois dépendances déclarées, huit composants embarqués. Dans la réalité, le rapport est souvent bien plus grand.

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.

À retenir. Chaque dépendance est un fournisseur. On ne fait pas entrer en cuisine quelqu'un dont on ignore le nom.

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.

Attaquant Dépôt public Outil de buildmal réglé paquet homonyme 1 2 paquet piégé 3 1 2 3 1. Un attaquant publie sur un dépôt public un paquet au nom d'une bibliothèqueinterne, en version plus élevée 2. L'outil de build, mal réglé, préfère la version la plus récente 3. Il télécharge le paquet piégé
  1. Un attaquant publie sur un dépôt public un paquet au nom d'une bibliothèque interne, en version plus élevée
  2. L'outil de build, mal réglé, préfère la version la plus récente
  3. Il télécharge le paquet piégé
Figure 2 : la confusion de dépendances
En pratique. La parade est de réserver ses noms internes et de dire à l'outil où chercher chaque famille de paquets.

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.

  • Ce qui entre dans le build et ce qui en sort
Figure 3 : la chaîne de fabrication. Chaque flèche est un point où l'on peut glisser autre chose que ce qui était prévu.
É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.

À retenir. Le serveur de build voit tout passer. C'est aussi pour cela qu'il est la meilleure place pour un intrus.

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.

Code source Premierenvironnement Comparaisondes empreintes Secondenvironnement code source 1 même code source 2 empreinte 3 empreinte 4 5 1 2 3 4 5 1. Un premier environnement compile le code source et produit un livrable 2. Un second environnement, différent du premier, compile le même code source 3. On relève l'empreinte du premier livrable 4. On relève celle du livrable recompilé ailleurs 5. Si les deux empreintes diffèrent, quelque chose s'est glissé en route
  1. Un premier environnement compile le code source et produit un livrable
  2. Un second environnement, différent du premier, compile le même code source
  3. On relève l'empreinte du premier livrable
  4. On relève celle du livrable recompilé ailleurs
  5. Si les deux empreintes diffèrent, quelque chose s'est glissé en route
Figure 4 : vérifier un livrable en le recompilant ailleurs

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.

Figure 5 : ce que chaque mécanisme 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.

Piège. Si le build a été corrompu avant la signature, la signature certifie la corruption.

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.

Dépôt de codenon modifié Serveur de build Attaquant Canal officielde mise à jour Clients d'Orion Sunspot 1 code source 2 3 4 livrable avec Sunburst 5 mise à jourd'Orion 6 1 2 3 4 5 6 1. À partir du 20 février 2020, Sunspot est installé sur le serveur de build et surveille lesprocessus 2. Le dépôt de code source n'est pas modifié : il reste propre 3. Dès qu'il détecte la compilation d'Orion, Sunspot remplace un fichier source parune version avec Sunburst 4. La compilation finie, il remet l'original : le dépôt reste propre, le livrable ne l'est pas 5. Le livrable sort de la chaîne officielle 6. Les versions publiées entre mars et juin 2020 partent vers les clients par le canalofficiel de mise à jour
  1. À partir du 20 février 2020, Sunspot est installé sur le serveur de build et surveille les processus
  2. Le dépôt de code source n'est pas modifié : il reste propre
  3. Dès qu'il détecte la compilation d'Orion, Sunspot remplace un fichier source par une version avec Sunburst
  4. La compilation finie, il remet l'original : le dépôt reste propre, le livrable ne l'est pas
  5. Le livrable sort de la chaîne officielle
  6. Les versions publiées entre mars et juin 2020 partent vers les clients par le canal officiel de mise à jour
Figure 6 : SolarWinds, du serveur de build aux clients

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.

  • Étape non modifiée
  • Étape où l'implant agit
  • Trajet du livrable contenant Sunburst
Figure 7 : l'attaque replacée sur la chaîne de fabrication

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.

À retenir. Si la cuisine est contaminée, le meilleur produit en sort contaminé, avec le cachet de la maison sur la boîte.

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.


Pour aller plus loin