Zum Inhalt springen
Trainingslager IT-Trainingslager

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 .env und rm im nächsten RUN.
  • Drei Werkzeuge reichen zum Nachweis: docker history --no-trunc, docker image inspect, docker save plus tar und grep.
  • 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 leaks

Erwartet:

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.arg

Erwartet:

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

Erwartet (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 NOTES

Erwartet (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-env

Fortschritt 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.dockerignore

Erwartet:

# 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/.env

Erwartet (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.json

Erwartet (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/.env

Erwartet:

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.rm

Erwartet:

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.env
docker build -q -f leaks/Dockerfile.rm -t notes-leak:rm .
docker run --rm --entrypoint ls notes-leak:rm /tmp/build.env

Erwartet (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 ls zeigt dir das nicht. Ein Image wird durch rm nicht 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'
done

Erwartet (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 1 wird daraus ein Pipeline-Gate. Die Datei trivy-secret.yaml liest 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-123

Erwartet (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-123

Erwartet:

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-123

Erwartet: 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 -1

Erwartet:

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-123

Erwartet:

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 --force

Tipp: Die Registry behält localhost:5001/notes-leak:multi samt Provenance. Erst docker volume rm docker-lab-registry-data lö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; ein COPY .env im build-Stage reist damit in die Registry.
  • Provenance mode=max enthä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).