Kapitel 2: Bestehende Bauverfahren bewerten und ertüchtigen
In diesem Kapitel lernst du:
- wie du eine Bestandsaufnahme aller Pipelines, Build-Hosts, Bezugsquellen und Secrets machst
- wie du ein Bauverfahren mit einem einfachen Reifegrad-Raster bewertest, angelehnt an die SLSA Build Levels
- welche typischen Risiken in gewachsenen Builds stecken und wie du sie mit hadolint und Trivy findest
- wie du ein Legacy-Dockerfile in kleinen, prüfbaren Schritten härtest
- wie du Erfolg messbar machst: Image-Größe, Befunde und reproduzierbare Digests im Vorher-Nachher-Vergleich
Worum geht es?
Stell dir eine Großküche vor, die seit zwanzig Jahren läuft. Das Essen schmeckt, die Gäste sind zufrieden. Dann kommt die Lebensmittelkontrolle. Sie fragt: Woher kommen die Zutaten? Wer hat Zugang zum Kühlraum? Steht irgendwo ein Eimer ohne Etikett? Kann man dasselbe Gericht morgen genauso kochen?
Plötzlich wird klar: Die Hälfte der Zutaten kauft ein Koch „irgendwo beim Großmarkt”. Der Kühlraumschlüssel hängt an einem Nagel neben der Tür. Das Rezept steht nur im Kopf von Kollegin Meier.
Genau so sieht es in vielen Organisationen mit Bauverfahren aus. Ein Bauverfahren (Build-Prozess) ist alles, was aus Quellcode ein auslieferbares Artefakt macht: Pipeline-Definition, Build-Host, Basisimages, Paketquellen, Skripte, Zugangsdaten. Es funktioniert, aber niemand kann sagen, warum es sicher sein sollte.
In diesem Kapitel gehst du vor wie die Kontrolle. Erst schaust du dir alles an (Inventar). Dann bewertest du es mit einem festen Raster. Danach räumst du in kleinen Schritten auf, die jeder für sich überprüfbar sind. Kein Big Bang, kein Neubau.
+-------------+ +-------------+ +--------------+ +---------------+
| 1. Inventar |-->| 2. Bewerten |-->| 3. Ertüch- |-->| 4. Messen |
| Was gibt es?| | Raster/Level| | tigen | | vorher/nachher|
+-------------+ +-------------+ +--------------+ +---------------+
^ |
| regelmäßig wiederholen |
+-------------------------------------------------------+
Eingänge eines Builds (Angriffsfläche):
Quellcode --+
Basisimage -+--> [ Build-Host / Runner ] --> Image --> Registry
Pakete -----+ ^
Skripte ----+ |
Secrets
Jeder Pfeil in den Build hinein ist eine Stelle, an der jemand etwas Fremdes einschleusen kann. Jeder Pfeil heraus ist eine Stelle, an der etwas Vertrauliches abfließen kann. Deine Aufgabe: diese Pfeile kennen, bewerten und absichern.
Die Konzepte in einfach
Bestandsaufnahme: Was du wissen musst, bevor du etwas änderst
Du kannst nur absichern, was du kennst. Das Inventar beantwortet vier Fragen.
| Bereich | Leitfrage | Beispiele |
|---|---|---|
| Pipelines | Wo wird gebaut, wer darf ändern? | .gitlab-ci.yml, Jenkinsfile, Shell-Skripte |
| Build-Hosts | Worauf läuft der Build? | VM „build01”, Runner-Pods, Laptops |
| Bezugsquellen | Woher kommen Zutaten? | Docker Hub, PyPI, apt, curl-Downloads |
| Secrets | Welche Zugangsdaten nutzt der Build? | Registry-Passwort, Deploy-Token, SSH-Key |
Zu jeder Pipeline notierst du außerdem: Wer ist verantwortlich? Wann lief sie zuletzt? Was baut sie, und wohin geht das Ergebnis? Ein Inventar ohne Verantwortliche ist eine Liste von Problemen ohne Lösungsweg.
Tipp: Halte das Inventar maschinenlesbar, zum Beispiel als YAML im Git. Dann kannst du es mit
yqauswerten und Änderungen per Merge Request nachvollziehen.
Praktische Quellen für das Inventar:
- Die Suche im Git-Server nach
FROM,curl,wget,pip install,npm install,--privileged. - Die Runner-Liste in GitLab (Admin-Bereich) oder die Agents in Jenkins.
- Firewall- und Proxy-Logs: Welche Ziele im Internet rufen Build-Hosts auf? Das ist oft die ehrlichste Quelle.
- Die CI/CD-Variablen in GitLab und die Credentials in Jenkins.
Reifegrad: ein Raster, angelehnt an SLSA
SLSA (Supply-chain Levels for Software Artifacts, gesprochen „Salsa”) ist ein Rahmenwerk der OpenSSF. Die SLSA-Spezifikation v1.0 definiert eine „Build Track” mit Stufen (Build Levels). Kurz gefasst:
| Level | Kernidee | Was das konkret heißt |
|---|---|---|
| Build L0 | nichts | kein Nachweis, wie gebaut wurde |
| Build L1 | Herkunftsnachweis existiert | Provenance wird erzeugt, Build ist skriptet |
| Build L2 | gehostete Plattform | Provenance signiert, Build auf eigener Plattform |
| Build L3 | gehärtete Plattform | Builds isoliert, Secrets für Build-Schritte unerreichbar |
Ein Herkunftsnachweis (Provenance) ist ein maschinenlesbares Dokument: „Dieses Artefakt mit diesem Digest wurde aus diesem Commit, mit dieser Pipeline, auf dieser Plattform gebaut.” Er ist für Software das, was der Lieferschein für Ware ist.
Merke: SLSA v1.0 fordert keine hermetischen oder reproduzierbaren Builds mehr. Das stand in der alten Version 0.1 als „Level 4”. Beides ist trotzdem sehr wertvoll, deshalb nehmen wir es in unser eigenes Raster auf.
Für die Praxis ist SLSA allein zu grob. Du willst auch wissen, ob ein
Dockerfile latest nutzt oder ob ein Passwort im Klartext
steht. Deshalb bauen wir ein eigenes, einfaches Raster. Jedes Kriterium
bekommt 0, 1 oder 2 Punkte:
| Kriterium | 0 Punkte | 1 Punkt | 2 Punkte |
|---|---|---|---|
| Basisimage | latest / ohne Tag |
fester Tag | Tag plus Digest |
| Abhängigkeiten | ungepinnt | Versionen gepinnt | Lockfile mit Hashes |
| Fremdskripte | curl \| bash |
Download mit Prüfung | keine, alles aus Spiegel |
| Secrets | im Code/Image | CI-Variable | Vault, kurzlebig |
| Laufzeit-User | root | non-root, ungeprüft | non-root, per Policy |
| Build-Host | langlebig, geteilt | Container-Runner | ephemer, isoliert |
| Reproduzierbarkeit | nicht geprüft | teilweise | Digest identisch |
| Provenance | keine | erzeugt | erzeugt und signiert |
Maximal sind 16 Punkte möglich. Die Zahl selbst ist nicht heilig. Wichtig ist, dass alle Teams mit demselben Raster messen und dass du Fortschritt zeigen kannst.
Einen ähnlichen, automatisierten Ansatz verfolgt die OpenSSF
Scorecard. Das Werkzeug prüft Repositories (vor allem auf
GitHub) mit Checks wie Pinned-Dependencies,
Token-Permissions, Dangerous-Workflow oder
Signed-Releases und vergibt je Check 0 bis 10 Punkte. Für
interne GitLab-Server ist es nur eingeschränkt nutzbar, aber die
Check-Liste ist eine gute Ideenquelle für dein eigenes Raster.
Die häufigsten Risiken in gewachsenen Builds
latest-Tags und Tags allgemein. Ein Tag
ist ein Zettel, den man umhängen kann. python:latest war
gestern Python 3.12 und ist heute vielleicht 3.14. Ein Angreifer mit
Schreibrechten auf die Quell-Registry kann einen Tag auf ein
manipuliertes Image zeigen lassen. Nur der Digest
(sha256:…) beschreibt den Inhalt eindeutig.
curl | bash. Ein Skript wird aus dem
Internet geladen und sofort ausgeführt. Niemand prüft, was drinsteht.
Ändert jemand das Skript auf dem Server, läuft beim nächsten Build
fremder Code mit allen Rechten des Builds.
Ungepinnte Abhängigkeiten.
pip install flask holt heute Version X und morgen Version
Y. Schlimmer: Ohne Hash-Prüfung merkst du nicht, wenn eine Datei auf dem
Paketserver ausgetauscht wurde.
Langlebige Build-Hosts. Die VM „build01” läuft seit drei Jahren. Jeder Build hinterlässt Spuren: Caches, temporäre Dateien, vielleicht ein kompromittiertes Werkzeug. Der nächste Build erbt das alles. Das nennt man Build-Kontamination.
Secrets in Variablen. ENV API_TOKEN=…
im Dockerfile landet dauerhaft in der Image-Konfiguration. Jeder, der
das Image ziehen kann, liest das Token mit docker inspect.
Auch ARG ist kein Versteck, denn Build-Argumente tauchen in
docker history auf.
Privilegierte Runner. Ein Runner mit
--privileged oder eingebundenem Docker-Socket
(/var/run/docker.sock) gibt jedem Pipeline-Job faktisch
Root-Rechte auf dem Host. Ein einziger böswilliger Merge Request reicht
für die Übernahme.
Ertüchtigung in kleinen Schritten
Ertüchtigen heißt: das Bestehende verbessern, ohne es wegzuwerfen. Die Reihenfolge folgt dem Prinzip „großer Effekt, kleines Risiko zuerst”.
| Schritt | Maßnahme | Wirkt gegen |
|---|---|---|
| 1 | Basisimage per Digest pinnen | umgehängte Tags, Überraschungs-Upgrades |
| 2 | Lockfile mit Hashes | manipulierte Pakete, Versionsdrift |
| 3 | Multi-Stage-Build | Compiler und Werkzeuge im Laufzeit-Image |
| 4 | non-root User | Rechteausweitung im Container |
| 5 | Secrets raus aus Image und Code | Datenabfluss |
| 6 | reproduzierbarer Build | unbemerkte Abweichungen |
| 7 | ephemere, hermetische Builds | Kontamination, Nachladen aus dem Netz |
| 8 | Provenance erzeugen und signieren | fehlender Herkunftsnachweis |
Ein paar Begriffe dazu:
- Pinning per Digest:
FROM python:3.12-slim@sha256:abc…. Der Tag bleibt als Lesehilfe stehen, maßgeblich ist der Digest. Updates kommen dann bewusst, zum Beispiel per Renovate-Merge-Request. - Lockfile mit Hashes: Eine Datei, die jede
Abhängigkeit (auch transitive) mit exakter Version und Prüfsumme
auflistet. pip prüft das mit
pip install --require-hashes. Fehlt ein Hash oder stimmt er nicht, bricht die Installation ab. - Multi-Stage-Build: Das Dockerfile hat mehrere
FROM-Abschnitte. In der ersten Stufe wird gebaut, in die letzte kopierst du nur das Ergebnis. - Reproduzierbarer Build: Gleiche Eingaben ergeben
bitgleiche Ausgaben, also denselben Digest. Störfaktoren sind vor allem
Zeitstempel. Die Umgebungsvariable
SOURCE_DATE_EPOCH(ein Unix-Zeitstempel, meist der des letzten Commits) ist der etablierte Standard, um Werkzeugen einen festen Zeitpunkt vorzugeben. BuildKit wertet sie ab Version 0.11 aus, das Umschreiben der Datei-Zeitstempel in den Layern (rewrite-timestamp) gibt es ab BuildKit 0.13. - Hermetischer Build: Der Build hat während der Ausführung keinen Netzzugang. Alle Eingaben sind vorher deklariert und geprüft. Kapitel 3 zeigt, wie du die Eingaben über einen Spiegel holst.
- Ephemerer Build: Jeder Build läuft in einer frischen Umgebung, die danach weggeworfen wird. Beispiel: ein Kubernetes-Runner-Pod pro Job.
Sicherheit: Ein reproduzierbarer Build ist ein starkes Prüfwerkzeug. Baut ein zweites, unabhängiges System denselben Digest, ist eine Manipulation am ersten Build-System sehr unwahrscheinlich.
Hands-on-Lab: Ein Legacy-Build wird erwachsen
Du übernimmst einen „gewachsenen” Build für die
demo-app. Du analysierst ihn, füllst den Bewertungsbogen
aus und härtest ihn Schritt für Schritt. Am Ende vergleichst du vorher
und nachher.
Voraussetzungen aus Kapitel 0: ~/seclab/demo-app
existiert, die Registry reg-build läuft auf
localhost:5001, und die Werkzeuge docker,
trivy, crane, jq und
yq sind installiert.
Schritt 1: Arbeitsverzeichnis vorbereiten
mkdir -p ~/seclab/kap02
cd ~/seclab/kap02
cp -r ~/seclab/demo-app legacy
cp -r ~/seclab/demo-app hardened
rm -f legacy/Dockerfile hardened/Dockerfile
ls legacyErwartete Ausgabe:
app.py k8s requirements-dev.txt requirements.txt tests
Wir löschen die vorhandenen Dockerfiles aus Kapitel 0 in den Kopien, weil wir sie in diesem Kapitel bewusst neu schreiben.
Schritt 2: Das Legacy-Dockerfile anlegen
So sieht ein typisches Dockerfile aus, das „seit Jahren funktioniert”. Lege es an:
cat > legacy/Dockerfile <<'EOF'
FROM python:latest
ENV API_TOKEN=lab-token-123
RUN apt-get update
RUN apt-get install -y curl gcc
RUN curl -sSL https://bootstrap.pypa.io/get-pip.py | python
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
EXPOSE 8000
CMD gunicorn -b 0.0.0.0:8000 app:app
EOFAchtung:
lab-token-123ist ein reiner Lab-Wert. Er steht hier absichtlich, damit du ihn später findest.
Dazu gehört ein Pipeline-Skript, wie es oft auf einem Build-Server liegt. Lege es nur zur Analyse an, ausführen musst du es nicht:
cat > legacy/build-legacy.sh <<'EOF'
#!/bin/bash
set -x
export REGISTRY_PASSWORD='Sommer2024!' # Lab-Wert
curl -sSL https://tools.example.com/install-scanner.sh | bash
docker login -u ci -p $REGISTRY_PASSWORD localhost:5001
docker run --privileged -v /var/run/docker.sock:/var/run/docker.sock \
docker:cli docker build -t localhost:5001/demo-app:latest /src
docker push localhost:5001/demo-app:latest
EOFZähle selbst, bevor du weiterliest: Wie viele Probleme siehst du in diesen 15 Zeilen?
Schritt 3: Die Bestandsaufnahme festhalten
Lege ein kleines, maschinenlesbares Inventar an:
cat > inventar.yaml <<'EOF'
pipelines:
- name: demo-app-legacy
owner: team-demo
definition: legacy/build-legacy.sh
runner:
host: build01
langlebig: true
privileged: true
bezugsquellen:
- docker.io/library/python:latest
- pypi.org
- deb.debian.org
- bootstrap.pypa.io
- tools.example.com
secrets:
- name: REGISTRY_PASSWORD
ablage: klartext-im-skript
- name: API_TOKEN
ablage: dockerfile-env
EOF
yq '.pipelines[] | select(.runner.privileged == true) | .name' inventar.yaml
yq '.pipelines[].bezugsquellen | length' inventar.yamlErwartete Ausgabe:
demo-app-legacy
5
Fünf verschiedene Bezugsquellen im Internet für eine kleine Flask-App. In einer echten Organisation mit 200 Pipelines ergibt das eine sehr lange Liste, die niemand kontrolliert. Genau das löst Kapitel 3.
Schritt 4: Den Legacy-Build bauen und messen
cd ~/seclab/kap02/legacy
docker build -t demo-app:legacy .
docker image ls demo-app:legacy --format '{{.Repository}}:{{.Tag}} {{.Size}}'Erwartete Ausgabe (Größe variiert):
demo-app:legacy 1.6GB
Die Größe liegt typischerweise deutlich über einem Gigabyte. Das volle Debian-Image bringt Compiler, Header und viele Bibliotheken mit.
Jetzt der Secret-Test:
docker inspect -f '{{json .Config.Env}}' demo-app:legacy | jq
docker inspect -f '{{.Config.User}}' demo-app:legacyErwartete Ausgabe (gekürzt):
[
"PATH=/usr/local/bin:...",
"API_TOKEN=lab-token-123",
...
]
Das Token ist für jeden lesbar, der das Image ziehen darf. Die zweite Ausgabe ist leer, das heißt: Der Container läuft als root.
Schritt 5: Dockerfile-Analyse mit hadolint
hadolint ist ein Linter für Dockerfiles. Er prüft Best Practices und
meldet Regeln mit IDs wie DL3007. Du brauchst ihn nicht zu
installieren, der Container reicht:
docker run --rm -i hadolint/hadolint < DockerfileErwartete Ausgabe (sinngemäß, genaue Liste je nach Version):
-:1 DL3007 warning: Using latest is prone to errors if the image will ever
update. Pin the version explicitly to a release tag
-:4 DL3008 warning: Pin versions in apt get install. ...
-:4 DL3015 info: Avoid additional packages by specifying `--no-install-recommends`
-:4 DL3059 info: Multiple consecutive `RUN` instructions. Consider consolidation.
-:5 DL4006 warning: Set the SHELL option -o pipefail before RUN with a pipe in it.
-:8 DL3042 warning: Avoid use of cache directory with pip. ...
-:10 DL3025 warning: Use arguments JSON notation for CMD and ENTRYPOINT arguments
Das - steht für „von stdin gelesen”. Beachte: hadolint
findet das Token in ENV nicht. Linter prüfen Stil und
bekannte Muster, keine Inhalte. Du brauchst mehrere Werkzeuge.
Schritt 6: Konfigurations- und Image-Scan mit Trivy
Trivy kann Konfigurationsdateien (Misconfiguration-Scan) und fertige Images (Schwachstellen-Scan) prüfen:
trivy config .Erwartete Ausgabe (gekürzt, IDs je nach Trivy-Version als
DS001 oder AVD-DS-0001):
Dockerfile (dockerfile)
Tests: ... (SUCCESSES: ..., FAILURES: ...)
Failures: ... (UNKNOWN: 0, LOW: ..., MEDIUM: ..., HIGH: ..., CRITICAL: 0)
AVD-DS-0001 (MEDIUM): Specify a tag in the 'FROM' statement for image 'python'
AVD-DS-0002 (HIGH): Specify at least 1 USER command in Dockerfile with
non-root user as argument
AVD-DS-0017 (HIGH): The instruction 'RUN <package-manager> update' should
always be followed by '<package-manager> install' in the same RUN statement.
AVD-DS-0029 (HIGH): '--no-install-recommends' flag is missed: ...
Jetzt der Schwachstellen-Scan des Images. Wir zählen nur HIGH und CRITICAL:
trivy image --quiet --severity HIGH,CRITICAL --format json demo-app:legacy \
| jq '[.Results[]?.Vulnerabilities // [] | length] | add'Erwartete Ausgabe: eine Zahl, oft im dreistelligen Bereich. Notiere sie. Der genaue Wert hängt vom Tag des Scans ab, denn die Schwachstellendatenbank wächst täglich.
Tipp: Bewahre Scan-Ergebnisse als JSON auf (
--output legacy-scan.json). So kannst du später belegen, wie der Stand vor der Ertüchtigung war. Kapitel 8 vertieft Triage und Schwellenwerte.
Schritt 7: Den Bewertungsbogen ausfüllen
Nimm das Raster aus dem Konzeptteil und bewerte den Legacy-Build. Lege die Datei an:
cd ~/seclab/kap02
cat > bewertung.md <<'EOF'
| Kriterium | Legacy | Begründung |
|--------------------|--------|-----------------------------------------|
| Basisimage | 0 | python:latest |
| Abhängigkeiten | 1 | Versionen gepinnt, keine Hashes |
| Fremdskripte | 0 | curl | python, curl | bash |
| Secrets | 0 | ENV im Image, Passwort im Skript |
| Laufzeit-User | 0 | root |
| Build-Host | 0 | build01, langlebig, privileged |
| Reproduzierbarkeit | 0 | nicht geprüft |
| Provenance | 0 | keine |
| Summe | 1/16 | entspricht SLSA Build L0 |
EOFEin Punkt für die Abhängigkeiten, weil requirements.txt
die direkten Pakete pinnt. Die transitiven Abhängigkeiten (etwa
Werkzeug oder urllib3) sind aber frei. Das ist
der typische Zustand: halb gepinnt fühlt sich sicher an, ist es aber
nicht.
Schritt 8: Härtung 1 – Basisimage per Digest pinnen
Ermittle den aktuellen Digest von python:3.12-slim:
PY_DIGEST=$(crane digest python:3.12-slim)
echo "$PY_DIGEST"Erwartete Ausgabe:
sha256:4a3f... (64 Hex-Zeichen)
Dieser Digest gehört zum Image-Index (Multi-Arch-Liste). Docker wählt
daraus automatisch die passende Architektur, also amd64
oder arm64. Den Wert setzt du gleich ins neue Dockerfile
ein.
Merke:
python:3.12-slimbasiert inzwischen auf Debian 13 „trixie”. Mit Digest ist das egal: Du bekommst immer exakt das Image, das du gepinnt hast. Ein Upgrade ist eine bewusste Änderung am Digest.
Schritt 9: Härtung 2 – Lockfile mit Hashes erzeugen
Wir erzeugen mit pip-compile aus dem Paket
pip-tools eine Lock-Datei. Das passiert in einem Container
mit derselben Python-Version wie im Build, denn die Auflösung kann von
der Python-Version abhängen:
cd ~/seclab/kap02/hardened
docker run --rm --user "$(id -u):$(id -g)" -e HOME=/tmp \
-v "$PWD":/w -w /w "python:3.12-slim@${PY_DIGEST}" \
sh -c 'pip install --quiet --user pip-tools && \
/tmp/.local/bin/pip-compile --quiet --generate-hashes \
--output-file requirements.lock requirements.txt'
grep -c -- '--hash=sha256' requirements.lock
head -n 12 requirements.lockErwartete Ausgabe (Ausschnitt):
40
#
# This file is autogenerated by pip-compile with Python 3.12
# by the following command:
#
# pip-compile --generate-hashes --output-file=requirements.lock ...
#
blinker==1.8.2 \
--hash=sha256:1779309f71bf2391...bf67c01 \
--hash=sha256:8f77b09d3bf7c795...9642d83
# via flask
certifi==2024.8.30 \
Die Zahl der Hashes und die Versionen der transitiven Pakete können
bei dir abweichen. Wichtig ist: Jedes Paket, auch die indirekten wie
blinker, certifi oder urllib3,
steht mit fester Version und mindestens einem Hash in der Datei.
Tipp: Statt
pip-toolskannst du auchuv pip compile --generate-hashesverwenden. Das ist deutlich schneller. Wichtig ist nur, dass das Lockfile im Repository liegt und per Review geändert wird.
Schritt 10: Härtung 3 – Multi-Stage, non-root, ohne Secrets
Jetzt das neue Dockerfile. Der Platzhalter
<DIGEST> wird im nächsten Befehl ersetzt:
cat > Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.12-slim@<DIGEST> AS build
ENV PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /build
COPY requirements.lock .
RUN pip install --require-hashes --no-deps --no-compile \
--prefix=/install -r requirements.lock
FROM python:3.12-slim@<DIGEST>
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
COPY --from=build /install /usr/local
WORKDIR /app
COPY app.py .
USER 10001:10001
EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]
EOF
sed -i.bak "s|@<DIGEST>|@${PY_DIGEST}|g" Dockerfile && rm Dockerfile.bak
grep '^FROM' DockerfileErwartete Ausgabe:
FROM python:3.12-slim@sha256:4a3f... AS build
FROM python:3.12-slim@sha256:4a3f...
Was hier passiert:
- Stufe
buildinstalliert die Pakete mit Hash-Prüfung nach/install.--no-depssorgt dafür, dass pip nichts nachlädt, was nicht im Lockfile steht.--no-compileverhindert.pyc-Dateien, die den Build weniger reproduzierbar machen würden. - Die Laufzeitstufe bekommt nur
/installundapp.py. Keingcc, keincurl, keinapt-Cache. USER 10001:10001setzt eine numerische UID und GID. Ein Eintrag in/etc/passwdist dafür nicht nötig. Das spart einenuseradd-Schritt, der Zeitstempel in/etc/shadowschreiben würde.COPY app.py .kopiert gezielt nur die Anwendung.COPY . .würde alles mitnehmen, auch versehentlich abgelegte.env-Dateien oder das.git-Verzeichnis.- Das Token ist weg. Braucht die Anwendung zur Laufzeit ein Token, kommt es als Kubernetes-Secret oder aus Vault (siehe Kapitel 6), nie aus dem Image.
Zur Sicherheit noch eine .dockerignore:
printf '%s\n' '.git' '.venv' '.env' '*.pyc' '__pycache__' 'tests' 'k8s' \
> .dockerignoreBauen und prüfen:
docker build -t demo-app:hardened .
docker run -d --rm --name demo-hardened -p 18000:8000 demo-app:hardened
sleep 2
curl -s http://localhost:18000/
docker exec demo-hardened id
docker stop demo-hardenedErwartete Ausgabe:
{"status":"ok"}
uid=10001 gid=10001 groups=10001
Die App läuft, und zwar als UID 10001.
Schritt 11: Erneut analysieren und vergleichen
docker run --rm -i hadolint/hadolint < Dockerfile
trivy config --quiet .
docker image ls --format '{{.Repository}}:{{.Tag}} {{.Size}}' | grep demo-app
trivy image --quiet --severity HIGH,CRITICAL --format json demo-app:hardened \
| jq '[.Results[]?.Vulnerabilities // [] | length] | add'Erwartete Ausgabe:
- hadolint: keine Ausgabe (Exit-Code 0).
trivy config: höchstens ein LOW-Befund zu fehlendemHEALTHCHECK. In Kubernetes übernimmt das eine Liveness-Probe, der Befund ist also vertretbar. Dokumentiere so eine Entscheidung (siehe Kapitel 10).- Größe: grob 130 bis 180 MB statt über 1 GB.
- Schwachstellen: deutlich weniger. Ganz null werden es nicht, denn
requests==2.25.0ist absichtlich verwundbar und bleibt für die Übungen in Kapitel 7 und 8 drin.
Merke: Ein kleineres Image ist nicht automatisch sicher. Aber jedes Paket, das nicht drin ist, kann auch keine Schwachstelle haben und muss nicht gepatcht werden.
Schritt 12: Das Pipeline-Skript härten
Jetzt das Skript. Lege eine gehärtete Fassung an:
cat > build.sh <<'EOF'
#!/usr/bin/env bash
# Gehärteter Build für demo-app (Lab, Kapitel 2)
set -euo pipefail
IMAGE="localhost:5001/demo-app"
VERSION="${VERSION:?Bitte VERSION setzen, z. B. VERSION=1.0.1}"
export SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-$(git log -1 --format=%ct \
2>/dev/null || echo 1700000000)}"
docker build --build-arg SOURCE_DATE_EPOCH -t "${IMAGE}:${VERSION}" .
docker push "${IMAGE}:${VERSION}"
DIGEST="$(crane digest "${IMAGE}:${VERSION}")"
echo "${IMAGE}@${DIGEST}" | tee image.ref
EOF
chmod +x build.sh
VERSION=1.0.1 ./build.shErwartete Ausgabe (letzte Zeile):
localhost:5001/demo-app@sha256:9c1e...
Was sich gegenüber build-legacy.sh geändert hat:
| Legacy | Gehärtet | Warum |
|---|---|---|
set -x |
set -euo pipefail |
keine Secrets im Log, Fehler brechen ab |
| Passwort im Skript | kein Passwort | Login macht die CI mit kurzlebigem Token |
curl \| bash |
entfernt | Werkzeuge kommen vorinstalliert im Runner-Image |
--privileged + Socket |
normaler Build | Runner-Isolation regelt die Plattform |
:latest |
Version + Digest | eindeutige Referenz für Signatur und Deployment |
Die Datei image.ref mit image@sha256:… ist
ab jetzt der Übergabepunkt. Signiert (Kapitel 5) und deployt wird nur
noch per Digest.
Schritt 13: Reproduzierbarkeit prüfen
Jetzt der spannendste Test. Wir bauen zweimal ohne Cache und
vergleichen die Digests. Dafür brauchen wir einen BuildKit-Builder mit
dem docker-container-Treiber, weil der Standard-Builder den
OCI-Export nicht in jeder Docker-Konfiguration unterstützt:
docker buildx create --name seclab-builder --driver docker-container
export SOURCE_DATE_EPOCH=1700000000
for i in 1 2; do
docker buildx build --builder seclab-builder --no-cache --provenance=false \
--build-arg SOURCE_DATE_EPOCH \
--output type=oci,dest=build-$i.tar,rewrite-timestamp=true \
--metadata-file meta-$i.json .
done
jq -r '."containerimage.digest"' meta-1.json meta-2.jsonErwartete Ausgabe:
sha256:7d2b...
sha256:7d2b...
Zwei identische Digests: Der Build ist reproduzierbar. Ohne
rewrite-timestamp=true oder ohne
SOURCE_DATE_EPOCH erhältst du zwei verschiedene Werte.
Probiere es aus.
Warum --provenance=false? Buildx hängt standardmäßig
eine Provenance-Attestierung an. Die enthält Start- und Endzeit des
Builds und ändert damit den Digest des Image-Index. Für den Vergleich
schalten wir sie ab. Das eigentliche Image bleibt davon unberührt.
Tipp: Weichen die Digests ab, hilft das Werkzeug
diffoci(Projekt „reproducible-containers”). Es zeigt Datei für Datei, was sich zwischen zwei Images unterscheidet.
Schritt 14: Provenance erzeugen (Ausblick)
Mit BuildKit erzeugst du einen SLSA-Herkunftsnachweis direkt beim Build:
BUILDX_METADATA_PROVENANCE=max docker buildx build --builder seclab-builder \
--provenance=mode=max --build-arg SOURCE_DATE_EPOCH \
--output type=oci,dest=build-prov.tar --metadata-file meta-prov.json .
jq '."buildx.build.provenance" | keys' meta-prov.jsonErwartete Ausgabe (je nach buildx-Version):
[
"buildType",
"invocation",
"materials",
"metadata"
]
Unter materials findest du das Basisimage mit Digest.
Unter invocation stehen die Build-Parameter. Das ist SLSA
Build L1. Für L2 muss der Nachweis von der Plattform signiert werden,
das machst du in Kapitel 5 mit Cosign. Falls deine buildx-Version das
Feld nicht in die Metadaten-Datei schreibt, ist die Attestierung
trotzdem im OCI-Archiv enthalten.
Trage das Ergebnis im Bewertungsbogen nach: Basisimage 2, Abhängigkeiten 2, Fremdskripte 2, Secrets 1, Laufzeit-User 1, Reproduzierbarkeit 2, Provenance 1. Der Build-Host bleibt bei 0, bis die Plattform umgestellt ist (Kapitel 1). Das ergibt 11 von 16 Punkten statt 1.
Schritt 15: Aufräumen
cd ~/seclab/kap02/hardened
rm -f build-*.tar meta-*.json
docker buildx rm seclab-builder
docker image rm demo-app:legacy demo-app:hardenedDas Image localhost:5001/demo-app:1.0.1 bleibt in
reg-build, du brauchst es in späteren Kapiteln wieder.
Fortschritt speichern? Kostenlos registrieren
Typische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
THESE PACKAGES DO NOT MATCH THE HASHES |
Lockfile für andere Python-Version oder veraltet | Lockfile im gleichen Basisimage neu erzeugen |
In --require-hashes mode, all requirements must have their versions pinned |
Paket fehlt im Lockfile | Paket in requirements.txt aufnehmen, neu
kompilieren |
exec format error beim Start |
Digest eines einzelnen Arch-Manifests gepinnt | Index-Digest pinnen (crane digest ohne
--platform) |
| Digests der zwei Builds verschieden | Zeitstempel, .pyc, Provenance |
SOURCE_DATE_EPOCH, rewrite-timestamp,
--no-compile, --provenance=false |
Permission denied beim Start als 10001 |
Anwendung schreibt ins Arbeitsverzeichnis | Schreibpfade auf /tmp oder ein Volume legen |
OCI exporter is not supported for the docker driver |
OCI-Export im Standard-Builder | docker-container-Builder wie in Schritt 13 |
pip-compile bricht mit Attributfehler ab |
pip-tools und pip passen nicht zusammen | neueste pip-tools-Version oder uv pip compile |
Übung: Zweiten Legacy-Build bewerten
Ein Team liefert dir dieses Dockerfile für einen kleinen Worker:
FROM node:20
ARG NPM_TOKEN=lab-npm-token-456
RUN echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
WORKDIR /srv
COPY . .
RUN npm install
RUN wget -qO- https://get.example.com/agent.sh | sh
CMD npm startDeine Aufgabe:
- Fülle den Bewertungsbogen (8 Kriterien, 0 bis 2 Punkte) aus.
- Nenne die drei Maßnahmen mit dem besten Verhältnis von Wirkung zu Aufwand.
- Schreibe eine gehärtete Fassung des Dockerfiles.
Hinweis 1: Schau dir genau an, was mit dem
NPM_TOKEN passiert. Wo steht es nach dem Build überall?
Denk an docker history und an die Datei
~/.npmrc in einem Layer.
Hinweis 2: Für npm entspricht npm ci
mit package-lock.json dem pip-Befehl mit
--require-hashes. Der Lockfile enthält
integrity-Hashes. Für das Token gibt es
BuildKit-Secret-Mounts:
RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci.
Lösung
Bewertung: Basisimage 1 (fester Major-Tag, kein Digest),
Abhängigkeiten 0 (npm install ignoriert Lock-Abweichungen
und aktualisiert), Fremdskripte 0 (wget | sh), Secrets 0
(Token im Build-Arg und im Layer), Laufzeit-User 0 (root), Build-Host 0
(unbekannt, also schlechtester Fall), Reproduzierbarkeit 0, Provenance
0. Summe: 1 von 16.
Die drei besten Maßnahmen: Token per Secret-Mount statt
ARG, npm ci mit Lockfile,
wget | sh entfernen und den Agenten als geprüftes Paket aus
dem Spiegel beziehen.
Gehärtete Fassung:
# syntax=docker/dockerfile:1
FROM node:20-slim@sha256:<DIGEST> AS build
WORKDIR /srv
COPY package.json package-lock.json ./
RUN --mount=type=secret,id=npmrc,target=/root/.npmrc \
npm ci --omit=dev --ignore-scripts
COPY src/ ./src/
FROM node:20-slim@sha256:<DIGEST>
WORKDIR /srv
COPY --from=build /srv /srv
USER 10001:10001
CMD ["node", "src/index.js"]Gebaut wird mit
docker build --secret id=npmrc,src=$HOME/.npmrc .. Das
Secret ist nur während des RUN sichtbar und landet in
keinem Layer. --ignore-scripts verhindert, dass
Install-Skripte von Paketen ausgeführt werden. Prüfe vorher, ob die
Anwendung Pakete mit nötigen Install-Skripten nutzt. Der Agent kommt,
falls wirklich nötig, als eigenes Paket aus dem Spiegel (Kapitel 3).
Fortschritt speichern? Kostenlos registrieren
Aus der Praxis
Nicht alles auf einmal. In einer Behörde oder einem
KRITIS-Unternehmen gibt es oft hunderte Pipelines. Wer alle gleichzeitig
umstellen will, scheitert am Widerstand der Teams. Bewährt hat sich:
Zuerst das Inventar automatisch erzeugen, dann die Bewertung als
Dashboard veröffentlichen, dann pro Quartal eine Mindeststufe festlegen.
Zum Beispiel: „Bis Ende Q2 kein latest und kein
Klartext-Secret mehr.”
Bewertung automatisieren. Der Bewertungsbogen sollte
kein Word-Dokument sein. Ein CI-Job pro Repository kann hadolint,
trivy config und eine Secret-Suche (gitleaks, siehe Kapitel
6) ausführen und das Ergebnis als JSON an eine zentrale Stelle schicken.
So siehst du Trends statt Momentaufnahmen.
Basisimages zentral bereitstellen. Ein
Plattform-Team pflegt eine kleine Zahl freigegebener Basisimages, zum
Beispiel python-3.12, node-20 und
java-21. Diese werden wöchentlich neu gebaut, gescannt und
signiert. Die Teams pinnen den Digest, Renovate schlägt Updates
automatisch per Merge Request vor. Damit wandert die Pflege vom
einzelnen Team zur Plattform.
Build-Hosts ablösen. Der langlebige Build-Server ist oft der schwierigste Punkt, weil viele Pipelines daran hängen. Ein gangbarer Weg: neue Pipelines nur noch auf ephemeren Kubernetes-Runnern zulassen, alte Pipelines mit Übergangsfrist migrieren (Kapitel 10). Privilegierte Runner bekommen ein eigenes Tag und eine Liste genehmigter Projekte.
Audit-Fähigkeit. Prüfer fragen selten nach Werkzeugen. Sie fragen: „Können Sie zeigen, dass das Artefakt in Produktion aus Commit X stammt?” Provenance plus Signatur plus Digest-basiertes Deployment beantworten genau das. Dokumentiere die Bewertung pro Pipeline mit Datum und Verantwortlichem. Bei regulierten Umgebungen ist das Nachweisdokumentation, zum Beispiel im Rahmen von IT-Grundschutz-Bausteinen zur Software-Entwicklung oder bei NIS2-Anforderungen an die Lieferkette.
Reproduzierbarkeit realistisch sehen. Bitgleiche Builds für jede Anwendung sind viel Arbeit. Fang mit den kritischsten Artefakten an, etwa Basisimages und sicherheitsrelevanten Komponenten. Ein zweiter, unabhängiger Builder, der nachts nachbaut und Digests vergleicht, ist ein starkes Kontrollinstrument.
Interviewfragen
F: Wie gehst du vor, wenn du die Bauverfahren einer Organisation bewerten sollst?
A: Zuerst ein Inventar: Pipelines, Build-Hosts, Bezugsquellen, Secrets, Verantwortliche. Dann eine Bewertung mit einem einheitlichen Raster, angelehnt an SLSA Build Levels und ergänzt um konkrete Kriterien wie Pinning und Secrets. Danach priorisierte, kleine Maßnahmen und messbare Ziele pro Quartal.
F: Was ist der Unterschied zwischen SLSA Build L2 und L3?
A: Bei L2 läuft der Build auf einer gehosteten Plattform, die die Provenance signiert. L3 fordert zusätzlich eine gehärtete Plattform: Builds sind voneinander isoliert, und die Signierschlüssel für die Provenance sind für die benutzerdefinierten Build-Schritte nicht erreichbar. Die Provenance ist damit nicht fälschbar.
F: Warum reicht ein fester Tag wie
python:3.12.4-slim nicht?
A: Tags sind veränderbar. Der Besitzer der Registry oder ein Angreifer mit Schreibrechten kann den Tag auf ein anderes Image zeigen lassen. Nur der Digest identifiziert den Inhalt kryptografisch. Der Tag bleibt als Lesehilfe stehen.
F: Was bewirkt
pip install --require-hashes?
A: pip installiert nur Pakete, deren Version gepinnt ist und deren heruntergeladene Datei zu einem der angegebenen SHA-256-Hashes passt. Ein ausgetauschtes Paket oder eine fehlende transitive Abhängigkeit führt zum Abbruch.
F: Wie machst du einen Container-Build reproduzierbar?
A: Alle Eingaben per Digest und Hash pinnen,
SOURCE_DATE_EPOCH setzen, bei BuildKit
rewrite-timestamp=true nutzen, nichtdeterministische
Artefakte wie .pyc-Dateien oder Zeitstempel in Dateien
vermeiden. Dann zweimal ohne Cache bauen und die Digests
vergleichen.
F: Warum ist ein Runner mit Docker-Socket gefährlich?
A: Wer den Docker-Socket nutzen kann, kann einen privilegierten Container mit dem Host-Dateisystem starten. Das ist faktisch Root auf dem Host. Jeder Job auf dem Runner kann damit andere Jobs, deren Secrets und den Host selbst übernehmen.
F: Was ist der Unterschied zwischen einem hermetischen und einem ephemeren Build?
A: Ephemer heißt, die Umgebung ist frisch und wird danach verworfen. Das schützt vor Kontamination zwischen Builds. Hermetisch heißt, der Build hat während der Ausführung keinen Netzzugang und nutzt nur vorher deklarierte Eingaben. Das schützt vor Nachladen unbekannter Inhalte.
Zusammenfassung
Das hast du gelernt:
- Ein Inventar aus Pipelines, Build-Hosts, Bezugsquellen und Secrets ist die Grundlage jeder Bewertung. Firewall-Logs sind oft die ehrlichste Quelle.
- Die SLSA Build Levels geben eine Richtung vor. Ein eigenes Punkte-Raster macht den Fortschritt konkret und vergleichbar.
latest,curl | bash, ungepinnte Abhängigkeiten, langlebige Build-Hosts, Secrets im Image und privilegierte Runner sind die typischen Risiken.- hadolint und
trivy configfinden viele Probleme automatisch, aber nicht alle. Ein Blick aufdocker inspectzeigt Secrets im Image. - Digest-Pinning, Lockfile mit Hashes, Multi-Stage und non-root sind kleine Schritte mit großer Wirkung.
- Mit
SOURCE_DATE_EPOCHundrewrite-timestampbaust du bitgleiche Images und kannst das mit zwei Digests beweisen. - Provenance ist der Lieferschein deines Artefakts. Signiert wird er in Kapitel 5, die Eingaben kommen ab Kapitel 3 aus einem Spiegel.