Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Security – Secure SDLC und Supply Chain

Ziel: Für das Gateway-Image eine SBOM erzeugen, es scannen, signieren und attestieren, einen CVE-Response-Drill durchspielen und Kyverno-Policies offline testen. · Dauer: ca. 180 min · Voraussetzung: Tag 4, Tag 6

Briefing

  • Supply Chain heißt: Du weißt, was im Image steckt (SBOM). Du weißt, welche Lücken bekannt sind (Scan). Du beweist, wer es gebaut hat (Signatur, Provenance).
  • Ein Scanner-Treffer ist noch kein Incident. Zur Triage gehören drei Fragen: Wird der Code erreicht? Wie wahrscheinlich ist ein Exploit (EPSS, KEV)? Wie schlimm wäre er (CVSS)?
  • Der Cluster vertraut nur signierten Images. Das erzwingt eine Admission-Policy (Kyverno), nicht die Disziplin der Teams.
  • Bei LLMs kommen dazu: Modellgewichte als Lieferkette, Prompt Injection und Datenfluss zwischen Mandanten.
Code -> Test/Lint -> govulncheck -> Build -> SBOM -> Scan -> Sign + Attest -> Registry
                                                                                 |
                        Kyverno (Admission): nur signiert, kein :latest, Limits  v
                                                                             Cluster

Drill 1: SBOM mit syft

mkdir -p ~/sre-lab/tag13 && cd ~/sre-lab/tag13
syft scan llm-gateway:dev -o table \
  -o spdx-json=sbom.spdx.json -o cyclonedx-json=sbom.cdx.json

Erwartet (gekürzt):

NAME                                 VERSION           TYPE
base-files                           12.4+deb12u15     deb
ca-certificates                      20250419~deb12u1  deb
github.com/prometheus/client_golang  v1.25.0           go-module
golang.org/x/time                    v0.16.0           go-module
stdlib                               go1.26.9          go-module
tzdata                               2026b-0+deb12u1   deb
jq -r '.spdxVersion, (.packages | length)' sbom.spdx.json
jq '[.components[].type] | group_by(.) | map({(.[0]): length}) | add' sbom.cdx.json
jq -r '.components[] | select(.name=="golang.org/x/time") | .purl' sbom.cdx.json

Erwartet:

SPDX-2.3
18
{
  "file": 950,
  "library": 17,
  "operating-system": 1
}
pkg:golang/golang.org/x/[email protected]

Warum? syft liest die Debian-Pakete aus distroless und die Go-Module aus den Build-Infos im Binary. Die purl ist der Schlüssel, über den Scanner Lücken zuordnen. SPDX kommt eher aus der Compliance-Welt (Lizenzen), CycloneDX aus der Security-Welt (VEX). Viele Kunden verlangen eins von beiden.

Tipp: Mit Colima oder Podman findet syft den Docker-Daemon nicht von selbst. Setze dann export DOCKER_HOST=unix://$HOME/.colima/default/docker.sock. Das gilt auch für trivy und grype.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Scannen mit trivy, grype und pip-audit

trivy image -q --scanners vuln llm-gateway:dev
trivy fs -q --scanners vuln ~/sre-lab/code/llm-gateway
grype -q llm-gateway:dev
grype -q sbom:sbom.spdx.json

Erwartet (gekürzt, beim ersten Lauf lädt trivy etwa 120 MB Datenbank):

│ llm-gateway:dev (debian 12.15) │  debian  │        1        │
│ llm-gateway                    │ gobinary │        0        │
│ tzdata  │ DLA-4792-1  │ UNKNOWN │ fixed │ 2026b-0+deb12u1 │ 2026c-0+deb12u1 │
│ go.mod │ gomod │        0        │
No vulnerabilities found
No vulnerabilities found

Der tzdata-Treffer ist ein Debian-Advisory (neue Zeitzonendaten), keine Sicherheitslücke. Ein Rebuild mit frischem distroless-Image behebt ihn. Deshalb filtern Pipelines meist mit --severity HIGH,CRITICAL.

Warum zwei Scanner? trivy und grype nutzen unterschiedliche Datenbanken und Zuordnungsregeln, und beide übersehen manchmal etwas. grype sbom: scannt nur die SBOM. So kannst du ein Image, das vor einem Jahr ausgeliefert wurde, gegen die heutige Datenbank prüfen, ohne es neu zu ziehen.

Für Python (llmctl, Tag 3) nimmst du pip-audit. Es läuft in einem venv:

python3 -m venv .venv && .venv/bin/pip install -q pip-audit
printf 'httpx==0.22.0\n' > requirements-alt.txt
.venv/bin/pip-audit -r requirements-alt.txt

Erwartet (gekürzt, IDs können je nach Datenbankstand abweichen):

Found 5 known vulnerabilities in 3 packages
Name  Version ID              Fix Versions
----- ------- --------------- ------------
httpx 0.22.0  PYSEC-2022-183  0.23.0
anyio 3.7.1   PYSEC-2026-4025 4.14.2
h11   0.12.0  PYSEC-2026-348  0.16.0

Warum? Zwei der drei Pakete hast du nie selbst angefordert. Sie kommen transitiv über httpx. pip-audit löst die Abhängigkeiten auf und prüft auch sie. Darum gehört ein Lockfile (pip-compile, uv lock) ins Repo.

Fortschritt speichern? Kostenlos registrieren

Drill 3: CVE-Response-Drill

Szenario: Ein Kollege bereitet JWT-Auth vor und zieht dafür eine alte Version von golang-jwt ins Projekt. Du arbeitest auf einer Kopie, das Original bleibt sauber.

cp -r ~/sre-lab/code/llm-gateway ~/sre-lab/tag13/cve-drill
cd ~/sre-lab/tag13/cve-drill
# Go-Version wie im Dockerfile, sonst bewerten die Scanner die falsche Stdlib
export GOTOOLCHAIN=$(docker run --rm golang:1.26 go env GOVERSION)   # z. B. go1.26.9
cat > jwtauth.go <<'EOF'
package main

import "github.com/golang-jwt/jwt/v5"

// tenantClaims: Vorbereitung für JWT-Auth statt statischer API-Keys.
type tenantClaims struct {
    Tenant string `json:"tenant"`
    jwt.RegisteredClaims
}
EOF
go get github.com/golang-jwt/jwt/[email protected] && go mod tidy
go build -o llm-gateway . && trivy rootfs -q --scanners vuln -f json llm-gateway \
  | jq -r '.Results[].Vulnerabilities[]?
    | [.PkgName, .VulnerabilityID, .Severity, .InstalledVersion, .FixedVersion] | @tsv'

Erwartet (gekürzt):

go: downgraded github.com/golang-jwt/jwt/v5 v5.3.1 => v5.2.1
go: downgraded github.com/prometheus/client_golang v1.25.0 => v1.23.2
go: downgraded github.com/prometheus/common v0.72.0 => v0.67.2
github.com/golang-jwt/jwt/v5  CVE-2025-30204  HIGH  v5.2.1  5.2.2

Achte auf die Zeilen mit downgraded. Die alte Version hat client_golang gleich mit heruntergezogen. Genau so landen alte Abhängigkeiten unbemerkt im Repo.

Triage, Schritt 1: Wird der Code erreicht? govulncheck prüft den Call-Graph:

go run golang.org/x/vuln/cmd/govulncheck@latest ./...

Erwartet:

No vulnerabilities found.

Your code is affected by 0 vulnerabilities.
This scan also found 1 vulnerability in packages you import and 0
vulnerabilities in modules you require, but your code doesn't appear to call
these vulnerabilities.

Ohne GOTOOLCHAIN nimmt Go die Version aus go.mod (go 1.26.0). Im Test meldeten govulncheck dann 27 und trivy sogar 49 Lücken in der Standardbibliothek, die das Image (go1.26.9) gar nicht hat. Jetzt baut der Kollege die JWT-Prüfung fertig:

cat >> jwtauth.go <<'EOF'

// tenantFromJWT prüft ein HS256-Token und liefert den Mandanten.
func tenantFromJWT(tok string) (string, bool) {
    var c tenantClaims
    _, err := jwt.ParseWithClaims(tok, &c, func(*jwt.Token) (any, error) {
        return []byte(env("JWT_SECRET", "")), nil
    }, jwt.WithValidMethods([]string{"HS256"}))
    return c.Tenant, err == nil && c.Tenant != ""
}
EOF
cat > patch.pl <<'EOF'
# fügt nach "tenant, ok := c.keys[key]" den JWT-Fallback ein
s/^(\t\ttenant, ok := c\.keys\[key\])$/$1
\t\tif !ok {
\t\t\ttenant, ok = tenantFromJWT(key)
\t\t}/;
EOF
perl -pi patch.pl main.go && rm patch.pl
gofmt -l . ; go run golang.org/x/vuln/cmd/govulncheck@latest ./...

Erwartet (gekürzt):

Vulnerability #1: GO-2025-3553
    Excessive memory allocation during header parsing in
    github.com/golang-jwt/jwt
    Found in: github.com/golang-jwt/jwt/[email protected]
    Fixed in: github.com/golang-jwt/jwt/[email protected]
    Example traces found:
      #1: jwtauth.go:14:31: llm.tenantFromJWT calls jwt.ParseWithClaims, which
          eventually calls jwt.Parser.ParseUnverified

Your code is affected by 1 vulnerability from 1 module.
exit status 3

Exit-Code 3 heißt „betroffen”. Damit bricht die CI ab (Drill 8).

Triage, Schritt 2: Wie wahrscheinlich, wie schlimm?

curl -s 'https://api.first.org/data/v1/epss?cve=CVE-2025-30204' \
  | jq -r '.data[0] | "\(.cve) epss=\(.epss) percentile=\(.percentile)"'
KEV=https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json
curl -s "$KEV" \
  | jq --arg c CVE-2025-30204 '[.vulnerabilities[] | select(.cveID==$c)] | length'
trivy rootfs -q --scanners vuln -f json llm-gateway \
  | jq -r '.Results[].Vulnerabilities[]?
    | "\(.CVSS.nvd.V3Score // .CVSS.ghsa.V3Score) \(.CVSS.ghsa.V3Vector)"'

Erwartet (EPSS ändert sich täglich):

CVE-2025-30204 epss=0.007360000 percentile=0.530940000
0
7.5 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Kriterium Wert Bedeutung
Erreichbar ja (ParseWithClaims) Bearer-Header kommt ungeprüft aus dem Internet
CVSS 7.5, nur A:H DoS über Speicher, kein Datenabfluss
EPSS / KEV 0,7 % / nicht gelistet kein bekannter Exploit in freier Wildbahn
Entscheidung Patch in 7 Tagen vor dem Release von JWT-Auth, kein Notfall-Deploy

Patch, Rebuild, Rescan:

go get github.com/golang-jwt/jwt/[email protected] && go mod tidy
go test ./... && go run golang.org/x/vuln/cmd/govulncheck@latest ./...
go build -o llm-gateway . && trivy rootfs -q --scanners vuln --exit-code 1 \
  --severity HIGH,CRITICAL llm-gateway >/dev/null && echo "✔ trivy sauber"
grype -q dir:. --fail-on high && echo "✔ grype sauber"
docker build -t llm-gateway:dev-jwt .          # danach SBOM und Signatur neu

Erwartet:

go: upgraded github.com/golang-jwt/jwt/v5 v5.2.1 => v5.2.2
ok      example.com/llm-gateway 0.260s
No vulnerabilities found.
✔ trivy sauber
No vulnerabilities found
✔ grype sauber

Kommunizieren: Kunden mit On-Prem-Installationen (Tag 14) brauchen eine kurze Security Advisory auf Englisch:

Security Advisory LLMGW-2026-003 – llm-gateway 1.8.1
Affected: llm-gateway 1.8.0 with JWT authentication enabled (JWT_SECRET set).
Issue: CVE-2025-30204 in golang-jwt (CVSS 7.5, availability only). A crafted
Authorization header can cause excessive memory use (denial of service).
Not affected: deployments using API keys only.
Fix: upgrade to 1.8.1 (image digest sha256:...). Workaround: unset JWT_SECRET.
Exploitation: no known exploitation (not in CISA KEV, EPSS 0.7%).

Tipp: Wenn ein Fund nicht erreichbar ist, dokumentierst du das maschinenlesbar als VEX (not_affected, z. B. mit vexctl oder OpenVEX). trivy und grype werten VEX aus, und der Fund taucht dann nicht jeden Tag wieder auf.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Signieren und attestieren mit cosign

Lokale Registry auf Port 5055, Lab-Schlüsselpaar, Signatur ohne Transparency Log:

cd ~/sre-lab/tag13
docker run -d --name reg13 -p 127.0.0.1:5055:5000 registry:2
docker tag llm-gateway:dev localhost:5055/llm-gateway:dev
docker push -q localhost:5055/llm-gateway:dev
R=localhost:5055/llm-gateway
DIGEST=$(curl -s -H 'Accept: application/vnd.oci.image.index.v1+json' \
  http://localhost:5055/v2/llm-gateway/manifests/dev \
  | jq -r '.manifests[] | select(.platform.os=="linux") | .digest')
echo "$DIGEST"
export COSIGN_PASSWORD=lab-cosign-pw                 # Lab-Passwort
cosign generate-key-pair
cosign signing-config create --out offline.json     # ohne Rekor und TSA
cosign sign --key cosign.key --signing-config offline.json -y "$R@$DIGEST"

Erwartet:

localhost:5055/llm-gateway:dev
sha256:e472730847994952a72ae952554588336bdf01fd027586ac1fa046865b2e2025
Private key written to cosign.key
Public key written to cosign.pub
Signing artifact...
Pushing signature to: localhost:5055/llm-gateway

Warum der Digest aus dem Index? Docker mit containerd-Image-Store schiebt einen OCI-Index (Plattform-Image plus Attestation-Manifest). Du signierst das Linux-Image selbst, also das, was der Kubelet zieht. Und du signierst immer einen Digest, nie einen Tag, denn ein Tag kann sich ändern.

cosign verify --key cosign.pub "$R@$DIGEST" 2>&1 | tail -1
cosign verify --key cosign.pub --insecure-ignore-tlog "$R@$DIGEST" 2>&1 \
  | grep -E '^  -'
COSIGN_PASSWORD=x cosign generate-key-pair --output-key-prefix fremd >/dev/null 2>&1
cosign verify --key fremd.pub --insecure-ignore-tlog "$R@$DIGEST" >/dev/null 2>&1 \
  || echo "✔ fremder Schlüssel abgelehnt"

Erwartet (gekürzt):

error during command execution: no matching attestations: failed to verify log
inclusion: not enough verified log entries from transparency log: 0 < 1
  - The cosign claims were validated
  - Existence of the claims in the transparency log was verified offline
  - The signatures were verified against the specified public key
✔ fremder Schlüssel abgelehnt

Warum scheitert der erste Verify? cosign v3 verlangt standardmäßig einen Eintrag im Transparency Log (Rekor). Im Lab gibt es keinen, deshalb --insecure-ignore-tlog. In Produktion signierst du keyless: Die CI meldet sich per OIDC bei Fulcio an, bekommt ein kurzlebiges Zertifikat, und Rekor protokolliert die Signatur. Einen Schlüssel, der geklaut werden kann, gibt es dann nicht.

SBOM als signierte Attestation an das Image hängen:

cosign attest --key cosign.key --signing-config offline.json -y \
  --type spdxjson --predicate sbom.spdx.json "$R@$DIGEST"
cosign verify-attestation --key cosign.pub --insecure-ignore-tlog \
  --type spdxjson "$R@$DIGEST" 2>/dev/null | jq -r '.payload' | base64 -d \
  | jq -r '.predicateType, .subject[0].digest.sha256, (.predicate.packages | length)'

Erwartet:

https://spdx.dev/Document
e472730847994952a72ae952554588336bdf01fd027586ac1fa046865b2e2025
18

Warum? Die SBOM ist jetzt fest an genau diesen Digest gebunden und signiert. Ein Kunde kann sie aus der Registry holen und prüfen. Eine SBOM als lose Datei im Wiki kann dagegen jeder austauschen.

SLSA-Provenance: Sie beschreibt, wer das Image wie und aus welchem Commit gebaut hat. BuildKit erzeugt sie mit docker buildx build --provenance=mode=max --sbom=true --push. In GitHub Actions macht das actions/attest-build-provenance. SLSA Build Level 3 verlangt einen gehärteten Build-Dienst, auf dem Entwickler nichts manipulieren können. Ein Laptop-Build erreicht höchstens Level 1. (Nicht live getestet, Doku: slsa.dev, docs.docker.com/build/attestations.)

Fortschritt speichern? Kostenlos registrieren

Drill 5: Kyverno-Policies offline testen

Kyverno 1.19 markiert ClusterPolicy als veraltet. Neue Policies schreibst du als ValidatingPolicy und ImageValidatingPolicy mit CEL-Ausdrücken. Alle Dateien liegen auch im Begleitcode unter ~/sre-lab/code/security/kyverno/.

mkdir -p ~/sre-lab/tag13/kyverno && cd ~/sre-lab/tag13/kyverno
cat > pod-guardrails.yaml <<'EOF'
# Lab-Policy (Tag 13): festes Image-Tag und Ressourcen für alle Pods
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
  name: pod-guardrails
spec:
  validationActions: [Deny]
  matchConstraints:
    resourceRules:
      - apiGroups: [""]
        apiVersions: [v1]
        operations: [CREATE, UPDATE]
        resources: [pods]
  validations:
    - message: "Image braucht einen festen Tag oder Digest, nicht :latest."
      expression: >-
        object.spec.containers.all(c,
          c.image.contains("@sha256:") ||
          (c.image.split("/")[c.image.split("/").size() - 1].contains(":") &&
           !c.image.endsWith(":latest")))
    - message: "CPU/Memory-Requests und ein Memory-Limit sind Pflicht."
      expression: >-
        object.spec.containers.all(c, has(c.resources) &&
          has(c.resources.requests) && "cpu" in c.resources.requests &&
          "memory" in c.resources.requests &&
          has(c.resources.limits) && "memory" in c.resources.limits)
EOF

Die Test-Pods (good-pod.yaml: Tag dev, Requests, Limit; bad-pod.yaml: einmal :latest, einmal ohne resources) und die Testdefinition kopierst du aus dem Code-Ordner:

cp ~/sre-lab/code/security/kyverno/{good-pod,bad-pod,kyverno-test}.yaml .
grep -A4 '^results' kyverno-test.yaml
kyverno apply pod-guardrails.yaml -r good-pod.yaml -r bad-pod.yaml
kyverno test . --remove-color | tail -1

Erwartet:

results:
  - policy: pod-guardrails
    kind: Pod
    resources: [gw-good]
    result: pass
Applying 1 policy rule(s) to 3 resource(s)...
policy pod-guardrails -> resource llm-system/Pod/gw-latest failed:
1 -  Image braucht einen festen Tag oder Digest, nicht :latest.
policy pod-guardrails -> resource llm-system/Pod/gw-nolimits failed:
1 -  CPU/Memory-Requests und ein Memory-Limit sind Pflicht.

pass: 1, fail: 2, warn: 0, error: 0, skip: 0
Test Summary: 3 tests passed and 0 tests failed

Warum split("/")? Bei localhost:5055/llm-gateway steckt der Doppelpunkt im Registry-Port. Ohne Tag würde ein naiver contains(":")-Check das Image durchlassen. kyverno test gehört in die CI des Policy-Repos, genau wie Unit-Tests.

Jetzt die Signaturprüfung. Der Public Key wird in die Policy eingebettet:

{ cat <<'EOF'
# Lab-Policy (Tag 13): nur mit dem Lab-Key signierte Gateway-Images zulassen
apiVersion: policies.kyverno.io/v1
kind: ImageValidatingPolicy
metadata:
  name: verify-llm-gateway
spec:
  validationActions: [Deny]
  matchConstraints:
    resourceRules:
      - apiGroups: [""]
        apiVersions: [v1]
        operations: [CREATE, UPDATE]
        resources: [pods]
  matchImageReferences:
    - glob: "localhost:5055/llm-gateway*"
  attestors:
    - name: lab
      cosign:
        key:
          data: |
EOF
sed 's/^/            /' ../cosign.pub
cat <<'EOF'
        ctlog:
          insecureIgnoreTlog: true      # Lab: Signatur ohne Rekor-Eintrag
          insecureIgnoreSCT: true
  validations:
    - message: "Image ist nicht mit dem Lab-Key signiert."
      expression: >-
        images.containers.map(i, verifyImageSignatures(i, [attestors.lab]))
        .all(n, n > 0)
EOF
} > verify-image.yaml
docker tag llm-gateway:dev localhost:5055/llm-gateway-unsigned:dev
docker push -q localhost:5055/llm-gateway-unsigned:dev
for n in signed unsigned; do
  repo=llm-gateway; [ $n = unsigned ] && repo=llm-gateway-unsigned
  printf 'apiVersion: v1\nkind: Pod\nmetadata: {name: gw-%s, namespace: llm-system}
spec:\n  containers:\n    - {name: gw, image: "localhost:5055/%s@%s"}\n' \
    "$n" "$repo" "$DIGEST" > pod-$n.yaml
done
kyverno apply verify-image.yaml -r pod-signed.yaml -r pod-unsigned.yaml

Erwartet:

Applying 1 policy rule(s) to 2 resource(s)...
policy verify-llm-gateway -> resource llm-system/Pod/gw-unsigned failed:
1 - verify-llm-gateway Image ist nicht mit dem Lab-Key signiert.

pass: 1, fail: 1, warn: 0, error: 0, skip: 0

Warum ein zweites Repo? Beide Pods nutzen denselben Digest, aber die Signatur hängt am Repo llm-gateway. Ein umgetaggtes Image verliert seine Signatur. Die Kyverno-CLI holt Signaturen live aus der Registry. Auf einem arm64-Mac musst du deshalb das Plattform-Manifest signieren, nicht den Index (Drill 4). Sonst meldet sie no child with platform linux/amd64.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Pod härten und Secrets aus OpenBao

mkdir -p ~/sre-lab/tag13/k8s && cd ~/sre-lab/tag13/k8s
cat > gw-hardened.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm-gateway
  namespace: llm-system
spec:
  replicas: 2
  selector:
    matchLabels: {app.kubernetes.io/name: llm-gateway}
  template:
    metadata:
      labels: {app.kubernetes.io/name: llm-gateway}
    spec:
      automountServiceAccountToken: false     # Gateway braucht keine K8s-API
      securityContext:
        runAsNonRoot: true
        runAsUser: 65532                       # nonroot aus distroless
        runAsGroup: 65532
        seccompProfile: {type: RuntimeDefault}
      containers:
        - name: gw
          image: localhost:5055/llm-gateway:dev
          ports: [{containerPort: 8080}]
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities: {drop: [ALL]}
          resources:
            requests: {cpu: 100m, memory: 64Mi}
            limits: {cpu: "1", memory: 128Mi}
EOF
kubectl apply --dry-run=client -f gw-hardened.yaml
trivy config -q gw-hardened.yaml | grep -E '^(Tests|Failures)|^KSV'

Erwartet (configured statt created, wenn das Gateway aus Tag 7 schon läuft):

deployment.apps/llm-gateway created (dry run)
Tests: 98 (SUCCESSES: 97, FAILURES: 1)
Failures: 1 (UNKNOWN: 0, LOW: 0, MEDIUM: 1, HIGH: 0, CRITICAL: 0)
KSV-0125 (MEDIUM): Container gw in deployment llm-gateway (namespace: llm-system)
uses an image from an untrusted registry.

Ohne securityContext meldet trivy für dasselbe Deployment 14 Fehler, 3 davon HIGH (u. a. KSV-0014 readOnlyRootFilesystem, KSV-0118 Default-Security-Context). KSV-0125 verschwindet, sobald deine Registry in der trivy-Konfiguration als vertrauenswürdig eingetragen ist. Das Gateway schreibt nichts auf die Platte, deshalb klappt readOnlyRootFilesystem ohne emptyDir. Das passt zu PSA restricted aus Tag 6.

TENANT_KEYS gehört nicht als Klartext ins Manifest. Hol die Keys aus OpenBao (Details im Buch „OpenBao zum Anfassen”, Tag 1 und Tag 11):

bao server -dev -dev-root-token-id=lab-root > bao.log 2>&1 & BAO_PID=$!
sleep 2
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=lab-root     # Lab-Token
bao kv put -mount=secret llm-gateway/tenant-keys \
  acme=lab-key-acme globex=lab-key-globex >/dev/null
bao policy write llm-gateway-read - <<'EOF'
path "secret/data/llm-gateway/*" { capabilities = ["read"] }
EOF
T=$(bao token create -policy=llm-gateway-read -ttl=15m -field=token)
BAO_TOKEN=$T bao kv get -mount=secret -format=json llm-gateway/tenant-keys \
  | jq -r '.data.data | to_entries | map("\(.key):\(.value)") | join(",")'
BAO_TOKEN=$T bao kv put -mount=secret llm-gateway/tenant-keys x=y >/dev/null 2>&1 \
  || echo "✔ Schreiben verboten (read-only Policy)"

Erwartet:

Success! Uploaded policy: llm-gateway-read
acme:lab-key-acme,globex:lab-key-globex
✔ Schreiben verboten (read-only Policy)

Im Cluster übernimmt das der External Secrets Operator (ESO). Er baut aus den KV-Feldern genau das Format, das das Gateway erwartet (nicht live getestet, ESO-API v1):

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: llm-gateway-keys
  namespace: llm-system
spec:
  refreshInterval: 1h
  secretStoreRef: {kind: ClusterSecretStore, name: openbao}  # Kubernetes-Auth
  target:
    name: llm-gateway-keys
    template:
      data:
        TENANT_KEYS: "acme:{{ .acme }},globex:{{ .globex }}"
  dataFrom:
    - extract: {key: llm-gateway/tenant-keys}

Das Deployment liest das Secret per envFrom: [{secretRef: {name: llm-gateway-keys}}]. Achtung: Das Gateway liest TENANT_KEYS nur beim Start. Nach einer Rotation braucht es einen Rollout, zum Beispiel mit Reloader oder einer Checksum-Annotation.

Fortschritt speichern? Kostenlos registrieren

Drill 7: LLM-spezifische Security

Mandantentrennung im Gateway: Kommt der Key beim Modellserver an? Kann ein Mandant einen anderen vortäuschen? Ein Echo-Upstream zeigt, was ankommt:

mkdir -p ~/sre-lab/tag13/llm && cd ~/sre-lab/tag13/llm
cat > echo_upstream.py <<'EOF'
"""Echo-Upstream: gibt die Header zurück, die beim Modellserver ankommen."""
import json
from http.server import BaseHTTPRequestHandler, HTTPServer


class H(BaseHTTPRequestHandler):
    def do_POST(self):
        self.rfile.read(int(self.headers.get("Content-Length", 0)))
        body = json.dumps({"seen": {k: v for k, v in self.headers.items()
                                    if k in ("Authorization", "X-Tenant")}})
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(body.encode())

    def log_message(self, *a):
        pass


HTTPServer(("127.0.0.1", 11500), H).serve_forever()
EOF
python3 echo_upstream.py & ECHO_PID=$!
(cd ~/sre-lab/code/llm-gateway && go build -o ~/sre-lab/tag13/llm/gw .)
LISTEN_ADDR=127.0.0.1:8088 UPSTREAM_URL=http://127.0.0.1:11500 \
  TENANT_KEYS="acme:lab-key-acme,globex:lab-key-globex" ./gw > gw.log 2>&1 & GW_PID=$!
sleep 1
curl -s -H 'Authorization: Bearer lab-key-globex' -H 'X-Tenant: acme' \
  -d '{}' 127.0.0.1:8088/v1/chat/completions; echo

Erwartet:

{"seen": {"X-Tenant": "globex"}}

Warum? Der Mandanten-Key erreicht den Modellserver nicht, und der gefälschte Header X-Tenant: acme wird überschrieben (Header.Set im Rewrite). Hätte das Gateway Header.Add benutzt, kämen beide Werte an. Dann entscheidet der Upstream, welchen er liest. Dieser Test gehört als Unit-Test in main_test.go.

Modell-Lieferkette: Pickle gegen safetensors. Ein Pickle-„Modell” führt beim Laden Code aus. safetensors ist ein JSON-Header plus rohe Zahlen.

cat > make_files.py <<'EOF'
"""Erzeugt eine bösartige Pickle-Datei und eine harmlose safetensors-Datei."""
import json
import pickle
import struct


class Evil:
    def __reduce__(self):  # wird beim Laden ausgeführt
        return (print, ("!!! Code beim Laden ausgeführt",))


with open("model.pkl", "wb") as f:
    pickle.dump({"weights": [0.1, 0.2], "x": Evil()}, f)

data = struct.pack("<4f", 0.1, 0.2, 0.3, 0.4)
header = {"w": {"dtype": "F32", "shape": [2, 2], "data_offsets": [0, len(data)]},
          "__metadata__": {"format": "pt"}}
h = json.dumps(header).encode()
with open("model.safetensors", "wb") as f:
    f.write(struct.pack("<Q", len(h)) + h + data)
EOF
cat > inspect_st.py <<'EOF'
"""Liest nur den JSON-Header einer safetensors-Datei, führt nichts aus."""
import json
import struct
import sys

with open(sys.argv[1], "rb") as f:
    n = struct.unpack("<Q", f.read(8))[0]
    print(json.dumps(json.loads(f.read(n))))
EOF
python3 make_files.py
python3 -c 'import pickle; pickle.load(open("model.pkl", "rb"))'
python3 -m pickletools model.pkl | grep -E "'(builtins|print)'"
python3 inspect_st.py model.safetensors

Erwartet (gekürzt):

!!! Code beim Laden ausgeführt
   50: \x8c     SHORT_BINUNICODE 'builtins'
   61: \x8c     SHORT_BINUNICODE 'print'
{"w": {"dtype": "F32", "shape": [2, 2], "data_offsets": [0, 16]}, ...}

Statt print könnte dort os.system stehen. Lade deshalb nur safetensors oder GGUF. Scanne Pickle-Dateien vorher mit picklescan oder modelscan, und setze in PyTorch torch.load(..., weights_only=True). Prüfe außerdem die Prüfsumme gegen die Quelle:

shasum -a 256 model.safetensors > SHA256SUMS
shasum -a 256 -c SHA256SUMS
printf 'x' >> model.safetensors; shasum -a 256 -c SHA256SUMS

Erwartet:

model.safetensors: OK
model.safetensors: FAILED
shasum: WARNING: 1 computed checksum did NOT match

Hugging Face zeigt den SHA256 jeder LFS-Datei an, und Ollama prüft Blobs per Digest. Mit cosign sign-blob oder dem OpenSSF-Projekt model-signing signierst du Gewichte wie Images.

Prompt Injection lässt sich nicht wegfiltern. Du begrenzt deshalb den Schaden:

  • Tools und Function Calling (Tag 5) laufen mit den Rechten des Mandanten, nie mit Plattform-Rechten.
  • Kein geteilter Cache und kein geteiltes RAG-Index-Segment über Mandanten hinweg. Prefix-Caching im Modellserver gehört pro Mandant isoliert oder bewertet.
  • Prompts und Antworten nur gekürzt oder gehasht loggen. Logs sind sonst ein Datenleck (Tag 9).
  • Ausgaben, die in Shell, SQL oder HTML landen, wie Benutzereingaben behandeln.

Aufräumen:

kill "$GW_PID" "$ECHO_PID" "$BAO_PID"
docker rm -f reg13

Fortschritt speichern? Kostenlos registrieren

Drill 8: Alles in die Pipeline

Die Pipeline liegt fertig im Begleitcode unter ~/sre-lab/code/security/ci/supply-chain.yml. Kopiere sie nach .github/workflows/ im Gateway-Repo. Job test läuft bei jedem Push und Pull Request: gofmt, go vet, go test -race, govulncheck. Job image läuft nur auf main, und das ist sein Kern:

    permissions:
      contents: read
      packages: write
      id-token: write          # OIDC-Token für keyless cosign
    steps:
      # ... checkout, login, buildx
      - id: build
        uses: docker/build-push-action@v6
        with:
          push: true
          tags: ${{ env.IMAGE }}:${{ github.sha }}
          provenance: mode=max  # SLSA-Provenance von BuildKit
          sbom: true
      # ... anchore/sbom-action schreibt sbom.spdx.json
      - name: Scan (bricht bei HIGH/CRITICAL mit Fix ab)
        uses: aquasecurity/[email protected]
        with:
          image-ref: ${{ env.IMAGE }}@${{ steps.build.outputs.digest }}
          severity: HIGH,CRITICAL
          ignore-unfixed: true
          exit-code: "1"
      - uses: sigstore/cosign-installer@v3
      - name: Sign und SBOM attestieren (keyless)
        env:
          REF: ${{ env.IMAGE }}@${{ steps.build.outputs.digest }}
        run: |
          cosign sign --yes "$REF"
          cosign attest --yes --type spdxjson --predicate sbom.spdx.json "$REF"
mkdir -p ~/sre-lab/tag13/ci && cd ~/sre-lab/tag13/ci
cp ~/sre-lab/code/security/ci/supply-chain.yml .
go run github.com/rhysd/actionlint/cmd/actionlint@latest supply-chain.yml \
  && echo "✔ actionlint"

Erwartet:

✔ actionlint

Warum diese Reihenfolge? Billige Checks laufen zuerst und auch in Pull Requests. Das Image wird nur von main gebaut, gescannt und erst danach signiert. Ein Image mit offenem HIGH-Fund bekommt also keine Signatur und kommt damit an Kyverno nicht vorbei. id-token: write braucht nur der Image-Job.

Sicherheit: Pinne Actions in Produktion auf den Commit-SHA (uses: actions/checkout@<40-stelliger SHA> # v5). Ein Tag wie @v3 kann nachträglich auf bösartigen Code zeigen. Genau so liefen schon Angriffe auf CI-Lieferketten. Prüfe die hier genannten Versionen vor der Nutzung.

In GitLab CI sieht es genauso aus: Stages test, build, scan, sign, und keyless cosign mit id_tokens: SIGSTORE_ID_TOKEN: aud: sigstore.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/sre-lab/tag13
jq -e '.spdxVersion=="SPDX-2.3"' sbom.spdx.json >/dev/null \
  && echo "✔ SPDX-SBOM" || echo "✘ SPDX-SBOM"
jq -e '.bomFormat=="CycloneDX"' sbom.cdx.json >/dev/null \
  && echo "✔ CycloneDX-SBOM" || echo "✘ CycloneDX-SBOM"
grep -q 'jwt/v5 v5.2.2' cve-drill/go.mod \
  && echo "✔ CVE gepatcht" || echo "✘ CVE offen"
export GOTOOLCHAIN=$(docker run --rm golang:1.26 go env GOVERSION)
(cd cve-drill && go run golang.org/x/vuln/cmd/govulncheck@latest ./... >/dev/null) \
  && echo "✔ govulncheck sauber" || echo "✘ govulncheck meldet Funde"
trivy image -q --scanners vuln --exit-code 1 --severity HIGH,CRITICAL \
  llm-gateway:dev >/dev/null && echo "✔ Image ohne HIGH/CRITICAL" || echo "✘ Image"
(cd kyverno && kyverno test . >/dev/null 2>&1) \
  && echo "✔ kyverno test" || echo "✘ kyverno test"
[ -f cosign.pub ] && grep -q 'PUBLIC KEY' kyverno/verify-image.yaml \
  && echo "✔ Signatur-Policy mit Lab-Key" || echo "✘ Signatur-Policy"

Erwartet:

✔ SPDX-SBOM
✔ CycloneDX-SBOM
✔ CVE gepatcht
✔ govulncheck sauber
✔ Image ohne HIGH/CRITICAL
✔ kyverno test
✔ Signatur-Policy mit Lab-Key

Challenge

Scanne, was du wirklich auslieferst: Hol das Binary aus llm-gateway:dev heraus und prüfe es mit govulncheck im Binary-Modus und mit trivy. Beide sollen sauber sein.

Hinweis: docker create legt einen Container an, ohne ihn zu starten, und docker cp kopiert auch aus distroless-Images ohne Shell.

Lösung

cd ~/sre-lab/tag13
id=$(docker create llm-gateway:dev)
docker cp "$id":/llm-gateway ./gw-from-image && docker rm "$id" >/dev/null
go run golang.org/x/vuln/cmd/govulncheck@latest -mode=binary ./gw-from-image
trivy rootfs -q --scanners vuln --exit-code 1 gw-from-image >/dev/null \
  && echo "✔ trivy: Binary sauber"

Erwartet:

No vulnerabilities found.
✔ trivy: Binary sauber

Warum? Der Binary-Modus nutzt die Go-Version und die Module, die im Binary eingebettet sind, also go1.26.9 aus dem Build-Image. Die lokale Toolchain spielt keine Rolle. Ohne Symboltabelle (-ldflags="-s -w") prüft govulncheck nur auf Modulebene, nicht auf Funktionsebene.

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • Typische Frage: „A critical CVE drops in a library you use. Walk me through the next 24 hours.” Antwort: inventarisieren (SBOM), Erreichbarkeit prüfen (govulncheck), EPSS/KEV bewerten, patchen, neu bauen, signieren, ausrollen, Kunden informieren, VEX für nicht betroffene Versionen.
  • Knackiger Satz: „CVSS tells me how bad it could be. Reachability and EPSS tell me how urgent it is.”
  • Supply Chain in einem Satz: „Every image in production is built by CI, has an SBOM attestation, is signed keyless, and the cluster refuses anything else.”
  • Brücke aus deiner Praxis: Vault/OpenBao als Root of Trust. Du kennst Schlüssel- rotation, Transit-Signaturen, Audit-Logs und Secret-Zero. cosign mit KMS-Key (hashivault://) ist dieselbe Denkweise.
  • LLM-Spezifika zeigen: Pickle-RCE, Datenlecks zwischen Mandanten über Caches und Logs, und dass Prompt Injection ein Berechtigungsproblem ist, kein Filterproblem.

Enterprise-Notiz

  • Air-gapped Kunden (Tag 14) haben keinen Zugang zu Rekor und Fulcio. Liefere die Signaturen mit (cosign save), nutze einen Key aus dem KMS oder eine eigene Sigstore-Instanz, und gib den Public Key oder die Trust Root über einen zweiten Kanal weiter.
  • Regulierte Kunden (Banken, Behörden, NIS2, Cyber Resilience Act) verlangen SBOMs pro Release, einen dokumentierten Prozess zum Umgang mit Schwachstellen und feste Fristen. Der CRA fordert die Meldung aktiv ausgenutzter Lücken innerhalb von 24 h.
  • Scanner-Datenbanken brauchen im Air-Gap einen Spiegel (trivy-db und grype-db als OCI-Artefakt in der internen Registry), sonst scannen sie gegen veraltete Daten.
  • Kyverno muss die interne Registry erreichen. Mit failurePolicy: Fail blockiert ein Registry-Ausfall alle Deployments. Plane Ausnahmen für kube-system und einen Break-Glass-Prozess.
  • Modellgewichte gehören in dieselbe Kette: Prüfsumme, Signatur, Herkunft und Lizenz pro Modellversion. Lade sie nur aus einem internen Spiegel, nie direkt aus dem Internet.