dredge-cargo

Isto NÃO é um gerenciador de senhas. NÃO é um aplicativo de notas. E definitivamente NÃO é um registro de proveniência taxonômica de espécimes bentônicos aberrantes do fundo do mar. Mas faz os dois primeiros melhor do que qualquer um. Brincadeira (nem tanto).

Instalar • Início Rápido • Funcionalidades • Comando Link • Comandos • Como Funciona • Segurança • Porquê

"Não me incomode com bagunça comum." — O Peixeiro

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

As funcionalidades legais que você nunca viu antes

• Armazenamento criptografado — Clone o repositório e obtenha um emaranhado criptográfico absoluto. Você não consegue nem saber o que há no repositório sem a senha. (Usei AES-256-GCM + Argon2id)
• Pesquisa instantânea — Criei um algoritmo de busca fuzzy personalizado porque sou preguiçoso e quero a entrada certa entre 300 outras em milissegundos sem ter que pensar nisso.
• Armazene qualquer coisa — notas, scripts, dotfiles, imagens, arquivos zip. Se é um arquivo e existe, pode ser armazenado no dredge.
• Vinculação de arquivo ao vivo — Recurso legal, crie um link simbólico de qualquer item para um caminho do sistema para que você possa ler e editar diretamente ou através do dredge. Qualquer alteração é sincronizada nos dois sentidos com o repositório.
• Com suporte Git — repositório privado que você possui. Então é só fazer git clone e você tem seus dados.
• Senha de sessão — Um prompt por sessão de terminal. Depois disso, você pode usar sem senha até fechar o terminal. (leia a seção de segurança para entender melhor)
• Lixeira + desfazer — itens excluídos vão para a lixeira. Então é só usar dredge undo se excluir acidentalmente.

O que armazenar no dredge?

Não vou te julgar. Chaves de API irritantes que aparecem apenas uma vez, configuração SSH, prompts de IA, senhas, scripts de shell literais que você pode executar, modelos de e-mail?, dotfiles (estranho, mas funciona bem), arquivos zip, lista de filmes, listas de URLs para acesso rápido... Até uma cópia legal do capítulo 2 de Chainsaw Man em japonês. (Eu posso ou não ter essa especificamente)

Instalar

Go

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

Certifique-se de que $GOPATH/bin (geralmente ~/go/bin) está no seu 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/

Início Rápido

# 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

Como funciona

"Não consigo imaginar o que está lá no fundo." — O Guardião do Farol

Ok, então resumindo:

Eu optei por usar duas principais tecnologias criptográficas: Argon2id e, claro, AES-256, mais especificamente a variante GCM.

Argon2id porque é A recomendação da RFC 9106 e o vencedor do PHC 2015. É isso. A variante GCM do AES porque torna todos os dados criptografados impossíveis de adulterar devido à impressão digital. É isso também.

Por enquanto estou armazenando tudo como arquivos criptografados em ~/.local/share/dredge/. Esse diretório também é um repositório git (pelo menos por enquanto). Então dredge push commita e envia tudo para backup. Cada item é um blob criptografado independente com um ID aleatório de 3 caracteres. Decidi que nenhum nome de arquivo deve ser exposto, então mesmo que alguém veja seus arquivos, não tem ideia do que está olhando.

O pipeline de criptografia

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)

Então todo o seu cofre compartilha a mesma chave derivada (isso significa que se você perder sua chave, perde seus dados — por favor, não perca sua chave). Cada item usa a mesma chave, cada um com seu próprio nonce aleatório. Se você criptografar o mesmo conteúdo duas vezes, produz ciphertext completamente diferente.

O que vive onde

~/.local/share/dredge/          ← o cofre (repositório git)
├── .git/
├── .gitignore                  ← exclui .spawned/ e links.json
├── .dredge-key                 ← salt + string de verificação criptografada  
├── items/
│   ├── xKP                     ← item criptografado                       
│   ├── mNq                     ← item criptografado                
│   └── ...
├── .spawned/                   ← cópias em texto plano de itens vinculados   
└── links.json                  ← manifesto de links simbólicos

Então todos os seus arquivos criptografados e .dredge-key estão no repositório git; todos os arquivos em texto plano (aqueles que você decidiu tornar legíveis pelo sistema) nunca serão rastreados. Então faça o que quiser com eles.

Modelo de sessão

Após seu primeiro comando em um terminal, a chave derivada de 32 bytes é armazenada em cache em $XDG_RUNTIME_DIR/dredge/$PPID/.key (acesso apenas root).

Todos os comandos subsequentes do dredge no MESMO terminal usam a chave em cache. Isso significa que você não será solicitado a digitar a senha novamente. Cada terminal tem seu próprio diretório isolado baseado no PID pai. Portanto, a chave é evaporada do disco assim que o terminal morre.

Segurança

"Melhor voltar com uma pequena captura do que não voltar de jeito nenhum." — O Peixeiro

Modelo de ameaça (fiz esta seção com IA, mas está correta)

Alguém clona seu repositório git privado: Eles obtêm blobs criptografados e .dredge-key. O salt não é secreto — seu propósito é tornar ataques de pré-computação impraticáveis. Sem sua senha, os itens são dados binários opacos. Argon2id torna o brute-force offline caro. Use uma senha forte.

Alguém tem acesso à sua sessão ativa: A chave derivada reside em $XDG_RUNTIME_DIR/dredge/$PPID/.key durante a duração daquela sessão de terminal. Cada terminal tem seu próprio diretório isolado — feche o terminal, a chave desaparece. Esse caminho tem escopo de usuário (modo 700) e é suportado por RAM. Um invasor com acesso de leitura ao seu diretório de sessão pode descriptografar seu cofre. Trate isso como qualquer credencial sensível em seu diretório home. Se alguém tem root na sua máquina, sua chave do dredge é a menor das suas preocupações.

Alguém tem acesso físico à sua máquina offline: Os itens no disco estão criptografados. A chave de sessão está em armazenamento suportado por RAM e não sobrevive a uma reinicialização. Itens vinculados (.spawned/) estão em texto plano no disco — veja abaixo.

Onde o texto plano existe

O arquivo gerado (.spawned) é o único texto plano persistente no disco, e ele só existe porque você explicitamente vinculou um item a um caminho do sistema. Todo o resto é apenas em memória.

Riscos

• --password / DREDGE_PASSWORD: Passar sua senha inline a expõe no histórico do shell e na saída do ps. Variáveis de ambiente podem vazar para processos filhos. Evite ambos em ambientes compartilhados.
• --vault / DREDGE_VAULT: Substitui o cofre ativo para um único comando sem persistir a alteração. Útil para scripts em vários cofres.
• Itens vinculados: O texto plano de um item vinculado reside no destino do link simbólico (ex.: ~/.ssh/config). Não é rastreado pelo git, mas está no disco em texto plano.

O comando link

Vincule qualquer item armazenado a um caminho no seu sistema de arquivos:

dredge link <id> ~/.ssh/config

Este comando criará um link simbólico em ~/.ssh/config apontando para uma cópia em texto plano gerenciada pelo dredge (o arquivo é exposto no disco para que você possa usá-lo). Você pode editar o arquivo diretamente ou através de dredge edit ou o que preferir; todas as alterações são sincronizadas de volta para o armazenamento criptografado automaticamente.

Auto-reparo: Se você renomear um link simbólico (ex.: mv ~/.ssh/config ~/.ssh/config-backup), o dredge detecta e rastreia o novo caminho automaticamente. Links simbólicos deletados são limpos na inicialização da sessão.

Em uma nova máquina:

git clone [email protected]:you/vault.git ~/.local/share/dredge
dredge link <id> ~/.ssh/config
# mesma configuração SSH, mesmas chaves, toda máquina rastreada pelo git para qualquer atualização

Esta é na verdade a razão pela qual construí o dredge. Minha configuração SSH é idêntica em todas as máquinas, mas eu não podia simplesmente colocá-las dentro dos meus dotfiles.

Todos os comandos

Sincronização Git (por wlad031)

A sincronização Git usa git puro e funciona com qualquer remoto (GitHub/GitLab/Gitea/etc).

dredge init aceita um remoto git opcional. Se você omiti-lo, o dredge inicializa um repositório git apenas local (sem remoto).

Comportamento de auto-commit: push, pull e sync preservam alterações não commitadas sincronizadas em um commit antes de reconciliar com o remoto. Se você precisar descartar alterações locais para priorizar a versão remota, use dredge drop.

Retenção automática de histórico: push e sync aplicam a política em dredge.toml. Metadados de itens e armazenamento binário têm limites independentes de versão por item e de bytes criptografados, enquanto history.deleted.retain_for controla por quanto tempo IDs deletados permanecem recuperáveis. Se a política não remover nada, o Dredge faz push normalmente. Se for necessária compactação, o Dredge verifica o histórico de substituição e usa um force-with-lease exato; uma atualização remota concorrente para com segurança em vez de ser sobrescrita. pull nunca compacta nem faz force-push.

Inspecione o histórico retido com dredge history, dredge history deleted ou dredge history <id>. Restaure um item criptografado deletado com dredge history restore <id>. Alterações de senha não recriptografam blobs históricos, portanto versões restauradas criadas sob uma senha antiga podem não descriptografar com a senha atual.

Formatos remotos aceitos:

# Abreviação GitHub (expandido para 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 (estilo 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

# Caminho local remoto (avançado)
dredge init /srv/git/dredge-vault.git

• O Dredge não cria repositórios remotos para você.
• Se origin não estiver configurado, dredge push/pull/sync emitirá erro com orientação.
• Se você já tiver um remoto git configurado, dredge init não o sobrescreverá.

Porquê

"Sou um colecionador — de muitas coisas; arte e artefatos, tesouros e verdades... e curiosidades que ocupam a periferia do desejo." — O Colecionador

O custo mental de guardar algo e não saber onde encontrá-lo quando precisa.

Fiquei irritado por ter coisas importantes (e não importantes também, apenas coisas em geral) espalhadas por toda parte, eu teria que acessar uma conta de e-mail que criei há 6 anos porque estava vinculada a um serviço aleatório ao qual precisava acessar urgentemente sem motivo algum... Enfim, percebi que muitas ferramentas, apesar de terem seus truques, todas se sobrepõem em um aspecto muito importante que é armazenar informações, então criei uma ferramenta que se especializa nessa sobreposição específica e deixa as ferramentas fazerem o que fazem de melhor.

Sou preguiçoso, então queria algo que simplesmente funcionasse e lesse minha mente, que não exigisse esforço para adicionar uma entrada nem para recuperá-la da base de conhecimento.

Baixei jrnl uma vez e gostei muito da ideia, mas odiei a execução devido a alguns parâmetros estranhos; literalmente não tinha separação de itens e uma pesquisa que combinava tudo. O Dredge é o que eu realmente queria. (então sim, basicamente uma ferramenta pessoal)

Contribuidores

Muito obrigado a vocês que contribuíram para o dredge:

timcondit

wlad031

Feito com por Luar