Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: SBOM und Signatur – syft und cosign

Ziel: Du erzeugst SBOMs in den gängigen Formaten, signierst notes-api in deiner Registry mit einem eigenen Schlüssel und hängst die SBOM als signierte Attestation an. · Dauer: ca. 75 min · Voraussetzung: Tag 13

Briefing

  • Eine SBOM (Software Bill of Materials) ist die Stückliste eines Images: Pakete, Versionen, Lizenzen, Package-URLs. syft erzeugt sie in SPDX, CycloneDX oder im eigenen syft-JSON.
  • cosign (Sigstore) signiert Images per Digest und legt Signatur und Attestationen als OCI-Artefakte neben das Image in die Registry.
  • Im Lab signierst du mit einem Schlüsselpaar und ohne öffentliches Transparency-Log – nichts verlässt die VM außer Richtung eigener Registry.
  • Eine Attestation ist eine signierte Aussage über das Image, hier: „das ist seine SBOM” (in-toto-Statement mit CycloneDX als Prädikat).
 notes-api@sha256:… ──syft──► api.cdx.json
        │                         │
        ├─cosign sign────────► Signatur   ┐  in der Registry als
        └─cosign attest ─────► Attestation┘  Tag sha256-<digest> (Referrers-Index)
 cosign verify / verify-attestation mit cosign.pub ──► ✔

Drill 1: syft – installieren und die erste SBOM

Steckbrief syft
Aufgabe SBOMs aus Images, Archiven und Ordnern erzeugen
Besonderheit viele Formate in einem Lauf; Grundlage von grype (Tag 13)
Projekt github.com/anchore/syft (Apache-2.0)
Version im Buch 1.55.0
source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag14 && cd ~/ct-lab/tag14
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag13/notes/." .
syft version | head -2
syft -q podman:docker.io/library/nginx:1.30.6-alpine | head -6

Erwartet (gekürzt):

Application:   syft
Version:       1.55.0
NAME                       VERSION           TYPE
alpine-baselayout          3.7.2-r1          apk
alpine-baselayout-data     3.7.2-r1          apk
alpine-keys                2.6-r0            apk
alpine-release             3.24.3-r0         apk
aom-libs                   3.14.1-r0         apk

Ohne Format gibt syft eine Tabelle aus – 71 Pakete bei nginx. Die Quelle wählst du wie bei grype per Präfix: podman: (über den Socket), registry:, docker-archive:, oci-archive:, oci-dir:, dir: und file:. Ohne Präfix probiert syft zuerst die Docker-API – dank DOCKER_HOST aus Tag 4 also ebenfalls den Podman-Socket – und zieht sonst aus der Registry.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Was syft findet

syft -q podman:localhost/notes-api:0.1.0

Erwartet:

NAME                            VERSION                             TYPE
example.com/notes-api           UNKNOWN                             go-module
github.com/google/uuid          v1.6.0                              go-module
github.com/jackc/pgpassfile     v1.0.0                              go-module
github.com/jackc/pgservicefile  v0.0.0-20240606120523-5a60cdf6a761  go-module
github.com/jackc/pgx/v5         v5.11.0                             go-module
github.com/jackc/puddle/v2      v2.2.2                              go-module
golang.org/x/sync               v0.17.0                             go-module
golang.org/x/text               v0.29.0                             go-module
stdlib                          go1.27.3                            go-module

Ein Image auf scratch hat keine Paketdatenbank – syft liest die Build-Informationen, die Go in jedes Binary schreibt, inklusive der Go-Version (stdlib). Auch der Quellordner lässt sich katalogisieren, ganz ohne Build:

syft -q dir:. | awk 'NR > 1 {print $NF}' | sort | uniq -c
syft -q dir:. -o purls | head -3

Erwartet:

      7 go-module
     66 npm
      8 python
pkg:npm/[email protected]
pkg:pypi/[email protected]
pkg:npm/[email protected]

Package-URLs (pkg:typ/name@version) sind der gemeinsame Schlüssel, über den Scanner und Datenbanken Pakete zuordnen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Formate – SPDX, CycloneDX, syft-JSON

-o ist wiederholbar, format=datei schreibt direkt in eine Datei. Ein Lauf, drei Formate, diesmal direkt aus deiner Registry:

syft -q "registry:$REG/notes/notes-api:0.1.0" -o syft-json=api.syft.json \
  -o cyclonedx-json=api.cdx.json -o spdx-json=api.spdx.json
ls -l api.* | awk '{print $5, $9}'
jq -r '"\(.bomFormat) \(.specVersion): \(.components|length) Komponenten"' api.cdx.json
jq -r '"\(.spdxVersion): \(.packages | length) Pakete"' api.spdx.json
jq -r '"syft-json \(.schema.version): \(.artifacts | length) Artefakte"' api.syft.json

Erwartet:

10364 api.cdx.json
14323 api.spdx.json
21589 api.syft.json
CycloneDX 1.7: 10 Komponenten
SPDX-2.3: 10 Pakete
syft-json 16.1.11: 9 Artefakte
Format Herkunft typisch für
SPDX (spdx-json, spdx-tag-value) Linux Foundation, ISO/IEC 5962 Lizenz-Compliance, Behörden
CycloneDX (cyclonedx-json, -xml) OWASP Sicherheit, VEX, Scanner
syft-JSON (syft-json) Anchore verlustfreie Ablage, grype

In SPDX und CycloneDX zählt das Image selbst als zehnter Eintrag mit. Ältere Spezifikationen gibt es per Suffix, etwa -o [email protected].

Fortschritt speichern? Kostenlos registrieren

Drill 4: Konvertieren

syft convert api.syft.json -o cyclonedx-json=konvertiert.cdx.json
jq -r '.bomFormat, (.components | length)' konvertiert.cdx.json
syft convert api.cdx.json -o syft-table 2>/dev/null | head -3

Erwartet:

[0000]  WARN convert is an experimental feature, run `syft convert -h` for help
CycloneDX
10
NAME                            VERSION                             TYPE
example.com/notes-api           UNKNOWN                             go-module
github.com/google/uuid          v1.6.0                              go-module

convert ist als experimentell markiert: Zwischen Formaten gehen Details verloren (github.com/anchore/syft/wiki/format-conversion). Verlustfrei ist nur der Weg aus syft-JSON – deshalb lohnt es sich, das syft-JSON immer mit abzulegen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: cosign – installieren, Schlüsselpaar

Steckbrief cosign
Aufgabe Images und Artefakte signieren, Signaturen und Attestationen prüfen
Besonderheit Signaturen liegen als OCI-Artefakte in derselben Registry; Schlüssel oder keyless
Projekt github.com/sigstore/cosign (Apache-2.0), Doku docs.sigstore.dev
Version im Buch v3.1.4
cosign version 2>&1 | grep -E 'GitVersion|Platform'
mkdir -p ~/ct-lab/keys && cd ~/ct-lab/keys
export COSIGN_PASSWORD=lab-cosign-pw-123
cosign generate-key-pair
ls -l | awk 'NR > 1 {print $1, $9}'
head -1 cosign.key
cd ~/ct-lab/tag14

Erwartet:

GitVersion:    v3.1.4
Platform:      linux/arm64
Private key written to cosign.key
Public key written to cosign.pub
-rw------- cosign.key
-rw-r--r-- cosign.pub
-----BEGIN ENCRYPTED SIGSTORE PRIVATE KEY-----

Der private Schlüssel ist mit dem Passwort aus COSIGN_PASSWORD verschlüsselt und nur für dich lesbar. Er gehört nie in ein Repository – ~/ct-lab/keys liegt bewusst außerhalb des Projektordners. Weitergeben darfst du nur cosign.pub.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Signieren ohne Transparency-Log

Signiert wird immer der Digest, nie der Tag – ein Tag kann morgen auf ein anderes Image zeigen. cosign meldet sich an der Registry mit dem Login aus ~/.docker/config.json (Tag 7). Der naheliegende Schalter für „kein öffentliches Log” ist in cosign v3 abgekündigt:

img="$REG/notes/notes-api@$(crane digest "$REG/notes/notes-api:0.1.0")"
echo "$img"
cosign sign --key ~/ct-lab/keys/cosign.key --tlog-upload=false --yes "$img" 2>&1 \
  | head -2 | cut -c1-88

Erwartet:

registry.ct.lab:5000/notes/notes-api@sha256:5e37fbeda66793686142a853dc1a102de52b486723…
Flag --tlog-upload has been deprecated, prefer using a --signing-config file with no tra
Error: --tlog-upload=false is not supported with --signing-config or --use-signing-confi

Seit v3 beschreibt eine Signing-Config, welche Sigstore-Dienste (Fulcio, Rekor, Zeitstempel) beim Signieren benutzt werden. Ohne Angabe holt cosign die öffentliche Konfiguration. Für das Lab erzeugst du eine leere – ohne Dienste:

cosign signing-config create --out lab-signing-config.json
cat lab-signing-config.json; echo
cosign sign --key ~/ct-lab/keys/cosign.key --signing-config lab-signing-config.json \
  --yes "$img"

Erwartet:

{"mediaType":"application/vnd.dev.sigstore.signingconfig.v0.2+json", "rekorTlogConfig":
{}, "tsaConfig":{}}
Signing artifact...
Pushing signature to: registry.ct.lab:5000/notes/notes-api

Sicherheit: Im Test lief das Signieren mit einem gesperrten Proxy (HTTPS_PROXY auf einen toten Port, NO_PROXY=registry.ct.lab) – es gab keinen einzigen Zugriff außerhalb der eigenen Registry. Ohne --signing-config würde cosign die Signatur ins öffentliche Rekor-Log schreiben.

Wo liegt die Signatur?

crane ls "$REG/notes/notes-api"
crane manifest "$REG/notes/notes-api:sha256-${img#*sha256:}" \
  | jq -r '.mediaType, .manifests[0].artifactType'
curl -s -o /dev/null -w '%{http_code}\n' -u "$REG_USER:$REG_PASS" \
  "https://$REG/v2/notes/notes-api/referrers/${img#*@}"

Erwartet:

0.1.0
sha256-5e37fbeda66793686142a853dc1a102de52b486723834fcbd9b1764b4ddb5db2
application/vnd.oci.image.index.v1+json
application/vnd.dev.sigstore.bundle.v0.3+json
404

cosign v3 speichert ein Sigstore-Bundle als OCI-Referrer. Die Registry 3.1.2 kennt die Referrers-API nicht (404), also nutzt cosign das Ausweichschema aus der OCI-Spec: einen Index unter dem Tag sha256-<digest>.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Verifizieren

Ein einfaches cosign verify --key … verlangt zusätzlich einen Eintrag im Transparency-Log und lädt dafür die öffentliche Sigstore-Vertrauensbasis (TUF). Den Eintrag gibt es hier bewusst nicht – das sagst du cosign ausdrücklich:

cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true "$img" \
  2>verify.log | jq -c '.[0].critical'
cat verify.log

Erwartet:

{"identity":{"docker-reference":"registry.ct.lab:5000/notes/notes-api@sha256:5e37fbe…"
},"image":{"docker-manifest-digest":"sha256:5e37fbe…"},"type":"https://sigstore.dev/co
sign/sign/v1"}
WARNING: Skipping tlog verification is an insecure practice that lacks transparency and
auditability verification for the signature.

Verification for registry.ct.lab:5000/notes/notes-api@sha256:5e37fbe… --
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

Auf stdout steht die geprüfte Nutzlast (JSON), auf stderr das Protokoll. Die Zeile zum Transparency-Log ist irreführend – geprüft wurde wegen --insecure-ignore-tlog nichts dergleichen, die Warnung darüber gilt. Entscheidend ist die letzte Zeile: Die Signatur passt zum öffentlichen Schlüssel. Und ein Image ohne Signatur?

podman push -q localhost/notes-api:0.2.0 "$REG/notes/notes-api:0.2.0"
cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  "$REG/notes/notes-api@$(crane digest "$REG/notes/notes-api:0.2.0")" 2>&1 | tail -1
echo "Exit: ${PIPESTATUS[0]}"

Erwartet:

error during command execution: no signatures found
Exit: 10

Fortschritt speichern? Kostenlos registrieren

Drill 8: SBOM als Attestation

cosign attest --key ~/ct-lab/keys/cosign.key --signing-config lab-signing-config.json \
  --yes --type cyclonedx --predicate api.cdx.json "$img"
cosign verify-attestation --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  --type cyclonedx "$img" 2>/dev/null > att.json; echo "Exit: $?"
jq -r '.payload' att.json | base64 -d \
  | jq -c '{_type, predicateType, n: (.predicate.components | length)}'

Erwartet:

Using payload from: api.cdx.json
Signing artifact...
Exit: 0
{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://cyclonedx.org/bom
","n":10}

--type cyclonedx setzt den Prädikat-Typ (https://cyclonedx.org/bom); ebenso gibt es spdxjson, slsaprovenance, vuln oder eine eigene URI. verify-attestation prüft Signatur und Typ und gibt das in-toto-Statement Base64-kodiert aus. Ein Verbraucher holt sich die SBOM so ohne Zugriff auf deinen Build – und weiß, dass sie von dir stammt.

Fortschritt speichern? Kostenlos registrieren

Drill 9: Was hängt am Image? cosign tree und download

cosign tree "$img" 2>&1 | LC_ALL=C tr -cd '\12\40-\176' | cut -c1-80

Erwartet (Symbole und Baumlinien entfernt):

 Supply Chain Security Related artifacts for an image: registry.ct.lab:5000/note
  https://sigstore.dev/cosign/sign/v1 artifacts via OCI referrer: registry.ct.la
     sha256:4fd43087f54817fe5caebbd1cb53be1107a43f0cd28bfb5e9c9fb2c7c7bb0af7
  https://cyclonedx.org/bom artifacts via OCI referrer: registry.ct.lab:5000/not
     sha256:5fc11d0a8b469def478ffbe6d21694387e32232bfd85515b56912a88e14cc7f8

cosign tree schmückt seine Ausgabe mit Emojis; tr lässt nur ASCII übrig. Am Image hängen zwei Referrer: die Signatur und die SBOM-Attestation, jeweils als Sigstore-Bundle.

cosign download attestation "$img" 2>/dev/null \
  | jq -r '.dsseEnvelope.payload' | base64 -d | jq -r '.predicateType'
cosign download attestation --predicate-type https://cyclonedx.org/bom "$img" \
  2>/dev/null | jq -r '.dsseEnvelope.payload' | base64 -d \
  | jq -r '.predicate.components[].name' | head -3

Erwartet:

https://sigstore.dev/cosign/sign/v1
https://cyclonedx.org/bom
example.com/notes-api
github.com/google/uuid
github.com/jackc/pgpassfile

download prüft nichts – es holt nur die Sigstore-Bundles. Für Entscheidungen immer verify-attestation nehmen.

Und die eigene CA? cosign ist ein Go-Programm und vertraut dem System-Zertifikatsspeicher, in den du deine CA an Tag 7 gelegt hast. Ohne ihn scheitert TLS; --registry-cacert reicht die CA dann direkt:

SSL_CERT_FILE=/dev/null SSL_CERT_DIR=/dev/null cosign verify \
  --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true "$img" 2>&1 \
  | tail -1 | cut -c1-88
SSL_CERT_FILE=/dev/null SSL_CERT_DIR=/dev/null cosign verify \
  --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  --registry-cacert "$LAB/registry/certs/ca.crt" "$img" >/dev/null 2>&1
echo "Exit: $?"

Erwartet:

error during command execution: Get "https://registry.ct.lab:5000/v2/": tls: failed to v
Exit: 0

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Schlüsselpaar und die vier Dateien:

cd ~/ct-lab/tag14
source ~/ct-lab/setup/env.sh
ls ~/ct-lab/keys
ls api.cdx.json api.spdx.json api.syft.json lab-signing-config.json

Erwartet:

cosign.key
cosign.pub
api.cdx.json
api.spdx.json
api.syft.json
lab-signing-config.json

Signatur und SBOM-Attestation sind gültig:

img="$REG/notes/notes-api@$(crane digest "$REG/notes/notes-api:0.1.0")"
cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true "$img" \
  >/dev/null 2>&1; echo "Exit: $?"
cosign verify-attestation --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  --type cyclonedx "$img" >/dev/null 2>&1; echo "Exit: $?"

Erwartet:

Exit: 0
Exit: 0

Challenge

Signiere notes-api:0.2.0 in deiner Registry mit der Annotation version=0.2.0, hänge eine SPDX-SBOM als Attestation an und prüfe beides – die Signatur nur dann als gültig, wenn die Annotation stimmt.

Hinweis: cosign sign -a key=value setzt Annotationen, cosign verify -a key=value verlangt sie; der SPDX-Typ heißt spdxjson.

Lösung

img2="$REG/notes/notes-api@$(crane digest "$REG/notes/notes-api:0.2.0")"
syft -q "registry:$REG/notes/notes-api:0.2.0" -o spdx-json=api-020.spdx.json
cosign sign --key ~/ct-lab/keys/cosign.key --signing-config lab-signing-config.json \
  --yes -a version=0.2.0 "$img2" 2>/dev/null
cosign attest --key ~/ct-lab/keys/cosign.key --signing-config lab-signing-config.json \
  --yes --type spdxjson --predicate api-020.spdx.json "$img2" 2>/dev/null
cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  -a version=0.2.0 "$img2" >/dev/null 2>&1; echo "Exit: $?"
cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  -a version=0.1.0 "$img2" >/dev/null 2>&1; echo "Exit: $?"
cosign verify-attestation --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  --type spdxjson "$img2" >/dev/null 2>&1; echo "Exit: $?"

Erwartet:

Exit: 0
Exit: 1
Exit: 0

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Schlüssel gehören in ein KMS oder HSM (--key awskms://…, gcpkms://…, hashivault://…, k8s://…), nicht auf Entwickler-Laptops; Passwort aus dem Secret-Store der Pipeline.
  • Keyless ist der Sigstore-Standard: Die Pipeline meldet sich per OIDC an, Fulcio stellt ein kurzlebiges Zertifikat aus, Rekor protokolliert die Signatur öffentlich – cosign verify prüft dann Identität und Aussteller statt eines Schlüssels. Für interne Images gibt es eigene Fulcio-/Rekor-Instanzen.
  • Signaturen nützen nur, wenn jemand sie prüft: Admission-Controller (Sigstore policy-controller, Kyverno) lassen nur signierte Images mit gültiger SBOM-Attestation in den Cluster.
  • Registry mit Referrers-API (OCI 1.1) wählen – oder beim Kopieren zwischen Registries die sha256-…-Tags mitnehmen (regctl, oras, Tag 8/9).
  • Keyless, Provenance (SLSA), VEX und Policies vertieft „Sichere Lieferketten zum Anfassen”.