Cosign et Kyverno : signer ses images et les vérifier à l'admission
Signature keyless avec Cosign en CI, attestations SBOM et provenance, vérification à l'admission avec l'ImageValidatingPolicy de Kyverno.
Scanner les images ne dit rien de leur origine. Si un poste de développeur, un jeton de registre fuité ou un pipeline mal cloisonné peut pousser dans le registre de production, le scanner validera tranquillement une image que personne n'a construite par le chemin prévu. La signature répond à une autre question : qui a produit ce digest précis ? Encore faut-il savoir exactement ce qu'elle prouve, et le vérifier au bon endroit.
Une signature Cosign lie un digest d'image à une identité. Elle ne dit pas que l'image est exempte de vulnérabilités, ni que le build n'a pas été compromis en amont : un pipeline piégé signera son propre artefact avec la même identité légitime. C'est pour cela que la signature se combine avec des attestations (SBOM, provenance de build) et avec une protection sérieuse du pipeline lui-même. Seule, elle déplace le problème ; avec le reste, elle ferme une vraie porte.
Ce que le mode keyless signe réellement
En mode keyless, il n'y a pas de clé privée longue durée à stocker. Cosign génère une paire de clés éphémère, obtient un jeton OIDC (dans GitHub Actions, celui du job), et l'échange auprès de Fulcio, l'autorité de certification de Sigstore, contre un certificat valable dix minutes. Ce certificat porte l'identité du signataire ; pour GitHub Actions, c'est l'URL du workflow et sa référence, par exemple https://github.com/acme/api/.github/workflows/release.yml@refs/heads/main, avec l'émetteur https://token.actions.githubusercontent.com. La signature est ensuite inscrite dans Rekor, le journal de transparence, ce qui permet de la vérifier après l'expiration du certificat.
Le gain est réel : plus de rotation de clé, plus de secret de signature à exfiltrer depuis la CI. Mais la confiance ne disparaît pas, elle se déplace vers l'identité OIDC. Quiconque peut modifier release.yml sur main, ou faire tourner ce workflow avec un contenu arbitraire, peut produire une signature parfaitement valide. La protection de branche, la revue obligatoire des fichiers de workflow et la restriction des déclencheurs font donc partie du dispositif de signature, pas de l'hygiène générale.
Deux limites méritent d'être connues avant de choisir ce mode. D'abord, l'instance publique de Rekor est publique : le certificat inscrit dans le journal expose le nom du dépôt et le chemin du workflow, y compris pour un dépôt privé. Si ces noms sont sensibles, il faut une instance Sigstore privée ou une signature par clé gérée dans un KMS (--key awskms://...). Ensuite, avec les workflows réutilisables, l'identité du certificat est celle du workflow appelé, pas celle du dépôt appelant : centraliser le build dans un workflow partagé est une bonne pratique, mais la vérification doit alors aussi contrôler le dépôt d'origine, que Fulcio inscrit dans les extensions du certificat (option --certificate-github-workflow-repository de cosign verify).
Signer dans le pipeline, toujours par digest
La documentation de Cosign insiste sur ce point : on signe image@sha256:..., jamais un tag. Un tag est mutable ; signer api:1.4.2 revient à signer ce que le tag désigne au moment de la commande, sans garantie que ce soit encore le cas au déploiement. Le digest sort directement de l'étape de build.
jobs:
release:
runs-on: ubuntu-latest
permissions:
contents: read
id-token: write # nécessaire pour obtenir le jeton OIDC
steps:
# checkout et connexion au registre omis
- uses: sigstore/cosign-installer@v4.1.3
- id: build
uses: docker/build-push-action@v7
with:
push: true
tags: registry.example.com/acme/api:${{ github.sha }}
- name: Signer l'image par digest
env:
DIGEST: ${{ steps.build.outputs.digest }}
run: cosign sign --yes "registry.example.com/acme/api@${DIGEST}"
Cosign 3 produit par défaut le nouveau format de bundle Sigstore et stocke les signatures via les referrers OCI 1.1. Avant de monter de version en CI, vérifiez que votre registre et la version de Kyverno déployée savent lire ce format : un cosign verify sur une image fraîchement signée et une politique en mode Audit sur un namespace de recette suffisent à le savoir.
Vérifier avec une identité exacte
Avant même Kubernetes, la vérification en ligne de commande sert à valider la chaîne et à écrire la politique d'admission avec les bonnes valeurs.
cosign verify \
--certificate-identity "https://github.com/acme/api/.github/workflows/release.yml@refs/heads/main" \
--certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
registry.example.com/acme/api@sha256:3f1c...e9a2
L'identité attendue doit être aussi précise que possible. Un motif du type https://github.com/acme/* accepte n'importe quel dépôt de l'organisation, n'importe quel workflow et n'importe quelle branche, y compris une branche de fonctionnalité qu'un développeur pousse sans revue. C'est presque équivalent à « signé par quelqu'un chez nous », ce qui n'est pas la garantie recherchée. Quand plusieurs dépôts publient des images, une expression régulière ancrée (--certificate-identity-regexp) qui fixe le fichier de workflow et la branche reste acceptable ; un joker sur tout le chemin ne l'est pas.
Vérifier à l'admission avec ImageValidatingPolicy
Kyverno a longtemps vérifié les images via des règles verifyImages dans une ClusterPolicy. Ce type est déprécié depuis Kyverno 1.19 et sa suppression est annoncée pour la 1.20 ; le remplaçant est l'ImageValidatingPolicy, stable depuis la 1.18, dont les validations s'écrivent en CEL. Une nouvelle politique doit s'écrire directement dans ce format, et les ClusterPolicy existantes ont un guide de migration qui fait correspondre chaque champ.
apiVersion: policies.kyverno.io/v1
kind: ImageValidatingPolicy
metadata:
name: verify-api-signature
spec:
validationActions: [Audit]
failurePolicy: Fail
matchConstraints:
resourceRules:
- apiGroups: ['']
apiVersions: ['v1']
operations: ['CREATE', 'UPDATE']
resources: ['pods']
matchImageReferences:
- glob: 'registry.example.com/acme/api*'
validationConfigurations:
mutateDigest: true
attestors:
- name: release
cosign:
keyless:
identities:
- subject: 'https://github.com/acme/api/.github/workflows/release.yml@refs/heads/main'
issuer: 'https://token.actions.githubusercontent.com'
ctlog:
url: 'https://rekor.sigstore.dev'
validations:
- expression: >-
images.containers.map(image, verifyImageSignatures(image, [attestors.release])).all(e, e > 0)
message: "Image non signée par le workflow de release de acme/api"
Quelques choix méritent une explication. mutateDigest réécrit le tag en digest dans le Pod admis : le nœud tire exactement l'image qui a été vérifiée, et un tag déplacé entre l'admission et le pull n'a plus d'effet. failurePolicy: Fail refuse les Pods si Kyverno ne répond pas ; c'est le bon réglage pour un contrôle de sécurité, mais il fait de Kyverno un composant critique du plan de contrôle, à déployer en haute disponibilité, et il faut exclure les namespaces système pour ne pas bloquer leur propre redémarrage.
Le piège le plus courant tient au périmètre. La politique ne s'applique qu'aux images couvertes par matchImageReferences : une image tirée de docker.io ou d'un autre registre lui échappe totalement. La vérification de signature doit donc s'accompagner d'une politique qui restreint les registres autorisés, sinon il suffit de changer de registre pour contourner le contrôle.
Attestations : SBOM et provenance
Une signature dit qui. Une attestation dit quoi : c'est une déclaration signée, au format in-toto, attachée au même digest. Les deux qui comptent pour la supply chain sont le SBOM (la liste des composants) et la provenance de build (quel builder, à partir de quelle source, avec quels paramètres). Cosign les produit avec la même identité keyless que la signature.
cosign attest --yes --type cyclonedx \
--predicate sbom.cdx.json \
registry.example.com/acme/api@sha256:3f1c...e9a2
cosign verify-attestation --type cyclonedx \
--certificate-identity "https://github.com/acme/api/.github/workflows/release.yml@refs/heads/main" \
--certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
registry.example.com/acme/api@sha256:3f1c...e9a2
Côté Kyverno, l'ImageValidatingPolicy déclare les attestations attendues dans spec.attestations et les vérifie avec verifyAttestationSignatures(), puis peut en lire le contenu avec extractPayload(), par exemple pour exiger un SBOM au format CycloneDX. Un SBOM signé prouve qui l'a produit, pas qu'il est complet : sa qualité dépend de l'outil qui le génère et du moment où il le fait. Nous recommandons de le générer à partir de l'image finale plutôt que du seul manifeste de dépendances, parce que c'est l'image qui tourne, avec ses paquets système.
La provenance est le sujet du référentiel SLSA, dont la piste Build définit des niveaux progressifs : au niveau 1, une provenance existe ; au niveau 2, elle est générée et signée par une plateforme de build hébergée ; au niveau 3, la plateforme est durcie pour empêcher les exécutions de s'influencer et tenir le secret de signature hors de portée des étapes définies par l'utilisateur. Le point clé du niveau 3 est justement là : une provenance générée par une étape du job que le développeur contrôle peut être falsifiée par ce même job.
Ce que le Cyber Resilience Act change
Le règlement européen sur la cyber-résilience (règlement (UE) 2024/2847) est entré en vigueur le 10 décembre 2024. Ses obligations de signalement des vulnérabilités activement exploitées s'appliquent depuis le 11 septembre 2026, et l'essentiel des obligations à partir du 11 décembre 2027, selon le résumé de la Commission européenne. Son annexe I demande aux fabricants de produits comportant des éléments numériques d'identifier et de documenter les composants, notamment au moyen d'un SBOM dans un format couramment utilisé et lisible par machine, couvrant au minimum les dépendances de premier niveau. Ce SBOM n'a pas à être publié, mais doit pouvoir être fourni aux autorités de surveillance du marché.
Le texte n'impose ni Cosign, ni signature d'image, ni Kubernetes. Il impose de savoir ce que contient ce que l'on livre et de traiter les vulnérabilités pendant la période de support. Un SBOM généré et attesté à chaque build, rattaché au digest déployé, est une manière solide d'en apporter la preuve. Que votre activité entre dans le périmètre du règlement est une question à trancher produit par produit, avec un juriste ; la chaîne technique, elle, a le même intérêt dans les deux cas.
Passer en mode Deny sans casser la production
La politique commence en Audit. Les rapports de politique (PolicyReports) listent alors les Pods qui auraient été refusés, sans rien bloquer. On y trouve en général des images tierces jamais signées, des images construites par un ancien pipeline et des charges oubliées. La durée de cette phase compte moins que sa couverture : un CronJob mensuel n'apparaîtra pas dans deux semaines d'audit. Nous recommandons d'attendre au moins un cycle complet de déploiements et de tâches planifiées sans violation avant de basculer.
Pour les images tierces, deux options tiennent la route : vérifier la signature de l'éditeur quand il en publie une, avec son identité à lui, ou importer l'image dans votre registre après analyse et la signer avec un workflow dédié. Dans le second cas, la signature atteste que l'image a passé votre processus d'import, et rien de plus.
Le passage à Deny se fait ensuite namespace par namespace, avec un namespaceSelector dans matchConstraints, en commençant par les environnements de recette. Prévoyez enfin une procédure d'exception documentée, via les PolicyException de Kyverno, avec une date d'expiration et une revue : sans elle, la première urgence de production se terminera par la suppression de la politique.
Besoin d'aide sur ce sujet ?
Nos ingénieurs peuvent auditer votre contexte et vous proposer un plan d'action concret.