Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: Schutz gegen Klartext

Ziel: Ein Pre-commit-Hook hält private Schlüssel und unverschlüsselte Secrets aus dem Repo, und du weißt, was zu tun ist, wenn doch etwas gepusht wurde. · Dauer: ca. 60 min · Voraussetzung: Tag 8

Briefing

  • Die häufigste Panne mit sops ist kein Kryptofehler, sondern ein git add . vor dem sops encrypt -i.
  • Zwei Prüfungen ergänzen sich: gitleaks erkennt bekannte Muster (age-Schlüssel, Tokens, Kubernetes-Secrets im Klartext). Eine Strukturprüfung verlangt, dass Dateien in den verschlüsselten Ordnern sops-Metadaten haben.
  • Ein Git-Hook läuft nur lokal und lässt sich mit --no-verify umgehen. Dieselbe Prüfung gehört deshalb zusätzlich in CI oder auf den Server.
  • Was einmal gepusht ist, ist verloren: Geheimnis wechseln, dann aufräumen.
 git commit ──► .git/hooks/pre-commit
                 ├─ gitleaks git --pre-commit --staged   (Muster)
                 ├─ sops-Metadaten in dev/ prod/ …?       (Struktur)
                 └─ Exit ≠ 0 ──► kein Commit

Drill 1: gitleaks installieren und die Historie prüfen

gitleaks nennt amd64 x64 – das übersetzt eine case-Zeile.

# auf argo
mkdir -p ~/sops/tag09 && cd ~/sops/tag09
ARCH=$(dpkg --print-architecture)
case $ARCH in amd64) GA=x64;; arm64) GA=arm64;; esac
G=https://github.com/gitleaks/gitleaks/releases/download/v8.30.1
curl -fsSLO $G/gitleaks_8.30.1_linux_$GA.tar.gz
curl -fsSLO $G/gitleaks_8.30.1_checksums.txt
grep " gitleaks_8.30.1_linux_$GA.tar.gz$" gitleaks_8.30.1_checksums.txt \
  | sha256sum -c
tar -xzf gitleaks_8.30.1_linux_$GA.tar.gz gitleaks
sudo install -m 0755 gitleaks /usr/local/bin/gitleaks
gitleaks version
cd ~/sops/repo
gitleaks git --no-banner --no-color . 2>&1 | tail -3

Erwartet:

gitleaks_8.30.1_linux_x64.tar.gz: OK
8.30.1
4:38PM ERR [git] fatal: unable to read files to diff
4:38PM INF 0 commits scanned.
4:38PM INF no leaks found

„no leaks found“ – aber 0 commits scanned? Die Fehlermeldung davor verrät es: gitleaks liest die Historie mit git log -p, und dabei greift dein textconv-Treiber aus Tag 8. Für alte Stände scheitert sops decrypt, git bricht ab, gitleaks prüft nichts und meldet trotzdem Entwarnung.

# auf argo
cd ~/sops/repo
gitleaks git --no-banner --no-color --log-opts="--no-textconv" . 2>&1 | tail -2

Erwartet:

4:38PM INF scanned ~17524 bytes (17.52 KB) in 705ms
4:38PM INF no leaks found

Jetzt wurden alle Commits geprüft. Merke: Ein Scanner, der nichts gescannt hat, ist schlimmer als keiner – immer die Zeile scanned lesen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Hook

Für --pre-commit gibt es keine --log-opts; dort schalten die Umgebungsvariablen GIT_CONFIG_* den Treiber für diesen einen Aufruf ab.

# auf argo
cd ~/sops/repo
cat > .git/hooks/pre-commit <<'EOF'
#!/bin/sh
# tag09: kein Klartext ins Repo
# 1) bekannte Schlüssel- und Token-Muster (textconv aus, sonst sieht gitleaks Klartext)
export GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0=diff.sopsdiffer.textconv
export GIT_CONFIG_VALUE_0=cat
gitleaks git --pre-commit --staged --redact --no-banner --no-color -l warn . || exit 1
# 2) Dateien in verschlüsselten Ordnern brauchen sops-Metadaten
rc=0
for f in $(git diff --cached --name-only --diff-filter=ACM); do
  case "$f" in
    dev/*|prod/*|notes/*|plattform/*|tresor/*)
      git show ":$f" | grep -qE '^(sops:|sops_mac=|\[sops\])|"sops": \{' || {
        echo "KLARTEXT: $f ist nicht mit sops verschlüsselt"; rc=1; } ;;
  esac
done
exit $rc
EOF
chmod +x .git/hooks/pre-commit
ls -l .git/hooks/pre-commit | cut -c1-10

Erwartet:

-rwxr-xr-x

Der Hook prüft den gestagten Inhalt (git show ":$f"), nicht die Datei auf der Platte – sonst ließe sich ein Klartext stagen und danach lokal verschlüsseln. Mit textconv würde gitleaks die entschlüsselten Werte sehen und jede verschlüsselte Datei als Leck melden; deshalb cat als Treiber.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Ein privater Schlüssel will ins Repo

Einbauen:

# auf argo
cd ~/sops/repo
cp ~/sops/tag06/anna.key tresor/anna.key
git add tresor/anna.key

Symptom:

# auf argo
cd ~/sops/repo
git commit -q -m "tag09: versehentlich"; echo "rc=$?"

Erwartet:

4:40PM WRN leaks found: 2
rc=1

Untersuchen:

# auf argo
cd ~/sops/repo
GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0=diff.sopsdiffer.textconv GIT_CONFIG_VALUE_0=cat \
  gitleaks git --pre-commit --staged --redact --no-banner --no-color -v . 2>&1 \
  | grep -E 'RuleID|File'

Erwartet:

RuleID:      generic-api-key
File:        tresor/anna.key
RuleID:      age-secret-key
File:        tresor/anna.key

Ursache: gitleaks kennt das Muster AGE-SECRET-KEY-1… (und hält sogar den Public-Key-Kommentar für verdächtig).

Fix und Nachweis:

# auf argo
cd ~/sops/repo
git restore --staged tresor/anna.key && rm tresor/anna.key
printf '*.key\n*.token\nkeys.txt\n' > .gitignore
git add .gitignore && git commit -q -m "tag09: Schlüsseldateien ignorieren"
git log --oneline | head -1

Erwartet:

48eca5a tag09: Schlüsseldateien ignorieren

.gitignore ist die erste Verteidigungslinie: Was ignoriert wird, landet nicht einmal mit git add . im Index.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Secret im Klartext

Einbauen: Zwei neue Dateien – ein Kubernetes-Secret und eine eigene Konfiguration, beide unverschlüsselt.

# auf argo
cd ~/sops/repo
kubectl create secret generic neu -n notes-dev \
  --from-literal=password=lab-db-neu-123 --dry-run=client -o yaml > dev/neu.yaml
printf 'db_password: lab-db-123\n' > notes/klar.yaml
git add notes/klar.yaml
git commit -q -m "tag09: Konfiguration"; echo "rc=$?"
git restore --staged notes/klar.yaml && rm notes/klar.yaml
git add dev/neu.yaml
git commit -q -m "tag09: neues Secret"; echo "rc=$?"

Erwartet:

KLARTEXT: notes/klar.yaml ist nicht mit sops verschlüsselt
rc=1
4:40PM WRN leaks found: 2
rc=1

lab-db-123 hat zu wenig Zufall, als dass gitleaks es für ein Passwort hielte – die Strukturprüfung fängt es. Das Kubernetes-Secret erkennt gitleaks selbst (Regel kubernetes-secret-yaml).

Fix und Nachweis:

# auf argo
cd ~/sops/repo
sops encrypt -i dev/neu.yaml
git add dev/neu.yaml && git commit -q -m "tag09: neues Secret" && echo "rc=$?"
git push -q

Erwartet:

rc=0

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Hook ist freiwillig

# auf argo
cd ~/sops/repo
git switch -q -c leck
printf 'password: lab-leck-123\n' > dev/leck.yaml
git add dev/leck.yaml
git commit -q --no-verify -m "tag09: Leck"; echo "rc=$?"
git rev-parse HEAD > ~/sops/tag09/leck.sha
git push -q origin leck 2>&1 | grep -c pull

Erwartet:

rc=0
1

--no-verify überspringt alle Hooks, und ein frischer Klon hat gar keinen – .git/hooks wird nicht mitgeklont. Das Leck ist jetzt auf dem Server; Forgejo bietet freundlich einen Pull Request dafür an.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Gepusht ist gepusht

Der Reflex: Branch löschen, fertig?

# auf argo
cd ~/sops/repo
git switch -q main && git branch -D leck >/dev/null
git push -q origin --delete leck
SHA=$(cat ~/sops/tag09/leck.sha)
curl -s -u lab:lab-forgejo-123 \
  http://172.16.0.182:30300/lab/secrets/raw/commit/$SHA/dev/leck.yaml

Erwartet:

password: lab-leck-123

Der Branch ist weg, der Commit nicht: Wer die Commit-ID kennt (aus einer E-Mail-Benachrichtigung, einem CI-Log, einem Fork, einem Klon), liest weiter. Git-Server räumen unerreichbare Objekte erst bei einer Garbage Collection nach Ablauf einer Frist auf – und Klone und Backups räumt niemand.

Die Reihenfolge im Ernstfall:

Schritt warum
1. Geheimnis wechseln (Datenbank, Token, Schlüssel) das alte ist verbrannt
2. Zugriffe im Zeitraum prüfen (Audit-Logs) wurde es benutzt?
3. Verschlüsselt neu committen der neue Wert gehört ins Repo
4. Historie bereinigen (git filter-repo, Server-GC) optional, kosmetisch

Fortschritt speichern? Kostenlos registrieren

Drill 7: Die ganze Historie und alle Branches prüfen

Ein Leck auf einem fremden Branch fällt nur auf, wenn du alle Refs prüfst. Lokal gibt es den Branch nicht mehr – auf dem Server ebenso wenig. Was gitleaks über alle lokalen Refs findet:

# auf argo
cd ~/sops/repo
gitleaks git --no-banner --no-color --log-opts="--no-textconv --all" . 2>&1 \
  | tail -2
git cat-file -t $(cat ~/sops/tag09/leck.sha)

Erwartet:

4:41PM INF scanned ~19316 bytes (19.32 KB) in 693ms
4:41PM INF no leaks found
commit

--all findet nichts mehr, weil kein Ref mehr auf den Commit zeigt – das Objekt liegt aber noch in deinem lokalen Repo (git cat-file -t sagt commit). Und lab-leck-123 würde gitleaks ohnehin nicht als Geheimnis erkennen. Muster-Scanner finden bekannte Formate; „was hier im Klartext steht, war mal geheim“ weißt nur du.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig, welche Dateimuster .gitignore ausschließt. Zeitziel: 10 s
  2. Prüfe, ob prod/notes-db.yaml aus Sicht des Hooks verschlüsselt ist (Strukturregel von Hand). Zeitziel: 30 s

Lösung

# auf argo
cd ~/sops/repo
cat .gitignore
git show :prod/notes-db.yaml | grep -cE '^(sops:|sops_mac=|\[sops\])'

Erwartet:

*.key
*.token
keys.txt
1

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf argo
cd ~/sops/repo && git status -sb
git ls-remote --heads origin | wc -l
test -x .git/hooks/pre-commit && echo "Hook aktiv"

Erwartet:

## main...origin/main
1
Hook aktiv

Challenge

Der Hook schützt nur deinen Klon. Klone das Repo frisch nach ~/sops/tag09/klon, prüfe, dass dort kein Hook aktiv ist, und richte ihn ein: Leg die Hook-Datei ins Repo unter hooks/pre-commit und lass Git per core.hooksPath darauf zeigen.

Hinweis: core.hooksPath ist eine lokale Einstellung – auch sie muss jeder einmal setzen, aber die Datei selbst ist dann versioniert.

Lösung

# auf argo
cd ~/sops/repo
mkdir -p hooks && cp .git/hooks/pre-commit hooks/pre-commit
git add hooks/pre-commit && git commit -q -m "tag09: Hook versioniert" && git push -q
git clone -q http://172.16.0.182:30300/lab/secrets.git ~/sops/tag09/klon
cd ~/sops/tag09/klon
ls .git/hooks | grep -c '^pre-commit$'
git config core.hooksPath hooks
printf 'pw: lab-x-123\n' > dev/x.yaml && git add dev/x.yaml
git commit -q -m test; echo "rc=$?"

Erwartet:

0
KLARTEXT: dev/x.yaml ist nicht mit sops verschlüsselt
rc=1

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf argo
rm -rf ~/sops/tag09/klon ~/sops/tag09/gitleaks_8.30.1_linux_*.tar.gz
cd ~/sops/repo && git config core.hooksPath hooks && git status -sb

Erwartet:

## main...origin/main

Ab jetzt nutzt auch dein Haupt-Klon den versionierten Hook.

Interview-Notiz

  • Wie verhinderst du Klartext-Secrets im Repo? .gitignore für Schlüsseldateien, Pre-commit-Hook (gitleaks + Strukturprüfung), dieselbe Prüfung in CI bzw. als Server-Hook, denn lokale Hooks sind freiwillig.
  • Ein Secret wurde gepusht – was tust du zuerst? Das Geheimnis wechseln. Historie umschreiben hilft nicht gegen Klone, Forks, Caches und Backups.

Enterprise-Notiz

  • Das pre-commit-Framework (.pre-commit-config.yaml) verteilt Hooks einheitlich, inklusive gitleaks und eigener Prüfungen.
  • Server-seitig: Secret-Scanning mit Push-Schutz (Git-Plattform), sonst gitleaks im ersten CI-Schritt jedes Pull Requests mit --log-opts über die neuen Commits.
  • Eigene gitleaks-Regeln (.gitleaks.toml, [extend] useDefault = true) für firmeneigene Token-Formate.
  • Ein Leck-Runbook mit Zuständigen pro Geheimnisart: Wer kann das DB-Passwort, den Cloud-Key, den age-Schlüssel binnen einer Stunde wechseln?