Kapitel 5: Offline-Signatur und Herkunftsprüfung mit eigenem Vertrauensanker (Cosign, eigene PKI)
In diesem Kapitel lernst du:
- warum eine Signatur mehr leistet als ein Hash und was ein Vertrauensanker ist,
- wie sich Sigstore mit Fulcio und Rekor von einer Offline-Signatur mit eigener PKI unterscheidet,
- wie du mit OpenSSL eine Offline-Root-CA, eine Intermediate-CA und ein Code-Signing-Zertifikat erstellst,
- wie du Images und Attestations (SLSA Provenance, CycloneDX) mit Cosign ohne Transparenzlog signierst und prüfst,
- wie Schlüsselschutz, Rotation und Widerruf in der Praxis funktionieren und wie Kyverno Signaturen im Cluster erzwingt.
Worum geht es?
Denk an einen Brief mit Wachssiegel. Das Siegel zeigt zweierlei: Der Brief wurde nicht geöffnet, und er kommt vom Besitzer des Siegelrings. Damit das funktioniert, musst du aber wissen, wie das echte Siegel aussieht. Hast du nie ein Original gesehen, kann dir jeder einen Brief mit irgendeinem Siegel schicken.
Bei Software ist es genauso. Ein Hash zeigt nur: “Das ist dasselbe wie vorher.” Eine Signatur zeigt zusätzlich: “Das kommt von jemandem, der den privaten Schlüssel besitzt.” Und damit du einer Signatur glaubst, brauchst du einen Vertrauensanker (trust anchor). Das ist das Original-Siegel, das du vorab sicher bekommen hast: ein öffentlicher Schlüssel oder ein Root-Zertifikat.
In Kapitel 4 hast du Images über eine Zonengrenze gebracht und dabei eine Absender-Signatur auf das Bundle gesetzt. Jetzt signierst du das Image selbst. Die Signatur reist mit dem Image durch alle Zonen und kann überall geprüft werden, auch im Cluster beim Start eines Pods.
Offline (Tresor) Build-Zone Ziel-Zone / Cluster
+----------------+ +---------------------+ +------------------------+
| Root-CA | | Intermediate-CA | | Vertrauensanker: |
| root.key |---->| stellt aus: | | root.crt bzw. |
| (nur zum | sig | Code-Signing-Zert. | | cosign.pub |
| Ausstellen) | | | | | | |
+----------------+ | v | | v |
| cosign sign | Image + | cosign verify |
| Image@sha256:... |==Signatur=>| Kyverno verifyImages |
| cosign attest | + Attest. | -> Pod startet |
| SLSA, CycloneDX | | oder nicht |
+---------------------+ +------------------------+
Kein Transparenzlog, kein Internet: alles läuft mit eigenen Schlüsseln
Die Konzepte in einfach
Integrität und Herkunft
Zwei Fragen, die man gern verwechselt:
| Frage | Begriff | Werkzeug |
|---|---|---|
| Ist es unverändert? | Integrität | Hash, Digest |
| Von wem kommt es? | Herkunft (Authentizität) | Signatur |
| Wie wurde es gebaut? | Herkunftsnachweis (Provenance) | signierte Attestation |
| Darf es laufen? | Autorisierung | Policy (Kyverno, OPA) |
Ein Image-Digest beantwortet nur die erste Frage. Eine Cosign-Signatur verknüpft den Digest mit einem Schlüssel und beantwortet damit die zweite. Eine Attestation ist eine signierte Aussage über das Image, zum Beispiel “gebaut von Pipeline 4711 aus Commit abc123”. Die Policy im Cluster entscheidet schließlich, welche Signaturen und Aussagen sie verlangt.
Merke: Eine Signatur sagt nichts über die Qualität. Auch Schadsoftware kann gültig signiert sein, wenn der Schlüssel gestohlen wurde oder die Pipeline kompromittiert ist. Signaturen beweisen Herkunft, nicht Unbedenklichkeit.
Was Cosign eigentlich signiert
Cosign signiert nicht das ganze Image, sondern eine kleine JSON-Nutzlast (payload), die den Digest enthält:
{
"critical": {
"identity": { "docker-reference": "localhost:5001/demo-app" },
"image": { "docker-manifest-digest": "sha256:3f1c..." },
"type": "cosign container image signature"
},
"optional": null
}Weil der Digest alle Schichten über ihre Hashes einschließt, deckt
die Signatur das gesamte Image ab. Die Signatur selbst legt Cosign in
derselben Registry ab. Cosign v2 nutzt dafür einen Tag
sha256-<hex>.sig. Cosign v3 speichert standardmäßig
ein Sigstore-Bundle als OCI-Referrer.
Der Vertrauensanker
Ein Vertrauensanker ist der Punkt, an dem deine Prüfkette endet. Du glaubst ihm, ohne ihn weiter zu prüfen. Deshalb ist die wichtigste Frage: Wie kommt der Anker sicher an den Ort der Prüfung?
- Schlüsselbasiert: Der Anker ist
cosign.pub. Er steht in der Policy, in einer ConfigMap oder in einem Repo mit geschütztem Zugriff. - Zertifikatsbasiert: Der Anker ist das Root-Zertifikat deiner eigenen CA. Signiert wird mit Zertifikaten, die diese CA ausgestellt hat. Die Policy prüft die Kette bis zur Root und zusätzlich die Identität im Zertifikat.
Der zertifikatsbasierte Weg skaliert besser. Du verteilst einmal das Root-Zertifikat und kannst dann viele Signierer mit eigenen Zertifikaten ausstatten, ohne jede Policy anzufassen.
Sigstore öffentlich oder eigene PKI
Sigstore ist das Projekt hinter Cosign. Es bietet einen öffentlichen Dienst für schlüssellose Signaturen (keyless signing):
- Fulcio ist eine CA. Sie stellt nach einem OIDC-Login (zum Beispiel über GitHub oder Google) ein Zertifikat aus, das nur etwa zehn Minuten gilt.
- Rekor ist ein öffentliches Transparenzlog (transparency log). Jede Signatur wird dort unveränderlich eingetragen, mit Zeitstempel.
- Der kurzlebige Schlüssel wird nach dem Signieren weggeworfen. Es gibt also keinen langlebigen Schlüssel, der gestohlen werden könnte.
Für viele Open-Source-Projekte ist das ideal. In einer Behörde oder einem air-gapped Netz geht es oft nicht:
| Aspekt | Sigstore öffentlich | Offline mit eigener PKI |
|---|---|---|
| Internet nötig | ja (Fulcio, Rekor, OIDC) | nein |
| Vertrauensanker | Sigstore-Root (TUF) | eigene Root-CA oder eigener Schlüssel |
| Metadaten öffentlich | ja, Identität und Digest im Log | nein |
| Zeitnachweis | Rekor-Eintrag | eigener Zeitstempeldienst (TSA) oder keiner |
| Schlüsselschutz | entfällt (kurzlebig) | deine Aufgabe (HSM, KMS) |
Ein oft übersehener Punkt: Im öffentlichen Rekor landen E-Mail-Adressen und Image-Namen. Für interne Projekte kann das schon ein Datenabfluss sein. Wer Sigstore trotzdem will, kann Fulcio, Rekor und einen Zeitstempeldienst auch selbst betreiben. Das ist eine eigene Sigstore-Instanz, also mehr Betriebsaufwand. In diesem Kapitel gehst du den schlanken Weg: eigene Schlüssel, eigene PKI, kein Transparenzlog.
Eine kleine PKI
PKI steht für Public Key Infrastructure. Eine typische Struktur hat drei Ebenen:
Root-CA offline, ca. 10 Jahre, stellt nur Intermediates aus
|
+-- Intermediate-CA eingeschränkt, ca. 5 Jahre, stellt Signierer aus
|
+-- Signierzertifikat kurz gültig, z. B. 1 Jahr, signiert Images
Die Root-CA ist offline. Ihr Schlüssel liegt im Tresor oder in einem HSM ohne Netzanschluss. Sie wird nur selten benutzt, etwa um eine neue Intermediate-CA auszustellen. Wird die Intermediate kompromittiert, sperrst du sie und stellst eine neue aus. Der Vertrauensanker, also das Root-Zertifikat, bleibt gleich.
Zertifikate haben Erweiterungen (extensions), die festlegen, was sie dürfen. Diese Einschränkungen (constraints) sind dein Sicherheitsnetz:
| Erweiterung | Bedeutung | Beispiel |
|---|---|---|
basicConstraints |
Ist es eine CA? Wie tief darf die Kette werden? | CA:true, pathlen:0 |
keyUsage |
Wofür der Schlüssel taugt | keyCertSign oder digitalSignature |
extendedKeyUsage |
Verwendungszweck | codeSigning |
subjectAltName |
Identität des Inhabers | email:release-signer@... |
pathlen:0 an der Intermediate heißt: Unter ihr darf
keine weitere CA entstehen. extendedKeyUsage = codeSigning
an der Intermediate heißt: Alles, was sie ausstellt, taugt nur zum
Code-Signieren, nicht etwa als TLS-Serverzertifikat. Cosign prüft beim
Verifizieren, dass die Kette den Zweck Code-Signing erlaubt.
Schlüsselschutz
Der private Schlüssel ist das Siegel. Wer ihn hat, kann in deinem Namen signieren. Die Schutzstufen:
| Stufe | Wo liegt der Schlüssel? | Einsatz |
|---|---|---|
| Datei | verschlüsselt auf der Platte (cosign.key) |
Lab, kleine Teams |
| KMS | in einem Key-Management-Dienst, nie exportierbar | Pipelines |
| Vault Transit | in HashiCorp Vault bzw. OpenBao, Signatur per API | eigener Betrieb |
| HSM | Hardware-Sicherheitsmodul, auch physisch geschützt | Root-CA, hoher Schutzbedarf |
Cosign spricht diese Ziele direkt über URIs an, etwa
--key hashivault://cosign für einen Vault-Transit-Schlüssel
(mit gesetzten VAULT_ADDR und VAULT_TOKEN),
awskms://, gcpkms:// oder
azurekms://. HSMs werden über PKCS#11 angebunden. Das
Prinzip ist immer gleich: Die Pipeline schickt den Hash zum Signieren
hin, der Schlüssel verlässt nie den geschützten Ort. Vault richtest du
in Kapitel 6 ein.
Attestations, in-toto und SLSA
Eine Attestation ist eine signierte Aussage über ein Artefakt. Cosign nutzt dafür das Format von in-toto. Eine in-toto-Aussage (statement) hat drei Teile:
{
"_type": "https://in-toto.io/Statement/v1",
"subject": [{ "name": "localhost:5001/demo-app",
"digest": { "sha256": "3f1c..." } }],
"predicateType": "https://slsa.dev/provenance/v1",
"predicate": { "...": "die eigentliche Aussage" }
}subject sagt, worüber gesprochen wird (per Digest).
predicateType sagt, welche Art Aussage es ist.
predicate ist der Inhalt. Die Aussage wird in einen
DSSE-Umschlag (Dead Simple Signing Envelope) gepackt
und signiert.
Typische Prädikate:
- SLSA Provenance: Wer hat wann, womit und aus welchem Quellstand gebaut. SLSA (Supply-chain Levels for Software Artifacts, gesprochen “Salsa”) definiert dafür ein Format und Stufen. Ab Build Level 2 muss die Provenance vom Build-System signiert sein, nicht vom Entwickler.
- CycloneDX oder SPDX: die SBOM als signierte Aussage (siehe Kapitel 7).
- Vulnerability Scan: das Ergebnis eines Scans zu einem Zeitpunkt (siehe Kapitel 8).
Im Cluster kann eine Policy dann nicht nur fragen “Ist das Image signiert?”, sondern auch “Wurde es von unserer Pipeline aus dem main-Branch gebaut?”.
Rotation und Widerruf
Schlüssel leben nicht ewig. Gründe für einen Wechsel sind ein geplanter Turnus, ein Personalwechsel oder ein Verdacht auf Kompromittierung.
Rotation (geplant) läuft mit Überlappung ab:
- Neues Schlüsselpaar oder neues Zertifikat erzeugen.
- Policy so ändern, dass alter und neuer Schlüssel akzeptiert werden.
- Pipeline auf den neuen Schlüssel umstellen. Laufende Images bei Bedarf neu signieren.
- Nach einer Übergangsfrist den alten Schlüssel aus der Policy entfernen.
Widerruf (Notfall) ist schwieriger, als man denkt. Cosign prüft keine Sperrlisten (CRL) und kein OCSP. Ein gesperrtes Zertifikat wird also nicht automatisch abgelehnt. Widerruf heißt in der Praxis:
- Den Schlüssel bzw. die Identität aus allen Policies entfernen.
- Bei einer kompromittierten Intermediate-CA eine neue Intermediate ausstellen und die alte nicht mehr in der Prüfung akzeptieren.
- Alle legitimen Images mit dem neuen Schlüssel neu signieren.
Darum sind kurze Laufzeiten so wertvoll: Ein Zertifikat, das nach 30 Tagen abläuft, muss man nicht lange sperren. Der Haken: Ohne vertrauenswürdigen Zeitstempel prüft Cosign die Gültigkeit zum aktuellen Zeitpunkt. Ein abgelaufenes Zertifikat macht dann auch alte, korrekte Signaturen ungültig. Abhilfe schafft ein eigener Zeitstempeldienst nach RFC 3161 (Time Stamping Authority, TSA). Er bestätigt, dass die Signatur entstand, als das Zertifikat noch gültig war.
Hands-on-Lab: Eigene PKI und Offline-Signaturen mit Cosign
Voraussetzungen: Kapitel 0 und 4. Die Registry reg-build
enthält demo-app:1.0.0, und cosign,
crane, syft, jq und OpenSSL sind
installiert.
Achtung: Für die PKI brauchst du OpenSSL 3.x. Das
opensslvon macOS ist LibreSSL und kennt einige Optionen nicht. Installiere OpenSSL 3 mitbrew install openssl@3und stelle$(brew --prefix openssl@3)/binvorne in denPATH.
Schritt 1: Vorbereitung und Cosign-Version
mkdir -p ~/seclab/pki/{root,intermediate} ~/seclab/kap05
cd ~/seclab/kap05
docker start reg-build reg-ziel
openssl version
cosign version | grep GitVersion
DIGEST=$(crane digest localhost:5001/demo-app:1.0.0)
IMAGE="localhost:5001/demo-app@${DIGEST}"
echo "$IMAGE"Erwartete Ausgabe (Versionen können abweichen):
OpenSSL 3.3.2 3 Sep 2024 (Library: OpenSSL 3.3.2 3 Sep 2024)
GitVersion: v2.4.1
localhost:5001/demo-app@sha256:3f1c...
Cosign hat sich zwischen v2 und v3 beim Offline-Signieren geändert. Damit die Befehle in diesem Kapitel für beide Versionen funktionieren, legst du die Offline-Optionen einmal in einem Array ab. Arrays funktionieren in bash und zsh gleich.
Für cosign v2.x:
OFFLINE=(--tlog-upload=false)Für cosign v3.x erzeugst du stattdessen eine leere Signing-Config ohne Transparenzlog und ohne Fulcio:
cosign signing-config create --out ~/seclab/kap05/signing-config-offline.json
cat ~/seclab/kap05/signing-config-offline.json
OFFLINE=(--signing-config "$HOME/seclab/kap05/signing-config-offline.json")Erwartete Ausgabe von cat:
{"mediaType":"application/vnd.dev.sigstore.signingconfig.v0.2+json",
"rekorTlogConfig":{}, "tsaConfig":{}}
Tipp: In cosign v3 funktioniert auch noch
--use-signing-config=false --tlog-upload=false, ist aber als veraltet markiert. Bei Zweifeln hilftcosign sign --help.
Schritt 2: Die Offline-Root-CA
Zuerst die Konfiguration. Sie enthält den Namen der Root-CA und zwei Profile: eines für die Root selbst und eines für die Intermediates, die sie ausstellt.
cat > ~/seclab/pki/root/root.cnf <<'EOF'
[ req ]
distinguished_name = dn
prompt = no
[ dn ]
C = DE
O = Seclab Lab
CN = Seclab Offline Root CA
[ v3_root ]
basicConstraints = critical, CA:true, pathlen:1
keyUsage = critical, keyCertSign, cRLSign
subjectKeyIdentifier = hash
[ v3_intermediate ]
basicConstraints = critical, CA:true, pathlen:0
keyUsage = critical, keyCertSign, cRLSign
extendedKeyUsage = codeSigning
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always
EOFJetzt Schlüssel und selbstsigniertes Zertifikat. Das Passwort ist ein Lab-Wert. In echt kommt es aus einem Tresor oder liegt gar nicht vor, weil der Schlüssel im HSM steckt.
cd ~/seclab/pki/root
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-384 \
-aes-256-cbc -pass pass:lab-root-pass -out root.key
chmod 400 root.key
openssl req -x509 -new -key root.key -passin pass:lab-root-pass \
-config root.cnf -extensions v3_root -sha384 -days 3650 -out root.crt
openssl x509 -in root.crt -noout -subject -enddate \
-ext basicConstraints,keyUsageErwartete Ausgabe:
subject=C=DE, O=Seclab Lab, CN=Seclab Offline Root CA
notAfter=Oct 6 09:00:00 2036 GMT
X509v3 Basic Constraints: critical
CA:TRUE, pathlen:1
X509v3 Key Usage: critical
Certificate Sign, CRL Sign
Schritt 3: Die Intermediate-CA
cat > ~/seclab/pki/intermediate/intermediate.cnf <<'EOF'
[ req ]
distinguished_name = dn
prompt = no
[ dn ]
C = DE
O = Seclab Lab
CN = Seclab Code Signing CA 1
[ v3_codesign ]
basicConstraints = critical, CA:false
keyUsage = critical, digitalSignature
extendedKeyUsage = critical, codeSigning
subjectAltName = email:[email protected]
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always
EOFDas Profil v3_codesign beschreibt, wie die
Signierzertifikate aussehen, die diese CA ausstellt. Jetzt Schlüssel,
Antrag (CSR, Certificate Signing Request) und Unterschrift durch die
Root:
cd ~/seclab/pki/intermediate
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-384 \
-aes-256-cbc -pass pass:lab-int-pass -out intermediate.key
chmod 400 intermediate.key
openssl req -new -key intermediate.key -passin pass:lab-int-pass \
-config intermediate.cnf -out intermediate.csr
openssl x509 -req -in intermediate.csr \
-CA ../root/root.crt -CAkey ../root/root.key -passin pass:lab-root-pass \
-CAcreateserial -days 1825 -sha384 \
-extfile ../root/root.cnf -extensions v3_intermediate \
-out intermediate.crt
openssl verify -CAfile ../root/root.crt intermediate.crtErwartete Ausgabe:
Certificate request self-signature ok
subject=C=DE, O=Seclab Lab, CN=Seclab Code Signing CA 1
intermediate.crt: OK
Ab jetzt würde die Root-CA in echt wieder in den Tresor wandern. Im
Lab bleibt sie liegen, aber merke dir: root.key wird in
diesem Kapitel nicht mehr angefasst.
Schritt 4: Das Signierzertifikat
Der Signierer bekommt einen eigenen Schlüssel. Ohne Passwort, weil du ihn gleich in das Cosign-Format importierst und dort verschlüsselst.
cd ~/seclab/kap05
cat > signer.cnf <<'EOF'
[ req ]
distinguished_name = dn
prompt = no
[ dn ]
C = DE
O = Seclab Lab
CN = release-signer
EOF
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-256 -out signer.key
chmod 600 signer.key
openssl req -new -key signer.key -config signer.cnf -out signer.csr
openssl x509 -req -in signer.csr \
-CA ~/seclab/pki/intermediate/intermediate.crt \
-CAkey ~/seclab/pki/intermediate/intermediate.key -passin pass:lab-int-pass \
-CAcreateserial -days 365 -sha256 \
-extfile ~/seclab/pki/intermediate/intermediate.cnf -extensions v3_codesign \
-out signer.crtPrüfe die ganze Kette und baue die Datei chain.pem.
Cosign erwartet die Reihenfolge: zuerst die Intermediate, am Ende die
Root.
openssl verify -CAfile ~/seclab/pki/root/root.crt \
-untrusted ~/seclab/pki/intermediate/intermediate.crt signer.crt
cat ~/seclab/pki/intermediate/intermediate.crt ~/seclab/pki/root/root.crt \
> ~/seclab/pki/chain.pem
openssl x509 -in signer.crt -noout -ext extendedKeyUsage,subjectAltNameErwartete Ausgabe:
signer.crt: OK
X509v3 Extended Key Usage: critical
Code Signing
X509v3 Subject Alternative Name:
email:[email protected]
Schritt 5: Cosign-Schlüsselpaar und erste Offline-Signatur
Jetzt der einfachste Weg: ein Cosign-Schlüsselpaar ohne Zertifikat. Cosign fragt nach einem Passwort. Für das Lab setzt du es per Umgebungsvariable.
cd ~/seclab/kap05
export COSIGN_PASSWORD='lab-cosign-pass' # nur Lab-Wert!
cosign generate-key-pair
ls -l cosign.*Erwartete Ausgabe:
Private key written to cosign.key
Public key written to cosign.pub
-rw------- 1 thomas staff 653 Oct 8 09:30 cosign.key
-rw-r--r-- 1 thomas staff 178 Oct 8 09:30 cosign.pub
Signiere das Image per Digest. Niemals per Tag: Ein Tag kann umgebogen werden, ein Digest nicht.
cosign sign --key cosign.key "${OFFLINE[@]}" -y "$IMAGE"Erwartete Ausgabe (cosign v2):
Pushing signature to: localhost:5001/demo-app
Wo liegt die Signatur? Schau in die Registry:
crane ls localhost:5001/demo-appBei cosign v2 siehst du einen neuen Tag
sha256-<hex>.sig. Bei cosign v3 liegt die Signatur
als Referrer am Image. Dann zeigt
oras discover --plain-http "$IMAGE" einen Eintrag vom Typ
application/vnd.dev.sigstore.bundle....
Schritt 6: Verifizieren und Gegenprobe
cosign verify --key cosign.pub --insecure-ignore-tlog=true "$IMAGE" | jq .Erwartete Ausgabe (gekürzt):
WARNING: Skipping tlog verification is an insecure practice that lacks transparency
and auditability verification for the signature.
Verification for localhost:5001/demo-app@sha256:3f1c... --
The following checks were performed on each of these signatures:
- The cosign claims were validated
- The signatures were verified against the specified public key
Danach folgt die signierte Nutzlast als JSON mit
docker-manifest-digest. Die Warnung ist hier gewollt. Du
verzichtest bewusst auf das öffentliche Transparenzlog.
Jetzt die Gegenprobe. Eine Prüfung, die nie fehlschlägt, ist keine Prüfung. Erzeuge einen fremden Schlüssel und prüfe damit:
cosign generate-key-pair --output-key-prefix fremd
cosign verify --key fremd.pub --insecure-ignore-tlog=true "$IMAGE"
echo "Exit-Code: $?"Erwartete Ausgabe:
Error: no matching signatures: ...
Exit-Code: 1
Diesen Exit-Code nutzt du in Pipelines und Skripten. Ungleich 0 heißt: nicht verwenden.
Schritt 7: Signieren mit Zertifikat und Kette
Jetzt kommt die eigene PKI ins Spiel. Cosign braucht den Signierschlüssel im eigenen Format. Importiere ihn:
cd ~/seclab/kap05
cosign import-key-pair --key signer.key --output-key-prefix signer-cosignErwartete Ausgabe:
Private key written to signer-cosign.key
Public key written to signer-cosign.pub
Jetzt signierst du mit Schlüssel, Zertifikat und Kette. Das Zertifikat wird in die Signatur eingebettet. Wer prüft, braucht dann nur noch das Root-Zertifikat.
Für cosign v2.x:
cosign sign --key signer-cosign.key \
--certificate signer.crt --certificate-chain ~/seclab/pki/chain.pem \
--tlog-upload=false -y "$IMAGE"Für cosign v3.x übergibst du zusätzlich deinen
eigenen Vertrauensanker als Trusted Root. Das ist eine JSON-Datei im
Sigstore-Format. Cosign kann sie aus deiner Kette erzeugen. Das Feld
heißt --fulcio, weil es den Platz der CA einnimmt. Die URL
ist dabei nur ein Etikett.
cosign trusted-root create \
--fulcio="url=https://pki.seclab.example,certificate-chain=$HOME/seclab/pki/chain.pem" \
--out ~/seclab/kap05/trusted-root.json
cosign sign --key signer-cosign.key \
--certificate signer.crt --certificate-chain ~/seclab/pki/chain.pem \
--trusted-root ~/seclab/kap05/trusted-root.json "${OFFLINE[@]}" -y "$IMAGE"Beim Prüfen gibst du die Kette (v2) bzw. die Trusted Root (v3) an und dazu die erwartete Identität. Das OIDC-Issuer-Feld gibt es in deinen Zertifikaten nicht, weil sie nicht von Fulcio kommen. Deshalb akzeptierst du dort jeden Wert. Auf ein SCT (Signed Certificate Timestamp aus einem öffentlichen CT-Log) verzichtest du ebenfalls.
Für cosign v2.x:
cosign verify \
--certificate-chain ~/seclab/pki/chain.pem \
--certificate-identity [email protected] \
--certificate-oidc-issuer-regexp '.*' \
--insecure-ignore-sct=true --insecure-ignore-tlog=true \
"$IMAGE" > /dev/null && echo "Kette ok"Ab cosign v2.4 gibt es alternativ --ca-roots und
--ca-intermediates. Für cosign v3.x:
cosign verify \
--trusted-root ~/seclab/kap05/trusted-root.json --allow-certificate-chain \
--certificate-identity [email protected] \
--certificate-oidc-issuer-regexp '.*' \
--insecure-ignore-sct=true --insecure-ignore-tlog=true \
"$IMAGE" > /dev/null && echo "Kette ok"Erwartete Ausgabe in beiden Fällen: die Tlog-Warnung, die Zeilen
“Verification for …” und am Ende Kette ok.
Achtung: Die Optionen für eigene CAs haben sich zwischen den Cosign-Versionen mehrfach geändert. In v3 sind
--certificate-chainund--ca-rootsbeim Verifizieren als veraltet markiert und werden durch--trusted-rootersetzt. Prüfe bei Fehlermeldungen zuerstcosign verify --helpdeiner Version.
Gegenprobe mit falscher Identität (v2-Variante, für v3 die Optionen wie oben tauschen):
cosign verify \
--certificate-chain ~/seclab/pki/chain.pem \
--certificate-identity [email protected] \
--certificate-oidc-issuer-regexp '.*' \
--insecure-ignore-sct=true --insecure-ignore-tlog=true "$IMAGE"Erwartete Ausgabe: ein Fehler mit dem Hinweis, dass die erwartete
Identität (SAN) nicht gefunden wurde, etwa
expected SAN value "[email protected]", got "[email protected]".
Die Kette allein reicht also nicht. Die Policy legt fest, welche
Identität signieren darf.
Schritt 8: Attestations für Provenance und SBOM
Jetzt signierst du Aussagen über das Image. Zuerst ein SLSA-Provenance-Prädikat im Format v1. Normalerweise erzeugt es die Pipeline (siehe Kapitel 1 und 2). Hier schreibst du es von Hand, um den Aufbau zu sehen.
cd ~/seclab/kap05
COMMIT=$(git -C ~/seclab/demo-app rev-parse HEAD 2>/dev/null \
|| echo 0000000000000000000000000000000000000000)
cat > provenance.json <<EOF
{
"buildDefinition": {
"buildType": "https://seclab.example/buildtypes/docker-build@v1",
"externalParameters": {
"repository": "https://gitlab.seclab.example/team/demo-app",
"ref": "refs/tags/v1.0.0"
},
"internalParameters": {},
"resolvedDependencies": [{
"uri": "git+https://gitlab.seclab.example/team/demo-app@refs/tags/v1.0.0",
"digest": { "gitCommit": "${COMMIT}" }
}]
},
"runDetails": {
"builder": { "id": "https://gitlab.seclab.example/runners/build-01" },
"metadata": {
"invocationId": "pipeline-4711",
"startedOn": "2026-10-08T08:00:00Z",
"finishedOn": "2026-10-08T08:04:12Z"
}
}
}
EOF
jq . provenance.json > /dev/null && echo "JSON ok"Signiere die Aussage als Attestation. slsaprovenance1
steht für den Typ https://slsa.dev/provenance/v1. Ältere
Cosign-Versionen ohne diesen Kurznamen akzeptieren die URI direkt als
--type.
cosign attest --key cosign.key "${OFFLINE[@]}" -y \
--type slsaprovenance1 --predicate provenance.json "$IMAGE"Jetzt die SBOM als zweite Attestation:
syft localhost:5001/demo-app:1.0.0 -o cyclonedx-json=sbom.cdx.json
cosign attest --key cosign.key "${OFFLINE[@]}" -y \
--type cyclonedx --predicate sbom.cdx.json "$IMAGE"Prüfe die Provenance und schau in den Umschlag hinein. Die Nutzlast ist Base64-kodiert:
cosign verify-attestation --key cosign.pub --insecure-ignore-tlog=true \
--type slsaprovenance1 "$IMAGE" 2>/dev/null \
| jq -r .payload | head -1 | base64 -d \
| jq '{type: .predicateType, subject: .subject[0].digest,
builder: .predicate.runDetails.builder.id}'Erwartete Ausgabe:
{
"type": "https://slsa.dev/provenance/v1",
"subject": { "sha256": "3f1c..." },
"builder": "https://gitlab.seclab.example/runners/build-01"
}Der Digest im subject muss dein $DIGEST
sein, ohne das Präfix sha256:. Damit ist die Aussage fest
an genau dieses Image gebunden.
Tipp:
cosign verify-attestationkann zusätzlich eine Policy in CUE oder Rego prüfen (--policy). So kannst du etwa erzwingen, dassbuilder.idzu deinen Runnern gehört. Ausführlich behandelt Kapitel 9 solche Regeln.
Schritt 9: Vorgriff auf Kapitel 9 - Kyverno prüft Signaturen
Im Cluster soll kein Pod mit unsigniertem Image starten. Kyverno ist
ein Admission Controller, der Anfragen an die Kubernetes-API prüft. Die
Regel verifyImages ruft dabei im Grunde dasselbe auf wie
cosign verify. Erzeuge die Policy mit deinem öffentlichen
Schlüssel:
cd ~/seclab/kap05
{
cat <<'EOF'
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: demo-app-signiert
spec:
validationFailureAction: Enforce
webhookTimeoutSeconds: 30
rules:
- name: cosign-signatur-pruefen
match:
any:
- resources:
kinds: ["Pod"]
namespaces: ["demo"]
verifyImages:
- imageReferences:
- "reg-build:5000/demo-app*"
- "reg-ziel:5000/demo-app*"
mutateDigest: true
verifyDigest: true
required: true
attestors:
- entries:
- keys:
rekor:
ignoreTlog: true
ctlog:
ignoreSCT: true
publicKeys: |-
EOF
sed 's/^/ /' cosign.pub
} > kyverno-verify-images.yaml
yq '.spec.rules[0].verifyImages[0].attestors[0].entries[0].keys.publicKeys' \
kyverno-verify-images.yamlErwartete Ausgabe: dein öffentlicher Schlüssel zwischen
-----BEGIN PUBLIC KEY----- und
-----END PUBLIC KEY-----. Damit ist die YAML-Einrückung
korrekt.
Was passiert hier? mutateDigest: true ersetzt den Tag im
Pod durch den geprüften Digest. Der Cluster startet also genau das
Image, dessen Signatur geprüft wurde. ignoreTlog und
ignoreSCT sind das Gegenstück zu den
--insecure-ignore-...-Optionen von Cosign. Anwenden und
testen wirst du die Policy in Kapitel 9. Dort klärst du auch, wie
Kyverno die HTTP-Registry im Lab erreicht.
Schritt 10: Aufräumen und Schlüssel sichern
cd ~/seclab/kap05
rm -f fremd.key fremd.pub signer.csr
chmod 600 cosign.key signer-cosign.key signer.key
unset COSIGN_PASSWORD
ls -l ~/seclab/pki/root ~/seclab/pki/intermediate ~/seclab/kap05
docker stop reg-build reg-zielBehalte cosign.key, cosign.pub, die PKI und
chain.pem. Die Kapitel 9 und 11 bauen darauf auf. Lösche
signer.key, wenn du ihn nicht mehr brauchst: Der
importierte signer-cosign.key ist der verschlüsselte
Ersatz.
Fortschritt speichern? Kostenlos registrieren
Typische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
--tlog-upload=false is not supported with --signing-config |
cosign v3 | Leere Signing-Config nutzen (Schritt 1) |
no matching signatures trotz Signatur |
Falscher Schlüssel oder per Tag signiert, Tag zeigt jetzt woanders hin | Per Digest signieren und prüfen, Schlüssel vergleichen |
x509: certificate signed by unknown authority |
Kette unvollständig oder falsche Reihenfolge | chain.pem = Intermediate, dann Root |
x509: certificate specifies an incompatible key usage |
EKU codeSigning fehlt an Blatt oder Intermediate |
Profil v3_codesign und v3_intermediate
prüfen |
certificate has expired bei altem Image |
Kein Zeitstempel, Prüfung zum aktuellen Zeitpunkt | TSA nutzen oder rechtzeitig neu signieren |
unknown option -ext |
LibreSSL statt OpenSSL 3 | brew install openssl@3, PATH anpassen |
HTTPS-Fehler gegen localhost:5001 |
Registry spricht nur HTTP | In cosign v3 ggf. --allow-http-registry setzen |
Übung: Die Signatur reist durch die Schleuse
In Kapitel 4 hast du demo-app:1.0.0 nach
reg-ziel übertragen, damals noch ohne Signatur. Jetzt ist
das Image signiert und hat zwei Attestations.
Aufgabe:
- Übertrage Image, Signaturen und Attestations von
localhost:5001nachlocalhost:5002. - Prüfe in der Zielzone mit
cosign verifynur mitcosign.pub, dass die Signatur gültig ist. - Prüfe auch die SLSA-Provenance in der Zielzone.
- Erkläre, warum die Prüfung gelingt, obwohl die Registry jetzt anders heißt als beim Signieren.
Hinweis 1: Für die Übertragung hast du in Kapitel 4
oras cp -r kennengelernt. Signaturen von cosign v2 sind
keine echten Referrer, sondern liegen unter eigenen Tags. Welche Tags
musst du also zusätzlich kopieren? Alternativ gibt es
cosign save --dir und cosign load --dir.
Hinweis 2: Schau dir noch einmal die signierte
Nutzlast im Konzeptteil an. Welches Feld prüft Cosign streng, und
welches nennt nur den ursprünglichen Ort? Was bleibt beim Kopieren mit
oras gleich?
Lösung
Übertragung direkt von Registry zu Registry (im echten Leben über das Bundle aus Kapitel 4):
docker start reg-build reg-ziel
DIGEST=$(crane digest localhost:5001/demo-app:1.0.0)
HEX="${DIGEST#sha256:}"
oras cp -r --from-plain-http --to-plain-http \
"localhost:5001/demo-app@${DIGEST}" localhost:5002/demo-app:1.0.0
for T in $(crane ls localhost:5001/demo-app \
| grep -E "^sha256-${HEX}\.(sig|att)$" || true); do
oras cp --from-plain-http --to-plain-http \
"localhost:5001/demo-app:${T}" "localhost:5002/demo-app:${T}"
done
crane ls localhost:5002/demo-appBei cosign v2 zeigt crane ls danach 1.0.0,
sha256-<hex>.sig und
sha256-<hex>.att. Bei cosign v3 hat
oras cp -r die Sigstore-Bundles als Referrer schon
mitgenommen.
Prüfung in der Zielzone:
cd ~/seclab/kap05
ZIEL="localhost:5002/demo-app@${DIGEST}"
cosign verify --key cosign.pub --insecure-ignore-tlog=true "$ZIEL" > /dev/null \
&& echo "Signatur in Zone B gültig"
cosign verify-attestation --key cosign.pub --insecure-ignore-tlog=true \
--type slsaprovenance1 "$ZIEL" > /dev/null && echo "Provenance in Zone B gültig"Erwartete Ausgabe (neben den Tlog-Warnungen):
Signatur in Zone B gültig
Provenance in Zone B gültig
Warum funktioniert das? Die Signatur hängt am Digest
(docker-manifest-digest), nicht am Registry-Namen.
oras cp kopiert Manifeste byte-genau, also bleibt der
Digest gleich. Das Feld docker-reference in der Nutzlast
nennt zwar noch localhost:5001/demo-app, aber Cosign prüft
standardmäßig den Digest, nicht diesen Namen. Hättest du das Image mit
einem Werkzeug kopiert, das das Manifest umschreibt, wäre der Digest neu
und die Signatur wertlos. Genau deshalb hat Kapitel 4 so viel Wert auf
Digest-Treue gelegt.
Alternative mit Cosign-Bordmitteln:
cosign save --dir ~/seclab/kap05/export "localhost:5001/demo-app@${DIGEST}"
cosign load --dir ~/seclab/kap05/export localhost:5002/demo-appFortschritt speichern? Kostenlos registrieren
Aus der Praxis
Schlüsselzeremonie. In regulierten Umgebungen wird eine Root-CA in einer Schlüsselzeremonie (key ceremony) erzeugt: offline, auf einem dedizierten Rechner oder direkt im HSM, mit mehreren Personen, Protokoll und Video. Der Schlüssel wird oft per Secret Sharing aufgeteilt, sodass etwa drei von fünf Verwahrern zusammenkommen müssen. Die Root wird danach nur für neue Intermediates oder Sperrungen hervorgeholt.
Wer signiert? Nicht der Entwickler-Laptop, sondern die Pipeline. Der Signierschlüssel liegt in einem KMS, in Vault Transit oder einem HSM. Die Pipeline darf ihn nur aus geschützten Branches und nach bestandenen Prüfungen benutzen. So bedeutet eine Signatur “durch unseren kontrollierten Prozess gegangen” und nicht nur “jemand hatte den Schlüssel”. In Organisationen mit Schleuse (Kapitel 4) signiert man oft zweimal: einmal die Build-Pipeline, einmal die Freigabe in der Zielzone. Der Cluster verlangt dann beide Signaturen.
Identitäten statt Schlüssel. Mit eigener PKI kannst
du jedem Team oder jeder Pipeline ein eigenes Zertifikat geben, etwa mit
der SAN [email protected]. Die Policy prüft Root und
Identität. Kommt ein Team dazu, stellst du ein Zertifikat aus, ohne
Policies im Cluster zu ändern.
Laufzeiten und Erneuerung. Bewährt haben sich kurze Laufzeiten für Signierzertifikate (Wochen bis wenige Monate) mit automatischer Erneuerung, mittlere für Intermediates und lange für die Root. Ablaufdaten gehören ins Monitoring. Ein abgelaufenes Signierzertifikat ohne Zeitstempel kann über Nacht alle Deployments blockieren.
Eigener Zeitstempeldienst. Wer Signaturen über Jahre
prüfbar halten muss, etwa wegen Aufbewahrungspflichten, betreibt eine
eigene TSA nach RFC 3161. Cosign kann beim Signieren einen Zeitstempel
einholen (--timestamp-server-url in v2, in v3 über die
Signing-Config) und beim Prüfen auswerten
(--use-signed-timestamps).
Eigene Sigstore-Instanz. Größere Organisationen betreiben Fulcio, Rekor und TSA intern, angebunden an das eigene Identitätsmanagement (zum Beispiel Keycloak als OIDC-Anbieter). Das bringt Keyless-Komfort und ein Transparenzlog ohne öffentliche Metadaten, kostet aber Betrieb und Hochverfügbarkeit.
Audit. Prüfer fragen nach: Wo liegt der Root-Schlüssel, wer hat Zugriff, wann wurde er zuletzt benutzt, wie läuft ein Widerruf ab, wurde er geübt? Halte ein PKI-Betriebshandbuch (Certificate Policy und Certification Practice Statement, in klein) und ein Notfall-Runbook bereit. Protokolliere jede Signatur der Pipeline mit Digest, Schlüssel-ID und Pipeline-ID zentral.
Interviewfragen
F: Was ist der Unterschied zwischen Integrität und Herkunft, und welches Werkzeug liefert was?
A: Integrität heißt unverändert, das liefert der Digest. Herkunft heißt von einem bestimmten Inhaber, das liefert die Signatur über den Digest, geprüft gegen einen Vertrauensanker. Wie gebaut wurde, beschreibt eine signierte Provenance-Attestation.
F: Warum signiert man per Digest und nicht per Tag?
A: Ein Tag ist ein veränderlicher Zeiger. Signiere ich per Tag und der Tag wird umgebogen, prüfe ich womöglich ein anderes Image als gedacht. Cosign signiert ohnehin den Digest. Beim Aufruf per Digest ist aber eindeutig, welches Image gemeint ist.
F: Wann würdest du Sigstore Keyless nicht einsetzen?
A: Wenn keine Internetverbindung zu Fulcio, Rekor und dem OIDC-Anbieter besteht (air-gapped) oder wenn Identitäten und Image-Namen nicht in einem öffentlichen Log landen dürfen. Dann eigene Schlüssel bzw. eigene PKI oder eine selbst betriebene Sigstore-Instanz.
F: Wie widerrufst du einen kompromittierten Signierschlüssel?
A: Cosign prüft keine CRL oder OCSP. Also entferne ich den Schlüssel bzw. die Identität sofort aus allen Policies, stelle einen neuen Schlüssel oder ein neues Zertifikat aus, signiere legitime Images neu und prüfe, was mit dem alten Schlüssel signiert wurde. Kurze Zertifikatslaufzeiten begrenzen den Schaden.
F: Warum eine Intermediate-CA, wenn man auch direkt mit der Root ausstellen könnte?
A: Damit die Root offline bleiben kann. Wird die
Intermediate kompromittiert, sperre ich sie und stelle eine neue aus.
Der Vertrauensanker, also das Root-Zertifikat, bleibt überall gleich.
Constraints wie pathlen:0 und EKU codeSigning
begrenzen zusätzlich, was die Intermediate darf.
F: Was ist eine Attestation, und wie hängt sie mit SLSA zusammen?
A: Eine signierte in-toto-Aussage über ein Artefakt,
gebunden per Digest im subject. SLSA definiert das Prädikat
für Provenance, also Builder, Quellen und Parameter, sowie Stufen für
die Vertrauenswürdigkeit des Builds. Policies können Provenance prüfen,
etwa “nur von unseren Runnern gebaut”.
F: Wo liegt der Signierschlüssel in einer guten Pipeline?
A: Nicht als Datei im Runner, sondern in einem KMS, in Vault Transit oder einem HSM. Die Pipeline darf nur signieren lassen, den Schlüssel aber nie lesen. Zugriff gibt es nur für geschützte Branches nach bestandenen Prüfungen.
F: Ein Image wurde in eine andere Registry kopiert. Ist die Signatur noch gültig?
A: Ja, solange der Digest gleich bleibt und die Signatur mitkopiert wurde. Die Signatur hängt am Digest. Werkzeuge, die das Manifest konvertieren, ändern den Digest und machen die Signatur unbrauchbar.
Zusammenfassung
Das hast du gelernt:
- Ein Digest sichert Integrität, eine Signatur die Herkunft. Beide sind nur so viel wert wie der Vertrauensanker, gegen den du prüfst.
- Sigstore Keyless nutzt Fulcio und Rekor und braucht Internet. Offline signierst du mit eigenen Schlüsseln oder eigener PKI und ohne Transparenzlog.
- Eine kleine PKI besteht aus einer Offline-Root, einer
eingeschränkten Intermediate (
pathlen:0, EKUcodeSigning) und kurzlebigen Signierzertifikaten mit klarer Identität. - Cosign signiert per Digest. In v2 schaltest du das Transparenzlog
mit
--tlog-upload=falseab, in v3 mit einer leeren Signing-Config. Geprüft wird mit--insecure-ignore-tlog=true. - Mit Zertifikat und Kette prüfst du gegen das Root-Zertifikat und die erwartete Identität, nicht gegen einzelne Schlüssel.
- Attestations binden Aussagen wie SLSA Provenance oder eine
CycloneDX-SBOM per Digest an das Image und lassen sich mit
cosign verify-attestationprüfen. - Schlüssel gehören in KMS, Vault Transit oder HSM. Cosign kennt keinen CRL-Widerruf, deshalb helfen kurze Laufzeiten, schnelle Policy-Änderungen und Zeitstempel.
- Kyverno
verifyImageserzwingt Signaturen im Cluster und pinnt dabei den geprüften Digest (Details in Kapitel 9).