deprecatedluar/dredge-cargoCofre CLI criptografado para notas, configurações, chaves e arquivos. Pesquise, não organize.
> 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).
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13610/534f3cc38369a739749d2f98a8e4ec4a1c5df0a0a597aff5295b8cb1e39cc08e.webp" alt="dredge-doge-vs-cheems"/>
[](https://goreportcard.com/report/github.com/DeprecatedLuar/dredge)
[](https://oosmetrics.com/repo/DeprecatedLuar/dredge-cargo)
[](https://go.dev)
<!-- [](https://codecov.io/gh/DeprecatedLuar/dredge-cargo) -->
<div align="center">
[Instalar](#install) • [Início Rápido](#quick-start) • [Funcionalidades](#features) • [Comando Link](#link) • [Comandos](#commands) • [Como Funciona](#how-it-works) • [Segurança](#security) • [Porquê](#why)
</div>
</div>
<div align="center">
Pesquise, não organize. **_Notas, configurações, chaves, segredos_** — cinco segundos a partir do seu terminal.
</div>
<div align="center">
<a href="https://github.com/DeprecatedLuar/dredge-cargo/stargazers">
<img src="https://img.shields.io/github/stars/DeprecatedLuar/dredge-cargo?style=for-the-badge&logo=github&color=1f6feb&logoColor=white&labelColor=black"/>
</a>
<a href="https://github.com/deprecatedluar/dredge-cargo/blob/main/LICENSE">
<img src="https://img.shields.io/github/license/DeprecatedLuar/dredge-cargo?style=for-the-badge&color=green&labelColor=black"/>
</a>
<a href="https://github.com/DeprecatedLuar/dredge-cargo/releases">
<img src="https://img.shields.io/github/v/release/DeprecatedLuar/dredge-cargo?style=for-the-badge&color=orange&labelColor=black"/>
</a>
</div>
---
> *"Não me incomode com bagunça comum."* — O Peixeiro
<div align="center">
<!-- demo gif -->
<img src="https://assets.kitploit.com/production/public/readmes/13610/a31d2a13bfbae4b1b41843137d86ddbc2c38b512972389761eab9dfc3ba6023d.gif" alt="dredge demo" width="800"/>
</div>
```bash
go install github.com/DeprecatedLuar/dredge-cargo/cmd/dredge@latest
```
<div align="right">
[outras opções de instalação ↓](#install)
</div>
---
<h2 id="features"><img height="44" src="https://assets.kitploit.com/production/public/readmes/13610/5e6da8f5d6e3dc6eb114152fb8cc8ee944547f43aa95f2cbb4b7430fde0c08a0.webp"/> As funcionalidades legais que você nunca viu antes</h2>
- **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.
---
<h2><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/21ca061b01116178eca9bbfd0698ebcaf0f63e614165fbc7b904f54508e01836.webp"/> O que armazenar no dredge?</h2>
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)
---
<h2 id="install"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/db2b1ad73c3323b870934910e70cd8249c788b4ffdfaf79b09c75c05c8741937.webp"/> Instalar</h2>
 
### Go
```bash
go install github.com/DeprecatedLuar/dredge-cargo/cmd/dredge@latest
```
Certifique-se de que `$GOPATH/bin` (geralmente `~/go/bin`) está no seu `PATH`.
### Universal
```bash
curl -sSL https://raw.githubusercontent.com/DeprecatedLuar/the-satellite/main/satellite.sh | bash -s -- install DeprecatedLuar/dredge-cargo:dredge
```
<details>
<summary>Outros Métodos de Instalação</summary>
<br>
**Instalação Manual**
1. Baixe o binário para seu SO em [releases](https://github.com/DeprecatedLuar/dredge-cargo/releases)
2. Torne executável: `chmod +x dredge-*`
3. Mova para o PATH: `mv dredge-* ~/.local/bin/dredge`
---
**A partir da Fonte**
```bash
git clone https://github.com/DeprecatedLuar/dredge-cargo
cd dredge-cargo
go build -o dredge ./cmd/dredge
mv dredge ~/.local/bin/
```
</details>
---
<h2 id="quick-start"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/b937e031192b68639bfed048d771e9881136e1d0915985740574b930022b2926.webp"/> Início Rápido</h2>
```bash
# 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
```
<details>
<summary>Uso</summary>
<br>
```bash
# 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
```
</details>
---
<h2 id="how-it-works"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/479f1ebf816d929f37e78e3a97679f47640eb18c52a9f1c129745bdffb7df1be.webp"/> Como funciona</h2>
> *"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.
<details>
<summary>Detalhes técnicos mais profundos</summary>
<br>
**Derivação de chave — Argon2id:** Parâmetros recomendados pela RFC 9106 (64 MB de memória, 4 threads, 1 iteração). O salt em `.dredge-key` não deve ser secreto; ele apenas garante que forçar sua senha por brute-force seja _muito_ caro, mesmo com o arquivo. Sua senha é o que mantém você seguro, então você sabe o que fazer.
**Cifra — AES-256-GCM:** Basicamente, imprime uma impressão digital em cada criptografia. Você obtém confidencialidade e integridade. Adulterar o ciphertext não resultará em lixo; a descriptografia falhará e gritará por socorro.
**Verificação de senha:** `.dredge-key` contém a string `dredge-vault-v1` criptografada com sua chave mestra. Em cada nova sessão, o dredge descriptografa isso para verificar se a senha está correta. Portanto, se você não obtiver `dredge-vault-v1` disso, a senha está errada, então a falha ocorre em ~100ms, em vez de descobrir uma senha errada no meio da operação.
**O que é armazenado em cache:** O arquivo de sessão armazena a chave derivada de 32 bytes (senha + salt), não a senha em si (não sou tão estúpido). Portanto, mesmo que alguém leia `.key` durante uma sessão ativa, não é possível recuperar sua senha a partir dela.
</details>
---
<h2 id="security"><img height="56" src="https://assets.kitploit.com/production/public/readmes/13610/8dd63d36b5812744ccd584320794a580b7e1ee13ac9d33a1af0fa8ef8e364381.webp"/> Segurança</h2>
> *"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
| Local | Quando | Tempo de vida |
|----------|------|---------|
| Apenas RAM | Cada visualização, pesquisa ou edição | Liberado quando o comando termina |
| `$XDG_RUNTIME_DIR/dredge/$PPID/edit-*.txt` | Durante `dredge edit` apenas | Excluído após o editor fechar |
| `~/.local/share/dredge/.spawned/<id>` | Após `dredge link` | Até você executar `dredge unlink` |
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.
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13610/dcc75e764202f8315a3a56114ee19e79a70acd9dcc1094f70031f022e18ad76d.webp" width="700"/>
</div>
<h2 id="link"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/ca14a510c662e4e6a349bbc44aa1eb397d2ded5d06ba7bd7f21f2cca50a0c1bd.webp"/> O comando link</h2>
Vincule qualquer item armazenado a um caminho no seu sistema de arquivos:
```bash
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.
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13610/474132cd19d95d478c40ab360838423dcfcef2033d09f230a8640051dcd08d8e.gif" alt="dredge link demo" width="800"/>
</div>
Em uma nova máquina:
```bash
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.
---
<h2 id="commands"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/8c572a94c96ee031536884f6f6d32202d53ca05943b0b1083ed05b86fad3641a.webp"/> Todos os comandos</h2>
<div align="left">
| Comando | Descrição | Exemplo |
|:--------|:------------|:--------|
| `add` / `a` / `new` / `+` | Adiciona um item (abre editor se não houver flag -c) | `dredge add "OpenAI Key" -c "sk-..." -t keys` |
| `search` / `s` | Pesquisa itens | `dredge search aws key` |
| `list` / `ls` | Lista todos os itens | `dredge ls` |
| `view` / `v` | Visualiza um item | `dredge view xKP` ou `dredge 1` |
| `cat` / `c` | Exibe conteúdo bruto (para pipe) | `dredge cat xKP \| bash` |
| `edit` / `e` | Edita um item | `dredge edit xKP` |
| `rm` | Remove (vai para lixeira) | `dredge rm 1 2 3` |
| `undo` | Restaura o último item removido | `dredge undo` |
| `link` / `ln` | Vincula item a um caminho do sistema | `dredge link xKP ~/.ssh/config` |
| `unlink` | Remove um link | `dredge unlink xKP` |
| `mv` / `rename` | Renomeia ID do item | `dredge mv xKP abc` |
| `export` | Exporta um item de arquivo para o disco | `dredge export xKP ./output/` |
| `copy` / `cp` | Copia conteúdo do item para a área de transferência | `dredge copy xKP` |
| `lock` | Bloqueia o cofre (limpa chave de sessão) | `dredge lock` |
| `init` / `use` | Inicializa ou ativa um cofre | `dredge init ~/vaults/work` |
| `push` / `pull` / `sync` | Sincronização Git (commita alterações automaticamente) | `dredge sync` |
| `drop` | Descarta alterações não commitadas | `dredge drop xKP` ou `dredge drop --all` |
| `status` | Mostra alterações pendentes | `dredge status` |
| `passwd` | Altera a senha do cofre | `dredge passwd` |
| `update` | Atualiza para a versão mais recente | `dredge update` |
</div>
### 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:
```bash
# 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á.
---
<h2 id="why"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/b68b7786d5870a11a1d49137213cb61e51a25165c205d3a99298d7a27a616242.webp"/> Porquê</h2>
<img src="https://assets.kitploit.com/production/public/readmes/13610/23c3be123dc3423443be52804789e0647f1aaa477647cc9945dad19e4fe789a2.webp" alt="dredge logo" align="right" width="200"/>
> *"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](https://jrnl.sh) 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)
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13610/90f2f36bb0ca104704eb98c1ad2711f7c53b008a66ddfc4334e4503986e515b7.webp" width="600"/>
</div>
---
<h2><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/dee19080cbb4c8dc2511711c86f32617b12ee55e34ffc08658215533f7420640.webp"/> Contribuidores</h2>
Muito obrigado a vocês que contribuíram para o dredge:
<table>
<tr>
<td align="center">
<a href="https://github.com/timcondit"><img src="https://assets.kitploit.com/production/public/readmes/13610/5c0d0e21e68f12b1687cb275ffdfa6b84b6b825998061fb623d88640fcd20f10.jpg" width="48" /><br/>timcondit</a>
</td>
<td align="center">
<a href="https://github.com/wlad031"><img src="https://assets.kitploit.com/production/public/readmes/13610/84d9b6594e04f211f09cbf1b128c591c80ac702807a91a75a5973a4bd384c238.jpg" width="48" /><br/>wlad031</a>
</td>
</tr>
</table>
---
<div align="center">
Feito com <img src="https://assets.kitploit.com/production/public/readmes/13610/1838297af83d5d3f60028a5f542ff33ccac6b76e0ebe57671a9d9e9f40ec40a1.webp" height="200" style="vertical-align:middle"/> por Luar
</div>