deprecatedluar/dredge-cargoCifrado CLI bóveda para notas, configuraciones, claves y archivos. Busca, no organices.
> Esto NO es un gestor de contraseñas. NO es una aplicación de notas. Y definitivamente NO es un registro de procedencia taxonómica de especímenes aberrantes bentónicos de aguas profundas. Pero hace las dos primeras mejor que cualquiera de ellas. Es broma (no realmente).
<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) • [Inicio rápido](#quick-start) • [Características](#features) • [El comando Link](#link) • [Comandos](#commands) • [Cómo funciona](#how-it-works) • [Seguridad](#security) • [Por qué](#why)
</div>
</div>
<div align="center">
Busca, no organices. **_Notas, configuraciones, claves, secretos_** — a cinco segundos desde tu 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>
---
> *"No me molestes con basura común."* — El Pescadero
<div align="center">
<!-- demo gif -->
<img src="https://assets.kitploit.com/production/public/readmes/13610/a31d2a13bfbae4b1b41843137d86ddbc2c38b512972389761eab9dfc3ba6023d.gif" alt="demo de dredge" width="800"/>
</div>
```bash
go install github.com/DeprecatedLuar/dredge-cargo/cmd/dredge@latest
```
<div align="right">
[otras opciones de instalación ↓](#install)
</div>
---
<h2 id="features"><img height="44" src="https://assets.kitploit.com/production/public/readmes/13610/5e6da8f5d6e3dc6eb114152fb8cc8ee944547f43aa95f2cbb4b7430fde0c08a0.webp"/> Las características interesantes que nunca has visto antes</h2>
- **Almacenamiento cifrado** — Clona el repositorio y obtén galimatías críptico absoluto. Ni siquiera puedes saber qué hay en el repositorio sin la contraseña. (Usé AES-256-GCM + Argon2id)
- **Búsqueda instantánea** — Hice un algoritmo de búsqueda difusa personalizado porque soy vago y quiero la entrada correcta entre 300 otras en milisegundos sin tener que pensar en ello.
- **Almacena cualquier cosa** — notas, scripts, dotfiles, imágenes, archivos zip. Si es un archivo y existe, se puede almacenar en dredge.
- **Enlace de archivos en vivo** — Característica genial, enlaza simbólicamente cualquier elemento a una ruta del sistema para que puedas leer y editar directamente o a través de dredge. Cualquier cambio se sincroniza en ambos sentidos con el repositorio.
- **Respaldado por Git** — repositorio privado que posees. Así que solo `git clone` y tienes tus datos.
- **Contraseña de sesión** — Una solicitud por sesión de terminal. Después de eso, puedes usar sin contraseña hasta que mates la terminal. (lee la sección de seguridad para entender mejor)
- **Papelera + deshacer** — los elementos eliminados van a la papelera. Así que solo usa `dredge undo` si eliminas accidentalmente.
---
<h2><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/21ca061b01116178eca9bbfd0698ebcaf0f63e614165fbc7b904f54508e01836.webp"/> ¿Qué almacenar en dredge?</h2>
No te juzgaré. Claves API molestas que se muestran solo una vez, configuración SSH, prompts de IA, contraseñas, scripts de shell literales que puedes ejecutar, ¿plantillas de correo electrónico?, dotfiles (raro pero funcionará bien), archivos zip, lista de películas, listas de URLs para acceso rápido...
Incluso una copia _legal_ de Chainsaw Man capítulo 2 en japonés. (Puede que tenga esa específicamente)
---
<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
```
Asegúrate de que `$GOPATH/bin` (normalmente `~/go/bin`) esté en tu `PATH`.
### Universal
```bash
curl -sSL https://raw.githubusercontent.com/DeprecatedLuar/the-satellite/main/satellite.sh | bash -s -- install DeprecatedLuar/dredge-cargo:dredge
```
<details>
<summary>Otros métodos de instalación</summary>
<br>
**Instalación manual**
1. Descarga el binario para tu sistema operativo desde [releases](https://github.com/DeprecatedLuar/dredge-cargo/releases)
2. Hazlo ejecutable: `chmod +x dredge-*`
3. Muévelo al PATH: `mv dredge-* ~/.local/bin/dredge`
---
**Desde fuente**
```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"/> Inicio rápido</h2>
```bash
# Inicializa con un remoto git existente
dredge init yourusername/vault # Abreviatura de GitHub
# o: dredge init [email protected]:you/vault.git
# Añade tu primer elemento
dredge add "OpenAI Key" -c "sk-..." -t keys api # abre el editor sin la bandera -c
# Búscalo
dredge search openai
# Empuja a git
dredge push
```
<details>
<summary>Uso</summary>
<br>
```bash
# Añade cualquier cosa
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 # archivos binarios también :D
# Búsqueda — solo escribe lo que recuerdes
dredge search prompt
dredge search aws key
dredge search ssh
# Ver, editar, eliminar
dredge view <id>
dredge edit <id>
dredge rm <id>
dredge undo # lo recuperó
# Los resultados de búsqueda están numerados — solo escribe el número para ver
dredge search ssh # muestra: 1. [xKP] SSH Config 2. [mNq] SSH Key
dredge 1 # lo ve directamente
# Sincronización Git
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"/> Cómo funciona</h2>
> *"No puedo imaginar qué hay ahí abajo en las profundidades."* — El Guardián del Faro
Bien, para resumir:
Me decidí por usar dos tecnologías criptográficas principales: Argon2id y, por supuesto, AES-256, más específicamente la variante GCM.
Argon2id porque es LA recomendación del RFC 9106 y el ganador del PHC de 2015. Eso es todo.
La variante GCM de AES porque hace que todos los datos cifrados sean imposibles de manipular debido a la huella digital. Eso es todo también.
Por ahora, almaceno todo como archivos cifrados en `~/.local/share/dredge/`. Ese directorio también es un repositorio git (al menos por ahora). Así que `dredge push` confirma y empuja todo para respaldo. Cada elemento es un blob cifrado independiente con un ID aleatorio de 3 caracteres. Decidí que ningún nombre de archivo debería exponerse, así que incluso si alguien puede ver tus cosas, no tiene idea de qué está mirando.
### El pipeline de cifrado
```
Tu contraseña
+ sal aleatorio de 16 bytes ← la sal se almacena en .dredge-key
→ Argon2id (64 MB de memoria · 4 hilos · 1 iteración)
→ clave maestra de 32 bytes (sal + contraseña = la clave real)
Clave maestra + contenido del elemento (TOML: título, etiquetas, contenido)
→ AES-256-GCM con un nuevo nonce aleatorio de 12 bytes por operación
→ [12B nonce][cifrado + 16B etiqueta de autenticación]
→ se escribe en disco como items/xKP (ID aleatorio, sin extensión)
```
Por lo tanto, toda tu bóveda comparte la misma clave derivada (esto significa que si pierdes tu clave, pierdes tus datos, por favor no pierdas tu clave). Cada elemento usa la misma clave, cada uno con su propio nonce aleatorio. Si cifras el mismo contenido dos veces, produce un texto cifrado completamente diferente básicamente.
### Qué vive dónde
```
~/.local/share/dredge/ ← la bóveda (repositorio git)
├── .git/
├── .gitignore ← excluye .spawned/ y links.json
├── .dredge-key ← sal + cadena de verificación cifrada
├── items/
│ ├── xKP ← elemento cifrado
│ ├── mNq ← elemento cifrado
│ └── ...
├── .spawned/ ← copias en texto plano de elementos enlazados
└── links.json ← manifiesto de enlaces simbólicos
```
Así que todos tus archivos cifrados y `.dredge-key` se almacenan en el repositorio git, todos los archivos de texto plano (los que decidiste hacer legibles por el sistema) nunca serán rastreados. Así que haz lo que quieras con ellos.
### Modelo de sesión
Después de tu primer comando en una terminal, la clave derivada de 32 bytes se almacena en caché en `$XDG_RUNTIME_DIR/dredge/$PPID/.key` (solo acceso root)
Todos los comandos posteriores de dredge en la MISMA terminal usan la clave almacenada en caché. Lo que significa que no se te pedirá contraseña de nuevo. Cada terminal obtiene su propio directorio aislado basado en el PID padre. Por lo tanto, la clave se evapora del disco una vez que la terminal muere.
<details>
<summary>Detalles técnicos más profundos</summary>
<br>
**Derivación de clave — Argon2id:** Parámetros recomendados por RFC 9106 (64 MB de memoria, 4 hilos, 1 iteración). La sal en `.dredge-key` no se supone que sea un secreto; solo asegura que la fuerza bruta de tu contraseña sea _muy_ costosa incluso con el archivo. Tu contraseña es lo que te mantiene seguro, así que ya sabes qué hacer.
**Cifrado — AES-256-GCM:** Básicamente, imprime huellas dactilares en cada cifrado. Obtienes tanto confidencialidad como integridad. Manipular el texto cifrado no se descifrará como basura, el descifrado fallará y pedirá ayuda.
**Verificación de contraseña:** `.dredge-key` contiene la cadena `dredge-vault-v1` cifrada con tu clave maestra. En cada nueva sesión, dredge descifra esto para verificar si la contraseña es correcta. Así que si no obtienes `dredge-vault-v1` de ello, la contraseña es incorrecta, por lo que falla en ~100 ms en lugar de descubrir una contraseña incorrecta a mitad de operación.
**Lo que se almacena en caché:** El archivo de sesión almacena la clave derivada de 32 bytes (contraseña + sal), no la contraseña en sí (no soy tan estúpido). Así que incluso si alguien lee `.key` durante una sesión activa, no puede recuperar tu contraseña de él.
</details>
---
<h2 id="security"><img height="56" src="https://assets.kitploit.com/production/public/readmes/13610/8dd63d36b5812744ccd584320794a580b7e1ee13ac9d33a1af0fa8ef8e364381.webp"/> Seguridad</h2>
> *"Mejor volver con una captura pequeña que no volver en absoluto."* — El Pescadero
### Modelo de amenaza (hice esta sección con IA pero es correcta)
**Alguien clona tu repositorio git privado:**
Obtienen blobs cifrados y `.dredge-key`. La sal no es secreta — su propósito es hacer que los ataques de precomputación sean poco prácticos. Sin tu contraseña, los elementos son datos binarios opacos. Argon2id hace que la fuerza bruta fuera de línea sea costosa. Usa una contraseña fuerte.
**Alguien tiene acceso a tu sesión en ejecución:**
La clave derivada vive en `$XDG_RUNTIME_DIR/dredge/$PPID/.key` durante la duración de esa sesión de terminal. Cada terminal obtiene su propio directorio aislado — cierra la terminal, la clave desaparece. Esa ruta tiene ámbito de usuario (modo 700) y está respaldada por RAM. Un atacante con acceso de lectura a tu directorio de sesión puede descifrar tu bóveda. Trátalo como cualquier credencial sensible en tu directorio personal. Si alguien tiene acceso root a tu máquina, tu clave de dredge es la menor de tus preocupaciones.
**Alguien tiene acceso físico a tu máquina apagada:**
Los elementos en disco están cifrados. La clave de sesión está en almacenamiento respaldado por RAM y no sobrevive a un reinicio. Los elementos enlazados (`.spawned/`) están en texto plano en disco — ver abajo.
### Dónde existe el texto plano
| Ubicación | Cuándo | Duración |
|:----------|:-------|:---------|
| Solo RAM | Cada vista, búsqueda o edición | Liberado cuando el comando sale |
| `$XDG_RUNTIME_DIR/dredge/$PPID/edit-*.txt` | Durante `dredge edit` solo | Eliminado después de que el editor cierra |
| `~/.local/share/dredge/.spawned/<id>` | Después de `dredge link` | Hasta que ejecutes `dredge unlink` |
El archivo spawn es el único texto plano persistente en disco, y solo existe porque enlazaste explícitamente un elemento a una ruta del sistema. Todo lo demás es solo en memoria.
### Advertencias
- **`--password` / `DREDGE_PASSWORD`:** Pasar tu contraseña en línea la expone en el historial del shell y en la salida de `ps`. Las variables de entorno pueden filtrarse a procesos hijos. Evítalo en entornos compartidos.
- **`--vault` / `DREDGE_VAULT`:** Sobrescribe la bóveda activa para un solo comando sin persistir el cambio. Útil para scripting a través de múltiples bóvedas.
- **Elementos enlazados:** El texto plano de un elemento enlazado vive en el destino del enlace simbólico (p. ej., `~/.ssh/config`). No está rastreado por git, pero está en disco en 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"/> El comando link</h2>
Enlaza cualquier elemento almacenado a una ruta en tu sistema de archivos:
```bash
dredge link <id> ~/.ssh/config
```
Este comando creará un enlace simbólico en `~/.ssh/config` apuntando a una copia en texto plano que dredge gestiona (el archivo se expone al disco para que puedas usarlo). Puedes editar el archivo directamente o mediante `dredge edit` o lo que te apetezca, todos los cambios se sincronizan automáticamente con el almacén cifrado.
**Autorreparación:** Si renombras un enlace simbólico (p. ej., `mv ~/.ssh/config ~/.ssh/config-backup`), dredge detecta y rastrea la nueva ruta automáticamente. Los enlaces simbólicos eliminados se limpian al inicio de la sesión.
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/13610/474132cd19d95d478c40ab360838423dcfcef2033d09f230a8640051dcd08d8e.gif" alt="demo de enlace de dredge" width="800"/>
</div>
En una máquina nueva:
```bash
git clone [email protected]:you/vault.git ~/.local/share/dredge
dredge link <id> ~/.ssh/config
# misma configuración SSH, mismas claves, cada máquina rastreada por git para cualquier actualización
```
Esta es _en realidad_ la razón por la que construí dredge. Mi configuración SSH es idéntica en cada máquina, pero no podía simplemente ponerlas dentro de mis dotfiles.
---
<h2 id="commands"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/8c572a94c96ee031536884f6f6d32202d53ca05943b0b1083ed05b86fad3641a.webp"/> Todos los comandos</h2>
<div align="left">
| Comando | Descripción | Ejemplo |
|:--------|:------------|:--------|
| `add` / `a` / `new` / `+` | Añadir un elemento (abre editor si no hay bandera -c) | `dredge add "OpenAI Key" -c "sk-..." -t keys` |
| `search` / `s` | Buscar elementos | `dredge search aws key` |
| `list` / `ls` | Listar todos los elementos | `dredge ls` |
| `view` / `v` | Ver un elemento | `dredge view xKP` o `dredge 1` |
| `cat` / `c` | Mostrar contenido sin procesar (para tuberías) | `dredge cat xKP \| bash` |
| `edit` / `e` | Editar un elemento | `dredge edit xKP` |
| `rm` | Eliminar (va a la papelera) | `dredge rm 1 2 3` |
| `undo` | Restaurar el último elemento eliminado | `dredge undo` |
| `link` / `ln` | Enlazar elemento a una ruta del sistema | `dredge link xKP ~/.ssh/config` |
| `unlink` | Eliminar un enlace | `dredge unlink xKP` |
| `mv` / `rename` | Renombrar ID de elemento | `dredge mv xKP abc` |
| `export` | Exportar un elemento de archivo al disco | `dredge export xKP ./output/` |
| `copy` / `cp` | Copiar contenido del elemento al portapapeles | `dredge copy xKP` |
| `lock` | Bloquear la bóveda (limpia la clave de sesión) | `dredge lock` |
| `init` / `use` | Inicializar o activar una bóveda | `dredge init ~/vaults/work` |
| `push` / `pull` / `sync` | Sincronización Git (confirma cambios automáticamente) | `dredge sync` |
| `drop` | Descartar cambios no confirmados | `dredge drop xKP` o `dredge drop --all` |
| `status` | Mostrar cambios pendientes | `dredge status` |
| `passwd` | Cambiar contraseña de la bóveda | `dredge passwd` |
| `update` | Actualizar a la última versión | `dredge update` |
</div>
### Sincronización Git (por wlad031)
La sincronización Git usa `git` simple y funciona con cualquier remoto (GitHub/GitLab/Gitea/etc).
`dredge init` acepta un remoto git opcional. Si lo omites, dredge inicializa un repositorio git solo local (sin remoto).
**Comportamiento de auto-confirmación:** `push`, `pull` y `sync` preservan los cambios no confirmados sincronizados en una confirmación antes de reconciliar con el remoto. Si necesitas descartar cambios locales para priorizar la versión remota, usa `dredge drop`.
**Retención automática del historial:** `push` y `sync` aplican la política en `dredge.toml`. Los metadatos del elemento y el almacenamiento binario tienen límites independientes de versión por elemento y de bytes cifrados, mientras que `history.deleted.retain_for` controla cuánto tiempo los IDs eliminados permanecen recuperables. Si la política no elimina nada, Dredge empuja normalmente. Si se necesita compactación, Dredge verifica el historial de reemplazo y usa un force-with-lease exacto; una actualización remota concurrente se detiene de manera segura en lugar de sobrescribirse. `pull` nunca compacta ni hace force-push.
Inspecciona el historial retenido con `dredge history`, `dredge history deleted` o `dredge history <id>`. Restaura un elemento cifrado eliminado con `dredge history restore <id>`. Los cambios de contraseña no vuelven a cifrar los blobs históricos, por lo que las versiones restauradas creadas con una contraseña anterior pueden no descifrarse con la contraseña actual.
Formatos de remoto aceptados:
```bash
# Abreviatura de GitHub (se expande a https://github.com/<propietario>/<repositorio>.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
# Ruta local remota (avanzado)
dredge init /srv/git/dredge-vault.git
```
- Dredge no crea repositorios remotos por ti.
- Si `origin` no está configurado, `dredge push`/`pull`/`sync` fallará con orientación.
- Si ya tienes un remoto git configurado, `dredge init` no lo sobrescribirá.
---
<h2 id="why"><img height="32" src="https://assets.kitploit.com/production/public/readmes/13610/b68b7786d5870a11a1d49137213cb61e51a25165c205d3a99298d7a27a616242.webp"/> Por qué</h2>
<img src="https://assets.kitploit.com/production/public/readmes/13610/23c3be123dc3423443be52804789e0647f1aaa477647cc9945dad19e4fe789a2.webp" alt="logo de dredge" align="right" width="200"/>
> *"Soy un coleccionista — de muchas cosas; arte y artefactos, tesoros y verdades... y curiosidades que ocupan la periferia del deseo."* — El Coleccionista
El esfuerzo mental de guardar algo y no saber dónde encontrarlo cuando lo necesitas.
Me harté de tener cosas importantes (y no importantes también, solo cosas en general) esparcidas por todas partes, tendría que acceder a una cuenta de correo que creé hace 6 años porque estaba vinculada a un servicio aleatorio al que necesitaba acceder urgentemente sin razón alguna... En fin, me di cuenta de que muchas herramientas, a pesar de tener sus trucos, todas coinciden en un aspecto muy importante que es almacenar información, así que hice una herramienta que se especializa en _ese_ solapamiento específico y deja que las herramientas hagan lo que mejor saben hacer.
Soy vago, así que quería algo que simplemente funcionara y leyera mi mente, que no requiriera esfuerzo para añadir una entrada ni para recuperarla de la base de conocimiento.
Descargué [jrnl](https://jrnl.sh) una vez y me gustó mucho la idea pero odié la ejecución debido a algunos parámetros extraños; literalmente no tenía separación de elementos y una búsqueda que coincidía con *todo*. Dredge es lo que realmente quería. (así que sí, básicamente una herramienta personal)
<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"/> Contribuyentes</h2>
Muchas gracias a ustedes que contribuyeron a 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">
Hecho con <img src="https://assets.kitploit.com/production/public/readmes/13610/1838297af83d5d3f60028a5f542ff33ccac6b76e0ebe57671a9d9e9f40ec40a1.webp" height="200" style="vertical-align:middle"/> por Luar
</div>