dredge-cargo

Ceci n'est PAS un gestionnaire de mots de passe. PAS une application de notes. Et certainement PAS un registre de provenance taxonomique d'un spécimen aberrant des profondeurs benthiques. Mais il fait mieux les deux premiers que l'un ou l'autre. Je rigole (pas vraiment).

Installation • Démarrage rapide • Fonctionnalités • La commande link • Commandes • Comment ça marche • Sécurité • Pourquoi

« Ne m'embêtez pas avec des babioles ordinaires. » — Le Poissonnier

go install github.com/DeprecatedLuar/dredge-cargo/cmd/dredge@latest

Les fonctionnalités géniales que vous n'avez jamais vues

• Stockage chiffré — Clonez le dépôt et obtenez du charabia cryptique absolu. Vous ne pouvez même pas dire ce qu'il y a dans le dépôt sans le mot de passe. (J'ai utilisé AES-256-GCM + Argon2id)
• Recherche instantanée — J'ai créé un algorithme de recherche floue personnalisé parce que je suis paresseux et que je veux la bonne entrée parmi 300 autres en une milliseconde sans avoir à y penser.
• Stockez n'importe quoi — notes, scripts, dotfiles, images, archives zip. Si c'est un fichier et qu'il existe, il peut être stocké dans dredge.
• Liaison de fichiers en direct — Fonctionnalité sympa, créez un lien symbolique vers n'importe quel élément sur un chemin système pour pouvoir lire et éditer directement ou via dredge. Toutes les modifications sont synchronisées dans les deux sens avec le dépôt.
• Basé sur Git — dépôt privé qui vous appartient. Donc faites simplement git clone et vous avez vos données.
• Mot de passe de session — Une seule demande par session de terminal. Après cela, vous pouvez utiliser sans mot de passe jusqu'à ce que vous tuiez le terminal. (lisez la section sécurité pour mieux comprendre)
• Corbeille + annulation — les éléments supprimés vont à la corbeille. Utilisez simplement dredge undo si vous supprimez accidentellement.

Que stocker dans dredge ?

Je ne vous jugerai pas. Clés API ennuyeuses qui ne s'affichent qu'une fois, configuration SSH, prompts IA, mots de passe, scripts shell littéraux que vous pouvez exécuter, modèles d'email ?, dotfiles (bizarres mais fonctionneront bien), archives zip, liste de films, listes d'URL pour un accès rapide...

Même une copie légale du chapitre 2 de Chainsaw Man en japonais. (Je peux ou non avoir celle-là spécifiquement)

Installation

Go

go install github.com/DeprecatedLuar/dredge-cargo/cmd/dredge@latest

Assurez-vous que $GOPATH/bin (généralement ~/go/bin) est dans votre PATH.

Universel

curl -sSL https://raw.githubusercontent.com/DeprecatedLuar/the-satellite/main/satellite.sh | bash -s -- install DeprecatedLuar/dredge-cargo:dredge

git clone https://github.com/DeprecatedLuar/dredge-cargo
cd dredge-cargo
go build -o dredge ./cmd/dredge
mv dredge ~/.local/bin/

Démarrage rapide

# Initialiser avec un dépôt git distant existant
dredge init yourusername/vault   # Raccourci GitHub
# ou : dredge init [email protected]:you/vault.git

# Ajouter votre premier élément
dredge add "OpenAI Key" -c "sk-..." -t keys api # ouvre l'éditeur sans le flag -c

# Le rechercher
dredge search openai

# Pousser vers git
dredge push

# Ajouter n'importe quoi
dredge add My SSH Config -t ssh dotfiles --import ~/.ssh/config
dredge add "Master Architect Prompt" --import prompt.md -t ai prompts
dredge add "Watchlist" -c "Dune 2, Oppenheimer..." -t lists
dredge add "project-backup" --import project.tar.gz   # fichiers binaires aussi :D

# Rechercher — tapez juste ce dont vous vous souvenez
dredge search prompt
dredge search aws key
dredge search ssh

# Voir, éditer, supprimer
dredge view <id>
dredge edit <id>
dredge rm <id>
dredge undo          # ramené

# Les résultats de recherche sont numérotés — tapez simplement le numéro pour voir
dredge search ssh    # affiche : 1. [xKP] SSH Config  2. [mNq] SSH Key
dredge 1             # le voir directement

# Synchronisation Git
dredge push
dredge pull
dredge sync          # pull + push

Comment ça marche

« Je n'imagine pas ce qu'il y a là-bas dans les profondeurs. » — Le Gardien du Phare

Bon alors pour résumer :

J'ai décidé d'utiliser deux technologies de chiffrement principales : Argon2id et bien sûr AES-256, plus précisément la variante GCM.

Argon2id parce que c'est LA recommandation du RFC 9106 et le vainqueur du PHC 2015. C'est tout. La variante GCM d'AES parce qu'elle rend toutes les données chiffrées impossibles à altérer grâce à l'empreinte. C'est tout aussi.

Pour l'instant, je stocke tout sous forme de fichiers chiffrés dans ~/.local/share/dredge/. Ce répertoire est également un dépôt git (du moins pour l'instant). Donc dredge push valide et pousse tout pour la sauvegarde. Chaque élément est un blob chiffré autonome avec un ID aléatoire de 3 caractères. J'ai décidé qu'aucun nom de fichier ne devrait être exposé, donc même si quelqu'un peut voir vos fichiers, il n'a aucune idée de ce qu'il regarde.

Le pipeline de chiffrement

Votre mot de passe
  + sel aléatoire de 16 octets  ← le sel est stocké dans .dredge-key
  → Argon2id (64 Mo de mémoire · 4 threads · 1 itération)
  → clé maîtresse de 32 octets (sel + mot de passe = la vraie clé)

Clé maîtresse + contenu de l'élément (TOML : titre, tags, contenu)
  → AES-256-GCM avec un nouveau nonce aléatoire de 12 octets par opération
  → [12B nonce][texte chiffré + tag d'authentification 16B]
  → écrit sur le disque sous items/xKP  (ID aléatoire, pas d'extension)

Donc l'ensemble de votre coffre partage la même clé dérivée (cela signifie que si vous perdez votre clé, vous perdez vos données, ne perdez pas votre clé s'il vous plaît). Chaque élément utilise la même clé, chacun avec son propre nonce aléatoire. Si vous chiffrez deux fois le même contenu, cela produit un texte chiffré complètement différent.

Qu'est-ce qui vit où

~/.local/share/dredge/          ← le coffre (dépôt git)
├── .git/
├── .gitignore                  ← exclut .spawned/ et links.json
├── .dredge-key                 ← sel + chaîne de vérification chiffrée  
├── items/
│   ├── xKP                     ← élément chiffré                       
│   ├── mNq                     ← élément chiffré                
│   └── ...
├── .spawned/                   ← copies en texte clair des éléments liés   
└── links.json                  ← manifeste des liens symboliques

Donc tous vos fichiers chiffrés et .dredge-key sont stockés dans le dépôt git, tous les fichiers en texte clair (ceux que vous avez décidé de rendre lisibles par le système) ne seront jamais suivis. Alors faites-en ce que vous voulez.

Modèle de session

Après votre première commande dans un terminal, la clé dérivée de 32 octets est mise en cache dans $XDG_RUNTIME_DIR/dredge/$PPID/.key (accès root uniquement)

Toutes les commandes dredge suivantes dans le MÊME terminal utilisent la clé en cache. Ce qui signifie que vous ne serez plus invité à entrer le mot de passe. Chaque terminal obtient son propre répertoire isolé basé sur le PID parent. Ainsi la clé s'évapore du disque une fois que le terminal meurt.

Sécurité

« Mieux vaut revenir avec une petite prise que de ne pas revenir du tout. » — Le Poissonnier

Modèle de menace (j'ai fait cette section avec l'IA mais c'est correct)

Quelqu'un clone votre dépôt git privé : Ils obtiennent des blobs chiffrés et .dredge-key. Le sel n'est pas secret — son but est de rendre les attaques par précalcul impraticables. Sans votre mot de passe, les éléments sont des données binaires opaques. Argon2id rend le brute-force hors ligne coûteux. Utilisez un mot de passe fort.

Quelqu'un a accès à votre session en cours : La clé dérivée se trouve dans $XDG_RUNTIME_DIR/dredge/$PPID/.key pendant toute la durée de cette session de terminal. Chaque terminal obtient son propre répertoire isolé — fermez le terminal, la clé disparaît. Ce chemin est limité à l'utilisateur (mode 700) et soutenu par la RAM. Un attaquant ayant un accès en lecture à votre répertoire de session peut déchiffrer votre coffre. Traitez-le comme n'importe quel identifiant sensible dans votre répertoire personnel. Si quelqu'un a un accès root à votre machine, votre clé dredge est le moindre de vos soucis.

Quelqu'un a un accès physique à votre machine hors ligne : Les éléments sur le disque sont chiffrés. La clé de session se trouve dans un stockage soutenu par la RAM et ne survit pas à un redémarrage. Les éléments liés (.spawned/) sont en texte clair sur le disque — voir ci-dessous.

Où se trouve le texte clair

Le fichier "spawned" est le seul texte clair persistant sur le disque, et il n'existe que parce que vous avez explicitement lié un élément à un chemin système. Tout le reste est uniquement en mémoire.

Mises en garde

• --password / DREDGE_PASSWORD : Transmettre votre mot de passe en ligne l'expose dans l'historique du shell et la sortie de ps. Les variables d'environnement peuvent fuiter vers les processus enfants. Évitez les deux dans les environnements partagés.
• --vault / DREDGE_VAULT : Remplacez le coffre actif pour une seule commande sans persister le changement. Utile pour les scripts sur plusieurs coffres.
• Éléments liés : Le texte clair d'un élément lié se trouve à la cible du lien symbolique (par ex. ~/.ssh/config). Il n'est pas suivi par git, mais il est sur le disque en texte clair.

La commande link

Liez n'importe quel élément stocké à un chemin sur votre système de fichiers :

dredge link <id> ~/.ssh/config

Cette commande créera un lien symbolique à ~/.ssh/config pointant vers une copie en texte clair que dredge gère (le fichier est exposé sur le disque pour que vous puissiez l'utiliser). Vous pouvez éditer le fichier directement ou via dredge edit ou ce que vous voulez, toutes les modifications sont synchronisées automatiquement avec le stockage chiffré.

Auto-réparation : Si vous renommez un lien symbolique (par ex. mv ~/.ssh/config ~/.ssh/config-backup), dredge détecte et suit automatiquement le nouveau chemin. Les liens symboliques supprimés sont nettoyés au démarrage de la session.

Sur une nouvelle machine :

git clone [email protected]:you/vault.git ~/.local/share/dredge
dredge link <id> ~/.ssh/config
#  même config SSH, mêmes clés, chaque machine suivie par git pour toute mise à jour

C'est en fait la raison pour laquelle j'ai construit dredge. Ma configuration SSH est identique sur chaque machine, mais je ne pouvais pas simplement les mettre dans mes dotfiles.

Toutes les commandes

Synchronisation Git (par wlad031)

La synchronisation Git utilise git simple et fonctionne avec n'importe quel dépôt distant (GitHub/GitLab/Gitea/etc).

dredge init accepte un dépôt git distant optionnel. Si vous l'omettez, dredge initialise un dépôt git local uniquement (pas de distant).

Comportement d'auto-validation : push, pull et sync préservent les modifications non validées synchronisées dans une validation avant de se réconcilier avec le distant. Si vous devez abandonner les modifications locales pour prioriser la version distante, utilisez dredge drop.

Conservation automatique de l'historique : push et sync appliquent la politique définie dans dredge.toml. Les métadonnées des éléments et le stockage binaire ont des limites indépendantes par élément et par nombre d'octets chiffrés, tandis que history.deleted.retain_for contrôle combien de temps les ID supprimés restent récupérables. Si la politique ne supprime rien, Dredge pousse normalement. Si un compactage est nécessaire, Dredge vérifie l'historique de remplacement et utilise un force-with-lease exact ; une mise à jour distante simultanée s'arrête en toute sécurité sans être écrasée. pull ne compacte jamais et ne force jamais le push.

Inspectez l'historique conservé avec dredge history, dredge history deleted ou dredge history <id>. Restaurez un élément chiffré supprimé avec dredge history restore <id>. Les changements de mot de passe ne rechiffrent pas les blobs historiques, donc les versions restaurées créées sous un ancien mot de passe peuvent ne pas se déchiffrer avec le mot de passe actuel.

Formats distants acceptés :

# Raccourci GitHub (étendu en https://github.com/<propriétaire>/<dépôt>.git)
dredge init owner/repo

# HTTPS
dredge init https://github.com/owner/repo.git
dredge init https://gitlab.com/group/repo.git

# SSH (similaire à scp)
dredge init [email protected]:owner/repo.git
dredge init [email protected]:group/repo.git

# URL SSH
dredge init ssh://[email protected]/owner/repo.git

# Chemin local distant (avancé)
dredge init /srv/git/dredge-vault.git

• Dredge ne crée pas de dépôts distants pour vous.
• Si origin n'est pas configuré, dredge push/pull/sync générera une erreur avec des conseils.
• Si vous avez déjà un dépôt git distant configuré, dredge init ne l'écrasera pas.

Pourquoi

« Je suis un collectionneur — de beaucoup de choses ; art et artefacts, trésors et vérités... et curiosités qui occupent la périphérie du désir. » — Le Collectionneur

La surcharge mentale liée à la sauvegarde de quelque chose et à ne pas savoir où le trouver quand on en a besoin.

J'en ai eu marre d'avoir des choses importantes (et sans importance aussi, juste des choses en général) éparpillées partout, je devais accéder à un compte email que j'avais créé il y a 6 ans parce qu'il était lié à un service aléatoire auquel je devais accéder de toute urgence pour aucune raison... Bref, j'ai réalisé que beaucoup d'outils, malgré leurs gadgets, se recoupent tous sur un aspect très important qui est le stockage d'informations, alors j'ai créé un outil qui se spécialise dans ce recoupement spécifique et laisse les outils faire ce qu'ils font de mieux.

Je suis paresseux, donc je voulais quelque chose qui fonctionne simplement et lit dans mes pensées, qui ne demande aucun effort pour ajouter une entrée ni pour la récupérer depuis la base de connaissances.

J'ai téléchargé jrnl une fois et j'ai vraiment aimé l'idée mais détesté l'exécution à cause de certains paramètres bizarres, il n'avait littéralement aucune séparation des éléments et une recherche qui correspondait à tout. Dredge est ce que je voulais réellement. (donc oui, c'est plutôt un outil personnel)

Contributeurs

Un grand merci à vous qui avez contribué à dredge :

timcondit

wlad031

Fait avec par Luar