# age — Dateien einfach und modern verschlüsseln

> Praxis-Guide zu age — moderne, einfache Dateiverschlüsselung mit X25519-Schlüsseln, Passphrasen und SSH-Keys als schlanke GPG-Alternative.

Source: https://www.jpkc.com/db/cheatsheets/security/age/

<!-- PROSE:intro -->
age ist ein bewusst einfaches, modernes Werkzeug zur Dateiverschlüsselung von Filippo Valsorda – gedacht als schlanke Alternative zu GPG, wenn du nur Dateien sicher verschlüsseln willst. Statt überladener Konfiguration arbeitest du mit kompakten X25519-Schlüsselpaaren oder einer einzigen Passphrase, optional auch mit vorhandenen SSH-Keys als Empfänger. Die beiden Kommandos `age` und `age-keygen` decken den gesamten Arbeitsablauf ab – verschlüsseln, entschlüsseln, Schlüssel erzeugen – ganz ohne Schlüsselbund-Verwaltung. Dieser Guide zeigt dir die wichtigsten Befehle für den Alltag, von der Schlüsselerzeugung bis zum verschlüsselten Backup-Archiv.
<!-- PROSE:intro:end -->

## Schlüsselerzeugung

`age-keygen` — Erzeugt ein neues Schlüsselpaar (Ausgabe auf stdout).

```bash
age-keygen
```

`age-keygen -o <file>` — Erzeugt ein Schlüsselpaar und speichert es in einer Datei.

```bash
age-keygen -o key.txt
```

`age-keygen -y <key-file>` — Extrahiert den öffentlichen Schlüssel aus einer Datei mit privatem Schlüssel.

```bash
age-keygen -y key.txt
```

## Verschlüsseln mit Empfänger-Schlüsseln

`age -r <public-key> -o <output> <input>` — Verschlüsselt eine Datei für den öffentlichen Schlüssel eines Empfängers.

```bash
age -r age1abc123... -o secret.txt.age secret.txt
```

`age -r <key1> -r <key2> -o <output> <input>` — Verschlüsselt für mehrere Empfänger.

```bash
age -r age1abc... -r age1xyz... -o secret.txt.age secret.txt
```

`age -R <recipients-file> -o <output> <input>` — Verschlüsselt mit einer Datei voller öffentlicher Empfänger-Schlüssel (einer pro Zeile).

```bash
age -R team-keys.txt -o secret.txt.age secret.txt
```

`age -r <public-key> < <input> > <output>` — Verschlüsselt über stdin/stdout (Piping).

```bash
tar czf - secrets/ | age -r age1abc... > secrets.tar.gz.age
```

## Verschlüsseln mit Passphrase

`age -p -o <output> <input>` — Verschlüsselt mit einer Passphrase (fragt sie interaktiv ab).

```bash
age -p -o backup.tar.gz.age backup.tar.gz
```

`age -p < <input> > <output>` — Passphrase-Verschlüsselung mit Piping.

```bash
cat secret.txt | age -p > secret.txt.age
```

## Entschlüsseln

`age -d -i <identity> -o <output> <input>` — Entschlüsselt mit einer Identity-Datei (privater Schlüssel).

```bash
age -d -i key.txt -o secret.txt secret.txt.age
```

`age -d -i <identity> < <input> > <output>` — Entschlüsselt mit Piping.

```bash
age -d -i key.txt < secrets.tar.gz.age | tar xzf -
```

`age -d -o <output> <input>` — Entschlüsselt eine passphrasen-verschlüsselte Datei (fragt die Passphrase ab).

```bash
age -d -o backup.tar.gz backup.tar.gz.age
```

`age -d -i <key1> -i <key2> <input>` — Probiert mehrere Identity-Dateien zum Entschlüsseln durch.

```bash
age -d -i personal.key -i work.key secret.txt.age
```

## SSH-Schlüssel-Unterstützung

`age -r '<ssh-public-key>' -o <output> <input>` — Verschlüsselt für einen öffentlichen SSH-Schlüssel (ed25519 oder RSA).

```bash
age -r 'ssh-ed25519 AAAA...' -o secret.age secret.txt
```

`age -R ~/.ssh/authorized_keys -o <output> <input>` — Verschlüsselt für alle SSH-Schlüssel in authorized_keys.

```bash
age -R ~/.ssh/authorized_keys -o secret.age secret.txt
```

`age -d -i ~/.ssh/id_ed25519 <input>` — Entschlüsselt mit einem privaten SSH-Schlüssel.

```bash
age -d -i ~/.ssh/id_ed25519 secret.age > secret.txt
```

## Häufige Muster

`tar czf - <dir> | age -r <key> > <output>` — Erzeugt ein verschlüsseltes Archiv.

```bash
tar czf - secrets/ | age -r age1abc... > secrets.tar.gz.age
```

`age -d -i <key> <input> | tar xzf -` — Entschlüsselt ein Archiv und entpackt es.

```bash
age -d -i key.txt secrets.tar.gz.age | tar xzf -
```

`age-keygen | tee key.txt | age-keygen -y` — Erzeugt einen Schlüssel und zeigt den öffentlichen Schlüssel in einem Befehl an.

```bash
age-keygen | tee key.txt | age-keygen -y
```

`echo '<secret>' | age -r <key> -a` — Verschlüsselt einen Text mit ASCII-Armor (textsicher).

```bash
echo 'password123' | age -r age1abc... -a
```

`age -d -i key.txt secret.age | <command>` — Entschlüsselt und leitet direkt an einen Befehl weiter.

```bash
age -d -i key.txt db-dump.sql.age | mysql -u root mydb
```

<!-- PROSE:outro -->
## Fazit

age beweist, dass Dateiverschlüsselung nicht kompliziert sein muss: keine Schlüsselbund-Verwaltung, keine endlosen Optionen – nur kurze, klar lesbare Befehle. Bewahre deine Identity-Datei (den privaten Schlüssel) so sorgfältig auf wie ein Passwort und gib sie niemals weiter; wer sie besitzt, kann alles entschlüsseln, was für dich bestimmt war. Bei der Passphrase-Variante ist deine Verschlüsselung nur so stark wie die Passphrase selbst – wähle sie entsprechend lang und einzigartig. Für Signaturen ist age bewusst nicht zuständig: Es verschlüsselt, mehr nicht – und macht genau das gut.

## Weiterführende Links

- [age – GitHub-Projekt](https://github.com/FiloSottile/age) – Quellcode, Releases und Dokumentation (englisch)
- [age-encryption.org](https://age-encryption.org/) – offizielle Projektseite und Format-Spezifikation (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [clamav](https://www.jpkc.com/db/cheatsheets/security/clamav/) – Open-Source-Virenscanner für Dateien und Mails
- [fail2ban](https://www.jpkc.com/db/cheatsheets/security/fail2ban/) – sperrt Angreifer-IPs anhand von Logmustern
- [firewalld](https://www.jpkc.com/db/cheatsheets/security/firewalld/) – dynamische Firewall-Verwaltung mit Zonen