Signer une image avec Cosign consiste à poser, dans le registre, une preuve cryptographique qui lie un digest à une clé privée ; vérifier consiste à contrôler cette preuve avec la clé publique correspondante. Cette leçon s'adresse à qui prépare le CKS (Certified Kubernetes Security Specialist) ou la KCSA (Kubernetes and Cloud Native Security Associate) et sait déjà épingler une image par son digest. Elle montre, avec cosign 3.1.3, comment générer les clés, signer, publier la clé publique dans le cluster et prouver que la vérification sait aussi refuser.
Le mode sans clé (keyless), l'écosystème Sigstore et les cas d'usage hors Kubernetes sont traités dans Cosign : signer et vérifier vos images conteneurs et dans Sigstore : signature keyless pour la supply chain. Cette page se limite à la signature par clé et à son usage dans un cluster.
Ce que vous allez apprendre
Section intitulée « Ce que vous allez apprendre »- Dire ce que prouve une signature d'image et ce qu'elle ne prouve pas
- Générer une paire de clés et garder la clé privée hors du cluster
- Signer un digest et retrouver la signature dans le registre
- Publier la clé publique dans un ConfigMap
- Vérifier une image et lire les trois codes de retour
- Dire comment l'admission s'appuie sur la signature, et diagnostiquer un échec
Prérequis
Section intitulée « Prérequis »- Savoir épingler une image par son digest : Supply Chain Security Kubernetes
- Un cluster Kubernetes avec kubectl configuré
- Un registre où vous pouvez pousser une image : un registre local suffit, lancé avec Docker sur votre poste
- L'outil
crane(Crane), qui lit le digest d'une image dans un registre : son installation vérifiée est donnée plus bas, avec une alternative sanscrane - Un accès à Internet depuis la machine qui signe : la signature par défaut de cosign contacte un service public de Sigstore (voir la section de signature)
Que prouve la signature d'une image ?
Section intitulée « Que prouve la signature d'une image ? »Une signature prouve deux choses : l'authenticité (l'image a bien été publiée par le détenteur de la clé privée) et l'intégrité (son contenu n'a pas changé depuis). Elle ne prouve pas l'absence de vulnérabilité : une image signée peut contenir des CVE critiques, et c'est le scan, décrit dans Scanner les images Kubernetes, qui les cherche.
Une signature ne vaut que par la clé qui la vérifie. Si n'importe qui peut obtenir la clé privée, la signature ne distingue plus votre image de celle d'un tiers. D'où la règle de la leçon : la clé privée reste sur la machine qui signe et n'entre jamais dans un objet du cluster, alors que la clé publique, elle, se publie.
Cosign, du projet Sigstore, est l'outil de signature courant dans l'écosystème des conteneurs. Les commandes de cette page ont été jouées avec cosign 3.1.3 et crane 0.22.1, un petit outil en ligne de commande pour interroger les registres.
Comment signer une image avec Cosign ?
Section intitulée « Comment signer une image avec Cosign ? »Signer demande trois gestes : installer cosign, générer une paire de clés, puis signer le digest de l'image. La signature est poussée dans le registre, à côté de l'image : il faut donc un registre où vous avez le droit d'écrire. Un registre local jetable suffit, et les commandes se rejouent sur votre poste sans compte chez un fournisseur. Une exception : avec cosign 3.1.3, la signature par défaut publie aussi une entrée dans le journal public Rekor de Sigstore, ce qui demande un accès réseau (détail dans la section « Signer le digest, pas le tag »).
# Un registre jetable sur le postedocker run -d --name registre -p 127.0.0.1:5555:5000 \ registry:3@sha256:ddf754342cfc8acc51a56d5d0ab6af06826461864460636d8bd5c546dab2a7b8Il faut ensuite deux images dans ce registre : lab-signe:1.0.0, que vous allez signer, et lab-non-signe:1.0.0, qui ne le sera jamais et servira à provoquer le code de retour 10. Les deux viennent d'images publiques épinglées par digest, copiées sous un autre nom vers le registre local.
docker pull gcr.io/distroless/static-debian12@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7abdocker tag gcr.io/distroless/static-debian12@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab localhost:5555/lab-signe:1.0.0docker push localhost:5555/lab-signe:1.0.0
docker pull nginx@sha256:8541484afbc9c8a5a8a99b379568ebbc957f658583ec9448fc43104229c03cf8docker tag nginx@sha256:8541484afbc9c8a5a8a99b379568ebbc957f658583ec9448fc43104229c03cf8 localhost:5555/lab-non-signe:1.0.0docker push localhost:5555/lab-non-signe:1.0.0Chaque docker push se termine par une ligne 1.0.0: digest: sha256:… size: … : ce digest est celui du registre, et c'est lui que vous signerez. Notez celui de chaque image.
Installer cosign avec vérification d'empreinte
Section intitulée « Installer cosign avec vérification d'empreinte »Un outil de supply chain se télécharge avec les mêmes précautions que kubectl dans la leçon Supply Chain Security Kubernetes : version épinglée et empreinte contrôlée. Le bloc compare l'empreinte SHA-256 du binaire à celle que Sigstore publie dans le fichier cosign_checksums.txt de chaque release, avant de le rendre exécutable.
COSIGN_VERSION=3.1.3base="https://github.com/sigstore/cosign/releases/download/v${COSIGN_VERSION}"curl -sSfLO "${base}/cosign-linux-amd64"curl -sSfLO "${base}/cosign_checksums.txt"grep " cosign-linux-amd64$" cosign_checksums.txt | sha256sum -c -chmod +x cosign-linux-amd64 && sudo mv cosign-linux-amd64 /usr/local/bin/cosignLa ligne sha256sum -c - doit répondre cosign-linux-amd64: OK. Sans ce OK, ne rendez pas le binaire exécutable.
Installer crane avec vérification d'empreinte, ou s'en passer
Section intitulée « Installer crane avec vérification d'empreinte, ou s'en passer »crane n'est pas installé avec le cluster ni avec Docker, et il n'est pas enseigné ailleurs dans ce parcours : on l'installe avec la même discipline que cosign. Le projet go-containerregistry publie, pour chaque release, une archive et un fichier checksums.txt. Le bloc épingle la version v0.22.1 et ne place le binaire dans le PATH que si l'empreinte correspond. Le nom de l'archive est celui de la page Crane ; les autres architectures sont listées sur la page des releases du projet.
VERSION=v0.22.1ARCHIVE=go-containerregistry_Linux_x86_64.tar.gzBASE="https://github.com/google/go-containerregistry/releases/download/${VERSION}"curl -fsSL -o "$ARCHIVE" "${BASE}/${ARCHIVE}"curl -fsSL -o checksums.txt "${BASE}/checksums.txt"grep " ${ARCHIVE}$" checksums.txt | sha256sum --check -tar -xzf "$ARCHIVE" cranesudo install -m 0755 crane /usr/local/bin/cranerm -f crane "$ARCHIVE" checksums.txtLa ligne sha256sum --check - doit répondre go-containerregistry_Linux_x86_64.tar.gz: OK. Sans ce OK, n'extrayez rien. Vous pouvez aussi vous passer de crane : le digest que docker push affiche à la fin de chaque envoi (étape précédente) est celui à signer ; dans ce cas, remplacez chaque appel crane digest des sections suivantes par ce digest relevé.
Générer la paire de clés
Section intitulée « Générer la paire de clés »cosign generate-key-pair écrit deux fichiers dans le répertoire courant : cosign.key (privée) et cosign.pub (publique). L'outil demande une passphrase, qui protège cosign.key. Pour la fournir sans dialogue, par exemple dans un script, la variable COSIGN_PASSWORD fait l'affaire, y compris vide dans un lab.
cosign generate-key-pairVérifiez que les deux fichiers existent avec ls cosign.*. cosign.key ne doit jamais quitter votre coffre : dans le lab de cette leçon, elle reste sur la machine qui signe, et le nettoyage la retire.
Signer le digest, pas le tag
Section intitulée « Signer le digest, pas le tag »Un tag peut être réaffecté à une autre image : on signe donc le digest. crane digest le résout, puis cosign sign signe ce digest précis.
crane digest localhost:5555/lab-signe:1.0.0# sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7abcosign sign --key cosign.key --allow-http-registry \ localhost:5555/lab-signe@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7abLe digest ci-dessus est celui relevé sur l'image lab-signe:1.0.0 de l'essai. Si crane digest en affiche un autre chez vous (selon la façon dont votre Docker envoie l'image au registre), reportez celui que vous lisez dans la commande cosign sign.
L'option --allow-http-registry n'existe que pour ce registre local sans TLS : ne la recopiez pas vers un registre de production.
Avec sa configuration de signature par défaut, cosign 3.1.3 publie aussi une entrée dans Rekor, le journal de transparence public de Sigstore. La machine qui signe doit donc joindre Internet, et cette entrée est publique et ne peut pas être effacée. Pour ne rien publier, par exemple en environnement isolé, la parade est une configuration de signature sans journal : elle est décrite dans le dépannage.
Signer par tag (lab-signe:1.0.0) fonctionne aussi, mais la signature se rattache de toute façon au digest que le tag désigne à cet instant. Si le tag bouge, la signature ne suit pas, et c'est précisément ce qu'on veut.
Où vit la signature, et comment la retrouver ?
Section intitulée « Où vit la signature, et comment la retrouver ? »La signature n'est pas dans l'image : c'est un artefact distinct, poussé dans le même dépôt sous un tag dérivé du digest. Le schéma suit l'échange dans le temps : regardez ce que le poste pousse dans le registre, puis ce que le vérificateur lui redemande.
Après signature, le dépôt porte donc deux tags. Cette commande les liste, et crane ls localhost:5555/lab-signe donne la même information :
curl -s http://localhost:5555/v2/lab-signe/tags/list{"name":"lab-signe","tags":["1.0.0","sha256-afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab"]}Le second tag est la signature. Avec cosign 3.x, elle est stockée comme un artefact qui référence l'image, selon la spécification OCI 1.1 (celle qui définit les registres de conteneurs).
Un registre qui n'a pas l'API Referrers, celle qui liste les artefacts rattachés à une image, range cet artefact sous le tag sha256-<digest>, comme ici. Un registre qui expose cette API peut ne pas montrer ce tag. Ce tag n'est plus suffixé .sig par défaut : beaucoup d'articles disent encore le contraire, et un test qui chercherait .sig déclarerait à tort qu'aucune signature n'existe.
Deux conséquences pratiques. Copier une image d'un registre à l'autre ne transporte pas sa signature, sauf à copier aussi cet artefact : une vérification qui échoue après une migration de registre peut avoir cette cause. Et comme le tag est dérivé du digest, resigner une image reconstruite produit un nouvel artefact, l'ancien restant en place.
Comment publier la clé publique dans le cluster ?
Section intitulée « Comment publier la clé publique dans le cluster ? »Pour que le cluster, ou un tiers, vérifie vos images, la clé publique doit être lisible dans le cluster. On la publie dans un ConfigMap : ici cosign-pub-key, dans le namespace chaine-signature (celui du lab, à créer avec kubectl create namespace chaine-signature s'il n'existe pas), sous la clé cosign.pub. Le nom de cette clé compte, car c'est sous ce nom que les outils la relisent.
kubectl -n chaine-signature create configmap cosign-pub-key \ --from-file=cosign.pub=cosign.pubNe publiez jamais la clé privée cosign.key, ni dans un ConfigMap ni dans un Secret : quiconque la lirait pourrait signer à votre place, et la signature n'aurait alors plus aucune valeur.
Pour vérifier comme le ferait un tiers, relisez la clé depuis le cluster plutôt que depuis votre fichier local :
kubectl -n chaine-signature get configmap cosign-pub-key \ -o jsonpath='{.data.cosign\.pub}' > cosign-du-cluster.pubLe fichier obtenu commence par -----BEGIN PUBLIC KEY-----. S'il est vide, le nom de la clé du ConfigMap est le premier suspect.
Comment vérifier que la signature protège vraiment ?
Section intitulée « Comment vérifier que la signature protège vraiment ? »Une vérification qui réussit ne prouve pas encore que la signature protège : il faut aussi la voir échouer quand elle le doit. Une chaîne qui accepte tout ressemble à une chaîne qui fonctionne. Les trois situations du tableau ont été jouées sur le registre local avec cosign 3.1.3 et rendent trois codes de retour différents. La commande suivante vérifie l'image signée avec la bonne clé publique.
cosign verify --key cosign.pub --allow-http-registry \ localhost:5555/lab-signe@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7abecho "code de retour : $?"Pour provoquer les deux autres cas, générez une seconde paire de clés dans un autre répertoire, pour ne pas écraser la première, et vérifiez la même image avec cette clé publique. Puis vérifiez l'image lab-non-signe:1.0.0, que personne n'a signée, avec la bonne clé (remplacez <digest-non-signe> par le digest relevé au docker push, ou par la sortie de crane digest localhost:5555/lab-non-signe:1.0.0). Chaque fois, echo affiche le code de retour.
mkdir autre-cle && (cd autre-cle && cosign generate-key-pair)cosign verify --key autre-cle/cosign.pub --allow-http-registry \ localhost:5555/lab-signe@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7abecho "code de retour : $?"
cosign verify --key cosign.pub --allow-http-registry \ localhost:5555/lab-non-signe@<digest-non-signe>echo "code de retour : $?"Avec la bonne clé, cosign détaille ce qu'il a contrôlé : les affirmations portées par la signature, leur trace dans le journal de transparence (vérifiée hors ligne), puis la signature elle-même avec la clé publique donnée.
Verification for localhost:5555/lab-signe@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab --The following checks were performed on each of these signatures: - The cosign claims were validated - Existence of the claims in the transparency log was verified offline - The signatures were verified against the specified public key| Situation | Code de retour | Message |
|---|---|---|
| Signature valide | 0 | le détail des contrôles ci-dessus |
| Mauvaise clé publique | 1 | no matching attestations: failed to verify log inclusion (vérification avec journal Rekor) |
| Image non signée | 10 | no signatures found |
La distinction entre 1 et 10 est exploitable. Une image non signée (10) signale un oubli dans la chaîne de build ; une signature qui ne correspond pas à la clé (1) signale un problème d'identité. Ces deux incidents n'appellent pas la même réaction, et un script doit tester le code de retour, pas le texte du message. Le message d'une mauvaise clé dépend d'ailleurs de la configuration de vérification : avec la configuration par défaut, qui contrôle l'inclusion dans Rekor, il vaut no matching attestations: failed to verify log inclusion, alors que le guide Cosign, qui vérifie sans journal, montre accepted signatures do not match threshold. Le code de retour, lui, reste le même.
Cosign réserve aussi les codes 11, 12 et 13 à d'autres échecs de vérification : un tag inexistant (11), aucune signature correspondante (12) et un certificat absent de la signature (13). Pour une mauvaise clé, cosign 3.1.3 a rendu le code 1, pas 12. Pour refuser une image, testez donc un code différent de zéro, et gardez 10 pour reconnaître l'image non signée.
Quand les essais sont finis, nettoyez : supprimez cosign.key, cosign.pub, cosign-du-cluster.pub et le dossier autre-cle (la seconde paire de clés), puis le fichier signing-config.json si vous l'avez créé. Supprimez ensuite le namespace du lab, ce qui retire aussi le ConfigMap cosign-pub-key, et enfin le registre jetable.
rm -rf cosign.key cosign.pub cosign-du-cluster.pub autre-cle signing-config.jsonkubectl delete namespace chaine-signaturedocker rm -f registreComment le cluster s'appuie-t-il sur la signature ?
Section intitulée « Comment le cluster s'appuie-t-il sur la signature ? »Cosign ne bloque rien dans le cluster : il répond à une question, « cette signature est-elle valable pour cette clé ». C'est l'admission, le contrôle que Kubernetes applique à chaque objet avant de l'accepter, qui transforme cette réponse en refus. En pratique, une politique Kyverno vérifie la signature de chaque image avant de créer le Pod : voir Kyverno pour la politique de vérification d'images, et Admission controllers pour le mécanisme général.
Vérification dans Kubernetes avec ImagePolicyWebhook
Section intitulée « Vérification dans Kubernetes avec ImagePolicyWebhook »L'ImagePolicyWebhook est un admission controller historique, désactivé par défaut, qui délègue la décision d'autorisation à un backend externe. Il reste documenté et utile pour comprendre les mécanismes de contrôle d'images, mais sur les clusters récents on rencontre plutôt des webhooks d'admission génériques (ValidatingAdmissionWebhook) ou des moteurs de policy comme Kyverno.
Un point d'architecture change la façon de l'évaluer : ImagePolicyWebhook ne décide de rien par lui-même. Il transmet la demande à un service externe, joignable en TLS, qui autorise ou refuse. La sécurité réelle du dispositif est donc celle de ce backend, de sa disponibilité et de ses règles, pas celle du contrôleur Kubernetes, qui se contente de relayer.
Le schéma suit une demande de création de Pod : regardez ce que fait le plugin (il relaie), ce que fait le backend (il répond), et ce qui se passe quand le backend ne répond pas.
La démonstration ci-dessous tient en deux fichiers de configuration et une modification du manifeste de l'API server, à faire sur chaque nœud du plan de contrôle. Dans /etc/kubernetes/manifests/kube-apiserver.yaml, le premier drapeau active le plugin et le second indique où lire sa configuration.
L'API server étant un Pod, le dossier /etc/kubernetes/admission/ doit lui être monté, sinon il ne verra jamais ces fichiers et bouclera au démarrage. Une erreur ici empêche l'API server de redémarrer : gardez une copie du manifeste hors du dossier des manifestes avant de le modifier, par exemple avec sudo cp /etc/kubernetes/manifests/kube-apiserver.yaml /root/kube-apiserver.yaml.sauvegarde.
La documentation Kubernetes demande d'activer le groupe d'API imagepolicy.k8s.io/v1alpha1 avec --runtime-config=imagepolicy.k8s.io/v1alpha1=true, à ajouter dans la même liste command. L'extrait ci-dessous ne le porte pas : ajoutez-le si l'API server n'applique pas la politique.
spec: containers: - command: - kube-apiserver # ... autres flags ... - --enable-admission-plugins=NodeRestriction,ImagePolicyWebhook - --admission-control-config-file=/etc/kubernetes/admission/admission-config.yaml volumeMounts: # ... montages existants ... - mountPath: /etc/kubernetes/admission name: admission-config readOnly: true volumes: # ... volumes existants ... - name: admission-config hostPath: path: /etc/kubernetes/admission type: DirectoryOrCreateapiVersion: apiserver.config.k8s.io/v1kind: AdmissionConfigurationplugins: - name: ImagePolicyWebhook configuration: imagePolicy: kubeConfigFile: /etc/kubernetes/admission/webhook-kubeconfig.yaml allowTTL: 50 denyTTL: 50 retryBackoff: 500 defaultAllow: false # Bloquer si le webhook est inaccessibleLe second fichier est un kubeconfig ordinaire : il dit à l'API server où joindre le backend et avec quelle autorité de certification le reconnaître. Il pointe sur une adresse où aucun backend n'écoute, ce que la démonstration qui suit n'exige pas de corriger. Dans un vrai dispositif, c'est ce backend, et non l'ImagePolicyWebhook, qui appellerait une vérification comme cosign verify.
apiVersion: v1kind: Configclusters: - name: image-policy cluster: certificate-authority: /etc/kubernetes/pki/ca.crt server: https://127.0.0.1:9443/verifycontexts: - name: image-policy context: cluster: image-policy user: kube-apiservercurrent-context: image-policyusers: - name: kube-apiserver user: {}Rejoué sur un cluster kind (Kubernetes dans Docker) en Kubernetes 1.37, l'API server est revenu en 33 secondes avec ces trois fichiers. Comme aucun backend n'écoute sur ce port, la première création de Pod a été refusée :
Error from server (Forbidden): pods "demo-ipw" is forbidden: Post "https://127.0.0.1:9443/verify?timeout=30s": dial tcp 127.0.0.1:9443: connect: connection refusedC'est le comportement attendu de defaultAllow: false : le message nomme la cause, le backend injoignable, et rien ne passe tant qu'il ne répond pas. Un cluster en production doit donc surveiller la disponibilité de ce backend comme celle de l'API server lui-même.
Quand la démonstration est faite, revenez en arrière : cette configuration refuse tous les Pods tant qu'aucun backend n'écoute. Remettez le manifeste sauvegardé, attendez que l'API server réponde de nouveau (kubectl get --raw /readyz doit afficher ok), puis vérifiez qu'un Pod se crée. Retirez enfin le dossier /etc/kubernetes/admission, devenu inutile puisque le manifeste d'origine ne le monte plus.
sudo cp /root/kube-apiserver.yaml.sauvegarde /etc/kubernetes/manifests/kube-apiserver.yamlkubectl get --raw /readyzkubectl run retour --image=nginx:1.31.3@sha256:8541484afbc9c8a5a8a99b379568ebbc957f658583ec9448fc43104229c03cf8kubectl delete pod retoursudo rm -r /etc/kubernetes/admissionTant que kubectl get --raw /readyz ne répond pas ok, laissez au kubelet le temps de relancer l'API server avant de créer le Pod.
Signature par clé ou signature keyless ?
Section intitulée « Signature par clé ou signature keyless ? »Cosign propose deux modes de signature. La signature par clé, celle que cette leçon détaille, est explicite : vous voyez ce que vous générez et ce que vous vérifiez. Elle vous laisse en revanche une clé privée de longue durée à protéger et à renouveler : si elle fuit, un tiers peut signer à votre place.
La signature keyless supprime ce problème en s'appuyant sur une identité OIDC (OpenID Connect, un protocole d'authentification), celle de votre exécution GitHub Actions ou GitLab CI, et sur un certificat éphémère. Elle convient à une chaîne de build automatisée qui dispose d'un fournisseur OIDC. Gardez la signature par clé pour comprendre le mécanisme et pour les environnements isolés où aucun fournisseur OIDC n'est joignable ; dans ce cas, sans accès aux services publics de Sigstore, signez avec une configuration de signature sans journal (voir le dépannage). Le guide Cosign détaille les deux.
Dépannage
Section intitulée « Dépannage »Quand une vérification échoue, le code de retour et le message disent presque toujours où chercher. Le tableau part du symptôme observé.
| Symptôme | Cause probable | Solution |
|---|---|---|
no signatures found, code 10 | Image jamais signée, ou signature non copiée avec l'image lors d'une migration de registre | Signer le digest, ou copier aussi l'artefact de signature |
no matching attestations, code 1 | Mauvaise clé publique, ou image re-signée avec une autre clé | Vérifier la clé ; signer et vérifier sur le même digest |
Un test cherche un tag .sig et n'en trouve pas | Avec cosign 3.x, le tag de signature est sha256-<digest> | Chercher sha256-<digest> |
--tlog-upload=false refusé, ou signature qui ne doit pas être publiée dans Rekor | Cosign 3.x refuse cette option avec sa configuration de signature par défaut, qui publie dans Rekor, et demande une configuration sans service de journal | Créer une configuration de signature vide et la passer avec --signing-config (commandes sous le tableau) |
Pod refusé avec connection refused | Backend d'ImagePolicyWebhook injoignable avec defaultAllow: false | Rétablir le backend : c'est le refus par défaut qui fait son travail |
| Clé introuvable dans le ConfigMap | La clé du ConfigMap ne s'appelle pas cosign.pub | Recréer le ConfigMap avec --from-file=cosign.pub=… |
Pour signer sans rien publier dans Rekor, reprenez la méthode du guide Cosign : cosign signing-config create écrit une configuration sans aucun service public, que cosign sign reçoit avec --signing-config (l'option -y évite la demande de confirmation). Comme aucun journal n'a été utilisé, la vérification demande --insecure-ignore-tlog=true.
cosign signing-config create --out signing-config.json # aucun service public
cosign sign --key cosign.key --signing-config signing-config.json \ --allow-http-registry -y \ localhost:5555/lab-signe@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab
cosign verify --key cosign.pub --insecure-ignore-tlog=true --allow-http-registry \ localhost:5555/lab-signe@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7abDans cette variante, la vérification ne contrôle plus l'inclusion dans un journal : c'est la clé publique seule qui engage la confiance.
Mettre en pratique
Section intitulée « Mettre en pratique »Le lab part d'un registre local monté sur le nœud, qui porte deux images non signées, appli/web:1.0 et appli/outil:1.0. Vous générez une paire de clés, signez appli/web:1.0 et publiez la clé publique dans le ConfigMap cosign-pub-key du namespace chaine-signature. Trois tests lisent l'état, jamais les commandes tapées : la clé publique est dans le ConfigMap sans trace de clé privée, la signature est poussée dans le registre, et la clé prise dans le ConfigMap accepte l'image signée et refuse l'autre.
À retenir
Section intitulée « À retenir »- Une signature prouve l'authenticité et l'intégrité, pas l'absence de vulnérabilité : le scan reste nécessaire.
- La clé privée reste sur la machine qui signe et n'entre jamais dans un objet du cluster ; seule
cosign.pubse publie, dans le ConfigMapcosign-pub-key. - On signe le digest résolu avec
crane digest, jamais le tag. - La signature par défaut de cosign 3.1.3 publie une entrée publique dans Rekor ; pour ne rien publier, on signe avec
--signing-config. - La signature est un artefact distinct, dans le même dépôt, sous le tag
sha256-<digest>avec cosign 3.x ; copier une image ne la copie pas. - Une vérification se prouve par son refus : 0 si la signature est valide, 1 si la clé est mauvaise, 10 si l'image n'est pas signée.
- Le cluster s'appuie sur la signature à l'admission (Kyverno, ImagePolicyWebhook) ; ImagePolicyWebhook relaie vers un backend dont dépend toute la sécurité, et
defaultAllow: falserefuse quand il est injoignable. - La signature keyless évite de garder une clé longue durée quand un fournisseur OIDC est disponible ; la signature par clé sert à comprendre le mécanisme et aux environnements isolés.
Contrôle de connaissances
Section intitulée « Contrôle de connaissances »Ces questions demandent de prédire le code de retour d'une vérification, de choisir ce qu'il faut signer et de diagnostiquer un échec de vérification ou d'admission.
Contrôle de connaissances
Validez vos connaissances avec ce quiz interactif
Informations
- Le chronomètre démarre au clic sur Démarrer
- Questions à choix multiples, vrai/faux et réponses courtes
- Vous pouvez naviguer entre les questions
- Les résultats détaillés sont affichés à la fin
Lance le quiz et démarre le chronomètre
Vérification
(0/0)Score par domaine
Un domaine regroupe plusieurs guides et reçoit plusieurs questions : son score est plus fiable qu'un score par thème, qui porte souvent sur une seule question.
Bilan
Points forts
Aucun sujet réussi à 80 % sur au moins deux questions pour l’instant.
Points faibles
Aucun sujet sous le seuil de réussite.
À faire ensuite
Des indices pour retenter votre chance ?
Continuer le cours : Image Scanning (Grype/Trivy)
Continuer le cours : Sécurité des conteneurs : de l'image au runtime
Nouveau quiz complet avec des questions aléatoires
Retravailler uniquement les questions ratées
Retour à la liste des certifications