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.ymlaussieht, 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:
- Der Spiegel: Er bestimmt, welche fremden Bausteine überhaupt hereinkommen.
- Der Signaturschlüssel: Er liegt offline auf dem Signatur-Arbeitsplatz, nie in der Pipeline (siehe Kapitel 5).
- 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-Netzkindund erreicht dortnexus,vault,reg-buildunddtrack-apiserverper Containername (siehe Kapitel 1). - Nexus spiegelt Docker Hub unter
nexus:8082und PyPI als Repositorypypi-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ührtnexus:8082als 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 darfreg-ziel:5000per 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-Repositoryroot/demo-deploylegst du in Schritt 11 an und stellst die Argo-CD-Applicationdemo-appaus Kapitel 1 darauf um. Heißen deine Projekte anders, passe Pfade,bound_claimsund 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 podsErwartet: 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/_catalogErwartet: 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.0Die 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.yamlErwartet: 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-appErwartet:
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_UPLOADundPROJECT_CREATION_UPLOAD, sonst scheitertautoCreate.
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 daysDie 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/trivyhilft). - Kein Secret in CI/CD-Variablen. Der
Dependency-Track-Schlüssel kommt nur in
sbom:uploadaus Vault und nur auf geschützten Refs. Das Token wird am Ende widerrufen. Hinweis: Das Schlüsselwortsecrets: vault:ist in GitLab Premium vorbehalten; mitid_tokensundcurlfunktioniert es auch in CE. - Ab dem Build zählt nur
IMAGE_DIGEST. Er wird perdotenv-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:imagenotfalls 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.0Lege 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.0Erwartet: 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.0Erwartet: 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üfecosign sign --helpund 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 .predicateTypeErwartet: 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.gzErwartet: 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-registriesErwartet: 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 mainErwartet:
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.0Erwartet 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 -cErwartet: 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:unsigniertErwartet: 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.27Erwartet: 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.txtSzenario 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.bakFü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_TOKENErwartet: 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:
- Sag vorher, was beim Deployment passiert und welche Policy-Regel reagiert.
- Stell das Szenario nach. Du brauchst keinen neuen Build: Erzeuge mit
crane mutateaus 1.1.0 ein neues Image1.1.1inlocalhost:5001, signiere es, aber attestiere es nicht. Übertrage es (vereinfacht: direkt percosign save/cosign load) nachlocalhost:5002/demo-app. - Versuche, es im Namespace
demozu starten, und lies die Fehlermeldung. - 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-111Erwartet: 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.ymlbezieht alles über den Spiegel, holt Secrets perid_tokenaus 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.