Tag 8: SBOM, Scan, Signatur, Provenance
Ziel: Das Image nach dem Bauen auf Schwachstellen scannen, eine Stückliste (SBOM) erzeugen, beides samt Herkunftsnachweis als Attestation an das Image hängen, es mit cosign signieren – und all das auf der VM prüfen. · Dauer: ca. 90 min · Voraussetzung: Tag 7
Briefing
- Trivy scannt ein Image auf bekannte Schwachstellen (CVEs) in Paketen und Go-Modulen.
- Eine SBOM (Software Bill of Materials) listet jede Komponente im Image. Syft erzeugt sie, z. B. im Format SPDX.
- Eine Attestation ist eine signierte Aussage über ein Artefakt: „dieses Image wurde von diesem Workflow aus diesem Commit gebaut“ (Provenance) oder „das ist seine SBOM“. GitHub signiert sie über Sigstore, ganz ohne eigene Schlüssel.
- cosign signiert Images ebenfalls schlüssellos: Das OIDC-Token des Laufs belegt, wer signiert hat.
- Alles bezieht sich auf den Digest
(
sha256:…), nie auf ein Tag – Tags können wandern.
image ──digest──► absichern: trivy (CVE) ─► syft (SBOM) ─► attest SBOM
─► attest Provenance ─► cosign sign
VM: gh attestation verify, cosign verify ◄── ghcr.io/<du>/notes-api@sha256:…
Drill 1: Digest weiterreichen und scannen
image.yml bekommt einen zweiten Job. Der erste reicht
den Digest des gebauten Images als Output weiter:
cd ~/gha-lab/notes-actions
cat > .github/workflows/image.yml <<'EOF'
name: image
on:
push:
branches: [main]
tags: ['v*']
paths-ignore: ['**.md']
pull_request:
workflow_dispatch:
permissions:
contents: read
packages: write
env:
IMAGE: ghcr.io/${{ github.repository_owner }}/notes-api
jobs:
image:
runs-on: ubuntu-24.04
outputs:
digest: ${{ steps.build.outputs.digest }}
steps:
- uses: actions/checkout@v7
- uses: docker/setup-buildx-action@v4
- if: github.event_name != 'pull_request'
uses: docker/login-action@v4
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- id: meta
uses: docker/metadata-action@v6
with:
images: ${{ env.IMAGE }}
tags: |
type=ref,event=branch
type=ref,event=pr
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}
type=sha
- id: build
uses: docker/build-push-action@v7
with:
context: .
platforms: linux/amd64,linux/arm64
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
build-args: |
VERSION=${{ steps.meta.outputs.version }}
REVISION=${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
absichern:
needs: image
if: github.event_name != 'pull_request'
runs-on: ubuntu-24.04
permissions:
contents: read
packages: write
id-token: write
attestations: write
env:
DIGEST: ${{ needs.image.outputs.digest }}
steps:
- uses: docker/login-action@v4
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Schwachstellen
uses: aquasecurity/[email protected]
with:
image-ref: ${{ env.IMAGE }}@${{ env.DIGEST }}
severity: HIGH,CRITICAL
ignore-unfixed: true
exit-code: "1"
EOF
git commit -qam "image: Digest weiterreichen, Trivy"
git push -qenv:auf oberster Ebene gilt für alle Jobs.${{ env.IMAGE }}setzt ihn inwith:ein.outputs.digestreicht den Digest aussteps.buildan den Jobabsichern. Dort steht er inenv.DIGEST; zusammen mitenv.IMAGEergibt das die unveränderliche Referenzghcr.io/<du>/notes-api@sha256:….permissions:im Job ersetzt die Rechte von oben vollständig.id-token: writeerlaubt dem Job, ein OIDC-Token anzufordern – das braucht Sigstore.attestations: writeerlaubt, Attestations bei GitHub abzulegen.- Der Job meldet sich selbst bei GHCR an: Jeder Job läuft auf einem
frischen Runner, die Anmeldung aus
imagegibt es hier nicht. Gebraucht wird sie ab Drill 2, wenn Attestations in die Registry wandern. exit-code: "1"macht den Step rot, wenn Trivy etwas abHIGHfindet, für das es schon eine Korrektur gibt (ignore-unfixed).
Mit der ID aus
gh run list --workflow image.yml --limit 1, sobald der Lauf
fertig ist:
gh run view <ID>Erwartet (gekürzt):
X main image · 41620540968
...
JOBS
✓ image in 1m13s (ID 125864812633)
X absichern in 13s (ID 125865407059)
✓ Set up job
X Schwachstellen
...
Rot. Was hat Trivy gefunden?
gh run view <ID> --log | grep -oE '│ golang.org/x/text .*' | cut -c1-80Erwartet:
│ golang.org/x/text │ CVE-2026-56851 │ HIGH │ fixed │ v0.29.0 │
Die Tabelle ist breiter; cut -c1-80 schneidet sie ab. Im
vollen Log stehen dahinter die Version mit der Korrektur und eine
Beschreibung:
gh run view <ID> --log | grep -oE 'CVE-2026-5685[0-9] .*' | cut -c1-90Erwartet:
CVE-2026-56851 │ HIGH │ fixed │ v0.29.0 │ 0.41.0 │ golang.org/...
CVE-2026-56852 │ │ │ │ 0.39.0 │ golang.org/...
- Trivy erkennt die Go-Binärdatei im Image und liest die eingebauten
Modulversionen aus – auch indirekte Abhängigkeiten wie
golang.org/x/text. - Zwei Lücken mit Schweregrad
HIGH, Statusfixed: Es gibt eine Version ohne sie. Ab 0.41.0 sind beide behoben.
Bei dir kann die Liste anders aussehen – jeden Tag kommen neue CVEs hinzu. Die Lösung ist immer dieselbe: die Abhängigkeit aktualisieren. Go hast du auf der VM nicht, ein Container mit Go genügt:
docker run --rm -u "$(id -u)" -e HOME=/tmp -v "$PWD":/src -w /src golang:1.27-alpine \
go get golang.org/x/[email protected]
git diff --statErwartet (gekürzt):
go: upgraded golang.org/x/sync v0.17.0 => v0.22.0
go: upgraded golang.org/x/text v0.29.0 => v0.41.0
go.mod | 4 ++--
go.sum | 4 ++++
2 files changed, 6 insertions(+), 2 deletions(-)
-e HOME=/tmp: Als dein Benutzer hat der Container kein beschreibbares Home-Verzeichnis, Go braucht aber eines für seinen Cache.go gethatgolang.org/x/syncgleich mit angehoben – die neue Version vonx/textverlangt es.
git commit -qam "deps: golang.org/x/text 0.41.0"
git push -qMit der neuen ID, sobald der Lauf fertig ist:
gh run view <ID> --log | grep -E 'absichern.*│ notes-api'Erwartet (Zeitstempel gekürzt):
absichern Schwachstellen ... │ notes-api │ gobinary │ 0 │ - │
Fortschritt speichern? Kostenlos registrieren
Drill 2: SBOM und SBOM-Attestation
Neue Steps hängst du direkt an – absichern ist der
letzte Job der Datei, die Einrückung von sechs Leerzeichen macht sie zu
Steps:
cat >> .github/workflows/image.yml <<'EOF'
- name: SBOM
uses: anchore/[email protected]
with:
image: ${{ env.IMAGE }}@${{ env.DIGEST }}
format: spdx-json
output-file: sbom.spdx.json
upload-release-assets: false
- name: SBOM-Attestation
uses: actions/attest@v4
with:
subject-name: ${{ env.IMAGE }}
subject-digest: ${{ env.DIGEST }}
sbom-path: sbom.spdx.json
push-to-registry: true
EOF
git commit -qam "image: SBOM"
git push -qsbom-actionruft Syft auf und lädt die SBOM außerdem als Artefakt hoch.upload-release-assets: false: Bei einem Tag-Push würde die Action die SBOM sonst auch an das Release hängen – dafür fehlt dem Jobcontents: write, und der Step scheitert mitResource not accessible by integration.actions/attestmitsbom-pathsigniert die SBOM und hängt sie mitpush-to-registryneben das Image in die Registry. Wer das Image hat, findet auch seine Stückliste.
Sobald der Lauf fertig ist:
gh run view <ID>Erwartet (gekürzt):
JOBS
✓ image in 1m2s (ID 125874935333)
✓ absichern in 23s (ID 125875422164)
ARTIFACTS
<du>~notes-actions~Q3IEUP.dockerbuild
<du>-notes-api_sha256_7145981e51f8728e420640328602a355f0859a61f05ffa821e79b...spdx.json
- Das zweite Artefakt ist die SBOM, benannt nach Image und Digest.
- Das erste legt
build-push-actionvon selbst an: einen Export des Builds, den Docker Desktop als Build-Bericht öffnen kann.
gh run download <ID> -p '*.spdx.json' -D /tmp/sbom
jq -r '.packages[].name' /tmp/sbom/*/*.json | sort | headErwartet (gekürzt):
example.com/notes-api
ghcr.io/<du>/notes-api
github.com/google/uuid
github.com/jackc/pgpassfile
github.com/jackc/pgservicefile
github.com/jackc/pgx/v5
github.com/jackc/puddle/v2
golang.org/x/sync
golang.org/x/text
stdlib
Das Image selbst, notes-api als Go-Modul, die Module aus
go.mod und stdlib – die Standardbibliothek von
Go in der Version, mit der gebaut wurde.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Provenance
cat >> .github/workflows/image.yml <<'EOF'
- name: Provenance
uses: actions/attest@v4
with:
subject-name: ${{ env.IMAGE }}
subject-digest: ${{ env.DIGEST }}
push-to-registry: true
EOF
git commit -qam "image: Provenance"
git push -qDieselbe Action, diesmal ohne sbom-path: Dann erzeugt
actions/attest eine SLSA-Provenance. Sie hält fest: welches
Repository, welcher Workflow, welcher Commit, welcher Runner. Prüfen auf
der VM, sobald der Lauf fertig ist:
gh attestation verify oci://ghcr.io/<du>/notes-api:main -R <du>/notes-actionsErwartet (gekürzt):
Loaded digest sha256:34516f7eafc7179c857bbf4c81c6a7eeb60475626d4af93101...... for ...
Loaded 1 attestation from GitHub API
The following policy criteria will be enforced:
- Predicate type must match:................ https://slsa.dev/provenance/v1
- Source Repository Owner URI must match:... https://github.com/<du>
- Source Repository URI must match:......... https://github.com/<du>/notes-actions
- Subject Alternative Name must match regex: (?i)^https://github\.com/<du>/notes-act...
- OIDC Issuer must match:................... https://token.actions.githubusercontent.com
✓ Verification succeeded!
The following 1 attestation matched the policy criteria
- Attestation #1
- Build repo:..... <du>/notes-actions
- Build workflow:. .github/workflows/image.yml@refs/heads/main
- Signer repo:.... <du>/notes-actions
- Signer workflow: .github/workflows/image.yml@refs/heads/main
ghholt zum Digest hinter:maindie Attestations und prüft sie gegen eine Richtlinie.-Rlegt fest: Sie muss aus diesem Repository stammen. Ein Image, das jemand anderes gebaut und unter deinem Namen hochgeladen hat, fällt durch.- Ohne weitere Angabe prüft
ghdie Provenance (slsa.dev/provenance/v1). Die SBOM-Attestation hängt am selben Digest; der Kontrollpunkt prüft sie gezielt.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Signieren mit cosign
cat >> .github/workflows/image.yml <<'EOF'
- uses: sigstore/[email protected]
- name: Signieren
run: cosign sign --yes "$IMAGE@$DIGEST"
EOF
git commit -qam "image: cosign"
git push -qcosign signohne Schlüssel holt sich ein OIDC-Token des Laufs, lässt sich von Sigstore ein kurzlebiges Zertifikat dafür ausstellen und signiert damit.--yesbestätigt, dass die Signatur in das öffentliche Transparenz-Log Rekor eingetragen wird."$IMAGE@$DIGEST"statt${{ … }}: Imrun:liest die Shell die Variablen – sicherer, wie Tag 9 zeigt.
cosign auf der VM:
mkdir -p ~/.local/bin
gh release download v3.1.4 -R sigstore/cosign -p cosign-linux-amd64 \
-O ~/.local/bin/cosign
chmod +x ~/.local/bin/cosign
cosign version | grep GitVersionErwartet:
GitVersion: v3.1.4
~/.local/bin steht bei Ubuntu im PATH,
sobald es existiert – nach dem ersten Anlegen einmal ab- und wieder
anmelden.
Sobald der Lauf fertig ist:
cosign verify ghcr.io/<du>/notes-api:main \
--certificate-identity-regexp '^https://github.com/<du>/notes-actions/' \
--certificate-oidc-issuer https://token.actions.githubusercontent.com >/dev/nullErwartet:
Verification for ghcr.io/<du>/notes-api:main --
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 code-signing certificate was verified using trusted certificate authority ...
cosign schreibt das Ergebnis der Prüfung nach stderr und
die Signaturen als JSON nach stdout; >/dev/null blendet
das JSON aus. Schlägt die Prüfung fehl, endet cosign mit
Error: no matching signatures.
--certificate-identity-regexp: Wer muss signiert haben? Ein Workflow aus deinem Repository.--certificate-oidc-issuer: Wer hat diese Identität bestätigt? Der OIDC-Dienst von GitHub Actions.- Beides zusammen ist die Richtlinie. Eine Signatur ohne diese Prüfung beweist nichts.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
gh run view <ID> --json jobs --jq '.jobs[] | .name + " " + .conclusion'Erwartet:
image success
absichern success
gh attestation verify oci://ghcr.io/<du>/notes-api:main -R <du>/notes-actions \
--predicate-type https://spdx.dev/Document/v2.3 >/dev/null; echo "Exit: $?"Erwartet:
Exit: 0
--predicate-type prüft gezielt die SBOM-Attestation.
gh attestation verify oci://ghcr.io/<du>/notes-api:main -R octocat/hello-world \
>/dev/null 2>&1; echo "Exit: $?"Erwartet:
Exit: 1
Aus einem fremden Repository gibt es keine Attestation für dieses Image.
Challenge
Trivy soll seine Funde zusätzlich in Code scanning von GitHub ablegen, damit sie unter Security erscheinen – ohne den Lauf rot zu machen.
Hinweis: Ein zweiter Trivy-Step mit
format: sarif, output: trivy.sarif und
exit-code: "0", danach
github/codeql-action/upload-sarif@v4. Der Job braucht
security-events: write.
Lösung
permissions: steht mitten im Job. Füge mit dem Editor
(nano oder vim) unter
attestations: write eine Zeile ein:
permissions:
contents: read
packages: write
id-token: write
attestations: write
security-events: write
Dann die Steps anhängen:
cat >> .github/workflows/image.yml <<'EOF'
- name: Schwachstellen als SARIF
uses: aquasecurity/[email protected]
with:
image-ref: ${{ env.IMAGE }}@${{ env.DIGEST }}
format: sarif
output: trivy.sarif
exit-code: "0"
- uses: github/codeql-action/upload-sarif@v4
with:
sarif_file: trivy.sarif
EOF
git commit -qam "image: Trivy-Funde nach Code scanning"
git push -qSobald der Lauf fertig ist:
gh api repos/{owner}/{repo}/code-scanning/analyses \
--jq '.[0] | .tool.name, .results_count'Erwartet (die Zahl kann abweichen):
Trivy
0
Null Funde im Image. Mit format: sarif meldet Trivy alle
Schweregrade, nicht nur HIGH. Funde erscheinen unter
Security → Code scanning.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Prüfen beim Deployment: Eine Signatur nützt nur, wenn jemand sie prüft. In Kubernetes übernehmen das Admission-Controller wie Kyverno oder der Sigstore Policy Controller: Images ohne passende Signatur oder Provenance werden abgewiesen.
- SLSA: Die Provenance von GitHub erfüllt SLSA Build Level 2, mit wiederverwendbaren Workflows (Tag 12) Level 3 – der Build läuft dann in einem Workflow, den das aufrufende Repository nicht verändern kann.
- Private Repositorys: Attestations dort brauchen GitHub Enterprise Cloud. Sie landen nicht im öffentlichen Rekor-Log.
- Rauschen: Trivy mit
exit-code: 1ohneignore-unfixedblockiert Builds wegen Lücken, für die es keine Korrektur gibt. Eine.trivyignoremit Begründung und Ablaufdatum ist besser als ein abgeschalteter Scan.