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.jsonErwartet (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.jsonErwartet:
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.jsonErwartet (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.txtErwartet (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 neuErwartet:
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. mitvexctloder 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)
EOFDie 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 -1Erwartet:
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.yamlErwartet:
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; echoErwartet:
{"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.safetensorsErwartet (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 SHA256SUMSErwartet:
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 reg13Fortschritt 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@v3kann 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: Failblockiert ein Registry-Ausfall alle Deployments. Plane Ausnahmen fürkube-systemund 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.