dredge-cargo

Dies ist KEIN Passwort-Manager. KEINE Notizen-App. Und definitiv KEINE taxonomische Herkunftsregistrierung für benthische Tiefsee-Abnormitäten. Aber die ersten beiden macht es besser als beide. Nur ein Scherz (nicht wirklich).

Installieren • Schnellstart • Funktionen • Der Link-Befehl • Befehle • So funktioniert's • Sicherheit • Warum

„Belästige mich nicht mit alltäglichem Krimskrams.“ — Der Fischhändler

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

Die coolen Funktionen, die du noch nie gesehen hast

• Verschlüsselter Speicher — Klone das Repo und erhalte absolut kryptischen Kauderwelsch. Du kannst nicht einmal erkennen, was im Repo ist, ohne das Passwort. (Ich habe AES-256-GCM + Argon2id verwendet)
• Sofortige Suche — Ich habe einen benutzerdefinierten Fuzzy-Suchalgorithmus entwickelt, weil ich faul bin und den richtigen Eintrag unter 300 anderen in Millisekunden finden will, ohne darüber nachdenken zu müssen.
• Alles speichern — Notizen, Skripte, Dotfiles, Bilder, Zip-Archive. Wenn es eine Datei ist und existiert, kann es in dredge gespeichert werden.
• Live-Dateiverlinkung — Coole Funktion: Verknüpfe einen beliebigen Eintrag mit einem Systempfad, sodass du direkt oder über dredge lesen und bearbeiten kannst. Änderungen werden in beide Richtungen mit dem Repo synchronisiert.
• Git-gestützt — Privates Repo, das dir gehört. Also einfach git clone und du hast deine Daten.
• Sitzungspasswort — Eine Eingabeaufforderung pro Terminalsitzung. Danach kannst du passwortlos arbeiten, bis du das Terminal schließt. (Lies den Sicherheitsabschnitt, um es besser zu verstehen)
• Papierkorb + Rückgängig — Gelöschte Elemente landen im Papierkorb. Verwende einfach dredge undo, wenn du versehentlich löschst.

Was in dredge speichern?

Ich urteile nicht. Nervige API-Schlüssel, die nur einmal angezeigt werden, SSH-Konfiguration, KI-Prompts, Passwörter, buchstäbliche Shell-Skripte, die du ausführen kannst, E-Mail-Vorlagen?, Dotfiles (seltsam, aber funktioniert einwandfrei), Zip-Archive, Filmliste, Listen von URLs für schnellen Zugriff...

Sogar eine legale Kopie von Chainsaw Man Kapitel 2 auf Japanisch. (Die habe ich möglicherweise auch genau so)

Installieren

Go

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

Stelle sicher, dass $GOPATH/bin (normalerweise ~/go/bin) in deinem PATH ist.

Universal

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/

Schnellstart

# Initialize with an existing git remote
dredge init yourusername/vault   # GitHub shorthand
# or: dredge init [email protected]:you/vault.git

# Add your first item
dredge add "OpenAI Key" -c "sk-..." -t keys api #opens the editor without -c flag

# Search for it
dredge search openai

# Push to git
dredge push

# Add anything
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   # binary files too :D

# Search — just type whatever you remember
dredge search prompt
dredge search aws key
dredge search ssh

# View, edit, remove
dredge view <id>
dredge edit <id>
dredge rm <id>
dredge undo          # brought it back

# Search results are numbered — just type the number to view
dredge search ssh    # shows: 1. [xKP] SSH Config  2. [mNq] SSH Key
dredge 1             # views it directly

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

So funktioniert's

"Ich kann mir nicht vorstellen, was da unten in der Tiefe ist." — Der Leuchtturmwärter

Okay, um es zusammenzufassen:

Ich habe mich für zwei Hauptkryptotechnologien entschieden: Argon2id und natürlich AES-256, genauer gesagt die GCM-Variante.

Argon2id, weil es die EMPFEHLUNG aus RFC 9106 und der Gewinner des PHC-Wettbewerbs 2015 ist. Das wars. Die GCM-Variante von AES, weil sie alle verschlüsselten Daten aufgrund von Fingerabdrücken manipulationssicher macht. Das wars auch.

Im Moment speichere ich alles als verschlüsselte Dateien in ~/.local/share/dredge/. Dieses Verzeichnis ist auch ein Git-Repository (zumindest vorerst). Also führt dredge push Änderungen aus und pusht alles zur Sicherung. Jeder Eintrag ist ein eigenständiger verschlüsselter Blob mit einer zufälligen 3-Zeichen-ID. Ich habe entschieden, dass keine Dateinamen preisgegeben werden sollen, sodass selbst wenn jemand deine Dateien sehen kann, er keine Ahnung hat, worum es sich handelt.

Die Verschlüsselungspipeline

Ihr Passwort
  + 16-Byte-Zufallssalz  ← das Salz wird in .dredge-key gespeichert
  → Argon2id (64 MB Speicher · 4 Threads · 1 Iteration)
  → 32-Byte-Hauptschlüssel (Salz + Passwort = der eigentliche Schlüssel)

Hauptschlüssel + Inhalt des Eintrags (TOML: Titel, Tags, Inhalt)
  → AES-256-GCM mit einem frischen zufälligen 12-Byte-Nonce pro Vorgang
  → [12B Nonce][Chiffretext + 16B Authentifizierungstag]
  → auf die Festplatte geschrieben als items/xKP (zufällige ID, keine Erweiterung)

Dein gesamter Tresor verwendet also denselben abgeleiteten Schlüssel (das bedeutet, wenn du deinen Schlüssel verlierst, verlierst du deine Daten – bitte verliere deinen Schlüssel nicht). Jeder Eintrag verwendet denselben Schlüssel, jeder mit seinem eigenen zufälligen Nonce. Wenn du denselben Inhalt zweimal verschlüsselst, entsteht vollständig unterschiedlicher Chiffretext.

Was wo lebt

~/.local/share/dredge/          ← der Tresor (Git-Repo)
├── .git/
├── .gitignore                  ← schließt .spawned/ und links.json aus
├── .dredge-key                 ← Salz + verschlüsselter Bestätigungsstring  
├── items/
│   ├── xKP                     ← verschlüsselter Eintrag                       
│   ├── mNq                     ← verschlüsselter Eintrag                
│   └── ...
├── .spawned/                   ← Klartext-Kopien verlinkter Einträge   
└── links.json                  ← Symlink-Manifest

Alle deine verschlüsselten Dateien und .dredge-key werden im Git-Repo gespeichert, alle Klartextdateien (diejenigen, die du für das System lesbar gemacht hast) werden niemals versioniert. Mach also damit, was du willst.

Sitzungsmodell

Nach deinem ersten Befehl in einem Terminal wird der abgeleitete 32-Byte-Schlüssel unter $XDG_RUNTIME_DIR/dredge/$PPID/.key (nur Root-Zugriff) zwischengespeichert.

Alle folgenden dredge-Befehle im GLEICHEN Terminal verwenden den zwischengespeicherten Schlüssel. Das bedeutet, dass du nicht mehr nach dem Passwort gefragt wirst. Jedes Terminal erhält sein eigenes isoliertes Verzeichnis basierend auf der übergeordneten PID. Der Schlüssel wird von der Festplatte entfernt, sobald das Terminal stirbt.

Sicherheit

„Besser mit einem kleinen Fang zurückzukommen, als gar nicht zurückzukommen.“ — Der Fischhändler

Bedrohungsmodell (Diesen Abschnitt habe ich mit KI erstellt, aber er ist korrekt)

Jemand klont dein privates Git-Repo: Sie erhalten verschlüsselte Blobs und .dredge-key. Das Salz ist nicht geheim – sein Zweck ist es, Vorausberechnungsangriffe unpraktikabel zu machen. Ohne dein Passwort sind die Einträge undurchsichtige Binärdaten. Argon2id macht Offline-Brute-Force teuer. Verwende ein starkes Passwort.

Jemand hat Zugriff auf deine laufende Sitzung: Der abgeleitete Schlüssel befindet sich während der Dauer dieser Terminalsitzung in $XDG_RUNTIME_DIR/dredge/$PPID/.key. Jedes Terminal erhält sein eigenes isoliertes Verzeichnis – schließe das Terminal, der Schlüssel ist weg. Dieser Pfad ist benutzerbezogen (Modus 700) und RAM-gestützt. Ein Angreifer mit Lesezugriff auf dein Sitzungsverzeichnis kann deinen Tresor entschlüsseln. Behandle ihn wie jede andere sensible Anmeldeinformation in deinem Home-Verzeichnis. Wenn jemand Root auf deinem Rechner hat, ist dein dredge-Schlüssel dein geringstes Problem.

Jemand hat physischen Zugriff auf dein ausgeschaltetes Gerät: Die Einträge auf der Festplatte sind verschlüsselt. Der Sitzungsschlüssel befindet sich im RAM-gestützten Speicher und überlebt einen Neustart nicht. Verlinkte Einträge (.spawned/) liegen im Klartext auf der Festplatte – siehe unten.

Wo Klartext existiert

Die gespawnte Datei ist der einzige dauerhafte Klartext auf der Festplatte, und sie existiert nur, weil du einen Eintrag explizit mit einem Systempfad verknüpft hast. Alles andere befindet sich nur im Speicher.

Einschränkungen

• --password / DREDGE_PASSWORD: Die Angabe deines Passworts inline macht es im Shell-Verlauf und in der ps-Ausgabe sichtbar. Umgebungsvariablen können an Kindprozesse durchsickern. Vermeide beides in gemeinsam genutzten Umgebungen.
• --vault / DREDGE_VAULT: Überschreibe den aktiven Tresor für einen einzelnen Befehl, ohne die Änderung dauerhaft zu machen. Nützlich für Skripte über mehrere Tresore hinweg.
• Verlinkte Einträge: Der Klartext eines verlinkten Eintrags befindet sich am Symlink-Ziel (z. B. ~/.ssh/config). Er wird nicht von Git verfolgt, liegt aber im Klartext auf der Festplatte.

Der Link-Befehl

Verknüpfe einen gespeicherten Eintrag mit einem Pfad in deinem Dateisystem:

dredge link <id> ~/.ssh/config

Dieser Befehl erstellt einen Symlink unter ~/.ssh/config, der auf eine Klartext-Kopie zeigt, die von dredge verwaltet wird (die Datei wird auf der Festplatte verfügbar gemacht, damit du sie nutzen kannst). Du kannst die Datei direkt oder über dredge edit oder wie auch immer bearbeiten; alle Änderungen werden automatisch mit dem verschlüsselten Speicher synchronisiert.

Automatische Reparatur: Wenn du einen Symlink umbenennst (z. B. mv ~/.ssh/config ~/.ssh/config-backup), erkennt dredge dies und verfolgt den neuen Pfad automatisch. Gelöschte Symlinks werden beim Sitzungsstart bereinigt.

Auf einem neuen Rechner:

git clone [email protected]:you/vault.git ~/.local/share/dredge
dredge link <id> ~/.ssh/config
#  same SSH config, same keys, every machine git tracked for any update

Das ist eigentlich der Grund, warum ich dredge gebaut habe. Meine SSH-Konfiguration ist auf jedem Rechner identisch, aber ich konnte sie nicht einfach in meine Dotfiles packen.

Alle Befehle

Git-Synchronisation (von wlad031)

Die Git-Sync verwendet einfaches git und funktioniert mit jedem Remote (GitHub/GitLab/Gitea/etc.).

dredge init akzeptiert optional einen Git-Remote. Wenn du ihn weglässt, initialisiert dredge ein lokales Git-Repo (ohne Remote).

Auto-Commit-Verhalten: push, pull und sync bewahren synchronisierte, nicht übernommene Änderungen in einem Commit auf, bevor sie mit dem Remote abgeglichen werden. Wenn du lokale Änderungen verwerfen musst, um die Remote-Version zu priorisieren, verwende dredge drop.

Automatische Aufbewahrung des Verlaufs: push und sync wenden die in dredge.toml festgelegte Richtlinie an. Elementmetadaten und Binärspeicher haben unabhängige versionsbezogene und verschlüsselte Byte-Grenzen, während history.deleted.retain_for steuert, wie lange gelöschte IDs wiederherstellbar bleiben. Wenn die Richtlinie nichts entfernt, pusht Dredge normal. Wenn eine Kompaktierung erforderlich ist, überprüft Dredge den Ersatzverlauf und verwendet eine exakte Force-with-Lease; ein gleichzeitiges Remote-Update stoppt sicher, anstatt überschrieben zu werden. pull kompaktiert nie und führt kein Force-Push durch.

Überprüfe den aufbewahrten Verlauf mit dredge history, dredge history deleted oder dredge history <id>. Stelle einen gelöschten verschlüsselten Eintrag mit dredge history restore <id> wieder her. Passwortänderungen verschlüsseln historische Blobs nicht neu, daher können wiederhergestellte Versionen, die unter einem älteren Passwort erstellt wurden, möglicherweise nicht mit dem aktuellen Passwort entschlüsselt werden.

Akzeptierte Remote-Formate:

# GitHub shorthand (expanded to https://github.com/<owner>/<repo>.git)
dredge init owner/repo

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

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

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

# Local path remote (advanced)
dredge init /srv/git/dredge-vault.git

• Dredge erstellt keine Remote-Repositories für dich.
• Wenn origin nicht konfiguriert ist, geben dredge push/pull/sync einen Fehler mit Anleitung aus.
• Wenn du bereits einen Git-Remote gesetzt hast, überschreibt dredge init diesen nicht.

Warum

„Ich bin ein Sammler – von vielen Dingen; Kunst und Artefakte, Schätze und Wahrheiten … und Kuriositäten, die am Rande des Begehrens stehen.“ — Der Sammler

Der mentale Aufwand, etwas zu speichern und nicht zu wissen, wo man es findet, wenn man es braucht.

Ich war genervt davon, dass wichtige (und unwichtige – einfach Dinge im Allgemeinen) überall verstreut waren. Ich musste auf ein E-Mail-Konto zugreifen, das ich vor 6 Jahren erstellt hatte, weil es mit einem zufälligen Dienst verknüpft war, auf den ich dringend zugreifen musste, aus keinem besonderen Grund … Jedenfalls wurde mir klar, dass viele Tools trotz ihrer Eigenheiten alle einen sehr wichtigen Aspekt gemeinsam haben: das Speichern von Informationen. Also habe ich ein Tool entwickelt, das sich auf diese spezifische Gemeinsamkeit spezialisiert und die Tools das machen lässt, was sie am besten können.

Ich bin faul, also wollte ich etwas, das einfach funktioniert und meine Gedanken liest, das keinerlei Aufwand erfordert, um einen Eintrag hinzuzufügen oder aus der Wissensdatenbank abzurufen.

Ich habe einmal jrnl heruntergeladen und mochte die Idee sehr, hasste aber die Umsetzung aufgrund einiger seltsamer Parameter. Es hatte buchstäblich keine Trennung von Einträgen und eine Suche, die alles matchte. Dredge ist das, was ich eigentlich wollte. (Also ja, im Grunde ein persönliches Tool)

Mitwirkende

Großen Dank an euch, die ihr zu dredge beigetragen habt:

timcondit

wlad031

Erstellt mit von Luar