Zum Inhalt springen
Trainingslager IT-Trainingslager

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:

  1. Transport-Integrität: Stimmt der Hash des gesamten Archivs?
  2. Archiv-Hygiene: Keine absoluten Pfade, kein .., keine Symlinks (Schutz vor Path Traversal, also dem Ausbrechen aus dem Zielverzeichnis beim Entpacken).
  3. Herkunft: Ist die Hashliste vom bekannten Absender signiert?
  4. Inhalts-Integrität: Stimmen alle Einzel-Hashes, gibt es keine zusätzlichen Dateien?
  5. Konsistenz: Passt der Digest im Begleitschein zum Image im OCI-Layout?
  6. Inhalt: Schwachstellen-Scan (Trivy), Secret-Scan, optional Malware-Scan (z. B. ClamAV).
  7. Image-Signatur: cosign verify gegen 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/_catalog

Erwartete 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.0

Merke 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: syft liest das Image hier aus dem lokalen Docker-Daemon, weil du es gerade gebaut hast. Soll es direkt aus der Registry lesen, setze SYFT_REGISTRY_INSECURE_USE_HTTP=true und nutze registry: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-app

Erwartete 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}"
done

Gibt 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 nutze oras cp oder cosign 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.key

Erwartete 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.json

Nun 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.tar

Beim 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".json

Erwartete 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.key

Lege ~/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 FREIGEBER ist 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
fi

Ausfü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.jsonl

Erwartete 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-ziel

Lass 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:

  1. Variante A: Ändere im Begleitschein das Feld absender auf angreifer, berechne die Hashliste neu und packe das Bundle neu, aber ohne neue Signatur.
  2. 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.tar

Erwartete 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.tar

Erwartete 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 staging nach release, 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 -r exportiert 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.