dredge-cargo v0.11.1

Questo NON è un password manager. NON è un'app per appunti. E sicuramente NON è un registro tassonomico di provenienza di esemplari aberranti bentonici di acque profonde. Ma fa le prime due cose meglio di entrambi. Sto scherzando (non proprio).

Installa • Avvio rapido • Funzionalità • Il comando Link • Comandi • Come funziona • Sicurezza • Perché

"Non infastidirmi con il caos comune." — Il Pesciaiolo

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

Le fantastiche funzionalità che non hai mai visto prima

• Archiviazione crittografata — Clona il repository e ottieni un assoluto gergo criptico. Non puoi nemmeno capire cosa c'è nel repository senza la password. (Ho usato AES-256-GCM + Argon2id)
• Ricerca istantanea — Ho creato un algoritmo di ricerca fuzzy personalizzato perché sono pigro e voglio la voce giusta tra 300 altre in millisecondi senza doverci pensare.
• Archivia qualsiasi cosa — note, script, dotfile, immagini, archivi zip. Se è un file ed esiste, può essere archiviato in dredge.
• Collegamento live dei file — Funzionalità interessante, collega simbolicamente qualsiasi elemento a un percorso di sistema in modo da poterlo leggere e modificare direttamente o tramite dredge. Qualsiasi modifica si sincronizza in entrambe le direzioni con il repository.
• Basato su Git — repository privato di tua proprietà. Quindi basta git clone e hai i tuoi dati.
• Password di sessione — Un prompt per sessione terminale. Dopodiché, puoi usare senza password finché non uccidi il terminale. (leggi la sezione sulla sicurezza per capire meglio)
• Cestino + annulla — gli elementi eliminati vanno nel cestino. Quindi basta usare dredge undo se elimini accidentalmente.

Cosa archiviare in dredge?

Non ti giudicherò. Fastidiose chiavi API che appaiono solo una volta, configurazione SSH, prompt AI, password, script shell veri e propri che puoi eseguire, template email?, dotfile (strano ma funzionerà bene), archivi zip, lista di film, elenchi di URL per accesso rapido...

Anche una copia legale del capitolo 2 di Chainsaw Man in giapponese. (Potrei averlo o meno, quello specifico)

Installa

Go

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

Assicurati che $GOPATH/bin (di solito ~/go/bin) sia nel tuo PATH.

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/

Avvio rapido

# 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

Come funziona

"Non riesco a immaginare cosa ci sia laggiù nelle profondità." — Il Guardiano del Faro

Ok, per riassumere: ho deciso di utilizzare due principali tecnologie crittografiche: Argon2id e ovviamente AES-256, più specificamente la variante GCM. Argon2id perché è LA raccomandazione dell'RFC 9106 e vincitore del PHC 2015. Questo è tutto. La variante GCM di AES perché rende tutti i dati crittografati impossibili da manomettere grazie all'impronta digitale. Anche questo è tutto.

Per ora sto archiviando tutto come file crittografati in ~/.local/share/dredge/. Quella directory è anche un repository git (almeno per ora). Quindi dredge push committa e invia tutto per il backup. Ogni elemento è un blob crittografato autonomo con un ID casuale di 3 caratteri. Ho deciso che nessun nome di file dovrebbe essere esposto, così anche se qualcuno può vedere i tuoi file, non ha idea di cosa stia guardando.

Il pipeline di crittografia

Your password
  + 16-byte random salt  ← the salt is stored in .dredge-key
  → Argon2id (64 MB memory · 4 threads · 1 iteration)
  → 32-byte master key (salt + password = the real key)

Master key + item content (TOML: title, tags, content)
  → AES-256-GCM with a fresh random 12-byte nonce per operation
  → [12B nonce][ciphertext + 16B auth tag]
  → written to disk as items/xKP  (random ID, no extension)

Quindi l'intero vault condivide la stessa chiave derivata (ciò significa che se perdi la chiave perdi i tuoi dati, per favore non perdere la chiave). Ogni elemento usa la stessa chiave, ciascuno con il proprio nonce casuale. Se crittografi due volte lo stesso contenuto, produce fondamentalmente ciphertext completamente diversi.

Cosa vive dove

~/.local/share/dredge/          ← the vault (git repo)
├── .git/
├── .gitignore                  ← excludes .spawned/ and links.json
├── .dredge-key                 ← salt + encrypted verification string  
├── items/
│   ├── xKP                     ← encrypted item                       
│   ├── mNq                     ← encrypted item                
│   └── ...
├── .spawned/                   ← plaintext copies of linked items   
└── links.json                  ← symlink manifest

Quindi tutti i tuoi file crittografati e .dredge-key sono archiviati nel repository git, tutti i file in testo semplice (quelli che hai deciso di rendere leggibili dal sistema) non verranno mai tracciati. quindi fanne quello che vuoi.

Modello di sessione

Dopo il primo comando in un terminale, la chiave derivata di 32 byte viene memorizzata nella cache in $XDG_RUNTIME_DIR/dredge/$PPID/.key (solo accesso root). Tutti i successivi comandi dredge nello STESSO terminale usano la chiave cache. Ciò significa che non ti verrà più richiesta la password. Ogni terminale ottiene la propria directory isolata basata sul PID genitore. Quindi la chiave svanisce dal disco appena il terminale muore.

Sicurezza

"Meglio tornare con un piccolo pescato che non tornare affatto." — Il Pesciaiolo

Modello di minaccia (ho fatto questa sezione con l'AI ma è corretta)

Qualcuno clona il tuo repository git privato: Ottengono blob crittografati e .dredge-key. Il salt non è segreto — il suo scopo è rendere impraticabili gli attacchi di precomputazione. Senza la tua password, gli elementi sono dati binari opachi. Argon2id rende costosa la forza bruta offline. Usa una password forte.

Qualcuno ha accesso alla tua sessione in esecuzione: La chiave derivata vive in $XDG_RUNTIME_DIR/dredge/$PPID/.key per la durata di quella sessione terminale. Ogni terminale ottiene la propria directory isolata — chiudi il terminale, la chiave è sparita. Quel percorso è limitato all'utente (modalità 700) e supportato da RAM. Un attaccante con accesso in lettura alla tua directory di sessione può decifrare il tuo vault. Trattalo come qualsiasi credenziale sensibile nella tua home directory. Se qualcuno ha root sulla tua macchina, la tua chiave dredge è l'ultimo dei tuoi problemi.

Qualcuno ha accesso fisico alla tua macchina offline: Gli elementi su disco sono crittografati. La chiave di sessione è in storage supportato da RAM e non sopravvive a un riavvio. Gli elementi collegati (.spawned/) sono in testo semplice su disco — vedi sotto.

Dove esiste il testo semplice

Il file spawnato è l'unico testo semplice persistente su disco, ed esiste solo perché hai collegato esplicitamente un elemento a un percorso di sistema. Tutto il resto è solo in memoria.

Avvertenze

• --password / DREDGE_PASSWORD: Passare la password inline la espone nella cronologia della shell e nell'output di ps. Le variabili d'ambiente possono essere esposte ai processi figli. Evita entrambi in ambienti condivisi.
• --vault / DREDGE_VAULT: Sovrascrivi il vault attivo per un singolo comando senza rendere persistente la modifica. Utile per script su più vault.
• Elementi collegati: Il testo semplice di un elemento collegato vive nella destinazione del symlink (es. ~/.ssh/config). Non è tracciato da git, ma è su disco in testo semplice.

Il comando link

Collega qualsiasi elemento archiviato a un percorso sul tuo filesystem:

dredge link <id> ~/.ssh/config

Questo comando creerà un symlink in ~/.ssh/config che punta a una copia in testo semplice gestita da dredge (il file viene esposto su disco così puoi usarlo). Puoi modificare il file direttamente o tramite dredge edit o come preferisci, tutte le modifiche si sincronizzano automaticamente con l'archivio crittografato.

Auto-riparazione: Se rinomini un symlink (es. mv ~/.ssh/config ~/.ssh/config-backup), dredge rileva e traccia automaticamente il nuovo percorso. I symlink eliminati vengono puliti all'avvio della sessione.

Su una nuova macchina:

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

Questa è effettivamente la ragione per cui ho costruito dredge. La mia configurazione SSH è identica su ogni macchina, ma non potevo semplicemente metterli dentro i miei dotfile.

Tutti i comandi

Sincronizzazione Git (da wlad031)

La sincronizzazione Git usa git semplice e funziona con qualsiasi remote (GitHub/GitLab/Gitea/ecc.).

dredge init accetta un remote git opzionale. Se lo ometti, dredge inizializza un repo git solo locale (nessun remote).

Comportamento auto-commit: push, pull e sync preservano le modifiche non committate sincronizzate in un commit prima di riconciliare con il remote. Se devi scartare le modifiche locali per dare priorità alla versione remota, usa dredge drop.

Conservazione automatica della cronologia: push e sync applicano la politica in dredge.toml. I metadati dell'elemento e lo storage binario hanno limiti indipendenti per versione dell'elemento e byte crittografati, mentre history.deleted.retain_for controlla per quanto tempo gli ID eliminati rimangono recuperabili. Se la politica non rimuove nulla, Dredge esegue il push normalmente. Se è necessaria una compattazione, Dredge verifica la cronologia di sostituzione e utilizza un esatto force-with-lease; un aggiornamento remoto concorrente si ferma in sicurezza invece di essere sovrascritto. pull non compatta mai né force-push.

Ispeziona la cronologia conservata con dredge history, dredge history deleted o dredge history <id>. Ripristina un elemento crittografato eliminato con dredge history restore <id>. I cambi di password non ricrittografano i blob storici, quindi le versioni ripristinate create con una password più vecchia potrebbero non decifrare con la password corrente.

Formati remote accettati:

# 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 non crea repository remoti per te.
• Se origin non è configurato, dredge push/pull/sync restituiranno un errore con indicazioni.
• Se hai già un remote git impostato, dredge init non lo sovrascriverà.

Perché

"Sono un collezionista — di molte cose; arte e manufatti, tesori e verità... e curiosità che occupano la periferia del desiderio." — Il Collezionista

Il sovraccarico mentale di salvare qualcosa e non sapere dove trovarlo quando ti serve.

Mi sono stufato di avere cose importanti (e non importanti, solo cose in generale) sparse ovunque, dovevo accedere a un account email creato 6 anni fa perché era collegato a un servizio casuale a cui dovevo urgentemente accedere per nessuna ragione... Comunque, ho realizzato che molti strumenti, nonostante i loro trucchi, si sovrappongono su un aspetto molto importante, ovvero l'archiviazione delle informazioni, così ho creato uno strumento specializzato in quella specifica sovrapposizione e lascia gli strumenti fare ciò che sanno fare meglio.

Sono pigro, quindi volevo qualcosa che funzionasse e leggesse nella mia mente, senza sforzo per aggiungere una voce o recuperarla dalla base di conoscenza.

Una volta ho scaricato jrnl e l'idea mi è piaciuta molto ma ho odiato l'esecuzione a causa di alcuni parametri strani, non aveva letteralmente separazione degli elementi e una ricerca che corrispondeva a tutto. Dredge è quello che volevo veramente. (quindi sì, praticamente uno strumento personale)

Contributori

Un grande grazie a voi ragazzi che avete contribuito a dredge:

timcondit

wlad031

Realizzato con da Luar