Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 3: Dateiformate und Teilverschlüsselung

Ziel: Du verschlüsselst JSON, dotenv, INI und Binärdateien, bringst ein Kubernetes-Secret so in Git, dass Kubernetes und Menschen es lesen können, und weißt, was der MAC alles schützt. · Dauer: ca. 60 min · Voraussetzung: Tag 2

Briefing

  • sops erkennt das Format an der Dateiendung: .yaml/.yml, .json, .env, .ini. Alles andere ist binary – die ganze Datei wird ein einziger Wert.
  • Standard ist: jeder Wert wird verschlüsselt. Für Kubernetes-Manifeste ist das falsch, denn auch apiVersion und kind wären dann ENC[…].
  • Mit --encrypted-regex, --unencrypted-regex, --encrypted-suffix und --unencrypted-suffix bestimmst du, welche Schlüssel verschlüsselt werden.
  • Der MAC deckt standardmäßig auch die Klartextwerte ab.
Format Endung Metadaten stehen in
YAML / JSON .yaml, .json Schlüssel sops
dotenv .env Zeilen sops_…=
INI .ini Abschnitt [sops]
binary alles andere JSON mit data und sops

Drill 1: JSON

# auf argo
mkdir -p ~/sops/tag03 && cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
printf '{"db": {"user": "notes", "password": "lab-db-123"}, "replicas": 2}\n' \
  > app.json
sops encrypt --age $ICH app.json > app.enc.json
jq -c '.db' app.enc.json | cut -c1-80
jq -r '.sops | keys | join(",")' app.enc.json
sops decrypt app.enc.json

Erwartet (gekürzt):

{"user":"ENC[AES256_GCM,data:tvzM/Mg=,iv:UaK7bjIQ1jcN5VXyK1/SJEP8EktFn6ARxqt+picPo
age,lastmodified,mac,unencrypted_suffix,version
{
    "db": {
        "user": "notes",
        "password": "lab-db-123"
    },
    "replicas": 2
}

Das Ergebnis ist gültiges JSON – jedes Werkzeug, das JSON liest, kommt mit der Datei zurecht. sops gibt JSON mit Tabulatoren eingerückt aus.

Fortschritt speichern? Kostenlos registrieren

Drill 2: dotenv

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
printf 'DB_USER=notes\nDB_PASSWORD=lab-db-123\n# Kommentar\nAPI_KEY=lab-key-123\n' \
  > app.env
sops encrypt --age $ICH app.env > app.enc.env
cut -c1-70 app.enc.env
sops decrypt app.enc.env

Erwartet (gekürzt):

DB_USER=ENC[AES256_GCM,data:YUAeRZg=,iv:4PvR0O2Ch8MX0DrJOAonUHFmFCSphp
DB_PASSWORD=ENC[AES256_GCM,data:Dlz0eu0wxhSmaA==,iv:aeesIqbYJy99pA/KAO
#ENC[AES256_GCM,data:K75BvcftNiyLfw==,iv:HjKRBkUOhG1MKaExOTIfDTF3SXhgJ
API_KEY=ENC[AES256_GCM,data:PezolV7zPm7vBHY=,iv:RiLrIt1sFdHLGjU5P7klF4
sops_age__list_0__map_enc=-----BEGIN AGE ENCRYPTED FILE-----\nYWdlLWVu
sops_age__list_0__map_recipient=age126j96yd6te036uya83l76w0afmlaj9vyyl
sops_lastmodified=2026-11-20T16:19:37Z
sops_mac=ENC[AES256_GCM,data:63U64qO/yHukE4DRGVylDrP46RXWCwOnQVlGPGJpJ
sops_unencrypted_suffix=_unencrypted
sops_version=3.13.3
DB_USER=notes
DB_PASSWORD=lab-db-123
# Kommentar
API_KEY=lab-key-123

dotenv ist flach: Die Struktur des sops-Blocks wird in Schlüsselnamen wie sops_age__list_0__map_enc übersetzt. Variablennamen mit sops_ am Anfang sind deshalb in dotenv-Dateien tabu.

Fortschritt speichern? Kostenlos registrieren

Drill 3: INI

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
printf '[db]\nuser = notes\npassword = lab-db-123\n\n[api]\nkey = lab-key-123\n' \
  > app.ini
sops encrypt --age $ICH app.ini > app.enc.ini
cut -c1-70 app.enc.ini | head -12

Erwartet (gekürzt):

[db]
user     = ENC[AES256_GCM,data:MUEhFzg=,iv:5bOQNpJgEUuGcWfzVucBsWpPeS9
password = ENC[AES256_GCM,data:uIq7ggyA2dyu9Q==,iv:DHZLwehtA99sclAE/hw

[api]
key = ENC[AES256_GCM,data:8JwsKoRMnElqi34=,iv:ULlHt2HqwVlYTiezwMMry+tG

[sops]
age__list_0__map_enc       = -----BEGIN AGE ENCRYPTED FILE-----\nYWdlL
age__list_0__map_recipient = age126j96yd6te036uya83l76w0afmlaj9vyyluxr
lastmodified               = 2026-11-20T16:19:37Z
mac                        = ENC[AES256_GCM,data:25FLqRfd7+bzkx8+lP8U0

Abschnitte bleiben erhalten, sops richtet die Gleichheitszeichen aus.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Binärdateien und falsche Endungen

Ein privater Schlüssel, ein Keystore, ein Zertifikatsbündel – nicht alles ist YAML.

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
head -c 32 /dev/urandom > tls.key.bin
sha256sum tls.key.bin | cut -c1-20
sops encrypt --age $ICH tls.key.bin > tls.key.bin.enc
jq -r 'keys | join(",")' tls.key.bin.enc
sops decrypt tls.key.bin.enc | sha256sum | cut -c1-20

Erwartet:

b4a860095c46c9cc5940
data,sops
b4a860095c46c9cc5940

Die Prüfsumme ist bei dir eine andere (Zufallsdaten), aber vorher und nachher gleich. Die ganze Datei steckt base64-kodiert und verschlüsselt im Feld data, die Hülle ist JSON. Beim Entschlüsseln kommt Byte für Byte die Originaldatei zurück.

Heikel wird es, wenn die Endung lügt: Eine dotenv-Datei namens app.txt behandelt sops als binary – dann hilft auch kein --encrypted-regex, und exec-env (Tag 8) findet keine Variablen.

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
cp app.env app.txt
sops encrypt --age $ICH app.txt | head -2 | cut -c1-40
sops encrypt --age $ICH --input-type dotenv --output-type dotenv app.txt \
  | head -2 | cut -c1-40

Erwartet:

{
    "data": "ENC[AES256_GCM,data:dJqXZMG
DB_USER=ENC[AES256_GCM,data:aK9UOSA=,iv
DB_PASSWORD=ENC[AES256_GCM,data:loMtTG5

Fortschritt speichern? Kostenlos registrieren

Drill 5: Ein Kubernetes-Secret

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
kubectl create secret generic notes-db -n notes --from-literal=password=lab-db-123 \
  --from-literal=user=notes --dry-run=client -o yaml > secret.yaml
cat secret.yaml
sops encrypt --age $ICH secret.yaml | head -9 | cut -c1-60

Erwartet:

apiVersion: v1
data:
  password: bGFiLWRiLTEyMw==
  user: bm90ZXM=
kind: Secret
metadata:
  name: notes-db
  namespace: notes
apiVersion: ENC[AES256_GCM,data:yig=,iv:BPOTXVVBtDpEvmIZvHQm
data:
    password: ENC[AES256_GCM,data:9jmgiihVRoRQXp80KJ50DQ==,i
    user: ENC[AES256_GCM,data:vDOIOZteW0k=,iv:EXTpHgNVtyRnL5
kind: ENC[AES256_GCM,data:Jas9+224,iv:ivl+IR7fblQ+y9psvYe1hb
metadata:
    name: ENC[AES256_GCM,data:5p4O21censU=,iv:CdnXSHbqhQtloCBSM
    namespace: ENC[AES256_GCM,data:BvrfHTc=,iv:2al6/MkPOJeYbSqaA

Base64 in data ist keine Verschlüsselung (bGFiLWRiLTEyMw== ist lab-db-123). Und voll verschlüsselt weiß niemand mehr, dass das ein Secret namens notes-db ist – weder ein Mensch im Review noch Kustomize oder Flux. Nur die Werte sollen weg:

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
sops encrypt --age $ICH --encrypted-regex '^(data|stringData)$' secret.yaml \
  > secret.enc.yaml
grep -v '^ \{8,\}' secret.enc.yaml | cut -c1-70

Erwartet:

apiVersion: v1
data:
    password: ENC[AES256_GCM,data:bjhTuZ68EMdXS2dRORMjFg==,iv:JbIY3N33
    user: ENC[AES256_GCM,data:g1EXKsm1WQo=,iv:g5bUDs8iEQkN0+fAJH6DHPt8
kind: Secret
metadata:
    name: notes-db
    namespace: notes
sops:
    age:
    encrypted_regex: ^(data|stringData)$
    lastmodified: "2026-11-20T16:19:51Z"
    mac: ENC[AES256_GCM,data:cwZGVZvTL9lN5xAwPVgipTaNT6T5HIjSDgCxqrkbt
    version: 3.13.3

encrypted_regex wirkt auf Schlüsselnamen: Alles unter data und stringData wird verschlüsselt, der Rest bleibt lesbar. Die Regel steht im sops-Block, damit spätere Änderungen mit sops edit sie wieder anwenden.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ins Cluster – aber entschlüsselt

Einbauen: Die verschlüsselte Datei direkt anwenden.

# auf argo
cd ~/sops/tag03
kubectl create namespace notes
kubectl apply -f secret.enc.yaml 2>&1 | cut -c1-88

Erwartet (gekürzt):

namespace/notes created
Error from server (BadRequest): error when creating "secret.enc.yaml": Secret in versi

Untersuchen:

# auf argo
cd ~/sops/tag03
kubectl apply -f secret.enc.yaml 2>&1 | grep -o 'cannot be handled.*'

Erwartet:

cannot be handled as a Secret: illegal base64 data at input byte 3

Ursache: Kubernetes erwartet in data Base64. ENC[AES2… ist kein gültiges Base64 (die eckige Klammer an Position 3). Bei stringData wäre es schlimmer: Der Chiffretext würde klaglos als Passwort gespeichert. Und den Block sops: kennt Kubernetes gar nicht.

Fix und Nachweis:

# auf argo
cd ~/sops/tag03
sops decrypt secret.enc.yaml | kubectl apply -f -
kubectl -n notes get secret notes-db -o jsonpath='{.data.password}' | base64 -d; echo

Erwartet:

secret/notes-db created
lab-db-123

Der Klartext fließt per Pipe direkt zu kubectl, ohne Datei. Genau das machen ab Tag 10 Flux und Argo CD für dich.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Suffixe statt Regex

Für eigene Konfigurationsdateien ist eine Namenskonvention oft lesbarer als ein Regex.

# auf argo
cd ~/sops/tag03
ICH=$(age-keygen -y ~/.config/sops/age/keys.txt)
printf 'db:\n  host_unencrypted: postgres.notes.svc\n  password: lab-db-123\n' \
  > suffix.yaml
sops encrypt --age $ICH suffix.yaml | head -3 | cut -c1-60
printf 'db:\n  host: postgres.notes.svc\n  password_enc: lab-db-123\n' > suffix2.yaml
sops encrypt --age $ICH --encrypted-suffix _enc suffix2.yaml | head -3 | cut -c1-60

Erwartet:

db:
    host_unencrypted: postgres.notes.svc
    password: ENC[AES256_GCM,data:yO7kkmH560uG1g==,iv:FeA5YM
db:
    host: postgres.notes.svc
    password_enc: ENC[AES256_GCM,data:dZrB58543ElSWA==,iv:IC
Option Wirkung
--unencrypted-suffix _unencrypted Standard: alles außer *_unencrypted
--encrypted-suffix _enc nur *_enc verschlüsseln
--unencrypted-regex REGEX alles außer passenden Schlüsseln
--encrypted-regex REGEX nur passende Schlüssel (und alles darunter)

Pro Datei gilt genau eine dieser Optionen; mehrere zugleich lehnt sops ab.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Der MAC schützt auch den Klartext

Einbauen: Jemand ändert im Review „nur schnell“ den Namespace – ein Klartextfeld.

# auf argo
cd ~/sops/tag03
cp secret.enc.yaml umgezogen.yaml
sed -i 's/namespace: notes/namespace: prod/' umgezogen.yaml

Symptom:

# auf argo
cd ~/sops/tag03
sops decrypt umgezogen.yaml 2>&1 | cut -c1-60

Erwartet (gekürzt):

MAC mismatch. File has 21C0FDDCD6AADA7383A6DD306348120D2C68F

Ursache: Der MAC wird über alle Werte gerechnet, auch die unverschlüsselten. Wer namespace ändert, ohne sops zu benutzen, bricht die Prüfsumme. Das ist gewollt: Sonst könnte ein Angreifer ein verschlüsseltes Secret unbemerkt in einen anderen Namespace umleiten.

Fix: Änderungen immer über sops – sops set oder sops edit. Ist der Schaden schon passiert und die Änderung gewollt, entschlüsselst du einmal mit --ignore-mac und verschlüsselst neu:

# auf argo
cd ~/sops/tag03
sops decrypt --ignore-mac umgezogen.yaml > /dev/null && echo lesbar
sops set umgezogen.yaml '["metadata"]["namespace"]' '"prod"' 2>&1 | cut -c1-30

Erwartet:

lesbar
MAC mismatch. File has 21C0FDD

Auch sops set prüft vorher den MAC. Bleibt nur der Weg über den Klartext:

# auf argo
cd ~/sops/tag03
sops decrypt --ignore-mac umgezogen.yaml \
  | sops encrypt --filename-override umgezogen.yaml \
    --age $(age-keygen -y ~/.config/sops/age/keys.txt) \
    --encrypted-regex '^(data|stringData)$' /dev/stdin > neu.yaml
mv neu.yaml umgezogen.yaml
sops decrypt umgezogen.yaml | grep namespace

Nachweis – Erwartet:

    namespace: prod

--filename-override sagt sops, welches Format die Standardeingabe hat. Wann man den MAC auf die verschlüsselten Werte beschränkt (mac_only_encrypted), zeigt Tag 4.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Verschlüssele ein Secret notes-api mit stringData (key: lab-key-123) so, dass nur stringData verschlüsselt ist, und wende es an. Zeitziel: 60 s
  2. Zeig den Klartext der INI-Datei. Zeitziel: 10 s

Lösung

# auf argo
cd ~/sops/tag03
cat > str.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata: {name: notes-api, namespace: notes}
stringData:
  key: lab-key-123
EOF
sops encrypt --age $(age-keygen -y ~/.config/sops/age/keys.txt) \
  --encrypted-regex '^(data|stringData)$' str.yaml > str.enc.yaml
sops decrypt str.enc.yaml | kubectl apply -f -
kubectl -n notes get secret notes-api -o jsonpath='{.data.key}' | base64 -d; echo
sops decrypt app.enc.ini

Erwartet:

secret/notes-api created
lab-key-123
[db]
user     = notes
password = lab-db-123

[api]
key = lab-key-123

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf argo
cd ~/sops/tag03
for f in app.enc.json app.enc.env app.enc.ini tls.key.bin.enc secret.enc.yaml; do
  sops filestatus $f; done
kubectl -n notes get secrets

Erwartet:

{"encrypted":true}
{"encrypted":true}
{"encrypted":true}
{"encrypted":true}
{"encrypted":true}
NAME        TYPE     DATA   AGE
notes-api   Opaque   1      40s
notes-db    Opaque   2      3m

Challenge

Erzeuge aus der verschlüsselten dotenv-Datei app.enc.env ein Secret notes-env im Namespace notes mit den drei Variablen als Schlüsseln – ohne dass der Klartext auf der Platte landet.

Hinweis: kubectl create secret generic kennt --from-env-file, und Bash kann eine Befehlsausgabe als Datei übergeben.

Lösung

# auf argo
cd ~/sops/tag03
kubectl -n notes create secret generic notes-env \
  --from-env-file=<(sops decrypt app.enc.env) --dry-run=client -o yaml \
  | kubectl apply -f -
kubectl -n notes get secret notes-env -o jsonpath='{.data}' | jq -r 'keys[]'

Erwartet:

secret/notes-env created
API_KEY
DB_PASSWORD
DB_USER

<(…) ist eine Prozess-Ersetzung: kubectl liest aus einer Pipe unter /dev/fd/, die Kommentarzeile ignoriert es.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf argo
kubectl delete namespace notes
cd ~/sops/tag03
rm -f app.json app.env app.ini app.txt tls.key.bin secret.yaml str.yaml \
  suffix.yaml suffix2.yaml
ls -1

Erwartet:

namespace "notes" deleted
app.enc.env
app.enc.ini
app.enc.json
secret.enc.yaml
str.enc.yaml
tls.key.bin.enc
umgezogen.yaml

Die verschlüsselten Übungsdateien dürfen liegen bleiben; kein späterer Tag braucht etwas aus ~/sops/tag03, und der Namespace notes ist wieder weg.

Interview-Notiz

  • Wie verschlüsselst du ein Kubernetes-Secret mit sops? Nur data/stringData (encrypted_regex: ^(data|stringData)$), damit apiVersion, kind und metadata lesbar bleiben; angewendet wird der entschlüsselte Inhalt.
  • Warum schlägt der MAC an, obwohl nur ein Klartextfeld geändert wurde? Der MAC deckt standardmäßig alle Werte ab, damit verschlüsselte Werte nicht unbemerkt in einen anderen Kontext verschoben werden.

Enterprise-Notiz

  • Formatregel pro Repo festlegen (z. B. nur YAML, nur *.enc.yaml), sonst wird aus einer falschen Endung schnell eine Binärdatei, die niemand reviewen kann.
  • Binärdateien (Keystores, Zertifikatsbündel) sind im Diff undurchsichtig – lieber als PEM-Text in YAML ablegen.
  • encrypted_regex gehört in .sops.yaml (Tag 4), nicht in die Finger der Entwickler.