Kapitel 4: Kontrollierte Artefakt-Übergabe über Zonen- und Netzgrenzen
In diesem Kapitel lernst du:
- warum Netze in Sicherheitszonen aufgeteilt werden und was eine Schleuse oder Datendiode leistet,
- wie du ein Container-Image samt SBOM und Signaturen als prüfbares Transfer-Bundle verpackst,
- wie ein Quarantäne-Bereich Integrität, Herkunft und Schwachstellen automatisch prüft,
- wie eine Freigabe nach dem Vier-Augen-Prinzip mit signiertem Freigabeprotokoll funktioniert,
- wie du nachweist, dass in der Zielzone exakt dasselbe Image ankommt (Digest-Vergleich).
Worum geht es?
Stell dir ein Labor mit Reinraum vor. Niemand trägt einfach einen Karton hinein. Alles geht durch eine Materialschleuse: Der Karton wird abgegeben, von außen abgewischt, geprüft, protokolliert. Erst wenn eine zweite Person unterschreibt, öffnet sich die innere Tür. Die beiden Türen sind nie gleichzeitig offen.
Genau so funktioniert die kontrollierte Übergabe von Software zwischen Netzzonen. Deine Build-Umgebung (Zone A) erzeugt ein Image. Die Produktionsumgebung (Zone B) darf es nicht einfach aus Zone A ziehen, weil zwischen beiden keine direkte Verbindung bestehen soll. Stattdessen wird das Image als Paket verpackt, durch eine Schleuse gereicht, geprüft, freigegeben und erst dann in Zone B importiert.
Zone A: Build/Intern Schleuse Zone B: Ziel/Produktion
+---------------------+ +-----------------------------+ +---------------------+
| reg-build | | eingang/ | | reg-ziel |
| localhost:5001 | | | | | localhost:5002 |
| demo-app:1.0.0 | | v | | |
| + SBOM, Signatur | | quarantaene/ -- Prüfung -- | | demo-app:1.0.0 |
| | | | | Hash, Signatur, Scan | | (gleicher Digest) |
| v | | v | | ^ |
| Export: OCI-Layout |===>| geprueft/ ---- Freigabe --->|===>| Import | |
| + SHA256SUMS + Sig | | | (2. Person) | | | |
| = Transfer-Bundle | | +--> abgelehnt/ | | |
+---------------------+ +-----------------------------+ +---------------------+
Einbahnstraße: Daten fließen nur von links nach rechts
Der wichtigste Gedanke: Die Zielzone vertraut nicht dem Transportweg, sondern nur dem, was sie selbst prüfen kann. Ein Bundle kann unterwegs manipuliert werden, ein USB-Stick kann vertauscht werden. Deshalb prüft die Schleuse alles noch einmal, und zwar mit Werkzeugen und Schlüsseln, die in der Zielzone liegen.
Die Konzepte in einfach
Das Zonenmodell
Eine Sicherheitszone ist ein Netzbereich mit einheitlichem Schutzbedarf und einheitlichen Regeln. Typische Zonen in einer Organisation:
| Zone | Beispiel | Schutzbedarf |
|---|---|---|
| Internet/Extern | Docker Hub, PyPI | nicht vertrauenswürdig |
| Build/Intern | GitLab, Runner, reg-build | mittel |
| Ziel/Produktion | Cluster, reg-ziel | hoch |
| Hochsicher/air-gapped | Leitstelle, VS-NfD-Netz | sehr hoch |
Zwischen den Zonen stehen Grenzen: Firewalls, Gateways oder sogar ein physischer Luftspalt (air gap), also gar keine Netzverbindung. Je höher der Schutzbedarf, desto weniger darf über die Grenze fließen, und desto genauer wird geprüft.
Merke: Eine Zonengrenze ist nur so stark wie ihre Ausnahmen. Jede direkte Verbindung “nur für die Registry” ist ein Loch in der Grenze.
Schleuse und Datendiode
Eine Schleuse ist ein Zwischenbereich zwischen zwei Zonen. Dort landen Daten, bevor sie weitergereicht werden. Die Schleuse hat eine eigene Prüflogik und ein eigenes Protokoll. Sie kann ein Server, ein Verzeichnis auf einem Fileserver oder ein Prozess mit Wechseldatenträgern sein.
Eine Datendiode (data diode) ist Hardware, die Daten physikalisch nur in eine Richtung durchlässt. Technisch fehlt zum Beispiel die Rückleitung einer Glasfaser. Damit ist ausgeschlossen, dass aus der geschützten Zone Daten zurückfließen oder ein Angreifer eine Verbindung zurück aufbaut. Weil kein Rückkanal existiert, gibt es auch kein TCP-Handshake. Datendioden arbeiten deshalb mit speziellen Proxys, die Dateien einseitig übertragen.
Für dich als Platform Engineer heißt das: Du kannst über eine solche
Grenze kein docker pull machen. Du brauchst Artefakte, die
als Dateien reisen können. Genau dafür ist das OCI-Layout da.
Pull oder Push über die Grenze?
Wer baut die Verbindung auf? Diese Frage entscheidet über die Angriffsfläche.
| Modell | Ablauf | Bewertung |
|---|---|---|
| Push von A nach B | Zone A schreibt in reg-ziel | riskant: A braucht Schreibrechte in B |
| Pull von B aus A | Zone B liest aus reg-build | besser: keine eingehende Verbindung in B |
| Pull über Schleuse | B holt aus der Schleuse | gut: keine direkte Verbindung A-B |
| Datei über Diode | A legt ab, Diode schiebt | sehr gut: technisch einseitig |
Faustregel: Verbindungen werden aus der höher geschützten Zone heraus aufgebaut, nie hinein. Eine Ausnahme ist die Datendiode, weil dort physikalisch kein Rückweg existiert.
Das Transfer-Bundle
Ein Container-Image ist kein einzelnes Ding, sondern ein Geflecht aus JSON-Dateien und Schichten (layers), die über ihre Hashes verknüpft sind. Das OCI Image Layout ist ein standardisiertes Verzeichnisformat, das ein solches Geflecht als Dateien ablegt:
oci/
oci-layout Versionskennung des Formats
index.json Einstiegspunkt: welche Manifeste gibt es, mit welchem Namen
blobs/sha256/<hash> alle Manifeste, Configs und Layer, benannt nach ihrem Hash
Weil jede Datei nach ihrem SHA-256-Hash benannt ist, nennt man das inhaltsadressiert (content-addressable). Ändert sich ein Byte, passt der Name nicht mehr.
Ein Referrer ist ein Artefakt, das auf ein Image
verweist, zum Beispiel eine SBOM oder eine Signatur. Es hat ein Feld
subject, das den Digest des Images enthält. Registries mit
Referrers-API können diese Verweise auflisten. Ältere Registries wie
registry:2 können das nicht. Werkzeuge wie
oras nutzen dann einen Ersatz: einen Tag namens
sha256-<hex>, unter dem ein Index mit allen Referrern
liegt. Cosign v2 legt Signaturen klassisch unter Tags wie
sha256-<hex>.sig ab.
Unser Transfer-Bundle besteht aus:
| Datei | Zweck |
|---|---|
oci/ |
Image plus Referrer im OCI-Layout |
begleitschein.json |
Was ist drin, welcher Digest, wer schickt es |
SHA256SUMS |
Hash jeder einzelnen Datei |
SHA256SUMS.sig |
Signatur des Absenders über die Hashliste |
Merke: Die Hashliste allein schützt nur vor versehentlicher Beschädigung. Wer das Bundle manipuliert, kann auch die Hashliste neu berechnen. Erst die Signatur des Absenders macht daraus einen Herkunftsnachweis.
Prüfung in der Quarantäne
Die Quarantäne ist ein abgeschotteter Bereich, in dem ein Bundle liegt, bis alle Prüfungen bestanden sind. Nichts aus der Quarantäne darf ausgeführt oder in Produktion verwendet werden. Typische Prüfungen, von schnell nach langsam:
- Transport-Integrität: Stimmt der Hash des gesamten Archivs?
- Archiv-Hygiene: Keine absoluten Pfade, kein
.., keine Symlinks (Schutz vor Path Traversal, also dem Ausbrechen aus dem Zielverzeichnis beim Entpacken). - Herkunft: Ist die Hashliste vom bekannten Absender signiert?
- Inhalts-Integrität: Stimmen alle Einzel-Hashes, gibt es keine zusätzlichen Dateien?
- Konsistenz: Passt der Digest im Begleitschein zum Image im OCI-Layout?
- Inhalt: Schwachstellen-Scan (Trivy), Secret-Scan, optional Malware-Scan (z. B. ClamAV).
- Image-Signatur:
cosign verifygegen den eigenen Vertrauensanker (siehe Kapitel 5).
Jede Prüfung liefert ein klares Ergebnis. Das Gesamtergebnis landet in einem Prüfprotokoll im JSON-Format, damit Maschinen und Auditoren es lesen können.
Schwellenwerte
Ein Scanner findet fast immer etwas. Die Frage ist, ab wann du ablehnst. Ein Schwellenwert (threshold) legt das fest, zum Beispiel “0 kritische, höchstens 5 hohe Schwachstellen mit verfügbarem Fix”. Schwellenwerte sind eine Richtlinie, keine Technik. Sie gehören dokumentiert und mit den Entwicklungsteams abgestimmt (siehe Kapitel 8 und 10).
Freigabe nach dem Vier-Augen-Prinzip
Technische Prüfungen bestehen heißt noch nicht “darf in Produktion”. Die Freigabe ist eine bewusste Entscheidung einer verantwortlichen Person. Beim Vier-Augen-Prinzip dürfen prüfende und freigebende Person nicht identisch sein. So kann niemand allein etwas durchwinken, weder aus Versehen noch absichtlich.
Die Freigabe wird als Datei festgehalten und signiert. Das Freigabeprotokoll enthält mindestens:
- welches Bundle (Hash) und welches Image (Digest),
- welches Prüfprotokoll zugrunde lag (Hash des Protokolls),
- wer freigegeben hat und wann.
Der Import in Zone B prüft diese Signatur. Ohne gültige Freigabe kein Import.
Nachvollziehbarkeit und Audit
Ein Auditor fragt typischerweise: “Welches Image läuft in Produktion, wer hat es freigegeben, auf Basis welcher Prüfung?” Diese Kette musst du lückenlos beantworten können:
Pod im Cluster -> Image-Digest -> Freigabe (signiert) -> Prüfprotokoll -> Bundle-Hash
-> Begleitschein -> Build in Zone A (Pipeline-ID, siehe Kapitel 1)
Dafür schreiben alle Schritte in ein Audit-Log, idealerweise nur anhängend (append-only) und zusätzlich an ein zentrales SIEM (Security Information and Event Management) weitergeleitet.
Hands-on-Lab: Die Schleuse zwischen reg-build und reg-ziel
Du baust jetzt den kompletten Weg nach: Export aus Zone A, Transfer, Quarantäne, Freigabe durch eine zweite Person, Import in Zone B und Digest-Vergleich.
Voraussetzungen aus Kapitel 0: Die Registries reg-build
(localhost:5001) und reg-ziel (localhost:5002) laufen, das
Image localhost:5001/demo-app:1.0.0 existiert, und
oras, crane, syft,
trivy, jq und openssl sind
installiert.
Schritt 1: Arbeitsverzeichnis und Registries prüfen
mkdir -p ~/seclab/kap04/{bin,keys,bundle}
mkdir -p ~/seclab/kap04/schleuse/{eingang,quarantaene,geprueft,abgelehnt}
mkdir -p ~/seclab/kap04/schleuse/{freigegeben,protokolle,vertrauen}
cd ~/seclab/kap04
docker start reg-build reg-ziel
curl -s http://localhost:5001/v2/_catalog
curl -s http://localhost:5002/v2/_catalogErwartete Ausgabe (die Liste von reg-ziel kann leer sein):
reg-build
reg-ziel
{"repositories":["demo-app"]}
{"repositories":[]}
Fehlt demo-app in reg-build, baue und pushe es wie in
Kapitel 0:
docker build -t localhost:5001/demo-app:1.0.0 ~/seclab/demo-app
docker push localhost:5001/demo-app:1.0.0Merke dir den Digest. Ab jetzt arbeiten wir nur noch damit:
DIGEST=$(crane digest localhost:5001/demo-app:1.0.0)
echo "$DIGEST"Erwartete Ausgabe: eine Zeile der Form sha256: gefolgt
von 64 Hex-Zeichen.
Schritt 2: SBOM als Referrer anhängen
Damit das Bundle mehr als nur das Image enthält, hängst du eine SBOM (Software Bill of Materials, also eine Stückliste aller Komponenten, siehe Kapitel 7) an das Image an.
syft localhost:5001/demo-app:1.0.0 -o cyclonedx-json=sbom.cdx.json
oras attach --plain-http \
--artifact-type application/vnd.cyclonedx+json \
"localhost:5001/demo-app@${DIGEST}" \
sbom.cdx.json:application/vnd.cyclonedx+json
oras discover --plain-http "localhost:5001/demo-app@${DIGEST}"Erwartete Ausgabe von oras discover (Digests
gekürzt):
localhost:5001/demo-app@sha256:3f1c...
└── application/vnd.cyclonedx+json
└── sha256:9a7b...
Tipp:
syftliest das Image hier aus dem lokalen Docker-Daemon, weil du es gerade gebaut hast. Soll es direkt aus der Registry lesen, setzeSYFT_REGISTRY_INSECURE_USE_HTTP=trueund nutzeregistry:localhost:5001/demo-app:1.0.0.
Wirf einen Blick auf die Tags. Weil registry:2 keine
Referrers-API hat, legt oras einen Ersatz-Tag an:
crane ls localhost:5001/demo-appErwartete Ausgabe:
1.0.0
sha256-3f1c...
Schritt 3: Image samt Referrern als OCI-Layout exportieren
Jetzt kommt der Export. oras cp -r kopiert das Image und
rekursiv alle Referrer. Die Option --to-oci-layout schreibt
in ein Verzeichnis statt in eine Registry. Wichtig: oras kopiert
Manifeste byte-genau, der Digest bleibt also gleich.
cd ~/seclab/kap04
rm -rf bundle && mkdir bundle
oras cp -r --from-plain-http \
"localhost:5001/demo-app@${DIGEST}" \
--to-oci-layout "bundle/oci:1.0.0"Falls du Kapitel 5 schon durchgearbeitet und das Image mit cosign v2
signiert hast, liegen Signatur und Attestation unter eigenen Tags
(.sig, .att). Diese findet
oras cp -r nicht, weil es keine echten Referrer sind. Nimm
sie explizit mit:
HEX="${DIGEST#sha256:}"
for T in $(crane ls localhost:5001/demo-app \
| grep -E "^sha256-${HEX}\.(sig|att|sbom)$" || true); do
echo "nehme mit: $T"
oras cp --from-plain-http "localhost:5001/demo-app:${T}" \
--to-oci-layout "bundle/oci:${T}"
doneGibt es keine solchen Tags, passiert nichts. Prüfe das Ergebnis:
jq -r '.manifests[]
| "\(.digest) \(.annotations["org.opencontainers.image.ref.name"] // "-")"' \
bundle/oci/index.json
oras discover --oci-layout "bundle/oci:1.0.0"Erwartete Ausgabe: Eine Zeile mit deinem $DIGEST und dem
Namen 1.0.0. Je nach oras-Version stehen weitere Zeilen für
die Referrer darunter. oras discover zeigt wieder die
CycloneDX-SBOM unter dem Image.
Achtung:
skopeo copy docker://... oci:...ist ein bekannter Weg, Images in ein OCI-Layout zu kopieren. skopeo konvertiert dabei aber Docker-Manifeste in OCI-Manifeste. Dann ändert sich der Digest, und alle Signaturen passen nicht mehr. Für digest-treue Übergaben nutzeoras cpodercosign save.
Schritt 4: Begleitschein, Hashliste und Absender-Signatur
Der Absender in Zone A braucht ein Schlüsselpaar. Der öffentliche Schlüssel wird einmalig, auf einem getrennten und vertrauenswürdigen Weg, in der Schleuse hinterlegt. Im Lab kopierst du ihn einfach.
cd ~/seclab/kap04
openssl ecparam -name prime256v1 -genkey -noout -out keys/absender.key
openssl ec -in keys/absender.key -pubout -out schleuse/vertrauen/absender.pub
chmod 600 keys/absender.keyErwartete Ausgabe:
read EC key
writing EC key
Jetzt der Begleitschein. Er beschreibt, was im Bundle steckt:
jq -n \
--arg image "demo-app" --arg tag "1.0.0" --arg digest "$DIGEST" \
--arg quelle "localhost:5001/demo-app" \
--arg erstellt "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
--arg absender "build-team" \
'{image:$image, tag:$tag, digest:$digest, quelle:$quelle,
erstellt:$erstellt, absender:$absender}' \
> bundle/begleitschein.json
cat bundle/begleitschein.jsonNun die Hashliste über alle Dateien und die Signatur darüber. Auf
macOS gibt es sha256sum nicht immer, dort nutzt du
shasum -a 256. Beide Werkzeuge erzeugen dasselbe
Format.
cd ~/seclab/kap04/bundle
SHA="sha256sum"; command -v sha256sum >/dev/null || SHA="shasum -a 256"
find . -type f ! -name 'SHA256SUMS*' | sort | xargs $SHA > SHA256SUMS
openssl dgst -sha256 -sign ../keys/absender.key -out SHA256SUMS.sig SHA256SUMS
head -3 SHA256SUMS
$SHA -c --status SHA256SUMS && echo "Hashliste ok"Erwartete Ausgabe:
5c2e... ./begleitschein.json
0a41... ./oci/blobs/sha256/0a41...
1f9d... ./oci/blobs/sha256/1f9d...
Hashliste ok
Fällt dir etwas auf? Bei den Blobs sind Hash und Dateiname identisch. Das ist die Inhaltsadressierung aus dem Konzeptteil.
Schritt 5: Bundle packen und Übertragung simulieren
cd ~/seclab/kap04
COPYFILE_DISABLE=1 tar -C bundle -cf demo-app-1.0.0.tar .
$SHA demo-app-1.0.0.tar > demo-app-1.0.0.tar.sha256
ls -lh demo-app-1.0.0.tar*COPYFILE_DISABLE=1 verhindert, dass macOS versteckte
._-Dateien ins Archiv packt. Diese würden später als
“unerwartete Dateien” auffallen. Unter Linux schadet die Variable
nicht.
Die “Übertragung” ist im Lab eine Kopie. In der Realität wäre das eine Datendiode, ein Transfer-Server oder ein Wechseldatenträger.
cp demo-app-1.0.0.tar demo-app-1.0.0.tar.sha256 schleuse/eingang/
ls schleuse/eingang/Erwartete Ausgabe:
demo-app-1.0.0.tar demo-app-1.0.0.tar.sha256
Schritt 6: Das Quarantäne-Prüfskript
Ab hier bist du gedanklich in der Schleuse. Das Skript nimmt ein
Bundle aus eingang/, verschiebt es in einen eigenen
Quarantäne-Ordner, prüft alles und legt es danach in
geprueft/ oder abgelehnt/ ab. Es gibt bewusst
kein freigegeben/: Das darf nur ein Mensch entscheiden
(Schritt 7).
Lege die Datei ~/seclab/kap04/bin/quarantaene-pruefen.sh
an:
#!/usr/bin/env bash
# quarantaene-pruefen.sh - technische Prüfung eines Transfer-Bundles
set -euo pipefail
NAME="${1:?Aufruf: $0 <bundle.tar>}"
S="${SCHLEUSE:-$HOME/seclab/kap04/schleuse}"
MAX_CRITICAL="${MAX_CRITICAL:-0}"
MAX_HIGH="${MAX_HIGH:-5}"
PRUEFER="${PRUEFER:-$(whoami)}"
sha256() {
if command -v sha256sum >/dev/null 2>&1; then sha256sum "$@"
else shasum -a 256 "$@"; fi
}
ID="${NAME%.tar}_$(date -u +%Y%m%dT%H%M%SZ)"
Q="$S/quarantaene/$ID" # Arbeitsordner dieses Bundles
I="$Q/inhalt" # entpackter Inhalt
PROT="$S/protokolle/$ID.json"
mkdir -p "$Q" "$S/protokolle" "$S/geprueft" "$S/abgelehnt"
R_HASH="offen"; R_SIG="offen"; R_DATEIEN="offen"; R_DIGEST="offen"
R_SCAN="offen"; CRIT=-1; HIGH=-1; SECRETS=-1; DIGEST=""; BUNDLE_SHA=""
abschluss() {
local ent="$1" grund="$2" ziel
if [ "$ent" = "bestanden" ]; then ziel="$S/geprueft/$ID"
else ziel="$S/abgelehnt/$ID"; fi
jq -n \
--arg id "$ID" --arg bundle "$NAME" --arg sha "$BUNDLE_SHA" \
--arg digest "$DIGEST" --arg pruefer "$PRUEFER" \
--arg zeit "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
--arg hash "$R_HASH" --arg sig "$R_SIG" --arg dat "$R_DATEIEN" \
--arg dig "$R_DIGEST" --arg scan "$R_SCAN" \
--argjson crit "$CRIT" --argjson high "$HIGH" --argjson sec "$SECRETS" \
--argjson maxc "$MAX_CRITICAL" --argjson maxh "$MAX_HIGH" \
--arg ent "$ent" --arg grund "$grund" \
'{id:$id, bundle:$bundle, bundle_sha256:$sha, image_digest:$digest,
pruefer:$pruefer, zeitpunkt:$zeit,
pruefungen:{transport_hash:$hash, absender_signatur:$sig,
dateien:$dat, digest_abgleich:$dig,
scan:{ergebnis:$scan, critical:$crit, high:$high, secrets:$sec,
schwelle:{critical:$maxc, high:$maxh}}},
entscheidung:$ent, grund:$grund}' > "$PROT"
jq -c . "$PROT" >> "$S/protokolle/audit.jsonl"
mv "$Q" "$ziel"
echo "$ent: $grund"
echo "Protokoll: $PROT"
}
ablehnen() { abschluss "abgelehnt" "$1"; exit 1; }
# 0. Aus dem Eingang in die Quarantäne holen
mv "$S/eingang/$NAME" "$S/eingang/$NAME.sha256" "$Q/"
# 1. Transport-Integrität des Archivs
if (cd "$Q" && sha256 -c --status "$NAME.sha256"); then R_HASH="ok"
else R_HASH="fehler"; ablehnen "Archiv-Hash stimmt nicht"; fi
BUNDLE_SHA=$(sha256 "$Q/$NAME" | cut -d' ' -f1)
# 2. Archiv-Hygiene: keine absoluten Pfade, kein .., keine Links
if tar -tf "$Q/$NAME" | grep -Eq '(^/|(^|/)\.\.(/|$))'; then
ablehnen "unsichere Pfade im Archiv"; fi
if tar -tvf "$Q/$NAME" | grep -q '^[lh]'; then
ablehnen "Links im Archiv sind nicht erlaubt"; fi
mkdir -p "$I" && tar -xf "$Q/$NAME" -C "$I"
# 3. Herkunft: Signatur des Absenders über die Hashliste
if openssl dgst -sha256 -verify "$S/vertrauen/absender.pub" \
-signature "$I/SHA256SUMS.sig" "$I/SHA256SUMS" >/dev/null 2>&1
then R_SIG="ok"; else R_SIG="fehler"; ablehnen "Absender-Signatur ungültig"; fi
# 4. Inhalts-Integrität: alle Hashes, keine fremden Dateien
if ! (cd "$I" && sha256 -c --status SHA256SUMS); then
R_DATEIEN="fehler"; ablehnen "Datei-Hash stimmt nicht"; fi
GELISTET=$(awk '{print $2}' "$I/SHA256SUMS" | sort)
VORHANDEN=$(cd "$I" && find . -type f ! -name 'SHA256SUMS*' | sort)
if [ "$GELISTET" != "$VORHANDEN" ]; then
R_DATEIEN="fehler"; ablehnen "fehlende oder zusätzliche Dateien"; fi
R_DATEIEN="ok"
# 5. Konsistenz: Digest im Begleitschein = Image im OCI-Layout
DIGEST=$(jq -r '.digest' "$I/begleitschein.json")
TAG=$(jq -r '.tag' "$I/begleitschein.json")
IDX=$(jq -r --arg t "$TAG" '.manifests[]
| select(.annotations["org.opencontainers.image.ref.name"]==$t)
| .digest' "$I/oci/index.json")
if [ "$DIGEST" = "$IDX" ]; then R_DIGEST="ok"
else R_DIGEST="fehler"; ablehnen "Digest passt nicht zum Begleitschein"; fi
# 6. Inhalt: Schwachstellen und Secrets (nur das Image, ohne Referrer)
oras cp --from-oci-layout "$I/oci:$TAG" \
--to-oci-layout "$Q/scan:$TAG" >/dev/null \
|| ablehnen "Image nicht aus OCI-Layout lesbar"
trivy image --input "$Q/scan" --scanners vuln,secret --ignore-unfixed \
--quiet --format json --output "$Q/trivy.json" \
|| ablehnen "Scan fehlgeschlagen"
CRIT=$(jq '[.Results[]?.Vulnerabilities[]? | select(.Severity=="CRITICAL")]
| length' "$Q/trivy.json")
HIGH=$(jq '[.Results[]?.Vulnerabilities[]? | select(.Severity=="HIGH")]
| length' "$Q/trivy.json")
SECRETS=$(jq '[.Results[]?.Secrets[]?] | length' "$Q/trivy.json")
if [ "$CRIT" -gt "$MAX_CRITICAL" ] || [ "$HIGH" -gt "$MAX_HIGH" ] \
|| [ "$SECRETS" -gt 0 ]; then
R_SCAN="fehler"
ablehnen "Schwelle überschritten (critical=$CRIT high=$HIGH secrets=$SECRETS)"
fi
R_SCAN="ok"
# 7. Optional: Image-Signatur prüfen (siehe Kapitel 5)
# 8. Optional: Malware-Scan, z. B. clamscan -r --no-summary "$I"
abschluss "bestanden" "alle technischen Prüfungen ok"Mach das Skript ausführbar und starte die Prüfung.
PRUEFER setzt du im Lab von Hand, damit du später zwei
Personen simulieren kannst.
chmod +x ~/seclab/kap04/bin/quarantaene-pruefen.sh
PRUEFER=alice ~/seclab/kap04/bin/quarantaene-pruefen.sh demo-app-1.0.0.tarBeim ersten Lauf lädt Trivy seine Schwachstellen-Datenbank herunter. Danach sieht die Ausgabe etwa so aus:
bestanden: alle technischen Prüfungen ok
Protokoll: /home/thomas/seclab/kap04/schleuse/protokolle/demo-app-1.0.0_2026...json
Wird das Bundle abgelehnt, lies den Grund. Die Anzahl der
Schwachstellen hängt vom aktuellen Stand der Trivy-Datenbank ab. Das
Basis-Image und gunicorn==22.0.0 können hohe Schwachstellen
mitbringen. Liegt die Zahl über 5, lege die Dateien erneut in den
Eingang und setze für das Lab MAX_HIGH=10. In echt würdest
du stattdessen das Image reparieren (siehe Kapitel 8).
Schau dir das Protokoll an:
ID=$(ls ~/seclab/kap04/schleuse/geprueft/ | tail -1)
jq . ~/seclab/kap04/schleuse/protokolle/"$ID".jsonErwartete Ausgabe (gekürzt):
{
"id": "demo-app-1.0.0_20261008T091502Z",
"bundle_sha256": "7d3e...",
"image_digest": "sha256:3f1c...",
"pruefer": "alice",
"pruefungen": {
"transport_hash": "ok",
"absender_signatur": "ok",
"dateien": "ok",
"digest_abgleich": "ok",
"scan": { "ergebnis": "ok", "critical": 0, "high": 2, "secrets": 0 }
},
"entscheidung": "bestanden"
}Schritt 7: Freigabe durch eine zweite Person
Die freigebende Person hat ihr eigenes Schlüsselpaar. Ihr
öffentlicher Schlüssel liegt in vertrauen/, damit der
Import später prüfen kann, ob die Freigabe echt ist.
cd ~/seclab/kap04
openssl ecparam -name prime256v1 -genkey -noout -out keys/freigeber-bob.key
openssl ec -in keys/freigeber-bob.key -pubout \
-out schleuse/vertrauen/freigeber.pub
chmod 600 keys/freigeber-bob.keyLege ~/seclab/kap04/bin/freigeben.sh an:
#!/usr/bin/env bash
# freigeben.sh - Freigabe eines geprüften Bundles (Vier-Augen-Prinzip)
set -euo pipefail
ID="${1:?Aufruf: $0 <bundle-id>}"
S="${SCHLEUSE:-$HOME/seclab/kap04/schleuse}"
FREIGEBER="${FREIGEBER:?FREIGEBER=<name> setzen}"
KEY="${FREIGEBER_KEY:?FREIGEBER_KEY=<pfad zum privaten Schlüssel> setzen}"
PROT="$S/protokolle/$ID.json"
sha256() {
if command -v sha256sum >/dev/null 2>&1; then sha256sum "$@"
else shasum -a 256 "$@"; fi
}
[ -d "$S/geprueft/$ID" ] || { echo "Bundle $ID ist nicht im Status geprüft"; exit 1; }
[ "$(jq -r .entscheidung "$PROT")" = "bestanden" ] \
|| { echo "Prüfprotokoll ist nicht bestanden"; exit 1; }
PRUEFER=$(jq -r .pruefer "$PROT")
if [ "$PRUEFER" = "$FREIGEBER" ]; then
echo "Vier-Augen-Prinzip verletzt: $FREIGEBER hat selbst geprüft"; exit 1
fi
jq . "$PROT"
read -r -p "Bundle $ID freigeben? (ja/nein) " ANTWORT
[ "$ANTWORT" = "ja" ] || { echo "Keine Freigabe."; exit 1; }
F="$S/geprueft/$ID/freigabe.json"
jq -n \
--arg id "$ID" \
--arg digest "$(jq -r .image_digest "$PROT")" \
--arg bundle_sha "$(jq -r .bundle_sha256 "$PROT")" \
--arg prot_sha "$(sha256 "$PROT" | cut -d' ' -f1)" \
--arg wer "$FREIGEBER" --arg pruefer "$PRUEFER" \
--arg zeit "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
'{id:$id, image_digest:$digest, bundle_sha256:$bundle_sha,
pruefprotokoll_sha256:$prot_sha, geprueft_von:$pruefer,
freigegeben_von:$wer, zeitpunkt:$zeit, entscheidung:"freigegeben"}' > "$F"
openssl dgst -sha256 -sign "$KEY" -out "$F.sig" "$F"
jq -c . "$F" >> "$S/protokolle/audit.jsonl"
mkdir -p "$S/freigegeben"
mv "$S/geprueft/$ID" "$S/freigegeben/$ID"
echo "Freigegeben: $S/freigegeben/$ID"Teste zuerst den Fehlerfall. Alice hat geprüft, also darf sie nicht freigeben:
chmod +x ~/seclab/kap04/bin/freigeben.sh
FREIGEBER=alice FREIGEBER_KEY=~/seclab/kap04/keys/freigeber-bob.key \
~/seclab/kap04/bin/freigeben.sh "$ID"Erwartete Ausgabe:
Vier-Augen-Prinzip verletzt: alice hat selbst geprüft
Jetzt gibt Bob frei und antwortet mit ja:
FREIGEBER=bob FREIGEBER_KEY=~/seclab/kap04/keys/freigeber-bob.key \
~/seclab/kap04/bin/freigeben.sh "$ID"Erwartete Ausgabe am Ende:
Bundle demo-app-1.0.0_20261008T091502Z freigeben? (ja/nein) ja
Freigegeben: /home/thomas/seclab/kap04/schleuse/freigegeben/demo-app-1.0.0_...
Sicherheit: Im Lab liegen beide Schlüssel in einem Ordner, und
FREIGEBERist nur eine Variable. Das ist Theater. In echt hat Bob seinen Schlüssel auf einer Smartcard oder einem Token, und die Identität kommt aus einem Login, nicht aus einer Umgebungsvariable.
Schritt 8: Import nach reg-ziel und Digest-Vergleich
Der Import ist der letzte Türsteher. Er vertraut nicht darauf, dass
etwas im Ordner freigegeben/ liegt. Er prüft die Signatur
der Freigabe, prüft, ob die Freigabe zu genau diesem Bundle passt, und
prüft die Hashliste noch einmal. Erst dann kopiert er.
Lege ~/seclab/kap04/bin/importieren.sh an:
#!/usr/bin/env bash
# importieren.sh - Import eines freigegebenen Bundles nach reg-ziel
set -euo pipefail
ID="${1:?Aufruf: $0 <bundle-id>}"
S="${SCHLEUSE:-$HOME/seclab/kap04/schleuse}"
ZIEL="${ZIEL_REGISTRY:-localhost:5002}"
D="$S/freigegeben/$ID"; I="$D/inhalt"; F="$D/freigabe.json"
sha256() {
if command -v sha256sum >/dev/null 2>&1; then sha256sum "$@"
else shasum -a 256 "$@"; fi
}
# 1. Freigabe echt?
openssl dgst -sha256 -verify "$S/vertrauen/freigeber.pub" \
-signature "$F.sig" "$F" >/dev/null \
|| { echo "Freigabe-Signatur ungültig"; exit 1; }
# 2. Freigabe passt zu diesem Bundle?
SOLL=$(jq -r .bundle_sha256 "$F")
IST=$(sha256 "$D"/*.tar | cut -d' ' -f1)
[ "$SOLL" = "$IST" ] || { echo "Freigabe gehört zu anderem Bundle"; exit 1; }
# 3. Inhalt seit der Prüfung unverändert?
(cd "$I" && sha256 -c --status SHA256SUMS) \
|| { echo "Inhalt nach Prüfung verändert"; exit 1; }
DIGEST=$(jq -r .image_digest "$F")
REPO=$(jq -r .image "$I/begleitschein.json")
TAG=$(jq -r .tag "$I/begleitschein.json")
# 4. Image mit allen Referrern kopieren, dann zusätzliche Tags (z. B. .sig)
oras cp -r --from-oci-layout "$I/oci:$TAG" \
--to-plain-http "$ZIEL/$REPO:$TAG"
for REF in $(jq -r '.manifests[].annotations["org.opencontainers.image.ref.name"]
// empty' "$I/oci/index.json"); do
[ "$REF" = "$TAG" ] && continue
oras cp --from-oci-layout "$I/oci:$REF" --to-plain-http "$ZIEL/$REPO:$REF"
done
# 5. Digest-Vergleich
ANGEKOMMEN=$(crane digest "$ZIEL/$REPO:$TAG")
if [ "$ANGEKOMMEN" = "$DIGEST" ]; then
echo "OK: $ZIEL/$REPO@$ANGEKOMMEN ist identisch mit der Freigabe"
else
echo "FEHLER: erwartet $DIGEST, angekommen $ANGEKOMMEN"; exit 1
fiAusführen:
chmod +x ~/seclab/kap04/bin/importieren.sh
~/seclab/kap04/bin/importieren.sh "$ID"Erwartete Ausgabe (gekürzt, das Format der oras-Meldungen variiert je nach Version):
Copied [oci-layout] .../inhalt/oci:1.0.0 => [registry] localhost:5002/demo-app:1.0.0
Digest: sha256:3f1c...
OK: localhost:5002/demo-app@sha256:3f1c... ist identisch mit der Freigabe
Vergleiche zur Sicherheit noch einmal von Hand beide Zonen und prüfe, ob die SBOM mitgereist ist:
crane digest localhost:5001/demo-app:1.0.0
crane digest localhost:5002/demo-app:1.0.0
oras discover --plain-http "localhost:5002/demo-app@${DIGEST}"Beide Digests müssen Zeichen für Zeichen gleich sein.
oras discover zeigt in reg-ziel dieselbe CycloneDX-SBOM wie
in reg-build.
Merke: Gleicher Digest heißt gleicher Inhalt. Darauf baut alles Weitere auf: Signaturen (Kapitel 5), SBOM-Zuordnung (Kapitel 7) und Policies im Cluster (Kapitel 9) beziehen sich immer auf den Digest.
Schritt 9: Audit-Spur ansehen
jq -r '[.zeitpunkt, .id, (.entscheidung // ""), (.pruefer // .freigegeben_von)]
| @tsv' ~/seclab/kap04/schleuse/protokolle/audit.jsonlErwartete Ausgabe:
2026-10-08T09:15:02Z demo-app-1.0.0_20261008T091502Z bestanden alice
2026-10-08T09:21:40Z demo-app-1.0.0_20261008T091502Z freigegeben bob
Damit kannst du die Frage des Auditors beantworten: Welches Image, wer hat geprüft, wer hat freigegeben, wann.
Schritt 10: Aufräumen
Die Registries brauchst du in Kapitel 5 wieder. Du kannst sie stoppen, ihre Daten bleiben im Container erhalten.
rm -rf ~/seclab/kap04/schleuse/quarantaene/*
docker stop reg-build reg-zielLass die Ordner freigegeben/, protokolle/
und keys/ stehen. Die Übung baut darauf auf.
Fortschritt speichern? Kostenlos registrieren
Typische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
| Digest in reg-ziel weicht ab | Export mit skopeo oder Docker hat Manifest konvertiert | Mit oras cp oder cosign save/load
arbeiten |
http: server gave HTTP response to HTTPS client |
Registry spricht nur HTTP | --plain-http, --from-plain-http,
--to-plain-http setzen |
| Skript meldet zusätzliche Dateien | macOS hat ._*-Dateien ins tar gepackt |
COPYFILE_DISABLE=1 tar ... |
| Signatur fehlt nach Import | cosign-v2-Signatur unter .sig-Tag, nicht als
Referrer |
.sig/.att-Tags explizit mitnehmen (Schritt
3) |
| Trivy hängt in Zone B | Kein Internet für Datenbank-Download | DB vorab spiegeln, --skip-db-update bzw.
--db-repository |
sha256sum: command not found |
macOS | shasum -a 256 nutzen (gleiches Format) |
| Freigabe-Signatur ungültig | Datei nach dem Signieren geändert (z. B. Editor) | Freigabe neu erstellen, nie von Hand editieren |
Übung: Manipulation und Schwellenwert erkennen
Du bist jetzt der Angreifer und danach wieder der Prüfer. Erzeuge aus deinem Bundle aus Schritt 5 zwei manipulierte Varianten und schicke sie durch die Schleuse:
- Variante A: Ändere im Begleitschein das Feld
absenderaufangreifer, berechne die Hashliste neu und packe das Bundle neu, aber ohne neue Signatur. - Variante B: Schicke das unveränderte Original,
setze aber für die Prüfung einen strengen Schwellenwert
MAX_HIGH=0.
Beantworte für jede Variante: An welcher Prüfung scheitert das Bundle, und was steht im Prüfprotokoll? Bonusfrage: Was müsste ein Angreifer zusätzlich haben, damit Variante A durchkommt?
Hinweis 1: Arbeite in einer Kopie:
cp -r ~/seclab/kap04/bundle ~/seclab/kap04/bundle-a. Nach
dem Ändern brauchst du wieder SHA256SUMS, ein neues tar und
die äußere .sha256-Datei. Schreibe das manipulierte tar
direkt in den Eingang, damit dein Original-Bundle erhalten bleibt. Die
alte SHA256SUMS.sig bleibt einfach liegen.
Hinweis 2: Achte auf die Reihenfolge der Prüfungen im Skript. Die äußere Prüfsumme und die Einzel-Hashes stimmen bei Variante A, weil du sie neu berechnet hast. Welche Prüfung kann der Angreifer ohne den privaten Schlüssel nicht fälschen? Bei Variante B ist alles echt. Welche Prüfung hängt von einer Richtlinie ab statt von Kryptografie?
Lösung
Variante A:
cp -r ~/seclab/kap04/bundle ~/seclab/kap04/bundle-a
cd ~/seclab/kap04/bundle-a
jq '.absender = "angreifer"' begleitschein.json > b.tmp && mv b.tmp begleitschein.json
SHA="sha256sum"; command -v sha256sum >/dev/null || SHA="shasum -a 256"
find . -type f ! -name 'SHA256SUMS*' | sort | xargs $SHA > SHA256SUMS
cd ~/seclab/kap04
COPYFILE_DISABLE=1 tar -C bundle-a -cf schleuse/eingang/demo-app-1.0.0.tar .
(cd schleuse/eingang && $SHA demo-app-1.0.0.tar > demo-app-1.0.0.tar.sha256)
PRUEFER=alice ~/seclab/kap04/bin/quarantaene-pruefen.sh demo-app-1.0.0.tarErwartete Ausgabe:
abgelehnt: Absender-Signatur ungültig
Im Protokoll steht transport_hash: "ok", aber
absender_signatur: "fehler". Der Angreifer konnte alle
Hashes neu berechnen, nicht aber die Signatur. Die äußere Prüfsumme hat
also nichts genützt. Sie schützt nur gegen Übertragungsfehler. Damit
Variante A durchkommt, bräuchte der Angreifer den privaten
Absender-Schlüssel, oder er müsste seinen eigenen öffentlichen Schlüssel
in vertrauen/ einschleusen. Deshalb gehören Vertrauensanker
unter strenge Kontrolle (siehe Kapitel 5).
Variante B:
cd ~/seclab/kap04
cp demo-app-1.0.0.tar demo-app-1.0.0.tar.sha256 schleuse/eingang/Dann mit strengem Schwellenwert prüfen:
MAX_HIGH=0 PRUEFER=alice ~/seclab/kap04/bin/quarantaene-pruefen.sh demo-app-1.0.0.tarErwartete Ausgabe, wenn mindestens eine hohe Schwachstelle mit Fix existiert:
abgelehnt: Schwelle überschritten (critical=0 high=2 secrets=0)
Alle kryptografischen Prüfungen sind ok, nur
scan.ergebnis ist fehler. Das Bundle ist echt,
aber es erfüllt die Richtlinie nicht. In der Praxis führt das nicht zur
Diskussion mit der Schleuse, sondern zu einem Ticket an das
Entwicklungsteam oder zu einer dokumentierten, befristeten Ausnahme
(siehe Kapitel 10).
Fortschritt speichern? Kostenlos registrieren
Aus der Praxis
Organisatorische Trennung. In regulierten Umgebungen (Behörden, KRITIS-Betreiber, Netze für Verschlusssachen) sind Absender, Prüfer und Freigeber verschiedene Rollen, oft in verschiedenen Teams. Das Build-Team darf nicht in die Schleuse schreiben, außer in den Eingang. Die Schleuse hat eigene Admins. Die Freigabe liegt beim Betrieb oder beim Informationssicherheitsbeauftragten. Diese Trennung steht im Betriebskonzept und wird bei Audits geprüft.
Technische Umsetzung. Statt eines Ordners mit Bash-Skripten findest du in der Praxis:
- Eine Quarantäne-Registry oder ein Quarantäne-Projekt, zum Beispiel ein Harbor-Projekt, das Pulls verhindert, solange der Scan Schwachstellen über dem Schwellenwert meldet. Nach Freigabe wird das Image per Replikation oder Promotion in das Produktivprojekt kopiert.
- Repository-Promotion in Nexus oder Artifactory: Das Artefakt wandert
von
stagingnachrelease, wenn alle Prüfungen grün sind. - Transfer-Server an der Zonengrenze, die Dateien entgegennehmen, prüfen und über eine Datendiode weiterreichen.
- Bei Behörden oft eine Sicherheitsgateway-Architektur nach BSI-Vorgaben, etwa nach dem Muster Paketfilter, Application-Level-Gateway, Paketfilter (P-A-P).
Signierte Freigaben. Statt openssl dgst
nutzt man cosign sign-blob, GPG oder ein Ticket-System mit
Workflow und digitaler Signatur. Wichtig ist nicht das Werkzeug, sondern
dass die Freigabe an den Digest gebunden ist. Eine Freigabe “für
demo-app:1.0.0” ist wertlos, weil ein Tag sich ändern kann.
Offline-Datenbanken. Scanner brauchen aktuelle
Daten. In air-gapped Zonen wird die Trivy-Datenbank selbst über die
Schleuse transportiert, typischerweise täglich. Trivy kann seine
Datenbank aus einer internen Registry laden
(--db-repository). Veraltete Scan-Daten sind ein
Audit-Befund. Überwache deshalb das Alter der Datenbank.
Gültigkeit von Freigaben. Eine Freigabe sollte ablaufen. Ein Image, das vor sechs Monaten freigegeben wurde, kann heute bekannte kritische Lücken haben. Viele Organisationen scannen Bestände in der Zielzone regelmäßig nach und widerrufen Freigaben bei neuen kritischen Funden.
Monitoring und Audit. Gute Kennzahlen für den Betrieb:
- Durchlaufzeit von Eingang bis Import (Median, 95. Perzentil),
- Ablehnungsquote und häufigste Ablehnungsgründe,
- Anzahl offener Bundles in
geprueft/, die auf Freigabe warten, - Alter der Scanner-Datenbank.
Das Audit-Log gehört auf einen manipulationssicheren Speicher, zum Beispiel WORM-Storage (Write Once, Read Many) oder mindestens ein Log-System, auf das die Schleusen-Admins keinen Schreibzugriff haben.
Notfälle. Plane einen dokumentierten Eilweg für Sicherheitsupdates, zum Beispiel mit verkürzter Freigabe, aber immer noch mit zwei Personen. Sonst wird im Ernstfall die Schleuse umgangen, und genau das will man verhindern.
Interviewfragen
F: Warum reicht eine SHA-256-Prüfsumme neben dem Bundle nicht aus?
A: Sie erkennt nur zufällige Beschädigung. Wer das Bundle ändern kann, kann auch die Prüfsumme neu berechnen. Für einen Herkunftsnachweis muss die Hashliste mit einem Schlüssel signiert sein, dessen öffentlicher Teil in der Zielzone als Vertrauensanker hinterlegt ist.
F: Was ist der Unterschied zwischen Pull und Push über eine Zonengrenze, und was bevorzugst du?
A: Bei Push baut die niedriger geschützte Zone eine Verbindung in die höhere auf und braucht dort Schreibrechte. Bei Pull holt die höhere Zone selbst. Ich bevorzuge Pull aus einer Schleuse oder einseitige Übertragung per Datendiode, damit keine eingehenden Verbindungen in die geschützte Zone nötig sind.
F: Wie stellst du sicher, dass in Produktion exakt das freigegebene Image läuft?
A: Durchgängig mit Digests arbeiten: Freigabe an den Digest binden, digest-treu übertragen (OCI-Layout mit oras), nach dem Import den Digest vergleichen und im Cluster Images per Digest referenzieren oder per Policy erzwingen (Kapitel 9).
F: Warum kann ein Export mit
docker save oder skopeo Probleme machen?
A: Beide können das Manifest verändern, etwa beim Konvertieren zwischen Docker- und OCI-Format. Dann ändert sich der Digest, und Signaturen und Freigaben, die am alten Digest hängen, passen nicht mehr. Außerdem nehmen sie Referrer wie SBOM und Signaturen nicht mit.
F: Was gehört in ein Prüfprotokoll?
A: Eindeutige ID, Bundle-Hash, Image-Digest, alle Einzelprüfungen mit Ergebnis, verwendete Schwellenwerte und Werkzeugversionen, Prüfer, Zeitpunkt und Entscheidung mit Begründung. Maschinenlesbar, damit Freigabe und Audit darauf aufbauen können.
F: Wie setzt du das Vier-Augen-Prinzip technisch durch?
A: Getrennte Identitäten und Schlüssel für Prüfung und Freigabe, eine technische Sperre gegen Selbstfreigabe und einen Import, der nur mit gültig signierter Freigabe läuft. Die Rollen werden über Gruppen im Identitätsmanagement vergeben, nicht über Variablen.
F: Ein Team beschwert sich, dass die Schleuse zu langsam ist. Was tust du?
A: Erst messen, wo die Zeit verloren geht: Scan, Warten auf Freigabe oder Transport. Dann gezielt verbessern, etwa automatische Vorprüfung schon in Zone A, klare Freigabe-Zeiten oder Vertretungsregeln. Die Prüfungen selbst nicht abschaffen, sondern vorziehen.
Zusammenfassung
Das hast du gelernt:
- Zonen trennen Bereiche mit unterschiedlichem Schutzbedarf. Daten fließen über Schleusen oder Datendioden, bevorzugt einseitig und ohne eingehende Verbindungen in die geschützte Zone.
- Ein Transfer-Bundle besteht aus einem OCI-Layout, einem
Begleitschein, einer Hashliste und einer Absender-Signatur.
oras cp -rexportiert Image und Referrer digest-treu. - Die Quarantäne prüft in fester Reihenfolge: Transport-Hash, Archiv-Hygiene, Absender-Signatur, Einzel-Hashes, Digest-Konsistenz und Inhalt per Trivy mit Schwellenwert.
- Das Ergebnis ist ein maschinenlesbares Prüfprotokoll. Technisch bestanden heißt noch nicht freigegeben.
- Die Freigabe erfolgt durch eine zweite Person, wird signiert und an Bundle-Hash, Image-Digest und Prüfprotokoll gebunden.
- Der Import prüft die Freigabe erneut und vergleicht danach den Digest in der Zielzone. Nur bei Gleichheit ist die Übergabe erfolgreich.
- Ein lückenloses Audit-Log verbindet den laufenden Pod mit Build, Prüfung und Freigabe.