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
apiVersionundkindwären dannENC[…]. - Mit
--encrypted-regex,--unencrypted-regex,--encrypted-suffixund--unencrypted-suffixbestimmst 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.jsonErwartet (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.envErwartet (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 -12Erwartet (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-20Erwartet:
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-40Erwartet:
{
"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-60Erwartet:
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-70Erwartet:
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-88Erwartet (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; echoErwartet:
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-60Erwartet:
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.yamlSymptom:
# auf argo
cd ~/sops/tag03
sops decrypt umgezogen.yaml 2>&1 | cut -c1-60Erwartet (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-30Erwartet:
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 namespaceNachweis – 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
- Verschlüssele ein Secret
notes-apimitstringData(key: lab-key-123) so, dass nurstringDataverschlüsselt ist, und wende es an. Zeitziel: 60 s - 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.iniErwartet:
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 secretsErwartet:
{"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 -1Erwartet:
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)$), damitapiVersion,kindundmetadatalesbar 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_regexgehört in.sops.yaml(Tag 4), nicht in die Finger der Entwickler.