Zum Inhalt springen
Trainingslager IT-Trainingslager

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 -q
  • env: auf oberster Ebene gilt für alle Jobs. ${{ env.IMAGE }} setzt ihn in with: ein.
  • outputs.digest reicht den Digest aus steps.build an den Job absichern. Dort steht er in env.DIGEST; zusammen mit env.IMAGE ergibt das die unveränderliche Referenz ghcr.io/<du>/notes-api@sha256:….
  • permissions: im Job ersetzt die Rechte von oben vollständig. id-token: write erlaubt dem Job, ein OIDC-Token anzufordern – das braucht Sigstore. attestations: write erlaubt, Attestations bei GitHub abzulegen.
  • Der Job meldet sich selbst bei GHCR an: Jeder Job läuft auf einem frischen Runner, die Anmeldung aus image gibt 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 ab HIGH findet, 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-80

Erwartet:

│ 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-90

Erwartet:

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, Status fixed: 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 --stat

Erwartet (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 get hat golang.org/x/sync gleich mit angehoben – die neue Version von x/text verlangt es.
git commit -qam "deps: golang.org/x/text 0.41.0"
git push -q

Mit 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 -q
  • sbom-action ruft 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 Job contents: write, und der Step scheitert mit Resource not accessible by integration.
  • actions/attest mit sbom-path signiert die SBOM und hängt sie mit push-to-registry neben 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-action von 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 | head

Erwartet (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 -q

Dieselbe 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-actions

Erwartet (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
  • gh holt zum Digest hinter :main die Attestations und prüft sie gegen eine Richtlinie. -R legt 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 gh die 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 -q
  • cosign sign ohne Schlüssel holt sich ein OIDC-Token des Laufs, lässt sich von Sigstore ein kurzlebiges Zertifikat dafür ausstellen und signiert damit.
  • --yes bestätigt, dass die Signatur in das öffentliche Transparenz-Log Rekor eingetragen wird.
  • "$IMAGE@$DIGEST" statt ${{ … }}: Im run: 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 GitVersion

Erwartet:

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/null

Erwartet:

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 -q

Sobald 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: 1 ohne ignore-unfixed blockiert Builds wegen Lücken, für die es keine Korrektur gibt. Eine .trivyignore mit Begründung und Ablaufdatum ist besser als ein abgeschalteter Scan.