Zum Inhalt springen
Trainingslager IT-Trainingslager

Kapitel 11: Abschlussprojekt – die ganze Kette

In diesem Kapitel lernst du:

  • wie alle Bausteine aus den Kapiteln 1 bis 10 zu einer durchgehenden, prüfbaren Lieferkette zusammenpassen
  • wie eine vollständige .gitlab-ci.yml aussieht, die nur über den Spiegel bezieht, scannt, eine SBOM erzeugt und Secrets aus Vault holt
  • wie du demo-app 1.1.0 offline signierst, über die Zonengrenze bringst und per Argo CD ausrollst
  • wie die Kette auf typische Angriffe und Fehler reagiert: unsigniertes Image, Docker-Hub-Image, kritische CVE, abgelaufene Ausnahme
  • woran du erkennst, dass ein Release wirklich „fertig” ist (Definition of Done)

Worum geht es?

Denk an eine Lieferkette für Medikamente. Der Wirkstoff kommt nur von geprüften Lieferanten. Die Herstellung läuft in einem sauberen Labor nach festem Rezept. Jede Charge wird geprüft, bekommt einen Beipackzettel und ein fälschungssicheres Siegel. An der Grenze zum Krankenhaus steht eine Warenannahme mit Quarantänelager. Erst wenn Siegel und Prüfprotokoll stimmen, kommt die Charge in den Medikamentenschrank. Und die Stationsschwester gibt nur Packungen mit intaktem Siegel aus.

Genau diese Kette baust du jetzt für deine Software. Jedes Kapitel war ein Glied. In diesem Kapitel schließt du sie zu einem Ablauf und schickst demo-app in Version 1.1.0 einmal komplett hindurch.

  INTERNET            ZONE BUILD / INTERN                    ZONE ZIEL / PRODUKTION
  Docker Hub, PyPI   |                                      |
        |            |                                      |
        v            |                                      |
  [Nexus-Spiegel]----+-> GitLab CI (Kap 1)                  |
   nexus:8082/:8081  |    verify: Bezugsweg, Ausnahmen      |
   (Kap 3)           |    test:   SAST, SCA, IaC, Secrets   |
                     |    build:  gehärtet, Buildah (Kap 2) |
  [Vault] -- JWT --->|    scan:   Trivy-Schwelle (Kap 8)    |
   (Kap 6)           |    sbom:   Syft -> Dependency-Track  |
                     |            (Kap 7)                   |
                     |          |                           |
                     |          v                           |
                     |  reg-build:5000/demo-app@sha256:...  |
                     |          |                           |
                     |          v                           |
                     |  Signatur-Arbeitsplatz (Kap 5)       |
                     |   cosign sign + attest (SBOM)        |
                     |          |                           |
                     |          v  Bundle + SHA256SUMS      |
                     |  ===== Zonengrenze (Kap 4) =========>|-> Quarantäne
                     |                                      |   reg-ziel/quarantaene
                     |                                      |   Prüfsummen, Signatur,
                     |                                      |   Re-Scan
                     |                                      |      | Freigabe
                     |                                      |      v
                     |                                      |   reg-ziel/demo-app
                     |                                      |      |
                     |                                      |   Argo CD (GitOps)
                     |                                      |      |
                     |                                      |   Kyverno (Kap 9):
                     |                                      |   Signatur, SBOM,
                     |                                      |   Registry, Policies
                     |                                      |      |
                     |                                      |   Pod läuft
  Ausnahmen mit Frist (Kap 10) gelten quer über alle Stufen: Register + Ablauf-Check

Die Konzepte in einfach

Kette heißt: jedes Glied liefert einen Nachweis

Eine sichere Lieferkette ist keine Sammlung von Werkzeugen, sondern eine Folge von Prüfpunkten. Jeder Prüfpunkt erzeugt einen Nachweis (Evidence), den der nächste Prüfpunkt oder ein Auditor nachvollziehen kann.

Glied Kapitel Nachweis
Bezug nur über Spiegel 3 Basis-Image und Pakete von nexus
Gehärteter Build 1, 2 Pipeline-Log, Image-Digest, Labels
Secrets ohne Variablen 6 Vault-Audit-Log, kurzlebiges Token
Scans mit Schwellen 8 Scan-Reports als Artefakte
SBOM 7 sbom.cdx.json, Projekt in Dependency-Track
Signatur, Attestation 5 .sig und .att am Digest
Übergabe 4 Bundle, Prüfsummen, Quarantäne-Protokoll
Durchsetzung 9 Kyverno-Policy, Admission-Entscheidung
Ausnahmen 10 exceptions.yaml, Git-Historie

Der Digest ist der rote Faden

Ein Tag wie 1.1.0 ist ein Etikett, das jemand umhängen kann. Der Digest (sha256:…) ist der Fingerabdruck des Inhalts. Ab dem Build arbeitet jedes Glied nur noch mit dem Digest: Scan, SBOM, Signatur, Übergabe und Deployment. So ist sichergestellt, dass genau das Image läuft, das geprüft wurde.

Wo liegt das Vertrauen?

Drei Dinge bilden den Vertrauensanker der Kette:

  1. Der Spiegel: Er bestimmt, welche fremden Bausteine überhaupt hereinkommen.
  2. Der Signaturschlüssel: Er liegt offline auf dem Signatur-Arbeitsplatz, nie in der Pipeline (siehe Kapitel 5).
  3. Der öffentliche Schlüssel in der Zielzone: Er steckt in der Kyverno-Policy und kommt über einen eigenen, kontrollierten Weg in die Zielzone, nie im selben Bundle wie das Image.

Sicherheit: Wer das Image und den Prüfschlüssel im selben Paket transportiert, kann beides gemeinsam fälschen. Vertrauensanker und Ware reisen immer getrennt.

Annahmen für dieses Kapitel

Dieses Kapitel baut auf deinem Lab aus den Kapiteln 0 bis 10 auf. Konkret nehmen wir an:

  • GitLab CE läuft auf http://localhost:8929, der Runner (Docker-Executor) startet Jobs im Docker-Netz kind und erreicht dort nexus, vault, reg-build und dtrack-apiserver per Containername (siehe Kapitel 1).
  • Nexus spiegelt Docker Hub unter nexus:8082 und PyPI als Repository pypi-proxy. Images anderer Registries (quay.io für Buildah) hast du als weiteren Proxy in derselben Docker-Gruppe angelegt oder einmalig kontrolliert importiert (siehe Kapitel 3). Die Docker-Engine des Runners führt nexus:8082 als Insecure Registry.
  • Vault hat die JWT-Methode für GitLab aktiviert (siehe Kapitel 6), Dependency-Track läuft (siehe Kapitel 7).
  • Kyverno und Argo CD laufen im Cluster kind-seclab, Kyverno darf reg-ziel:5000 per HTTP abfragen (siehe Kapitel 9).
  • Das Anwendungsprojekt heißt in GitLab root/demo-app, so wie es der erste Push in Kapitel 1 angelegt hat. Das Deploy-Repository root/demo-deploy legst du in Schritt 11 an und stellst die Argo-CD-Application demo-app aus Kapitel 1 darauf um. Heißen deine Projekte anders, passe Pfade, bound_claims und URLs an.

Hands-on-Lab: demo-app 1.1.0 durch die ganze Kette

Schritt 1: Ausgangslage prüfen

mkdir -p ~/seclab/kap11 && cd ~/seclab/kap11
docker ps --format '{{.Names}}' | sort
kubectl config use-context kind-seclab
kubectl -n kyverno get pods
kubectl -n argocd get pods

Erwartet: In der Containerliste stehen mindestens gitlab, gitlab-runner, nexus, vault, reg-build, reg-ziel und die Dependency-Track-Container (die exakten Namen hängen von deinen Compose-Dateien ab). Kyverno- und Argo-CD-Pods sind Running.

Ein kurzer Rauchtest pro Dienst:

curl -s -o /dev/null -w 'nexus %{http_code}\n' http://localhost:8081/
curl -s http://localhost:8200/v1/sys/health | jq -r '"vault sealed=\(.sealed)"'
curl -s http://localhost:8080/api/version | jq -r '"dtrack \(.version)"'
curl -s http://localhost:5001/v2/_catalog
curl -s http://localhost:5002/v2/_catalog

Erwartet: nexus 200, vault sealed=false, eine Dependency-Track-Version und zwei JSON-Kataloge der Registries.

Schritt 2: Version 1.1.0 vorbereiten

Wechsle ins Repository der Anwendung und lege einen Branch an:

cd ~/seclab/demo-app
git switch -c release-1.1.0

Die Version steht nicht im Code: app.py aus Kapitel 0 liest sie aus der Umgebungsvariablen APP_VERSION und fällt nur ohne sie auf 1.0.0 zurück. app.py bleibt deshalb unverändert. Du setzt 1.1.0 an den Stellen, die diese Variable füllen: im Dockerfile per ARG/ENV (unten), in der Pipeline als Variable APP_VERSION, die build:image als Build-Argument übergibt (Schritt 5), und im Deployment des Deploy-Repositorys (Schritt 11). Der env-Eintrag im Deployment überschreibt den Wert aus dem Image, deshalb muss er mitziehen.

Stelle außerdem sicher, dass das Dockerfile Basis-Images ausschließlich über den Spiegel bezieht. Entscheidend sind die ARG-, ENV- und FROM-Zeilen; der Rest entspricht deinem gehärteten Dockerfile aus Kapitel 2:

ARG BASE_REGISTRY=nexus:8082
FROM ${BASE_REGISTRY}/library/python:3.12-slim AS build
ARG PIP_INDEX_URL
ARG PIP_TRUSTED_HOST
WORKDIR /build
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

FROM ${BASE_REGISTRY}/library/python:3.12-slim
ARG APP_VERSION=1.1.0
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 APP_VERSION=${APP_VERSION}
COPY --from=build /install /usr/local
WORKDIR /app
COPY app.py .
USER 10001
EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

ARG APP_VERSION steht bewusst in der zweiten Stufe: Ein ARG gilt nur in der Stufe, in der es deklariert ist. Der Default 1.1.0 greift bei einem lokalen Build, in der Pipeline gewinnt das Build-Argument. pip liest PIP_INDEX_URL und PIP_TRUSTED_HOST als Umgebungsvariablen. Build-Argumente stehen während RUN als Umgebungsvariablen bereit, deshalb holt pip die Pakete vom Nexus-PyPI-Proxy statt von pypi.org.

Tipp: In der Produktion pinnst du das Basis-Image zusätzlich per Digest (python:3.12-slim@sha256:…) und lässt ein Werkzeug wie Renovate den Digest per MR aktualisieren (siehe Kapitel 2).

Prüfe, dass keine FROM-Zeile am Spiegel vorbeigeht:

grep -E '^FROM ' Dockerfile | grep -vE '^FROM \$\{BASE_REGISTRY\}/' \
  || echo "OK: alle FROM-Zeilen nutzen BASE_REGISTRY"

Erwartet: OK: alle FROM-Zeilen nutzen BASE_REGISTRY.

Schritt 3: Ausnahme mit Frist für einen bekannten Befund

demo-app enthält absichtlich requests==2.25.0. In unserem Szenario kann das Team requests erst in Version 1.2.0 anheben, weil ein angebundener Altclient getestet werden muss. Für eigene, direkte Abhängigkeiten setzen wir die Schwelle bewusst niedrig auf MEDIUM, denn dort können wir selbst aktualisieren. Also braucht 1.1.0 eine befristete Ausnahme (siehe Kapitel 10).

Zuerst schaust du, welche Befunde es genau sind:

trivy fs --scanners vuln --severity MEDIUM,HIGH,CRITICAL \
  --format json -q . \
  | jq -r '.Results[].Vulnerabilities[]?
      | "\(.PkgName) \(.VulnerabilityID) \(.Severity) fix=\(.FixedVersion)"'

Erwartete Ausgabe (Stand der Trivy-Datenbank Oktober 2026, bei dir eventuell mehr oder andere IDs):

requests CVE-2023-32681 MEDIUM fix=2.31.0
requests CVE-2024-35195 MEDIUM fix=2.32.0
requests CVE-2024-47081 MEDIUM fix=2.32.4
requests CVE-2026-25645 MEDIUM fix=2.33.0

Übernimm die Skripte aus Kapitel 10 und lege Register und Ignore-Datei an. Trage deine IDs ein:

mkdir -p ci
cp ~/seclab/kap10/check-exceptions.sh ~/seclab/kap10/check-trivyignore.sh ci/
CREATED=$(date -u +%F)
EXPIRES=$(date -u -d '+60 days' +%F 2>/dev/null || date -u -v+60d +%F)
CVES="CVE-2023-32681 CVE-2024-35195 CVE-2024-47081 CVE-2026-25645"

cat > exceptions.yaml <<EOF
exceptions:
  - id: EXC-2026-001
    type: vulnerability
    target: demo-app
    reference: "pkg:pypi/[email protected]"
    findings: [$(echo $CVES | sed 's/ /, /g')]
    reason: "Upgrade requests bricht Altclient, Migration in demo-app 1.2.0"
    risk: medium
    compensation: "Kein verify=False (Semgrep-Regel), kein .netrc im Image"
    owner: [email protected]
    approver: [email protected]
    ticket: SEC-123
    created: "${CREATED}"
    expires: "${EXPIRES}"
EOF

echo "vulnerabilities:" > .trivyignore.yaml
for c in $CVES; do
  cat >> .trivyignore.yaml <<EOF
  - id: ${c}
    purls: ["pkg:pypi/[email protected]"]
    statement: "EXC-2026-001: Migration requests in 1.2.0"
    expired_at: ${EXPIRES}
EOF
done

ci/check-exceptions.sh exceptions.yaml
ci/check-trivyignore.sh .trivyignore.yaml exceptions.yaml

Erwartet: OK EXC-2026-001: gueltig bis …, Ergebnis: Ausnahmeregister gueltig und für jede CVE eine Zeile OK CVE-… -> EXC-2026-001.

Jetzt muss der SCA-Scan grün sein:

trivy fs --scanners vuln --severity MEDIUM,HIGH,CRITICAL \
  --ignorefile .trivyignore.yaml --exit-code 1 -q . ; echo "Exit: $?"

Erwartet: keine offenen Befunde mehr in der Tabelle und Exit: 0.

Merke: Die Ausnahme gilt nur für genau dieses Paket in genau dieser Version (purls). Taucht derselbe CVE in einer anderen Komponente auf, schlägt der Scan trotzdem an.

Schritt 4: Vault und Dependency-Track für die Pipeline vorbereiten

Die Pipeline braucht genau ein Secret: den API-Schlüssel für Dependency-Track. Er liegt in Vault, die Pipeline holt ihn per id_token (siehe Kapitel 6). Die folgenden Befehle setzen das für dieses Kapitel auf. Wenn du in Kapitel 6 schon eine JWT-Konfiguration hast, ergänze nur Policy und Rolle.

export VAULT_ADDR=http://localhost:8200 VAULT_TOKEN=root   # nur Lab!
vault kv put secret/demo-app/dtrack api_key="<API-Key aus Kapitel 7>"

vault policy write demo-app-ci - <<'EOF'
path "secret/data/demo-app/*" {
  capabilities = ["read"]
}
EOF

vault auth list | grep -q '^jwt/' || vault auth enable jwt
vault write auth/jwt/config \
  jwks_url="http://gitlab:8929/oauth/discovery/keys" \
  bound_issuer="http://localhost:8929"

vault write auth/jwt/role/demo-app - <<'EOF'
{
  "role_type": "jwt",
  "user_claim": "sub",
  "bound_audiences": ["http://vault:8200"],
  "bound_claims": {
    "project_path": "root/demo-app",
    "ref_protected": "true"
  },
  "token_policies": ["demo-app-ci"],
  "token_ttl": "10m"
}
EOF
vault read -field=bound_claims auth/jwt/role/demo-app

Erwartet: map[project_path:root/demo-app ref_protected:true].

Was heißt das? Nur Jobs aus dem Projekt root/demo-app auf einem geschützten Branch oder Tag bekommen ein Vault-Token, und das nur für 10 Minuten. Ein Merge Request aus einem Feature-Branch kommt an den Schlüssel nicht heran. Schütze deshalb in GitLab unter Settings → Repository → Protected tags das Muster v*.

Achtung: Der API-Key braucht in Dependency-Track die Berechtigungen BOM_UPLOAD und PROJECT_CREATION_UPLOAD, sonst scheitert autoCreate.

Schritt 5: Die vollständige .gitlab-ci.yml

Hier ist die gesamte Pipeline. Lies sie einmal von oben nach unten und ordne jeden Job einem Kapitel zu.

# .gitlab-ci.yml - demo-app: die ganze Kette (Kapitel 11)
workflow:
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_PIPELINE_SOURCE == "schedule"
    - if: $CI_COMMIT_TAG =~ /^v[0-9]+\.[0-9]+\.[0-9]+$/
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

stages: [verify, test, build, scan, sbom, handover]

variables:
  MIRROR: "nexus:8082"                      # einziger Bezugsweg (Kap 3)
  PIP_INDEX_URL: "http://nexus:8081/repository/pypi-proxy/simple"
  PIP_TRUSTED_HOST: "nexus"
  IMAGE: "reg-build:5000/demo-app"
  APP_VERSION: "1.1.0"
  VAULT_ADDR: "http://vault:8200"
  DT_URL: "http://dtrack-apiserver:8080"
  TRIVY_DB_REPOSITORY: "nexus:8082/aquasec/trivy-db:2"
  TRIVY_CACHE_DIR: ".trivycache"
  TRIVY_NO_PROGRESS: "true"

# ---------------- verify: Bezugsweg, Version, Ausnahmen ----------------
verify:bezugsweg:
  stage: verify
  image: nexus:8082/alpine/k8s:1.31.13
  script:
    - |
      bad=$(grep -E '^FROM ' Dockerfile \
        | grep -vE '^FROM \$\{BASE_REGISTRY\}/' || true)
      if [ -n "$bad" ]; then
        echo "FEHLER: Basis-Image am Spiegel vorbei: $bad"; exit 1
      fi
      grep -qE '^ARG BASE_REGISTRY=nexus:8082$' Dockerfile \
        || { echo "FEHLER: BASE_REGISTRY muss nexus:8082 sein"; exit 1; }
    - |
      if [ -n "${CI_COMMIT_TAG:-}" ] && [ "$CI_COMMIT_TAG" != "v$APP_VERSION" ]
      then
        echo "FEHLER: Tag $CI_COMMIT_TAG passt nicht zu $APP_VERSION"; exit 1
      fi

verify:ausnahmen:
  stage: verify
  image: nexus:8082/alpine/k8s:1.31.13
  script:
    - ci/check-exceptions.sh exceptions.yaml
    - ci/check-trivyignore.sh .trivyignore.yaml exceptions.yaml

# ---------------- test: SAST, SCA, IaC, Secrets (Kap 8) ----------------
test:sast:
  stage: test
  image: nexus:8082/semgrep/semgrep:1.180.0
  script:
    - semgrep scan --config .semgrep/ --error --metrics=off .

test:sca:
  stage: test
  image:
    name: nexus:8082/aquasec/trivy:0.74.0
    entrypoint: [""]
  script:
    - trivy fs --insecure --scanners vuln --severity MEDIUM,HIGH,CRITICAL
        --ignorefile .trivyignore.yaml --exit-code 1 .
  cache:
    key: trivy-db
    paths: [.trivycache/]

test:iac:
  stage: test
  image:
    name: nexus:8082/bridgecrew/checkov:3.3.26
    entrypoint: [""]
  script:
    - checkov -d k8s --framework kubernetes --config-file .checkov.yaml
        --compact

test:secrets:
  stage: test
  image:
    name: nexus:8082/zricethezav/gitleaks:v8.30.1
    entrypoint: [""]
  variables:
    GIT_DEPTH: "0"
  script:
    - git config --global --add safe.directory "$CI_PROJECT_DIR"
    - gitleaks git --redact --no-banner .

# ---------------- build: gehaertet, nur ueber den Spiegel (Kap 2) -------
build:image:
  stage: build
  image: nexus:8082/buildah/stable:v1.43
  variables:
    STORAGE_DRIVER: vfs
    BUILDAH_ISOLATION: chroot
  script:
    - TAG="${CI_COMMIT_TAG#v}"; TAG="${TAG:-$CI_COMMIT_SHORT_SHA}"
    - buildah build --tls-verify=false
        --build-arg BASE_REGISTRY="$MIRROR"
        --build-arg PIP_INDEX_URL="$PIP_INDEX_URL"
        --build-arg PIP_TRUSTED_HOST="$PIP_TRUSTED_HOST"
        --build-arg APP_VERSION="$APP_VERSION"
        --label org.opencontainers.image.version="$APP_VERSION"
        --label org.opencontainers.image.revision="$CI_COMMIT_SHA"
        --label org.opencontainers.image.source="$CI_PROJECT_URL"
        -t "$IMAGE:$TAG" .
    - buildah push --tls-verify=false --digestfile digest.txt "$IMAGE:$TAG"
    - echo "IMAGE_TAG=$TAG" > build.env
    - echo "IMAGE_DIGEST=$(cat digest.txt)" >> build.env
    - cat build.env
  artifacts:
    reports:
      dotenv: build.env

# ---------------- scan: Image mit Schwellenwert (Kap 8) -----------------
scan:image:
  stage: scan
  needs: [build:image]
  image:
    name: nexus:8082/aquasec/trivy:0.74.0
    entrypoint: [""]
  script:
    - REF="$IMAGE@$IMAGE_DIGEST"
    - trivy image --insecure --scanners vuln --severity HIGH,CRITICAL
        --ignore-unfixed --ignorefile .trivyignore.yaml --exit-code 1
        --format json --output trivy-image.json "$REF" || rc=$?
    - trivy convert --format table trivy-image.json
    - exit "${rc:-0}"
  cache:
    key: trivy-db
    paths: [.trivycache/]
  artifacts:
    when: always
    paths: [trivy-image.json]
    expire_in: 90 days

# ---------------- sbom: erzeugen und hochladen (Kap 7, Kap 6) -----------
sbom:generate:
  stage: sbom
  needs: [build:image]
  image:
    name: nexus:8082/anchore/syft:v1.54.1-debug
    entrypoint: [""]
  variables:
    SYFT_REGISTRY_INSECURE_USE_HTTP: "true"
  script:
    - syft scan "registry:$IMAGE@$IMAGE_DIGEST"
        -o cyclonedx-json=sbom.cdx.json
  artifacts:
    paths: [sbom.cdx.json]
    expire_in: 90 days

sbom:upload:
  stage: sbom
  needs: [build:image, sbom:generate]
  image: nexus:8082/alpine/k8s:1.31.13
  id_tokens:
    VAULT_ID_TOKEN:
      aud: http://vault:8200
  rules:
    - if: $CI_COMMIT_REF_PROTECTED == "true"
  script:
    - |
      VAULT_TOKEN=$(curl -sf -X POST "$VAULT_ADDR/v1/auth/jwt/login" \
        -d "{\"role\":\"demo-app\",\"jwt\":\"$VAULT_ID_TOKEN\"}" \
        | jq -r .auth.client_token)
      [ -n "$VAULT_TOKEN" ] && [ "$VAULT_TOKEN" != "null" ] \
        || { echo "FEHLER: Vault-Login fehlgeschlagen"; exit 1; }
      DT_API_KEY=$(curl -sf -H "X-Vault-Token: $VAULT_TOKEN" \
        "$VAULT_ADDR/v1/secret/data/demo-app/dtrack" \
        | jq -r .data.data.api_key)
      curl -sf -X POST "$DT_URL/api/v1/bom" -H "X-Api-Key: $DT_API_KEY" \
        -F "autoCreate=true" -F "projectName=demo-app" \
        -F "projectVersion=$IMAGE_TAG" -F "[email protected]"
      echo
      curl -sf -X POST -H "X-Vault-Token: $VAULT_TOKEN" \
        "$VAULT_ADDR/v1/auth/token/revoke-self"

# ---------------- handover: Release-Kandidat fuer Signatur (Kap 4/5) ----
release-candidate:
  stage: handover
  needs: [build:image, scan:image, sbom:generate, sbom:upload]
  image: nexus:8082/alpine/k8s:1.31.13
  rules:
    - if: $CI_COMMIT_TAG
  script:
    - |
      jq -n \
        --arg image "$IMAGE" --arg digest "$IMAGE_DIGEST" \
        --arg version "$APP_VERSION" --arg commit "$CI_COMMIT_SHA" \
        --arg pipeline "$CI_PIPELINE_URL" \
        --arg sbom "$(sha256sum sbom.cdx.json | cut -d' ' -f1)" \
        --arg scan "$(sha256sum trivy-image.json | cut -d' ' -f1)" \
        '{image: $image, digest: $digest, version: $version,
          commit: $commit, pipeline: $pipeline,
          sbom_sha256: $sbom, scan_sha256: $scan}' > release-candidate.json
    - cat release-candidate.json
  artifacts:
    paths: [release-candidate.json, sbom.cdx.json, trivy-image.json]
    expire_in: 90 days

Die wichtigsten Entscheidungen in Kürze:

  • Jedes Job-Image kommt von nexus:8082. Auch die Werkzeuge selbst sind Teil der Lieferkette. Die Versionen sind gepinnt und stammen aus deinem Spiegel; passe sie an den Stand deines Spiegels an (crane ls nexus:8082/aquasec/trivy hilft).
  • Kein Secret in CI/CD-Variablen. Der Dependency-Track-Schlüssel kommt nur in sbom:upload aus Vault und nur auf geschützten Refs. Das Token wird am Ende widerrufen. Hinweis: Das Schlüsselwort secrets: vault: ist in GitLab Premium vorbehalten; mit id_tokens und curl funktioniert es auch in CE.
  • Ab dem Build zählt nur IMAGE_DIGEST. Er wird per dotenv-Artefakt an alle folgenden Jobs weitergereicht.
  • Zwei Schwellen: eigene Abhängigkeiten ab MEDIUM (test:sca), Image-Inhalte ab HIGH mit verfügbarem Fix (scan:image).
  • Nichts wird in der Pipeline signiert. Der Release-Kandidat geht an den Signatur-Arbeitsplatz.

Achtung: Buildah braucht im Runner-Container je nach Umgebung zusätzliche Rechte (zum Beispiel ein angepasstes Seccomp-Profil). Welche Variante du nutzt und wie du sie härtest, hast du in Kapitel 2 entschieden. Ersetze build:image notfalls durch deinen Build-Job von dort, die restlichen Jobs bleiben gleich.

Für test:sast und test:iac nutzt die Pipeline deine Dateien aus Kapitel 8 (Schritte 3, 8 und 9): das Verzeichnis .semgrep/ mit den eigenen Regeln (Semgrep holt im Offline-Betrieb keine Regeln aus dem Internet) und .checkov.yaml, die auf die Baseline k8s/.checkov.baseline verweist und den begründeten Skip enthält. Kopiere die drei aus der Arbeitskopie von Kapitel 8 ins Repository und prüfe sie lokal:

cd ~/seclab/demo-app
cp -r ~/seclab/kap08/demo-app/.semgrep ~/seclab/kap08/demo-app/.checkov.yaml .
cp ~/seclab/kap08/demo-app/k8s/.checkov.baseline k8s/
semgrep scan --config .semgrep/ --error --metrics=off . ; echo "Exit: $?"
checkov -d k8s --framework kubernetes --config-file .checkov.yaml --compact
echo "Exit: $?"

Erwartet: zweimal Exit: 0. Die /ping-Route aus Kapitel 8 gibt es in diesem Repository nicht, und die Altbefunde in k8s/ stehen in der Baseline.

Schritt 6: Pipeline ausführen und Ergebnisse prüfen

Speichere die Datei als .gitlab-ci.yml, committe alles und stoße erst eine MR-Pipeline an:

git add .gitlab-ci.yml Dockerfile ci/ exceptions.yaml .trivyignore.yaml \
  .semgrep/ .checkov.yaml k8s/.checkov.baseline
git commit -m "release: demo-app 1.1.0 durch die ganze Kette"
git push -u origin release-1.1.0

Lege in GitLab einen Merge Request an. Erwartet: verify, test, build, scan und sbom:generate laufen grün. sbom:upload und release-candidate erscheinen nicht, weil der Branch nicht geschützt ist und kein Tag vorliegt. Genau so soll es sein.

Nach dem Merge setzt du den Release-Tag:

git switch main && git pull
git tag -a v1.1.0 -m "demo-app 1.1.0"
git push origin v1.1.0

Erwartet: Die Tag-Pipeline läuft komplett durch, inklusive sbom:upload und release-candidate. Im Log von sbom:upload steht eine JSON-Antwort mit einem token (die Verarbeitungs-ID von Dependency-Track). Im Frontend http://localhost:8088 taucht das Projekt demo-app in Version 1.1.0 mit seinen Komponenten auf.

Prüfe den Digest in der Build-Registry:

crane digest localhost:5001/demo-app:1.1.0

Erwartet: derselbe sha256:…-Wert wie IMAGE_DIGEST im Log von build:image.

Schritt 7: Release-Kandidat abholen und offline signieren

Jetzt wechselst du die Rolle: Du bist der Signatur-Arbeitsplatz (siehe Kapitel 5). Hol die Artefakte des Jobs release-candidate über die API. Das Token ist ein persönliches Lab-Token mit Scope read_api:

cd ~/seclab/kap11
export GITLAB_TOKEN="<dein Lab-Token>"
API="http://localhost:8929/api/v4/projects/root%2Fdemo-app"
curl -sf -H "PRIVATE-TOKEN: $GITLAB_TOKEN" -o rc.zip \
  "$API/jobs/artifacts/v1.1.0/download?job=release-candidate"
unzip -o rc.zip
DIGEST=$(jq -r .digest release-candidate.json)
echo "$DIGEST"

Erwartet: release-candidate.json, sbom.cdx.json, trivy-image.json liegen im Ordner, DIGEST beginnt mit sha256:.

Vor dem Signieren prüfst du, ob alles zusammenpasst. Unterschreibe nie etwas, das du nicht geprüft hast:

[ "$(crane digest localhost:5001/demo-app:1.1.0)" = "$DIGEST" ] \
  && echo "OK: Digest stimmt"
[ "$(shasum -a 256 sbom.cdx.json | cut -d' ' -f1)" = \
  "$(jq -r .sbom_sha256 release-candidate.json)" ] && echo "OK: SBOM stimmt"

Erwartet: zweimal OK. Jetzt signierst du das Image und hängst die SBOM als signierte Attestation an:

cosign sign --key ~/seclab/kap05/cosign.key --tlog-upload=false \
  "localhost:5001/demo-app@${DIGEST}"
cosign attest --key ~/seclab/kap05/cosign.key --tlog-upload=false \
  --type cyclonedx --predicate sbom.cdx.json \
  "localhost:5001/demo-app@${DIGEST}"

Nach Eingabe des Schlüssel-Passworts erwartet: Meldungen wie Pushing signature to: localhost:5001/demo-app bzw. ein Hinweis auf die hochgeladene Attestation.

Achtung: Mit cosign v3 sind je nach Version zusätzliche Flags nötig, etwa --use-signing-config=false, und das Standard-Ablageformat für Signaturen hat sich geändert. Prüfe cosign sign --help und nutze für dieses Lab cosign v2.x wie in Kapitel 0, damit Kyverno die Signaturen sicher findet.

Gegenprobe:

cosign verify --key ~/seclab/kap05/cosign.pub --insecure-ignore-tlog=true \
  "localhost:5001/demo-app@${DIGEST}" \
  | jq -r '.[0].critical.image["docker-manifest-digest"]'
cosign verify-attestation --key ~/seclab/kap05/cosign.pub \
  --insecure-ignore-tlog=true --type cyclonedx \
  "localhost:5001/demo-app@${DIGEST}" \
  | jq -r '.payload' | base64 -d | jq -r .predicateType

Erwartet: Der Digest aus critical.image und der Prädikattyp https://cyclonedx.org/bom. Diesen Wert brauchst du gleich in der Kyverno-Policy. Im Lab signierst du direkt gegen die Registry; die strikt getrennte Variante, bei der der Schlüssel einen vollständig isolierten Rechner nie verlässt, kennst du aus Kapitel 5.

Schritt 8: Übergabe-Bundle bauen

Das Bundle enthält das Image mit Signatur und Attestation, die Nachweise und eine signierte Prüfsummenliste (siehe Kapitel 4). Der öffentliche Schlüssel kommt nicht hinein.

rm -rf bundle && mkdir bundle
cosign save --dir bundle/image "localhost:5001/demo-app@${DIGEST}"
cp release-candidate.json sbom.cdx.json trivy-image.json bundle/
(cd bundle && find . -type f ! -name 'SHA256SUMS*' -print0 \
  | xargs -0 shasum -a 256 > SHA256SUMS)
cosign sign-blob --key ~/seclab/kap05/cosign.key --tlog-upload=false \
  --output-signature bundle/SHA256SUMS.sig bundle/SHA256SUMS
tar -czf demo-app-1.1.0-bundle.tar.gz -C bundle .
ls -lh demo-app-1.1.0-bundle.tar.gz

Erwartet: ein Archiv von einigen zehn MB. Auf Linux kannst du statt shasum -a 256 auch sha256sum verwenden.

Schritt 9: Quarantäne und Freigabe in der Zielzone

Simuliere die Zonengrenze, indem du das Archiv in ein eigenes Verzeichnis „hinüberträgst”:

rm -rf ziel && mkdir ziel
tar -xzf demo-app-1.1.0-bundle.tar.gz -C ziel
cd ziel
cosign verify-blob --key ~/seclab/kap05/cosign.pub \
  --insecure-ignore-tlog=true --signature SHA256SUMS.sig SHA256SUMS
shasum -a 256 -c SHA256SUMS | grep -v ': OK$' || echo "OK: alle Prüfsummen"

Erwartet: Verified OK und OK: alle Prüfsummen. Der öffentliche Schlüssel kommt in der Zielzone aus ihrem eigenen Vertrauensspeicher, hier simuliert durch ~/seclab/kap05/cosign.pub.

Jetzt lädst du das Image in die Quarantäne und prüfst dort erneut:

DIGEST=$(jq -r .digest release-candidate.json)
cosign load --dir image localhost:5002/quarantaene/demo-app
cosign verify --key ~/seclab/kap05/cosign.pub --insecure-ignore-tlog=true \
  "localhost:5002/quarantaene/demo-app@${DIGEST}" > /dev/null \
  && echo "OK: Signatur in Quarantäne gültig"
trivy image --scanners vuln --severity HIGH,CRITICAL --ignore-unfixed \
  --exit-code 1 -q "localhost:5002/quarantaene/demo-app@${DIGEST}" \
  && echo "OK: Re-Scan in Zielzone ohne HIGH/CRITICAL"

Erwartet: beide OK-Zeilen. Der Re-Scan ist wichtig, weil zwischen Build und Übergabe neue CVEs veröffentlicht worden sein können. In einer echten air-gapped Zone nutzt Trivy dafür eine eigens übertragene Datenbank (siehe Kapitel 8).

Freigabe: Das geprüfte Bundle wird in das Produktiv-Repository geladen und mit dem Versions-Tag versehen:

cosign load --dir image localhost:5002/demo-app
crane tag "localhost:5002/demo-app@${DIGEST}" 1.1.0
crane digest localhost:5002/demo-app:1.1.0
crane ls localhost:5002/demo-app
cd ..

Erwartet: Der Digest entspricht $DIGEST. crane ls zeigt 1.1.0 sowie die cosign-Tags sha256-….sig und sha256-….att.

Merke: Quarantäne und Freigabe sind getrennte Repositories mit getrennten Rechten. Aus quarantaene/ darf im Cluster nie etwas laufen. Das erzwingt gleich die Kyverno-Policy.

Schritt 10: Kyverno-Policies der Zielzone

Wenn du die Policies aus Kapitel 9 schon hast, vergleiche sie mit diesen. Neu ist hier vor allem die Pflicht zur SBOM-Attestation.

cat > zielzone-policies.yaml <<'EOF'
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: verify-demo-app-supply-chain
spec:
  webhookTimeoutSeconds: 30
  rules:
    - name: signatur-und-sbom
      match:
        any:
          - resources:
              kinds: ["Pod"]
              namespaces: ["demo"]
      verifyImages:
        - imageReferences: ["reg-ziel:5000/*"]
          failureAction: Enforce
          mutateDigest: true
          verifyDigest: true
          required: true
          attestors:
            - entries:
                - keys:
                    publicKeys: PLATZHALTER
                    rekor:
                      ignoreTlog: true
                    ctlog:
                      ignoreSCT: true
          attestations:
            - type: https://cyclonedx.org/bom
              attestors:
                - entries:
                    - keys:
                        publicKeys: PLATZHALTER
                        rekor:
                          ignoreTlog: true
                        ctlog:
                          ignoreSCT: true
---
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: restrict-image-registries
spec:
  rules:
    - name: nur-zielregistry
      match:
        any:
          - resources:
              kinds: ["Pod"]
              namespaces: ["demo"]
      validate:
        failureAction: Enforce
        message: "Nur freigegebene Images aus reg-ziel:5000 sind erlaubt."
        pattern:
          spec:
            containers:
              - image: "reg-ziel:5000/*"
    - name: keine-quarantaene
      match:
        any:
          - resources:
              kinds: ["Pod"]
              namespaces: ["demo"]
      validate:
        failureAction: Enforce
        message: "Images aus der Quarantäne dürfen nicht laufen."
        pattern:
          spec:
            containers:
              - image: "!reg-ziel:5000/quarantaene/*"
EOF
PUB="$HOME/seclab/kap05/cosign.pub" yq -i \
  '(.. | select(tag == "!!str" and . == "PLATZHALTER")) = load_str(strenv(PUB))' \
  zielzone-policies.yaml
grep -c "BEGIN PUBLIC KEY" zielzone-policies.yaml
kubectl apply -f zielzone-policies.yaml
kubectl get clusterpolicy verify-demo-app-supply-chain restrict-image-registries

Erwartet: 2 (der Schlüssel steht an beiden Stellen), danach beide Policies mit READY = True.

Der yq-Befehl ersetzt jeden Text PLATZHALTER durch den Inhalt der Datei cosign.pub. So tippst du den Schlüssel nie von Hand ab. Feldnamen wie failureAction auf Ebene von verifyImages gibt es ab Kyverno 1.13; bei älteren Versionen steht stattdessen spec.validationFailureAction: Enforce.

Schritt 11: Deployment über Argo CD

Bis hierher liest Argo CD die Manifeste aus k8s/ des Anwendungsprojekts root/demo-app (siehe Kapitel 1). Für Releases trennst du Anwendung und Auslieferung: Wer Code ändert, ändert damit nicht automatisch, was im Cluster läuft. Lege dafür einmalig das Deploy-Repository an, mit den aktuellen Manifesten als Startpunkt. GitLab legt das Projekt wie in Kapitel 1 beim ersten Push an (Benutzer root, Passwort ist dein glpat--Token):

mkdir -p ~/seclab/demo-deploy && cd ~/seclab/demo-deploy
git init -q -b main
cp -r ~/seclab/demo-app/k8s . && rm -f k8s/.checkov.baseline
git add k8s && git commit -qm "deploy: Manifeste aus demo-app übernommen"
git remote add origin http://localhost:8929/root/demo-deploy.git
git push -u origin main

Erwartet: remote: The private project root/demo-deploy was successfully created.

Argo CD braucht Lesezugriff auf das neue Projekt. Lege wie in Kapitel 1, Schritt 12, im Projekt demo-deploy ein Deploy-Token argocd mit Scope read_repository an. Dann meldest du dich bei Argo CD an und stellst die Application demo-app auf das neue Repository um:

kubectl -n argocd port-forward svc/argocd-server 8443:443 >/dev/null 2>&1 &
ARGO_PF=$!
sleep 3
argocd login localhost:8443 --username admin --insecure \
  --password "$(argocd admin initial-password -n argocd | head -n1)"
GITLAB_IP=$(docker inspect -f \
  '{{(index .NetworkSettings.Networks "kind").IPAddress}}' gitlab)
read -r DT_USER    # Deploy-Token-Benutzer, z. B. gitlab+deploy-token-2
read -rs DT_PASS   # Token, wird nicht angezeigt
argocd repo add "http://${GITLAB_IP}:8929/root/demo-deploy.git" \
  --username "$DT_USER" --password "$DT_PASS"
unset DT_PASS
argocd app set demo-app \
  --repo "http://${GITLAB_IP}:8929/root/demo-deploy.git" --path k8s
argocd app get demo-app | grep -E '^(Repo|Sync Status):'

Erwartet: Repo: endet auf /root/demo-deploy.git, dazu Sync Status: Synced. Die Manifeste sind dieselben, deshalb startet Argo CD keine neuen Pods. Hast du das Admin-Passwort von Argo CD geändert, gib es bei argocd login direkt ein.

Im Deploy-Repository setzt du jetzt das Image auf Tag und Digest. Der Tag ist für Menschen lesbar, der Digest ist verbindlich. APP_VERSION im Deployment ziehst du mit, sonst meldet /version weiter 1.0.0:

cd ~/seclab/demo-deploy
git switch -c demo-app-1.1.0
DIGEST=$(jq -r .digest ~/seclab/kap11/release-candidate.json)
NEW_IMAGE="reg-ziel:5000/demo-app:1.1.0@${DIGEST}" yq -i \
  '(select(.kind == "Deployment") | .spec.template.spec.containers[0].image)
     = strenv(NEW_IMAGE)' k8s/deployment.yaml
yq -i '(select(.kind == "Deployment") | .spec.template.spec.containers[0].env[]
     | select(.name == "APP_VERSION") | .value) = "1.1.0"' k8s/deployment.yaml
git diff
git commit -am "demo-app 1.1.0 (${DIGEST})"
git push -u origin demo-app-1.1.0

Erwartet im Diff: nur die Image-Zeile und der Wert von APP_VERSION ändern sich. Lege den MR an, lass ihn reviewen und merge ihn. Argo CD erkennt die Änderung beim nächsten Abgleich; du kannst nachhelfen:

argocd app sync demo-app
argocd app wait demo-app --health --timeout 180
kubectl -n demo get deploy demo-app \
  -o jsonpath='{.spec.template.spec.containers[0].image}{"\n"}'
kubectl -n demo port-forward deploy/demo-app 8000:8000 >/dev/null &
APP_PF=$!
sleep 2; curl -s http://localhost:8000/version; kill "$APP_PF"

Erwartet: Argo CD meldet Synced und Healthy, das Image enthält @sha256:…, und /version liefert 1.1.0.

Ein Blick in die Policy Reports bestätigt, dass Kyverno geprüft hat:

kubectl -n demo get policyreport -o json | jq -r '.items[].results[]?
  | select(.policy == "verify-demo-app-supply-chain")
  | "\(.rule) \(.result)"' | sort | uniq -c

Erwartet: Zeilen mit pass für die Regel signatur-und-sbom (bzw. ihre Auto-Gen-Variante).

Schritt 12: Fehlerszenarien durchspielen

Eine Kette ist nur so gut wie ihre Reaktion auf Fehler. Spiele die vier Szenarien nacheinander durch. Für jedes gibt es ein erwartetes Ergebnis; weicht deines ab, hast du eine Lücke gefunden.

Szenario A: unsigniertes Image. Jemand schiebt an der Übergabe vorbei ein verändertes Image direkt in die Zielregistry. crane mutate erzeugt ein neues Image mit neuem Digest, für das es keine Signatur gibt:

crane mutate localhost:5002/demo-app:1.1.0 \
  --label seclab.test=unsigniert -t localhost:5002/demo-app:unsigniert
kubectl -n demo run unsigniert --image=reg-ziel:5000/demo-app:unsigniert

Erwartet: Abweisung durch den Admission-Webhook, sinngemäß:

Error from server: admission webhook "mutate.kyverno.svc-fail" denied the request:
... verify-demo-app-supply-chain ... signatur-und-sbom:
failed to verify image reg-ziel:5000/demo-app:unsigniert:
.attestors[0].entries[0].keys: no signatures found

Szenario B: Image aus Docker Hub. Zwei Stellen fangen das ab. Im Cluster:

kubectl -n demo run nginx --image=docker.io/library/nginx:1.27

Erwartet: Abweisung durch restrict-image-registries, Regel nur-zielregistry, mit der Meldung „Nur freigegebene Images aus reg-ziel:5000 sind erlaubt.”

In der Pipeline: Ändere im Branch die erste FROM-Zeile auf FROM python:3.12-slim AS build und pushe. Erwartet: Job verify:bezugsweg schlägt fehl mit FEHLER: Basis-Image am Spiegel vorbei: FROM python:3.12-slim AS build. Alle späteren Stages laufen nicht. Selbst wenn jemand den Check entfernt, scheitert der Build, weil der Runner keinen Weg ins Internet hat (siehe Kapitel 3). Mach die Änderung danach rückgängig.

Szenario C: kritische CVE. Ein Entwickler fügt eine alte Bibliothek hinzu:

cd ~/seclab/demo-app
echo "pyyaml==5.3.1" >> requirements.txt
trivy fs --scanners vuln --severity MEDIUM,HIGH,CRITICAL \
  --ignorefile .trivyignore.yaml --exit-code 1 -q . ; echo "Exit: $?"

Erwartet: Die Tabelle zeigt pyyaml CVE-2020-14343 CRITICAL fixed 5.4, Exit: 1. In der Pipeline scheitert test:sca, der Build startet gar nicht erst. Die richtige Reaktion ist ein Upgrade (pyyaml>=5.4), keine Ausnahme: Für eine kritische, behebbare CVE wird das Security-Team keine Frist genehmigen. Entferne die Zeile wieder:

git checkout -- requirements.txt

Szenario D: abgelaufene Ausnahme. Simuliere, dass die Frist von EXC-2026-001 verstrichen ist:

cp exceptions.yaml exceptions.yaml.orig
cp .trivyignore.yaml .trivyignore.yaml.orig
yq -i '.exceptions[0].expires = "2026-01-01"' exceptions.yaml
sed -i.bak 's/expired_at: .*/expired_at: 2026-01-01/' .trivyignore.yaml
ci/check-exceptions.sh exceptions.yaml; echo "Exit: $?"
trivy fs --scanners vuln --severity MEDIUM,HIGH,CRITICAL \
  --ignorefile .trivyignore.yaml --exit-code 1 -q . > /dev/null; echo "Exit: $?"
mv exceptions.yaml.orig exceptions.yaml
mv .trivyignore.yaml.orig .trivyignore.yaml && rm -f .trivyignore.yaml.bak

Für .trivyignore.yaml nutzen wir hier sed statt yq, weil Trivy expired_at nur als ungequotetes YAML-Datum akzeptiert. yq würde einen gequoteten Text schreiben, und Trivy bricht dann mit einem Parse-Fehler ab.

Erwartet: FEHLER EXC-2026-001: abgelaufen seit 2026-01-01 mit Exit: 1, und der Trivy-Scan liefert ebenfalls Exit: 1, weil die Ignores nicht mehr greifen. Die Pipeline wird also an zwei Stellen rot: in verify:ausnahmen und in test:sca. Weil verify:ausnahmen auch in der nächtlichen Schedule-Pipeline läuft, merkt das Team den Ablauf am nächsten Morgen, nicht erst beim nächsten Release. Für Kyverno-Ausnahmen übernimmt das der CronJob aus Kapitel 10.

Zusammengefasst:

Szenario Wer stoppt? Wo?
A: unsigniertes Image Kyverno verifyImages Admission im Cluster
B: Docker-Hub-Image Pipeline-Check, Kyverno-Registry-Regel CI und Cluster
C: kritische CVE test:sca (Trivy-Schwelle) CI, vor dem Build
D: abgelaufene Ausnahme Register-Check, Trivy expired_at CI, auch nachts

Schritt 13: Aufräumen

kubectl -n demo delete pod unsigniert nginx --ignore-not-found
crane delete "localhost:5002/demo-app@$(crane digest \
  localhost:5002/demo-app:unsigniert)" 2>/dev/null || true
rm -rf ~/seclab/kap11/ziel ~/seclab/kap11/bundle ~/seclab/kap11/rc.zip
kill "$ARGO_PF" 2>/dev/null
unset GITLAB_TOKEN VAULT_TOKEN

Erwartet: Die Test-Pods sind weg. crane delete funktioniert nur, wenn deine registry:2 mit REGISTRY_STORAGE_DELETE_ENABLED=true läuft; sonst bleibt das Test-Image liegen, was im Lab unkritisch ist. Die Deployment-Version 1.1.0 und die Policies lässt du stehen, sie sind dein Referenzzustand. Wenn du das Lab komplett beenden willst, stoppst du die Container mit docker stop und löschst den Cluster mit kind delete cluster --name seclab.

Fortschritt speichern? Kostenlos registrieren

Definition of Done

Ein Release ist erst „fertig”, wenn alle Punkte belegt sind. Diese Checkliste kannst du direkt als MR-Vorlage im Deploy-Repository ablegen.

Nr Kriterium Nachweis
1 Alle Basis-Images und Pakete über Nexus Job verify:bezugsweg grün
2 Build in CI aus getaggtem Commit Tag-Pipeline, Label revision
3 Keine Secrets in Variablen oder Repo test:secrets grün, Vault-Audit
4 SAST, SCA, IaC unter Schwelle Jobs test:* grün, Reports
5 Image-Scan ohne HIGH/CRITICAL mit Fix trivy-image.json
6 SBOM erzeugt und in Dependency-Track Projekt demo-app 1.1.0
7 Signatur und SBOM-Attestation am Digest cosign verify(-attestation)
8 Bundle mit signierten Prüfsummen SHA256SUMS.sig verifiziert
9 Quarantäne: Signatur und Re-Scan ok Protokoll der Freigabe
10 Deployment per GitOps-MR mit Digest MR im Deploy-Repo, Argo CD
11 Kyverno-Prüfung bestanden Policy Report pass
12 Alle Ausnahmen gültig und befristet verify:ausnahmen grün

Typische Stolperfallen

Symptom Ursache Lösung
Job-Image lässt sich nicht ziehen Nexus nicht als Insecure Registry beim Runner Docker-Daemon-Konfig (Kap 1, 3)
sbom:upload fehlt in MR-Pipeline Absicht: nur geschützte Refs Tag v* schützen und taggen
Vault-Login liefert null aud, Issuer oder bound_claims passen nicht id_token-Claims mit Rolle vergleichen
Dependency-Track antwortet 403 API-Key ohne PROJECT_CREATION_UPLOAD Berechtigung im Team ergänzen
Kyverno: „no signatures found” trotz Signatur Signatur nicht mitkopiert oder cosign-v3-Format crane ls, cosign v2 nutzen
Kyverno erreicht Registry nicht HTTP-Registry ohne Freigabe --allowInsecureRegistry (Kap 9)
Attestation-Prüfung schlägt fehl Falscher type in der Policy predicateType mit cosign auslesen
Re-Scan in Zielzone rot, CI war grün neue CVE seit dem Build Neuer Build, ggf. befristete Ausnahme
Argo CD bleibt OutOfSync Kyverno ändert Tag zu Digest (mutateDigest) Digest schon im Git setzen

Übung: Die fehlende SBOM-Attestation

Ein Kollege hat eine dringende Version 1.1.1 gebaut und signiert, aber vergessen, die SBOM zu attestieren. Er hat sie korrekt über Bundle und Quarantäne in localhost:5002/demo-app:1.1.1 freigegeben.

Deine Aufgabe:

  1. Sag vorher, was beim Deployment passiert und welche Policy-Regel reagiert.
  2. Stell das Szenario nach. Du brauchst keinen neuen Build: Erzeuge mit crane mutate aus 1.1.0 ein neues Image 1.1.1 in localhost:5001, signiere es, aber attestiere es nicht. Übertrage es (vereinfacht: direkt per cosign save/cosign load) nach localhost:5002/demo-app.
  3. Versuche, es im Namespace demo zu starten, und lies die Fehlermeldung.
  4. Behebe das Problem richtig und weise nach, dass der Pod danach startet.

Hinweis 1

Die Policy verify-demo-app-supply-chain hat zwei Teile: attestors (Signatur) und attestations (SBOM). Beide müssen erfüllt sein. Welche Teile davon erfüllt 1.1.1?

Hinweis 2

Für die richtige Behebung brauchst du eine SBOM, die genau zu diesem Digest gehört. Eine alte SBOM von 1.1.0 anzuhängen wäre falsch, auch wenn Kyverno es nicht merken würde. Erzeuge sie mit syft scan registry:localhost:5001/demo-app@<digest>.

Lösung

Vorhersage: Die Signaturprüfung besteht, die Attestation-Prüfung nicht. Kyverno weist den Pod mit einem Fehler zur Regel signatur-und-sbom ab, sinngemäß „no matching attestations” für den Typ https://cyclonedx.org/bom.

cd ~/seclab/kap11
crane mutate localhost:5001/demo-app:1.1.0 \
  --label org.opencontainers.image.version=1.1.1 \
  -t localhost:5001/demo-app:1.1.1
D=$(crane digest localhost:5001/demo-app:1.1.1)
cosign sign --key ~/seclab/kap05/cosign.key --tlog-upload=false \
  "localhost:5001/demo-app@${D}"
rm -rf b111 && cosign save --dir b111 "localhost:5001/demo-app@${D}"
cosign load --dir b111 localhost:5002/demo-app
crane tag "localhost:5002/demo-app@${D}" 1.1.1
kubectl -n demo run demo-111 --image="reg-ziel:5000/demo-app:1.1.1@${D}"

Erwartet: Abweisung durch verify-demo-app-supply-chain, Regel signatur-und-sbom, mit einem Hinweis auf die fehlende Attestation.

Richtige Behebung: SBOM für genau diesen Digest erzeugen, attestieren, Bundle neu übertragen:

syft scan "registry:localhost:5001/demo-app@${D}" \
  -o cyclonedx-json=sbom-1.1.1.cdx.json
cosign attest --key ~/seclab/kap05/cosign.key --tlog-upload=false \
  --type cyclonedx --predicate sbom-1.1.1.cdx.json \
  "localhost:5001/demo-app@${D}"
rm -rf b111 && cosign save --dir b111 "localhost:5001/demo-app@${D}"
cosign load --dir b111 localhost:5002/demo-app
kubectl -n demo run demo-111 --image="reg-ziel:5000/demo-app:1.1.1@${D}"
kubectl -n demo wait --for=condition=Ready pod/demo-111 --timeout=60s
kubectl -n demo delete pod demo-111

Erwartet: pod/demo-111 created, dann condition met. Die eigentliche Lehre: Der Kollege hat einen Schritt manuell vergessen. Langfristig gehört die Attestation in dasselbe Skript wie die Signatur, damit es nur „beides oder nichts” gibt. Und in einer echten Organisation wäre 1.1.1 natürlich durch die Pipeline gelaufen, nicht per crane mutate entstanden.

Fortschritt speichern? Kostenlos registrieren

Aus der Praxis

In regulierten Umgebungen (Behörden, KRITIS, Verteidigung) sieht die Kette strukturell genauso aus, nur die Glieder sind auf mehr Personen und Systeme verteilt:

  • Rollentrennung (Vier-Augen-Prinzip): Wer den Code schreibt, darf nicht signieren. Wer signiert, darf nicht in der Zielzone freigeben. Jede Rolle hat eigene Konten, eigene Rechner und eigene Protokolle.
  • Signatur-Arbeitsplatz: Ein gehärteter, netzloser Rechner, oft mit HSM oder Smartcard. Release-Kandidaten kommen per Datenträger-Schleuse oder Datendiode, Signaturen gehen auf demselben Weg zurück.
  • Freigabeprotokoll: Die Quarantäne erzeugt pro Bundle ein Protokoll (Prüfsummen, Signaturprüfung, Re-Scan, Freigebender, Zeitpunkt). Dieses Protokoll ist das zentrale Dokument im Audit.
  • Monitoring der Kette selbst: Alarm bei abgelehnten Admission-Requests (Kyverno-Metriken), bei Pipeline-Läufen mit deaktivierten Sicherheitsjobs, bei Vault-Logins mit unbekannten Claims und bei bald ablaufenden Ausnahmen.
  • Regelmäßige Übungen: Die vier Fehlerszenarien aus Schritt 12 eignen sich als vierteljährlicher Test. Das ist wie eine Brandschutzübung: Erst wenn die Kette nachweislich Fehler stoppt, ist sie belastbar.
  • Notfallpfad: Für kritische Sicherheitsupdates gibt es einen beschleunigten, aber nicht verkürzten Weg: dieselben Prüfungen, nur mit Bereitschaftsrollen statt Wochenplanung.

Reflexionsfragen

Nimm dir für diese Fragen Zeit und beantworte sie schriftlich. Es gibt keine Musterlösung; es geht darum, deine eigene Kette zu verstehen.

  • Welches Glied deiner Kette ist am schwächsten, und woran merkst du das?
  • Wenn ein Angreifer den GitLab-Runner übernimmt: Was kann er erreichen, was nicht? Welche Rolle spielt der Offline-Schlüssel dabei?
  • Was passiert, wenn der Signatur-Arbeitsplatz zwei Wochen ausfällt? Gibt es einen geordneten Ausweichweg?
  • Welche Nachweise aus diesem Kapitel würdest du einem Auditor zuerst zeigen?
  • Welche der Prüfungen könnten Teams als lästig empfinden, und wie würdest du sie nach Kapitel 10 einführen?
  • Wo verlässt du dich noch auf Tags statt auf Digests?

Ausblick

Deine Kette ist solide. Drei Erweiterungen lohnen sich als nächster Schritt.

SLSA Build Level 3

SLSA (Supply-chain Levels for Software Artifacts) beschreibt Reifegrade für Builds. Für Build Level 3 muss die Build-Plattform einen Herkunftsnachweis (Provenance) erzeugen, den die Build-Schritte selbst nicht fälschen können, und die einzelnen Builds müssen voneinander isoliert sein. In deiner Kette würde das bedeuten: Nicht ein Job in der .gitlab-ci.yml schreibt die Provenance, sondern ein vertrauenswürdiger Dienst außerhalb des Jobs, mit eigenem Schlüssel, und Kyverno prüft zusätzlich eine https://slsa.dev/provenance/v1-Attestation (Builder-ID, Quell-Repository, Commit).

Interne Rekor-Instanz

Im Lab signierst du ohne Transparenzlog (--tlog-upload=false). Eine eigene Rekor-Instanz in der internen Zone gibt dir ein manipulationssicheres, nur anhängbares Protokoll aller Signaturen. Damit erkennst du auch Signaturen, die mit einem gestohlenen Schlüssel heimlich erzeugt wurden. Kyverno würde dann statt ignoreTlog: true die URL und den öffentlichen Schlüssel deines Rekor prüfen. Für zeitliche Nachweise ergänzt man oft eine eigene Timestamp Authority.

Notary Project (Notation) als Alternative

Notation ist das Werkzeug des CNCF Notary Project (oft „Notary v2” genannt). Es signiert OCI-Artefakte mit klassischen X.509-Zertifikaten und speichert Signaturen über die OCI-Referrers-Schnittstelle. Für Organisationen mit bestehender PKI (wie deiner Offline-Root-CA aus Kapitel 5) ist das attraktiv: Vertrauen wird über eine Trust-Policy an Zertifikatsketten gebunden, nicht an einzelne Schlüssel. Kyverno unterstützt Notation über type: Notary in verifyImages. Die Entscheidung Cosign oder Notation hängt vor allem an deiner PKI-Strategie und an den Werkzeugen, die deine Registry unterstützt.

Interviewfragen

F: Beschreibe in zwei Minuten eine sichere Lieferkette für Container-Images. A: Bezug nur über einen Spiegel, Build in einer gehärteten CI aus getaggtem Commit, Secrets per kurzlebigem Token aus Vault, Scans mit klaren Schwellen, SBOM in Dependency-Track. Dann Offline-Signatur und SBOM-Attestation am Digest, Übergabe als Bundle mit signierten Prüfsummen in eine Quarantäne, Re-Scan und Freigabe. Deployment per GitOps mit Digest, Kyverno prüft Signatur, Attestation und Herkunftsregistry. Ausnahmen laufen befristet über ein Register.

F: Warum signiert die Pipeline nicht selbst? A: Weil ein kompromittierter Runner sonst beliebige Images gültig signieren könnte. Mit Offline-Signatur braucht ein Angreifer zusätzlich Zugriff auf einen getrennten Arbeitsplatz mit eigenem Schlüssel. Der Preis ist ein manueller Schritt, den man durch klare Prüfskripte absichert.

F: Warum scannst du in der Zielzone noch einmal, obwohl die CI schon gescannt hat? A: Weil zwischen Build und Freigabe Tage liegen können, in denen neue CVEs bekannt werden. Außerdem ist die Zielzone ein eigener Vertrauensbereich; sie verlässt sich nicht blind auf Ergebnisse aus einer anderen Zone.

F: Ein Team will ein Image direkt aus Docker Hub deployen, „nur zum Testen”. Wie reagierst du? A: Ich erkläre, dass Bezug nur über den Spiegel erlaubt ist, und biete an, das Image in den Spiegel aufzunehmen, inklusive Scan. Für reine Tests gibt es eine Sandbox außerhalb der Produktionskette. Technisch verhindern es Netzwerk-Egress-Sperren, der Pipeline-Check und die Kyverno-Registry-Regel.

F: Woran erkennst du, dass ein Deployment genau das geprüfte Image nutzt? A: Am Digest. Er steht im Release-Kandidaten, in Signatur und Attestation, im Bundle und im Deploy-Manifest. Kyverno prüft die Signatur gegen diesen Digest und mit mutateDigest wird auch ein Tag auf den Digest festgeschrieben.

F: Eine kritische CVE wird am Freitagabend in einem laufenden Image bekannt. Was tust du? A: Bewerten, ob die verwundbare Komponente erreichbar ist. Wenn ja: Fix über den normalen, beschleunigten Weg bauen, signieren, übergeben. Bis dahin kompensieren, zum Beispiel per NetworkPolicy oder WAF-Regel, und das als befristete Ausnahme dokumentieren. Dependency-Track zeigt, welche anderen Projekte dieselbe Komponente enthalten.

F: Was würdest du an dieser Kette als Nächstes verbessern? A: Nicht fälschbare Provenance Richtung SLSA Build L3, eine interne Rekor-Instanz für Transparenz und die Automatisierung der Signatur-Vorprüfung, damit der manuelle Schritt kleiner wird. Je nach PKI-Strategie lohnt auch ein Blick auf Notation.

Zusammenfassung

Das hast du gelernt:

  • Eine sichere Lieferkette ist eine Folge von Prüfpunkten, von denen jeder einen nachvollziehbaren Nachweis erzeugt.
  • Der Digest ist der rote Faden von Build bis Deployment; Tags sind nur Etiketten.
  • Die vollständige .gitlab-ci.yml bezieht alles über den Spiegel, holt Secrets per id_token aus Vault, scannt mit Schwellen und erzeugt SBOM und Release-Kandidat, signiert aber nicht selbst.
  • Signatur und SBOM-Attestation entstehen offline; Image und Vertrauensanker reisen getrennt.
  • Übergabe-Bundle, Quarantäne mit Re-Scan und getrennte Freigabe sichern die Zonengrenze.
  • Argo CD rollt per GitOps-MR aus, Kyverno lässt nur signierte, attestierte Images aus der freigegebenen Registry zu.
  • Die vier Fehlerszenarien zeigen, dass die Kette an der richtigen Stelle stoppt, und eignen sich als regelmäßige Übung.
  • Befristete Ausnahmen halten die Kette arbeitsfähig, ohne sie aufzuweichen; ihr Ablauf macht die Pipeline automatisch wieder rot.