Supply chain et signatures¶
Cette page explique le pourquoi des deux mécanismes de supply chain greffés sur la pipeline de release Kirexo : la signature keyless de l'image kirexo-prod (job docker:sign-prod) et le SBOM attaché à chaque release GitLab (job release:sbom), ainsi que la manière dont ils s'appliquent à une image publiée pour deux architectures. Pour la mécanique factuelle, voir la Référence Pipeline GitLab CI ; pour la vérification côté serveur, voir Vérifier la signature de l'image avant de la pull.
Le problème à résoudre¶
Un déploiement de prod typique enchaîne docker compose pull puis up -d. La seule chose que le démon Docker garantit, c'est l'intégrité du transport : l'image reçue est bien celle annoncée par le registry. Mais rien ne dit qui a poussé l'image, ni à partir de quel commit, ni avec quelle toolchain. Trois scénarios concrets que ce trou de confiance ouvre :
- Un compte d'écriture sur le registry est compromis. Une image
kirexo-prod:0.0.1retaggée à la main par un attaquant atterrit sur la prod sans qu'aucun contrôle ne déclenche d'alarme. - Une dépendance Composer dans
vendor/est rétrocompromise (typosquat, prise de contrôle du mainteneur upstream). L'audit de sécurité hebdo arrive trop tard pour les déploiements déjà partis avec cette version. - Six mois après une release, un auditeur conformité demande la liste exhaustive des composants embarqués dans l'image alors déployée. La pipeline a déjà recyclé les caches Docker, l'image elle-même peut avoir été expirée par la cleanup policy. Personne ne peut produire l'inventaire de manière fiable.
Les deux mécanismes répondent chacun à une question distincte : « cette image est-elle bien sortie de notre pipeline ? » (signature) et « qu'y a-t-il exactement dedans ? » (SBOM).
Pourquoi la signature keyless plutôt qu'une PKI dédiée¶
L'approche historique de la signature d'image consistait à générer une paire de clés, stocker la privée dans un coffre-fort (Vault, KMS), distribuer la publique aux consommateurs, et faire signer chaque image par la CI. Trois charges opérationnelles non triviales : rotation des clés, contrôle d'accès au coffre, distribution de la publique à jour à tous les serveurs.
Le mode keyless de cosign / sigstore remplace cette PKI par une chaîne de confiance courte-vie :
- La CI demande à GitLab un JWT OIDC pour le job courant, signé par GitLab. Ce JWT porte l'identité du pipeline (URL du projet, ref, sha du commit) et a une durée de vie de quelques minutes.
- La CI échange ce JWT contre un certificat X.509 éphémère auprès de Fulcio, la CA publique de sigstore. Fulcio valide le JWT auprès du provider OIDC GitLab, puis émet un cert lié à cette identité, valide ~10 minutes.
- La CI signe le digest de l'image avec la clé privée associée à ce cert, et publie l'attestation dans Rekor, un log de transparence public immuable (modèle Merkle, à la manière des Certificate Transparency Logs HTTPS).
Aucune clé privée à long terme n'est jamais matérialisée — la clé est générée à la volée dans le runner, le cert expire avant qu'on ait le temps de l'exfiltrer, et la révocation se fait par expiration plutôt que par CRL. Côté Kirexo, le seul coût opérationnel résiduel est de suivre les versions de cosign et syft, épinglées via le tag des FROM de supply-chain/Dockerfile (cf. section ci-dessous) — le manager dockerfile natif de Renovate suit ces tags automatiquement, sans customManager à maintenir.
Le compromis assumé est la dépendance à un service tiers public (Fulcio + Rekor, opérés par la Linux Foundation). En contrepartie, l'audit a posteriori devient gratuit : n'importe qui peut interroger Rekor pour vérifier qu'une signature a bien été publiée, sans demander quoi que ce soit à GitLab ni à Kirexo. C'est cette traçabilité publique qui rend la chaîne « pipeline GitLab → image en prod » réellement attaquable par un auditeur — pas seulement par nous.
Pourquoi vérifier la signature côté serveur, pas seulement en CI¶
La signature n'a de valeur que si quelqu'un la vérifie au moment du déploiement. Vérifier en CI uniquement reviendrait à dire « c'est nous qui avons buildé, on se croit sur parole » — exactement le trou de confiance qu'on cherche à fermer. C'est le cosign verify côté serveur, avec une regex d'identité épinglée sur ^https://gitlab\.com/shaurifr/kirexo, qui ferme la boucle. Si une image présente sur le registry ne porte pas de signature compatible avec cette regex, le verify échoue et le déploiement est refusé.
La regex est volontairement stricte (pas un préfixe lâche kirexo) pour qu'une image émise par un fork ou un autre namespace soit rejetée par défaut. Assouplir cette regex revient à élargir la surface de confiance — décision à ne jamais prendre à la légère sous prétexte de débloquer un déploiement urgent.
La discipline « pas de pull avant verify » est documentée dans le how-to Vérifier la signature de l'image avant de la pull. L'idéal est d'encapsuler cette vérification dans le même script shell qui pilote le déploiement, pour qu'un oubli soit physiquement impossible.
Pourquoi un SBOM (et pourquoi deux formats)¶
Le SBOM (Software Bill of Materials) est l'inventaire exhaustif des composants embarqués dans une image : paquets OS Alpine, extensions PHP, dépendances Composer présentes dans vendor/. C'est le pendant statique des CVE — une fois qu'on connaît la liste, un outil comme Dependency-Track peut alerter chaque fois qu'une CVE est publiée pour un de ces composants, sans avoir à rescanner l'image.
La pipeline Kirexo génère les SBOM de chaque tag de release via syft, un par architecture de l'image (cf. Un SBOM par architecture), et les attache à la release GitLab en deux formats :
- SPDX JSON (norme ISO 5962) est le format de référence des juristes et des auditeurs conformité (OpenChain, NTIA Minimum Elements). C'est ce que demande un audit logiciel formel, ou un service achats qui exige un inventaire signé pour la couverture juridique.
- CycloneDX JSON (OWASP) est le format de référence des outils de sécurité opérationnels (Dependency-Track, Trivy en mode SBOM, GitHub Advanced Security, Snyk). C'est ce qu'on alimente à un pipeline d'audit continu pour corréler la composition de l'image avec les CVE publiées.
Les deux formats portent en grande partie la même information ; les générer en parallèle évite à l'équipe consommatrice de devoir convertir, et garantit que la conformité juridique et l'audit sécurité parlent du même SBOM produit par la même pipeline.
Le SBOM est publié dans le Generic Package Registry du projet, comme le bundle d'installation, et non laissé en artifact de job. Un artifact expire et peut être supprimé ; GitLab déconseille d'en attacher à une release. Un SBOM référencé par une release doit rester téléchargeable aussi longtemps que la release existe : c'est précisément six mois ou deux ans plus tard qu'un auditeur le réclame. Le lien porte en outre un chemin sans version, qui donne un permalien vers le SBOM de la dernière release (cf. Assets de release et permaliens).
Pourquoi une image custom kirexo-supply-chain¶
Les deux outils — cosign et syft — sont distribués par leurs auteurs sous forme d'images officielles (gcr.io/projectsigstore/cosign, anchore/syft). Ces images sont distroless : pas de shell, pas d'utilitaires Unix, juste le binaire et ses dépendances dynamiques. Choix défendable côté upstream — surface d'attaque minimale pour un outil de supply chain — mais incompatible avec le GitLab Runner SaaS, qui enveloppe systématiquement le script d'un job dans sh -c "step_script". Sans sh dans l'image, le job échoue avant même d'exécuter sa première instruction (exec: "sh": executable file not found in $PATH).
La parade retenue est une image custom kirexo-supply-chain (supply-chain/Dockerfile), buildée par la CI au même titre que kirexo-docs (cf. Pipeline GitLab CI — docker:build-supply-chain) : une base Alpine minimale qui fournit sh, et au-dessus de laquelle on copie les binaires officiels depuis les images upstream via un multi-stage Docker (COPY --from=gcr.io/projectsigstore/cosign:<tag> et COPY --from=anchore/syft:<tag>). Les versions vivent dans le tag des FROM du Dockerfile ; un bump = éditer le tag + commit, et docker:build-supply-chain rebuild automatiquement l'image dès que supply-chain/Dockerfile change sur main.
Trois alternatives envisagées et écartées :
| Alternative | Raison du refus |
|---|---|
| Garder les images officielles distroless | Échec système immédiat sur GitLab Runner SaaS — non négociable. |
Télécharger cosign et syft depuis les releases GitHub upstream avec vérification SHA256 dans le Dockerfile |
Les runners GitLab SaaS bloquent régulièrement les sorties HTTP vers les CDN GitHub Releases (objects.githubusercontent.com → curl: (28) Connection timed out). Première version livrée sous cette forme, KO en production de la CI. Les pulls Docker (gcr.io, Docker Hub) marchent sans problème depuis le même runner. |
Forker les images officielles upstream pour y ajouter sh |
Maintenance d'un fork sur deux projets externes, sans intérêt fonctionnel — autant assembler nous-mêmes une image minimale. |
Le compromis assumé est le transfert de la confiance du couple (release GitHub + SHA256 figé localement) vers les registries source (gcr.io/projectsigstore pour cosign, Docker Hub anchore/syft pour syft). En contrepartie, Sigstore et Anchore publient eux-mêmes leurs images sur ces registries — c'est la même chaîne de confiance que celle qui sécurise n'importe quel FROM du Dockerfile racine du projet, et c'est précisément la propriété qu'exploite le manager dockerfile natif de Renovate pour proposer les bumps automatiquement. L'épinglage se fait par tag (v3.1.3 côté cosign, v1.51.0 côté syft), pas par digest immuable @sha256:… : si on voulait fermer la fenêtre théorique où un mainteneur de l'image source pourrait retagger une version déjà publiée, il faudrait passer aux digests — au prix de bumps à la main (Renovate gère les tags, pas les digests par défaut). Tant qu'on accepte de faire confiance à Sigstore et Anchore pour ne pas réécrire un tag historique, l'épinglage par tag est suffisant pour notre modèle de menace et garde le bénéfice du suivi automatique.
Pourquoi une image multi-architecture, et comment elle reste vérifiable¶
Kirexo s'installe à partir des seules images publiées par une pipeline de tag. Une image construite par un docker build ordinaire hérite de l'architecture du runner qui la produit, amd64 sur les runners GitLab par défaut. Un tiers qui héberge sur ARM (Raspberry Pi, VPS Ampere, Mac Apple Silicon) ne pourrait alors rien installer. L'image kirexo-prod publiée sur tag est donc un index OCI qui référence, quand les deux jambes ont réussi, deux images, linux/amd64 et linux/arm64 : Docker y choisit celle de l'hôte, sans que l'installateur ait à le demander. La section amd64 obligatoire, arm64 best-effort explique pourquoi une release peut ne contenir que linux/amd64.
Sur tag seulement¶
Seules les pipelines de tag produisent une image installable. Les builds de MR servent à exercer le garde-fou et le smoke test HTTP de l'image prod, pas à livrer. Construire l'arm64 à chaque MR doublerait le coût de ces pipelines sans rien produire que quelqu'un installe. La contrepartie est connue : le chemin multi-architecture (jambe arm64, assemblage de l'index, signature récursive) ne s'exécute qu'au moment d'une release. Ce qui ne peut pas être prouvé avant est listé dans la référence de la pipeline.
Un runner natif plutôt que l'émulation¶
Trois façons de produire deux architectures ont été comparées :
| Option | Verdict | Raison |
|---|---|---|
| Deux jobs natifs, amd64 sur le runner par défaut et arm64 sur un runner arm64 hébergé, puis fusion en un index | Retenue | Pas d'émulation. Le garde-fou et le smoke test HTTP, qui démarrent l'image, tournent sur la vraie architecture, sans modification de leurs scripts. La durée murale est celle de la jambe la plus longue, plus une fusion qui ne touche que le registry. |
Un seul job docker buildx build --platform linux/amd64,linux/arm64 sous émulation QEMU |
Écartée | La compilation des extensions PHP sous émulation est plusieurs fois plus lente, et le smoke test HTTP devrait tourner lui aussi sous émulation. L'ensemble approcherait la durée maximale d'un job. |
| Un builder buildx à plusieurs nœuds | Écartée | Il faudrait un démon arm64 joignable depuis le job amd64, ce que DinD sur runner hébergé ne permet pas sans infrastructure dédiée. |
Le runner arm64 retenu est le plus petit disponible sur le plan GitLab du projet. Il ne dispose pas du cache de l'image de base, construite en amd64 seul : la jambe arm64 recompile les extensions PHP à chaque tag. C'est le coût accepté pour ne pas rendre multi-architecture toutes les images de la CI.
amd64 obligatoire, arm64 best-effort¶
Chaque jambe pousse uniquement un tag d'architecture, kirexo-prod:<version>-amd64 ou -arm64. Les références qu'un installateur utilise, kirexo-prod:<version> et :latest, sont créées en une seule opération, par un job qui exige la réussite de la jambe amd64 et vérifie que l'index contient exactement les plateformes attendues.
La première version de cette chaîne exigeait aussi la jambe arm64 : une version existait pour les deux architectures, ou n'existait pas. Le premier tag de version a montré le coût de cette règle. Le runner arm64 est hébergé par GitLab et consomme un quota de minutes mensuel ; le quota épuisé, la jambe arm64 n'a jamais démarré, et rien n'a été publié, pas même l'image amd64, qui sert la plupart des installations. Une dépendance hors du contrôle du projet bloquait toutes les releases.
La règle retenue inverse la priorité : amd64 est obligatoire, arm64 est best-effort. Quand la jambe arm64 échoue ou ne démarre pas, la version sort en linux/amd64 seul. L'objection qui avait écarté ce choix, des versions installables sur une seule architecture sans que rien ne le signale, est levée par le signalement : la note de release porte alors une section « Architecture » qui le dit. Un administrateur sur arm64 lit cette note avant de mettre à jour, et reste sur la version précédente.
arm64 n'entre dans l'index que sur un signal explicite de sa jambe, écrit en toute fin de job, donc seulement si elle a tout réussi. Il n'est jamais déduit de la présence d'un tag -arm64 dans le registry : ce tag peut dater d'une exécution précédente, ou avoir été poussé par une jambe tombée ensuite sur un contrôle post-push. Déduire la présence d'arm64 du registry ferait entrer dans l'index une image qui n'a pas passé tous les contrôles.
Les tags d'architecture restent dans le registry : l'index est assemblé à partir d'eux. Ceux qui figurent dans l'index sont signés et vérifiables, puisqu'ils désignent ses images, mais ils ne font pas partie du contrat d'installation. Un -arm64 resté hors de l'index, après une jambe tombée en fin de parcours, n'est ni signé ni vérifiable. Une installation épinglée sur -arm64 perdrait ce que l'index apporte, le choix automatique de l'image, et dépendrait d'un nom que rien ne garantit dans la durée.
Signer l'index par digest, récursivement¶
La signature d'un index ne couvre pas, en elle-même, les images qu'il référence. Or un hôte arm64 ne tire pas l'index : il le lit, puis tire l'image linux/arm64 par son digest. Si seule la signature de l'index existait, un vérificateur qui contrôle ce que l'hôte exécute réellement, l'image de plateforme, ne trouverait rien à vérifier. cosign sign --recursive signe l'index et chaque image de plateforme : la vérification tient quelle que soit la référence considérée.
La signature porte sur le digest de l'index, jamais sur un tag. Un tag est mutable : signer :latest, c'est signer ce qu'il désigne au moment de la signature, sans garantie que ce soit encore ce que le registry servira. Le digest désigne un contenu, et les trois tags publics le pointent : une seule signature les couvre tous.
La CI se vérifie elle-même, avec l'identité du consommateur¶
Après avoir signé, la pipeline rejoue cosign verify sur chaque référence publiée (tags publics, tags d'architecture, digests des images de plateforme), avec la regex d'identité et l'émetteur que documente la procédure de déploiement. Ce n'est pas une redondance avec la vérification côté serveur : celle-ci reste la seule qui ferme la boucle de confiance. La post-vérification protège d'autre chose, d'une signature produite mais invérifiable par le consommateur (identité différente, image enfant non couverte, stockage des signatures mal géré par le registry). Sans elle, le défaut n'apparaîtrait qu'au premier déploiement refusé, chez l'installateur. Avec elle, la release n'est pas publiée.
Un SBOM par architecture¶
Quand l'index contient deux images, elles ne sont pas identiques : elles partent des mêmes sources, mais chacune embarque les paquets Alpine et les binaires de son architecture. Un SBOM unique ne peut pas décrire l'index, et une release linux/amd64 seule garde la même forme, un SBOM par image de plateforme. Syft, appelé sur un index, choisit d'ailleurs lui-même une plateforme, et le SBOM produit ne dirait pas laquelle. Chaque SBOM est donc produit à partir du digest d'une image de plateforme, le même que celui que la signature récursive couvre : le SBOM linux/arm64 décrit exactement l'image signée qu'un hôte arm64 exécute. Deux formats par architecture donnent deux fichiers par release linux/amd64 seule, quatre avec arm64 (cf. Assets de release et permaliens).
Limite assumée : le scan CVE ne voit qu'une architecture¶
Le scan CVE de la release reçoit l'index, et le scanner le résout vers une seule plateforme, a priori amd64. L'image arm64, quand elle est publiée, n'est pas scannée. Elle part des mêmes dépôts Alpine, mis à jour dans la même étape du build, mais rien ne garantit des versions de paquets identiques. Ajouter un scan par architecture est possible ; il n'a pas été jugé nécessaire à ce stade. En attendant, le SBOM linux/arm64 permet à un outil tiers comme Dependency-Track de corréler cette image aux CVE publiées.
Le triangle traçabilité, conformité, audit¶
Les trois angles que la combinaison signature + SBOM ferme :
| Question posée | Réponse | Mécanisme |
|---|---|---|
| Traçabilité — Qui a buildé cette image, à partir de quel commit, à quel moment ? | Le JWT capturé par Fulcio porte URL du projet, ref, sha. Rekor publie cette attestation immuable, pour l'index et pour chaque image de plateforme. | Signature keyless récursive + log Rekor. |
| Conformité — Quel inventaire logiciel cette image embarque-t-elle ? Sous quelles licences ? | SBOM SPDX (norme ISO, accepté par OpenChain et NTIA), un par architecture. | release:sbom → assets SPDX linux/amd64 et linux/arm64. |
| Audit sécurité — Quelles CVE concernent les composants de cette image ? | SBOM CycloneDX consommé par Dependency-Track / Trivy, un par architecture. | release:sbom → assets CycloneDX linux/amd64 et linux/arm64. |
Les trois angles portent sur les mêmes objets : les digests des images de plateforme. La signature couvre ces digests, chaque SBOM est produit à partir de l'un d'eux. Chaque angle est résolu par un mécanisme distinct, mais ils partagent la même propriété d'audit a posteriori : la signature reste interrogeable via Rekor indépendamment de Kirexo, et le SBOM reste lisible sans avoir à pull l'image d'origine. Si demain le projet est archivé, ces artefacts restent vérifiables tant que les services publics sigstore et le registry GitLab existent.
Voir aussi¶
- Pipeline GitLab CI — Signature keyless de
kirexo-prod— détail factuel du jobdocker:sign-prod. - Pipeline GitLab CI — Job
release:sbom— détail factuel de la génération SBOM. - Pipeline GitLab CI — Construction multi-architecture de
kirexo-prod— jambes, index, invariants de publication. - Vérifier l'image de sa plateforme — vérification par digest d'une image de plateforme.
- Vérifier la signature de l'image avant de la pull — procédure côté serveur.
- SBOM disponible en asset de la release — comment récupérer les SBOM côté consommateur.