Tag 11: Wie Secrets durchsickern
Ziel: Einen API-Key auf vier Wegen ins Image bringen und ihn jedes Mal mit Bordmitteln wiederfinden. · Dauer: ca. 75 min · Voraussetzung: Tag 10
Briefing
- Ein Image ist ein Stapel von Tar-Archiven plus eine JSON-Config mit History. Alles, was in einem der beiden steht, liest jeder, der das Image ziehen darf.
- Vier typische Lecks:
ARG,ENV,COPY .envundrmim nächstenRUN. - Drei Werkzeuge reichen zum Nachweis:
docker history --no-trunc,docker image inspect,docker saveplustarundgrep. - Merksatz: Was in einem Layer war, bleibt drin.
im Dockerfile wo der Key danach steckt
ARG + --build-arg ───────────► History (RUN |1 KEY=…), Build-Log, Provenance
ENV ───────────► Image-Config, History, jeder Container
COPY .env ───────────► Layer-Tar
rm im nächsten RUN ───────────► Layer-Tar darunter, darüber nur ein Whiteout
Drill 1: Das Leck-Labor
source ~/docker-lab/setup/env.sh
mkdir -p ~/docker-lab/tag11 && cd ~/docker-lab/tag11
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag10/notes/." .Die zweite Kopie legt den Stand vom Ende von Tag 10 darüber – auch wenn du ihn übersprungen hast. Heute bleibt das kanonische Dockerfile unangetastet. Die absichtlich kaputten Varianten holst du dir in einen eigenen Ordner:
cp -R "$LAB/code/tag11/leaks" .
ls -1 leaksErwartet:
Dockerfile.arg
Dockerfile.copy
Dockerfile.copy.dockerignore
Dockerfile.env
Dockerfile.multi
Dockerfile.rm
Dockerfile.rm.dockerignore
trivy-secret.yaml
Für Drill 4 und 5 schaust du in die Layer. docker save
schreibt ein Image als Tar-Archiv: ein Archiv pro Layer, dazu
manifest.json, das die Layer von unten (Base-Image) nach
oben auflistet.
Sicherheit: Alle Lecks heute benutzen
lab-api-key-123. Mit einem echten Key wäre jeder der folgenden Builds ein Sicherheitsvorfall.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Leck 1 – ARG
Der häufigste Gedanke: „Ein ARG landet nicht im Image,
also ist es sicher.” Halb richtig. Dockerfile.arg übergibt
den Key als Build-Argument und hat noch eine Debug-Zeile vergessen:
sed -n '4,12p' leaks/Dockerfile.argErwartet:
FROM golang:1.27-alpine
WORKDIR /src
COPY . .
RUN go build -o /usr/local/bin/notes-api .
ARG NOTES_API_KEY
# "Nur kurz zum Debuggen" – landet im Build-Log und in der History.
RUN echo "Konfig-Check: NOTES_API_KEY=${NOTES_API_KEY}"
USER 65532:65532
ENTRYPOINT ["notes-api"]docker build --progress=plain -f leaks/Dockerfile.arg \
--build-arg NOTES_API_KEY=lab-api-key-123 -t notes-leak:arg notes-api 2>&1 \
| grep -E 'Konfig-Check|SecretsUsed'Erwartet (gekürzt, kann je nach Version abweichen):
#9 [5/5] RUN echo "Konfig-Check: NOTES_API_KEY=${NOTES_API_KEY}"
#9 0.131 Konfig-Check: NOTES_API_KEY=lab-api-key-123
- SecretsUsedInArgOrEnv: Do not use ARG or ENV instructions for sensitive data
(ARG "NOTES_API_KEY") (line 8)
Leck Nummer eins ist das Build-Log, und CI-Systeme archivieren Logs gern monatelang. Jetzt das Image selbst:
docker history --no-trunc --format '{{.CreatedBy}}' notes-leak:arg | head -4
docker image inspect --format '{{json .Config.Env}}' notes-leak:arg \
| grep -c lab-api-keyErwartet (gekürzt, kann je nach Version abweichen):
ENTRYPOINT ["notes-api"]
USER 65532:65532
RUN |1 NOTES_API_KEY=lab-api-key-123 /bin/sh -c echo "Konfig-Check: NOTES_API_KEY=…
ARG NOTES_API_KEY=lab-api-key-123
0
Warum? Die Umgebung des Containers enthält den Key nicht
(0), aber BuildKit schreibt ihn zweimal in die History: Die
ARG-Zeile bekommt den übergebenen Wert angehängt, und jedes
folgende RUN trägt die Build-Argumente seines Stages vor
sich her (|1 heißt „ein Argument”). Selbst ohne die
Debug-Zeile wäre der Key also lesbar. Die Dockerfile-Referenz warnt
genau davor.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Leck 2 – ENV
Die nächste Idee: den Wert nicht ins Dockerfile schreiben, sondern
per ARG hereinreichen und als ENV „für die
Laufzeit” übernehmen:
sed -n '8,9p' leaks/Dockerfile.env
docker build -q -f leaks/Dockerfile.env \
--build-arg NOTES_API_KEY=lab-api-key-123 -t notes-leak:env notes-api
docker image inspect --format '{{json .Config.Env}}' notes-leak:env \
| jq -r '.[]' | grep NOTES
docker history --no-trunc --format '{{.CreatedBy}}' notes-leak:env \
| grep -E '^(ARG|ENV)'Erwartet (gekürzt, kann je nach Version abweichen):
ARG NOTES_API_KEY
ENV NOTES_API_KEY=${NOTES_API_KEY}
sha256:4e0b…
NOTES_API_KEY=lab-api-key-123
ENV NOTES_API_KEY=lab-api-key-123
ARG NOTES_API_KEY=lab-api-key-123
Dreifach drin: in der Config und zweimal, schon aufgelöst, in der
History. Der Container startet damit sogar ohne -e – und
verrät den Key jedem mit Zugriff auf den Docker-Socket:
docker run -d --name notes-leak-env notes-leak:env
docker logs notes-leak-env | head -1
docker inspect --format '{{json .Config.Env}}' notes-leak-env | jq -r '.[]' \
| grep NOTESErwartet (gekürzt, kann je nach Version abweichen):
time=… level=INFO msg="api key loaded" source=env
NOTES_API_KEY=lab-api-key-123
Das gilt übrigens genauso für
docker run -e NOTES_API_KEY=…: Auch ein zur Laufzeit
gesetzter Wert steht in docker inspect. Wie man das
vermeidet, zeigt Tag 14.
docker rm -f notes-leak-envFortschritt speichern? Kostenlos registrieren
Drill 4: Leck 3 – COPY .env
An Tag 0 hattest du Glück, weil die .env außerhalb des
Kontexts lag. Jetzt baust du mit dem Projektordner als Kontext. Deine
.dockerignore von Tag 3 würde die .env
eigentlich fernhalten – aber das Leck-Dockerfile bringt eine eigene
Ignore-Datei mit:
cat leaks/Dockerfile.copy.dockerignoreErwartet:
# LEAK-DEMO: Diese Datei ersetzt die .dockerignore im Projektordner vollständig.
# Sie ergänzt sie nicht – und .env steht hier nicht drin.
.git
**/node_modules
Warum? Liegt neben einem Dockerfile eine Datei
<Dockerfile-Name>.dockerignore, hat sie Vorrang vor
der .dockerignore im Kontext-Wurzelordner. In Monorepos mit
vielen Dockerfiles passiert das schneller, als man denkt.
docker build -q -f leaks/Dockerfile.copy -t notes-leak:copy .
docker run --rm --entrypoint cat notes-leak:copy /src/.envErwartet (gekürzt, kann je nach Version abweichen):
sha256:a71c…
# Lokale Entwicklungswerte – Lab-Werte, niemals produktiv verwenden
NOTES_API_KEY=lab-api-key-123
Jetzt das Image auspacken und die Layer-Liste lesen:
mkdir -p /tmp/copy && docker save notes-leak:copy | tar -x -C /tmp/copy
jq -r '.[0].Layers[]' /tmp/copy/manifest.jsonErwartet (Hashes weichen ab):
blobs/sha256/7b229517ed22…
blobs/sha256/c012d78a862f…
blobs/sha256/82e0bb27ae78…
blobs/sha256/c8e3100880d8…
blobs/sha256/4f4fb700ef54…
blobs/sha256/f35597f293c9…
blobs/sha256/2e9a4c4dcbe7…
blobs/sha256/231e4162e645…
Die unteren sechs Layer stammen von golang:1.27-alpine,
Nummer 7 ist das COPY. Was steckt darin?
L=$(jq -r '.[0].Layers[6]' /tmp/copy/manifest.json)
tar -tf "/tmp/copy/$L" | grep env
tar -xOf "/tmp/copy/$L" src/.envErwartet:
src/.env
src/.env.example
src/leaks/Dockerfile.env
# Lokale Entwicklungswerte – Lab-Werte, niemals produktiv verwenden
NOTES_API_KEY=lab-api-key-123
jq zählt ab 0, [6] ist also das siebte
Layer. tar -xOf schreibt eine Datei aus dem Archiv nach
stdout. Die .env liegt im Layer, mit Key.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Leck 4 – rm im nächsten RUN
Der Klassiker unter den Reparaturversuchen: Datei kopieren, benutzen, löschen.
sed -n '6,13p' leaks/Dockerfile.rmErwartet:
COPY .env /tmp/build.env
COPY notes-api/ .
# Der Build "braucht" den Key, z. B. für einen Integrationstest (hier nur geprüft).
RUN set -a && . /tmp/build.env && set +a \
&& test -n "$NOTES_API_KEY" \
&& go build -o /usr/local/bin/notes-api .
# Aufräumen im nächsten Layer – zu spät.
RUN rm /tmp/build.envdocker build -q -f leaks/Dockerfile.rm -t notes-leak:rm .
docker run --rm --entrypoint ls notes-leak:rm /tmp/build.envErwartet (gekürzt, kann je nach Version abweichen):
sha256:c09e…
ls: /tmp/build.env: No such file or directory
Im Container ist die Datei weg. Und in den Layern? Layer 7 ist das
COPY, das letzte Layer das rm:
mkdir -p /tmp/rm && docker save notes-leak:rm | tar -x -C /tmp/rm
L=$(jq -r '.[0].Layers[6]' /tmp/rm/manifest.json)
tar -tf "/tmp/rm/$L"
L=$(jq -r '.[0].Layers[-1]' /tmp/rm/manifest.json)
tar -tf "/tmp/rm/$L"Erwartet:
tmp/
tmp/build.env
tmp/
tmp/.wh.build.env
Im laufenden Container ist die Datei weg, im Image nicht. Das
rm erzeugt ein neues Layer mit einer Löschmarkierung
(.wh.build.env); das Layer darunter mit dem Klartext wird
unverändert mitgeliefert. Löschen im selben RUN hätte die
Datei aus den Layern gehalten, aber nicht aus COPY .env –
die einzige saubere Lösung ist ein Build-Secret (Tag 13).
Achtung:
docker image lszeigt dir das nicht. Ein Image wird durchrmnicht kleiner und nicht sauberer, nur das oberste Dateisystem sieht anders aus.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Was Build Checks sehen – und was nicht
SecretsUsedInArgOrEnv kennst du seit Tag 0. Lass alle
vier Lecks prüfen:
for f in arg env copy rm; do
ctx=notes-api; [ "$f" = copy ] || [ "$f" = rm ] && ctx=.
printf '%-5s ' "$f"
docker build --check -f "leaks/Dockerfile.$f" "$ctx" >/dev/null 2>&1 \
&& echo "keine Warnung" || echo "Warnung (Exit ≠ 0)"
done
docker build --check -f leaks/Dockerfile.env notes-api 2>&1 | grep 'sensitive'Erwartet (gekürzt, kann je nach Version abweichen):
arg Warnung (Exit ≠ 0)
env Warnung (Exit ≠ 0)
copy keine Warnung
rm keine Warnung
Do not use ARG or ENV instructions for sensitive data (ARG "NOTES_API_KEY")
Do not use ARG or ENV instructions for sensitive data (ENV "NOTES_API_KEY")
Die Regel prüft nur Namen von ARG und
ENV, nie Werte und nie Dateien. Im BuildKit-Quellcode ist
das ein regulärer Ausdruck: Ein Namensteil (getrennt durch
_) muss apikey, auth,
credential(s), key, password,
pword, passwd, psw,
secret oder token lauten; Namensteile
public, file oder version heben
die Warnung wieder auf. Daraus folgt:
| Name | Warnung? | Warum |
|---|---|---|
NOTES_API_KEY |
ja | Namensteil KEY |
NOTES_PASS |
nein | PASS steht nicht in der Liste |
NOTES_CREDS |
nein | CREDS steht nicht in der Liste |
NOTES_API_KEY_FILE |
nein | FILE hebt auf – zu Recht, ein Pfad ist kein Secret (Tag
14) |
Build Checks sind ein guter Stolperdraht, aber kein Secret-Scanner.
Fortschritt speichern? Kostenlos registrieren
Drill 7: trivy als Secret-Scanner
for i in arg env copy rm; do
printf '%-5s ' "$i"
trivy image --quiet --scanners secret --format json "notes-leak:$i" \
| jq '[.Results[]?.Secrets[]?] | length'
doneErwartet (gekürzt, kann je nach Version abweichen):
arg 0
env 0
copy 0
rm 0
Nichts. trivys eingebaute Regeln erkennen Token-Formate mit festem
Aufbau (AWS-Keys, GitHub-Tokens, private Schlüssel …). Ein selbst
ausgedachter Key wie der von notes fällt durch. (Meldet
trivy bei dir Funde in Dateien des Base-Images, ist das ein anderes
Thema – der notes-Key ist nicht darunter.) Deshalb liegt
eine eigene Regel bereit:
grep -v '^#' leaks/trivy-secret.yaml
trivy image --quiet --scanners secret --secret-config leaks/trivy-secret.yaml \
notes-leak:rm | grep -E 'secrets\)|added by|NOTES'Erwartet (gekürzt, kann je nach Version abweichen):
rules:
- id: notes-api-key
category: notes
title: notes API key
severity: CRITICAL
regex: lab-api-key-[0-9]+
keywords:
- lab-api-key
tmp/build.env (secrets)
tmp/build.env:2 (offset: 84 bytes) (added by 'COPY .env /tmp/build.env # buildkit')
2 [ NOTES_API_KEY=***************
trivy durchsucht jedes Layer einzeln und behält Funde auch dann, wenn
ein späteres Layer die Datei löscht – im trivy-Quellcode steht dazu
sinngemäß „Secrets aus allen Layern speichern, auch wenn sie weiter oben
entfernt werden”. Für ARG und ENV braucht es
zusätzlich den Scan der Image-Config:
trivy image --quiet --scanners secret --image-config-scanners secret \
--secret-config leaks/trivy-secret.yaml --format json notes-leak:env \
| jq -r '.Results[]? | select(.Secrets) | .Target'Erwartet (gekürzt, kann je nach Version abweichen):
config.json
Tipp: Mit
--exit-code 1wird daraus ein Pipeline-Gate. Die Dateitrivy-secret.yamlliest trivy auch ohne--secret-config, wenn sie im aktuellen Ordner liegt.
Noch früher setzt trivy fs an: Es durchsucht den
Projektordner, bevor überhaupt ein Image entsteht, genau so, wie eine
Pipeline das Repository prüft:
trivy fs -q --scanners secret --secret-config leaks/trivy-secret.yaml -f json . \
| jq -r '.Results[]? | select(.Secrets) | "\(.Target):\(.Secrets[0].StartLine)"'Erwartet (gekürzt, kann je nach Version abweichen):
.env:2
notes-api/Dockerfile.naiv:6
Zwei Funde, zwei Bedeutungen. .env ist auf deinem Laptop
erlaubt, darf aber nie ins Repository und nie in den Build-Kontext (Tag
12); im Klon einer Pipeline wäre dieser Fund ein Alarm.
Dockerfile.naiv dagegen hat den Key im Quelltext stehen:
ein echtes Leck, das jeder mit Lesezugriff auf das Repository sieht.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Multi-Stage versteckt, Provenance verrät
Dockerfile.multi benutzt das ARG nur im
build-Stage, das Final-Image ist scratch mit
dem Binary:
docker build -q -f leaks/Dockerfile.multi \
--build-arg NOTES_API_KEY=lab-api-key-123 -t notes-leak:multi notes-api
docker history --no-trunc --format '{{.CreatedBy}}' notes-leak:multi
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-leak:multi | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
| grep -ac lab-api-key-123Erwartet (gekürzt, kann je nach Version abweichen):
sha256:77d2…
ENTRYPOINT ["/notes-api"]
USER 65532:65532
COPY /out/notes-api /notes-api # buildkit
0
Die Schleife packt jedes Blob aus dem Archiv mit
tar -xOf nach stdout aus, egal ob gepackt oder nicht; Blobs
ohne Tar (Manifest, Config) überspringt sie still. grep -a
liest das Ergebnis wie Text, -c zählt die Zeilen mit
Treffer: null.
Das Final-Image ist sauber: Seine History enthält nur die Anweisungen
des letzten Stages. Aber Tag 10 hat dir Provenance-Attestations mit
mode=max beigebracht, und die beschreiben den ganzen Build,
inklusive Build-Argumente:
docker buildx build --builder docker-lab -q -f leaks/Dockerfile.multi \
--build-arg NOTES_API_KEY=lab-api-key-123 --provenance=mode=max \
-t localhost:5001/notes-leak:multi --push notes-api
docker buildx imagetools inspect localhost:5001/notes-leak:multi \
--format '{{json .Provenance}}' | grep -o '"build-arg:NOTES_API_KEY":"[^"]*"'Erwartet (gekürzt, kann je nach Version abweichen):
sha256:5be1…
"build-arg:NOTES_API_KEY":"lab-api-key-123"
Die Dockerfile-Referenz nennt genau diese beiden Orte für
Build-Argumente: docker history und Provenance im Modus
max. Multi-Stage hilft gegen den ersten, nicht gegen den
zweiten – und der Build-Cache des Stages build enthält den
Wert ebenfalls.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
ARG-Leck in der History (Drill 2):
cd ~/docker-lab/tag11
docker history --no-trunc --format '{{.CreatedBy}}' notes-leak:arg \
| grep -c lab-api-key-123Erwartet:
2
ENV-Leck in der Image-Config (Drill 3):
docker image inspect --format '{{json .Config.Env}}' notes-leak:env \
| grep -o 'NOTES_API_KEY=[^"]*'Erwartet:
NOTES_API_KEY=lab-api-key-123
rm-Leck unter dem Whiteout (Drill 5):
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-leak:rm | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
| grep -ac lab-api-key-123Erwartet: mehr als null Treffer, obwohl die Datei gelöscht ist.
3
Der Build Check schweigt bei COPY .env (Drill 6):
docker build --check -f leaks/Dockerfile.copy . 2>&1 | tail -1Erwartet:
Check complete, no warnings found.
Das Final-Image von notes-leak:multi ist sauber (Drill
8):
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-leak:multi | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
| grep -ac lab-api-key-123Erwartet:
0
Challenge
Prüfe das kanonische Image notes-api:tag11 an allen drei
Stellen – History, Image-Config, Layer – auf einen Key nach dem Muster
lab-api-key-.
Hinweis: Drei Werkzeuge, drei Stellen:
docker history --no-trunc,
docker image inspect und die Layer-Schleife aus Drill
8.
Lösung
cd ~/docker-lab/tag11
docker build -q -t notes-api:tag11 notes-api
docker history --no-trunc notes-api:tag11 | grep -c lab-api-key-
docker image inspect notes-api:tag11 | grep -c lab-api-key-
rm -rf /tmp/img && mkdir /tmp/img
docker save notes-api:tag11 | tar -x -C /tmp/img
for l in /tmp/img/blobs/sha256/*; do tar -xOf "$l" 2>/dev/null; done \
| grep -ac lab-api-key-Erwartet (gekürzt):
sha256:350a33cc6090…
0
0
0
Dreimal null: Das kanonische Image ist sauber.
notes-leak:multi wäre es auch – und trotzdem steht dort der
Key in der Provenance (Drill 8). Ein Audit, das nur das Image ansieht,
findet nicht alles. Aufräumen:
chmod -R u+w /tmp/copy /tmp/rm && rm -rf /tmp/copy /tmp/rm /tmp/img
docker ps -a --filter name=^notes- --format '{{.Names}}' | xargs -r docker rm -f
docker image ls --format '{{.Repository}}:{{.Tag}}' \
| grep -E '^(notes-|localhost:5001/)' | xargs -r docker rmi
docker buildx prune --builder docker-lab --all --forceTipp: Die Registry behält
localhost:5001/notes-leak:multisamt Provenance. Erstdocker volume rm docker-lab-registry-datalöscht sie – in einer echten Registry hieße das: Tag und Manifest löschen und die Garbage Collection laufen lassen.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Ein gefundener Key gilt als kompromittiert: zuerst rotieren, dann aufräumen. Kopien liegen in Registry-Spiegeln, Pull-Through-Caches, CI-Runnern und auf Laptops.
- Registry-Cache mit
--cache-to …,mode=max(Tag 4) exportiert auch die Layer der Zwischen-Stages; einCOPY .envimbuild-Stage reist damit in die Registry. - Provenance
mode=maxenthält Build-Argumente; in öffentlichen Repositories legen die Buildx-GitHub-Actions sie laut Docker-Doku standardmäßig ans Image. - Maskierte CI-Variablen (GitLab, GitHub) schwärzen nur das Log, nicht Image, Cache oder Attestations.
- Secret-Scan als Gate in der Pipeline: trivy mit eigenen Regeln für
interne Key-Formate,
--exit-code 1, dazu Build Checks mit# check=error=true(Tag 9).