Ein moderner Git-basierter age-verschlüsselter Geheimnisverwalter für Teams.
<p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://s13.gifyu.com/images/b7mxd.webp">
<source media="(prefers-color-scheme: light)" srcset="https://s13.gifyu.com/images/b7mxl.webp">
<img alt="Das Cottage-Logo" width="600" src="https://assets.kitploit.com/production/public/readmes/7490/2c8e4c6f8fa352cb9dcf2d8f22c3d84926c09a69fca9a6632d008c61b5417c28.webp">
</picture>
</p>
[](https://github.com/sayanarijit/cottage/actions/workflows/cottage-verify.yml)
[](https://crates.io/crates/cottage)
[](https://pypi.org/project/cottage/)
[](https://www.npmjs.com/package/@sayanarijit/cottage)
[](https://hub.docker.com/r/sayanarijit/cottage)
**cott*age*** ist ein GitOps-Tool für Teams zur Verwaltung von [age-verschlüsselten](https://age-encryption.org/) Secrets in Git-Repositories.
Es bietet einen einfachen Workflow zum Verschlüsseln/Entschlüsseln von Secrets, zur Verwaltung von Empfängern und hält
Secrets aus dem Repository heraus, während die einfache Weitergabe über VCS weiterhin möglich ist. cottage generiert außerdem
geschwärzte Vorschauen verschlüsselter Secrets für bessere Sichtbarkeit und unterstützt sowohl
persistente als auch temporäre Entschlüsselungs-Workflows, wobei sichergestellt wird, dass Secrets niemals im Klartext
committet werden.
1. [Funktionen](#funktionen)
2. [Installation](#installation)
3. [Editor-Integrationen](#editor-integrationen)
1. [VS Code-Erweiterung](#vs-code-erweiterung)
2. [Cursor- und Eclipse-Erweiterung](#cursor-und-eclipse-erweiterung)
3. [Vim-Plugin](#vim-plugin)
4. [KI-Agenten-Integrationen](#ki-agenten-integrationen)
1. [Claude Code-Integration](#claude-code-integration)
2. [GitHub Copilot-Integration](#github-copilot-integration)
3. [Codex-Integration](#codex-integration)
4. [Antigravity (agy)-Integration](https://github.com/sayanarijit/cottage/blob/main/%3C#antigravity-(agy)-integration>)
5. [Cursor-Integration](#cursor-integration)
5. [Schnellstart](#schnellstart)
6. [GitOps](#gitops)
7. [Git-Hooks](#git-hooks)
8. [Zugriffskontrolle](#zugriffskontrolle)
1. [Regeln](#regeln)
2. [Verifizierung](#verifizierung)
9. [Jeder Anbieter als Upstream](#jeder-anbieter-als-upstream)
1. [Beispiel-Plugins](#beispiel-plugins)
10. [Mit jedem Gerät synchronisieren](#mit-jedem-gerät-synchronisieren)
11. [Mehr erfahren](#mehr-erfahren)
12. [Fehlerbehebung](#fehlerbehebung)
13. [Vergleich](#vergleich)
1. [age vs. andere Verschlüsselung](#age-vs-andere-verschlüsselung)
2. [cottage vs. SOPS](#cottage-vs-sops)
3. [cottage vs. dotenvx](#cottage-vs-dotenvx)
4. [cottage vs. agebox](#cottage-vs-agebox)
## Funktionen
- **Sicher vor Offenlegung**: Nutzt Rusts Typsystem, um sicherzustellen, dass Fehler niemals versehentlich Secrets offenlegen können.
- **Teamfreundlich**: Teile öffentliche Schlüssel (Empfänger) im Repository, halte private Schlüssel (Identitäten) lokal.
- **Zugriffskontrolle**: Einfache Allow/Deny-Regeln zur Steuerung, welche Secrets für welche Empfänger verschlüsselt werden.
- **Verwaltet .gitignore**: Aktualisiert `.gitignore` automatisch, um unverschlüsselte Secrets aus dem Repository herauszuhalten.
- **Vorschauen**: Generiert zeitgestempelte geschwärzte Vorschauen verschlüsselter Secrets für bessere Sichtbarkeit.
- **Aussagekräftige Diffs**: Hält Git-Diffs sauber und überprüfbar, während `ctg diff` den Diff lokal geänderter Secrets mit den getrackten verschlüsselten Gegenstücken anzeigt.
- **Checksummen-Verifizierung**: Verhindert Manipulation durch Überprüfung, dass verschlüsselte Secrets und Empfängerlisten mit den Metadaten übereinstimmen.
- **Git-Hooks**: Einfache Einrichtung von Git-Hooks zum automatischen Prüfen/Verschlüsseln von Secrets vor dem Commit und Entschlüsseln nach dem Checkout.
- **Persistenter Secrets-Workflow**: `ctg decrypt/sync` behält entschlüsselte Secrets auf der Festplatte.
- **Intelligenter Bereinigungs-Lebenszyklus**: `ctg run` (Kurzform `ctgx`) und `ctg edit` entschlüsseln Secrets vor der Operation und behalten sie auf der Festplatte, wenn sie bereits vorher vorhanden waren, oder bereinigen sie danach automatisch, wenn sie es nicht waren.
- **Bereinigung nach Abschluss**: `ctg encrypt --clean`, `ctg run --clean` und `ctg edit --clean` stellen sicher, dass entschlüsselte Dateien von der Festplatte bereinigt werden, auch wenn sie vorher vorhanden waren.
- **Umgebungsinjektions-Workflow**: `ctg env` injiziert entschlüsselte Secrets als Umgebungsvariablen, um einen Befehl auszuführen, ohne sie überhaupt auf die Festplatte zu schreiben.
- **Sicheres Secret-Piping**: `ctg cat PATH` entschlüsselt im Speicher und gibt auf stdout aus, für direktes stdin-Piping an andere Tools.
- **Bereinigung**: `ctg clean` löscht alle entschlüsselten Secrets aus dem lokalen Repository, damit du deine KI-Agenten mit etwas weniger Sorge laufen lassen kannst.
- **Unterstützt jj und Nicht-Git-Verzeichnisse**: `ctg init` verwandelt jedes Verzeichnis in einen Secret-Store.
- **Mit jedem Anbieter synchronisieren**: Ermöglicht die Konfiguration jedes Anbieters mit einer API als Upstream und die Nutzung von `ctg pull/diff/push` wie `git pull/diff/push`.
- **Mit jedem Gerät synchronisieren**: Mit cottage verschlüsselte und in einem Git-Repository verwaltete Secrets können geräteübergreifend mit [Cottage Sync](https://cottage-sync.github.io) synchronisiert werden.
## Installation
```bash
# rust: cargo-binstall/cargo
cargo binstall --locked cottage
cargo install --locked cottage
# python: pip/uv/uvx
pip install cottage
uv pip install cottage
uvx --from cottage ctg --version
# node: yarn/pnpm/npx
yarn global add @sayanarijit/cottage
pnpm add -g @sayanarijit/cottage
npx -p @sayanarijit/cottage ctg --version
```
Auch als Docker-Images verfügbar:
```bash
# Docker
docker run --rm -v $PWD:/app sayanarijit/cottage --version
# Podman
podman run --rm -v $PWD:/app quay.io/sayanarijit/cottage --version
```
Oder lade die neueste Version von [GitHub](https://github.com/sayanarijit/cottage/releases) herunter.
## Editor-Integrationen
### VS Code-Erweiterung
Verwende die [Cottage VS Code-Erweiterung](https://github.com/sayanarijit/vscode-plugin-cottage), um `ctg` zu installieren, Copilot-Sicherheits-Hooks hinzuzufügen, Dateien aus dem Explorer zu verschlüsseln und `.cott.age`-Dateien über den Editor-Workflow zu öffnen.
[](https://marketplace.visualstudio.com/items?itemName=sayanarijit.vscode-plugin-cottage)
Installiere sie aus dem [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=sayanarijit.vscode-plugin-cottage) oder baue und installiere sie lokal aus [`vscode-plugin-cottage`](https://github.com/sayanarijit/vscode-plugin-cottage).
### Cursor- und Eclipse-Erweiterung
Lade die [VSX-Datei](https://open-vsx.org/extension/sayanarijit/vscode-plugin-cottage) herunter und installiere sie in deiner Cursor- oder Eclipse-IDE. Sie funktioniert ähnlich wie die VS Code-Erweiterung.
### Vim-Plugin
Verwende das [cottage.vim](https://github.com/sayanarijit/cottage.vim)-Plugin, um Secrets aus Vim oder Neovim zu verschlüsseln/entschlüsseln.
[](https://asciinema.org/a/1264076)
## KI-Agenten-Integrationen
Alle unten aufgeführten Integrationen hindern KI-Agenten daran, `ctg`/`ctgx` direkt auszuführen und Secret-Dateien anzuzeigen oder zu bearbeiten: alles innerhalb von `.cottage/`, jede `*.cott.*`-Datei (verschlüsselte `*.cott.age`-Blobs und geschwärzte `*.cott.toml`-Vorschauen) und jede entschlüsselte Datei, die noch ein `*.cott.age`-Gegenstück auf der Festplatte hat.
### Claude Code-Integration
Wenn du Claude Code verwendest, füge [`.claude/settings.json`](https://github.com/sayanarijit/cottage/blob/main/.claude/settings.json) und [`.claude/hooks/deny-secrets.py`](https://github.com/sayanarijit/cottage/blob/main/.claude/hooks/deny-secrets.py) zu deinen Repositories mit Secrets hinzu, damit Claude Code-Sitzungen Secrets sicher handhaben, oder installiere das [claude-plugin-cottage](https://github.com/sayanarijit/claude-plugin-cottage)-Plugin.
### GitHub Copilot-Integration
Wenn du GitHub Copilot in VS Code verwendest, füge [`.github/hooks/ctg-policy.json`](https://github.com/sayanarijit/cottage/blob/main/.github/hooks/ctg-policy.json) und [`.github/hooks/scripts/deny_ctg_command.py`](https://github.com/sayanarijit/cottage/blob/main/.github/hooks/scripts/deny_ctg_command.py) zu deinen Repositories mit Secrets hinzu, damit Copilot-Sitzungen entschlüsselte Dateien bereinigen, direkte `ctg`-Shell-Befehle blockieren und den Zugriff auf Secret-Dateien blockieren, oder installiere die [vscode-plugin-cottage](https://github.com/sayanarijit/vscode-plugin-cottage)-Erweiterung, um das aus VS Code heraus einzurichten.
VS Code lädt auch Hook-Definitionen aus [`.claude/settings.json`](https://github.com/sayanarijit/cottage/blob/main/.claude/settings.json). Wenn du sowohl Claude- als auch Copilot-Hook-Dateien im selben Repository behältst, stelle sicher, dass du nicht versehentlich denselben Bereinigungs-Hook zweimal ausführst.
### Codex-Integration
Wenn du Codex verwendest, füge [`.codex/hooks.json`](https://github.com/sayanarijit/cottage/blob/main/.codex/hooks.json) und [`.codex/hooks/deny-ctg.py`](https://github.com/sayanarijit/cottage/blob/main/.codex/hooks/deny-ctg.py) zu deinen Repositories mit Secrets hinzu, damit Codex-Sitzungen Secrets sicher handhaben, oder installiere das [codex-plugin-cottage](https://github.com/sayanarijit/codex-plugin-cottage)-Plugin.
Codex erfordert, dass lokale Hooks vor der Ausführung überprüft werden. Nach dem Hinzufügen der Dateien starte Codex im Repository und verwende `/hooks`, um die Projekt-Hooks zu überprüfen und ihnen zu vertrauen.
### Antigravity (agy)-Integration
Wenn du Antigravity (`agy`) verwendest, füge [`.agents/hooks.json`](https://github.com/sayanarijit/cottage/blob/main/.agents/hooks.json) und [`.agents/scripts/deny-ctg.py`](https://github.com/sayanarijit/cottage/blob/main/.agents/scripts/deny-ctg.py) zu deinen Repositories mit Secrets hinzu, damit Antigravity-Sitzungen Secrets sicher handhaben, oder installiere das [agy-plugin-cottage](https://github.com/sayanarijit/agy-plugin-cottage)-Plugin.
### Cursor-Integration
Wenn du Cursor verwendest, füge [`.cursor/hooks.json`](https://github.com/sayanarijit/cottage/blob/main/.cursor/hooks.json), [`.cursor/hooks/deny-ctg.py`](https://github.com/sayanarijit/cottage/blob/main/.cursor/hooks/deny-ctg.py), [`.cursor/hooks/deny-read-secrets.py`](https://github.com/sayanarijit/cottage/blob/main/.cursor/hooks/deny-read-secrets.py), [`.cursor/rules/deny-ctg.mdc`](https://github.com/sayanarijit/cottage/blob/main/.cursor/rules/deny-ctg.mdc) und [`.cursorignore`](https://github.com/sayanarijit/cottage/blob/main/.cursorignore) zu deinen Repositories mit Secrets hinzu, damit Cursor-Sitzungen Secrets sicher handhaben.
Cursor erfordert, dass Hooks zuerst aktiviert werden. Öffne Cursor Settings > Hooks und aktiviere Hooks, dann starte die Agenten-Sitzung neu, damit die Projekt-Hooks wirksam werden. `.cursorignore` hält Secret-Dateien zusätzlich aus Cursors Indexierung und dem Kontext des Agenten heraus.
## Schnellstart
Projekt initialisieren:
```bash
mkdir project && cd project
git init # Optional, cottage works better with git but it's not required
ctg init # Sets up the .cottage directory and necessary files
tree -a
# .
# ├ .cottage/ <- Auto-generated by `ctg init`
# │ └ recipients/ <- This is where your team keeps the public keys of all the recipients.
# │ └ sayanarijit <- Your public key. Commit it. To use an existing public key, just copy that key here.
# ├ .git/...
# └ .gitattributes <- Added `*.cott.age binary linguist-generated filter=cottage-encrypted -diff` to avoid polluting git diff
# Your private key is stored safely in `~/.config/cottage/identity/<dirname>/<timestamp>.key`.
# You can run `ctg clean --all` anytime to clean up everything cottage ever did.
```
Ein Secret erstellen oder bearbeiten:
```bash
# `ctg edit` decrypts the file before opening in $EDITOR and re-encrypts upon save.
# If the decrypted file was not present on disk before running `ctg edit`, it is cleaned up afterwards.
# If it was already present, it is kept on disk.
ctg edit secret.yml
# Use `--clean` with `ctg edit` or `ctg encrypt` to ensure decrypted files are deleted even if present before
ctg edit secret.yml --clean # Opens in $EDITOR, encrypts on save, and cleans up
ctg encrypt secret.yml --clean # Encrypts secret.yml and cleans up
# encrypt secret.yml
# into secret.yml.cott.age
# edit secret.yml.cott.toml
# edit .gitignore
# delete secret.yml
```
Einen Befehl mit entschlüsselten Secrets ausführen:
```bash
cat secret.yml
# cat: secret.yml: No such file or directory
# `ctg run` (or shortcut `ctgx`) decrypts secrets before running the command.
# If the decrypted files were not present on disk beforehand, they are automatically cleaned up after the command finishes.
# If they were already present beforehand, they are kept on disk.
ctg run -- kubectl apply -f secret.yml # decrypts secret.yml.cott.age to secret.yml and runs the command
ctg run -- kubectl apply -f secret.yml.cott.age # also replaces the path argument with the decrypted file path
ctg run -- kubectl apply -f . # decrypts all .cott.age files in . and runs the command
ctg run -- ./deploy.sh # decrypts all .cott.age files in repo and runs the command
cat secret.yml
# cat: secret.yml: No such file or directory
# Use `--clean` to ensure decrypted files are cleaned up even if they were present before
ctg run --clean ./deploy.sh
```
Oder verwende die Kurzform:
```bash
ctgx -- ./deploy.sh
ctgx --clean -- ./deploy.sh
```
Ein entschlüsseltes Secret lesen und weiterleiten, ohne es auf die Festplatte zu schreiben:
```bash
ctg cat secret.yml.cott.age
ctg cat secret.yml | kubectl apply -f -
ctg cat .env.prod | docker run --rm --env-file /dev/stdin my-image:latest
```
Einen Befehl mit als Umgebungsvariablen injizierten Secrets ausführen, ohne überhaupt auf die Festplatte zu schreiben:
```bash
ctg env -- ./deploy.sh # Export secrets from .env.cott.age (default) without writing them to disk, then run deploy.sh
ctg env -F .env.prod.cott.age -- ./deploy.sh # exports from .env.prod.cott.age instead of .env.cott.age
ctg env -F secrets.json.cott.age -- printenv COTTAGE_SECRET # Also supports non-dotenv files.
```
## GitOps
Um deine Secrets mit Teammitgliedern zu teilen, pushe einfach in das Git-Repository.
```bash
git add .
git commit -m "Add secret.yml"
git push origin main
```
Bitte deine Teammitglieder, ihre öffentlichen Schlüssel zu `.cottage/recipients` hinzuzufügen und die
Änderungen zu pushen. Dann kannst du pullen und die Secrets für sie neu verschlüsseln.
```bash
git pull origin main
ctg decrypt --skip-verify-recipients # Decrypt missing secrets for re-encryption
ctg encrypt # Re-encrypt all secrets
# encrypt secret.yml
# into secret.yml.cott.age
# edit secret.yml.cott.toml
ctg clean # optional
# delete secret.yml
# review changes, commit and push
git add .
git commit -m "Add new recipient to secrets"
git push origin main
```
Jetzt können deine Teammitglieder die neuesten Änderungen pullen und die Secrets für sich selbst entschlüsseln.
## Git-Hooks
Du kannst [prek](https://github.com/j178/prek) oder [pre-commit](https://pre-commit.com/) verwenden, um Git-Hooks einzurichten, die Secrets vor dem Commit automatisch prüfen/verschlüsseln und nach dem Checkout entschlüsseln.
Siehe die [Beispiel-prek-Konfiguration hier](https://github.com/sayanarijit/cottage/blob/main/examples/prek.toml).
Nach dem Hinzufügen der `prek.toml`-Datei führe aus:
```bash
prek install
prek install --hook-type post-checkout
prek install --hook-type post-merge
prek install --hook-type post-rewrite
```
## Zugriffskontrolle
### Regeln
In der Metadatendatei kannst du annotieren, für welche Empfänger das Secret verschlüsselt werden soll.
Dies ermöglicht dir, unterschiedliche Secrets für unterschiedliche Umgebungen (z. B. Staging vs. Produktion) zu haben und sie nur für die relevanten Empfänger zu verschlüsseln.
```toml
# secret.yml.cott.toml
[secret]
allow = ["sayanarijit"] # Only encrypt for sayanarijit
```
```toml
# secret.yml.cott.toml
[secret]
deny = ["sayanarijit"] # Encrypt for everyone except sayanarijit
```
```toml
# secret.yml.cott.toml
[secret]
allow = ["env/staging/*"] # Supports glob patterns, only encrypt for recipients in env/staging
deny = ["env/staging/badservice"] # Encrypt for everyone in env/staging except badservice
```
Deny-Regeln haben Vorrang vor Allow-Regeln.
Siehe [Metadaten-Spezifikation](https://github.com/sayanarijit/cottage/blob/main/SPECIFICATION.md#secretmetadata) für weitere Details.
### Verifizierung
Du kannst `ctg verify` in CI ausführen, um zu überprüfen, dass die verschlüsselten Secrets und Empfängerlisten mit den Metadatenregeln übereinstimmen, um Manipulation zu verhindern.
```yaml
# .github/workflows/cottage-verify.yml
name: Cottage Verify
on: [push, pull_request]
permissions:
contents: read
jobs:
verify-secrets:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Verify secrets
run: docker run --rm -v "${{ github.workspace }}:/app" ghcr.io/sayanarijit/cottage verify
```
## Jeder Anbieter als Upstream
Mit cottage kannst du Secrets mit jedem Anbieter synchronisieren, der eine API hat, nicht nur mit Git.
Erstelle dazu eine Datei namens `cottage.toml` im Projektstammverzeichnis und konfiguriere die Upstream-Einstellungen.
Siehe die [Beispiel-`cottage.toml` hier](https://github.com/sayanarijit/cottage/blob/main/cottage.toml) und die [secret-spezifische Upstream-Konfiguration hier](https://github.com/sayanarijit/cottage/blob/main/examples/secrets/secret.json.cott.toml).
Siehe eine [Beispiel-Plugin-Implementierung hier](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-vault-in-kubernetes.py).
Der Workflow ähnelt Git, aber statt `git pull` und `git push` führst du `ctg pull` und `ctg push` aus, um Secrets mit dem konfigurierten Upstream zu synchronisieren.
Beispiel:
```bash
# Pull latest changes into local encrypted secrets
# Similar to `git pull origin`
ctg pull myvault
# Compare diff with local decrypted secrets
ctg diff
# Sync local decrypted secrets with local encrypted secrets
ctg sync
# Push changes from local encrypted secrets to upstream
# Similar to `git push origin main`
ctg push myvault
```
Siehe [Upstream-Konfigurationsspezifikation](https://github.com/sayanarijit/cottage/blob/main/SPECIFICATION.md#upstreamconfig) für weitere Details.
### Beispiel-Plugins
Cottage unterstützt verschiedene Plugin-Anbieter zur Synchronisierung deiner Secrets. Gebrauchsfertige Plugin-Skripte sind im Verzeichnis [examples/plugins](https://github.com/sayanarijit/cottage/blob/main/examples/plugins) verfügbar:
- [1Password](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-onepassword.py)
- [AWS Secrets Manager](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-aws-secretsmanager.py)
- [Azure Key Vault](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-azure-keyvault.py)
- [Bitwarden](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-bitwarden.py)
- [Dashlane](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-dashlane.py)
- [Doppler](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-doppler.py)
- [ejson](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-ejson.py)
- [GitHub Secrets](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-github-secrets.py)
- [Google Cloud Secret Manager](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-gcp-secretmanager.py)
- [HashiCorp Vault](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-vault.py) (siehe auch [Vault in Kubernetes](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-vault-in-kubernetes.py))
- [Keeper Security](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-keeper.py)
- [KeePass (Passhole)](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-passhole.py)
- [LastPass](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-lastpass.py)
- [pass (password-store)](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-pass.py)
- [Proton Pass](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-protonpass.py)
- [System Keyring](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-keyring.py)
- [Zoho Vault](https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-zoho-vault.py)
## Mit jedem Gerät synchronisieren
Verwende [Cottage Sync](https://cottage-sync.github.io), um deine Secrets geräteübergreifend zu synchronisieren und sie ohne CLI zu durchsuchen.
## Mehr erfahren
Siehe das Verzeichnis [examples](https://github.com/sayanarijit/cottage/blob/main/examples) für weitere Anwendungsbeispiele.
## Fehlerbehebung
```bash
# See debug logs with -v, -vv or -vvv
ctg run -vvv -- ./deploy.sh
```
## Vergleich
### age vs. andere Verschlüsselung
[age](https://age-encryption.org) verwendet einen modernen, einfachen Algorithmus, der für sichere Dateiverschlüsselung optimiert ist, mit Fokus auf Benutzerfreundlichkeit und minimale Angriffsfläche. Es [unterstützt auch SSH-RSA- und Ed25519-Schlüssel](https://words.filippo.io/using-ed25519-keys-for-encryption/), obwohl es empfohlen wird, unterschiedliche Schlüssel für getrennte Zwecke und Geltungsbereiche zu verwenden.
### cottage vs. SOPS
Während [SOPS](https://getsops.io/) und cottage viele überlappende Funktionen haben, hat cottage die folgenden Vorteile:
- Automatische Verwaltung von .gitignore, um sicherzustellen, dass unverschlüsselte Secrets niemals in Git committet werden.
- Verschlüsselte Secrets sind reine age-verschlüsselte .age-Dateien, was eine bessere Interoperabilität mit einem breiteren Ökosystem von Tools ermöglicht.
- Sauberere Diffs – anders als SOPS, das Diffs für jeden Wert jedes Secrets generiert, selbst wenn die tatsächliche Änderung nur das Hinzufügen/Entfernen eines Empfängers ist, generiert cottage nur einen Diff pro Datei, der explizit die Änderung in der Empfänger-Checksumme aufzeigt.
### cottage vs. dotenvx
cottage übernimmt die `ctg env`-API von [dotenvx](https://dotenvx.com).
- Unterstützt jeden Dateityp, nicht nur dotenv-Dateien.
- Verwaltet mehrere Secrets in einem Repository.
- Zugriffskontrollregeln zur Verschlüsselung von Secrets für bestimmte Empfänger.
- Sauberere Diffs – siehe [cottage vs. SOPS](#cottage-vs-sops).
### cottage vs. agebox
[agebox](https://github.com/slok/agebox) ist in der Kernphilosophie sehr ähnlich zu cottage, aber es fehlen viele [Funktionen](#funktionen).