@dotrino/vaultd 0.38.0 → 0.49.0

package/README.md

@@ -73,7 +73,7 @@ solo de qué cert se emitió un día.
 
 ```sh
 dotrino-vault members            # el acta: qué llaves son tuyas y qué puede hacer cada una
-dotrino-vault caps <ID> +firma   # cambia permisos (+firma -guarda +lee …)
+dotrino-vault caps <ID> +firma   # cambia permisos (+firma -guarda +lee +administra +aprueba …)
 ```
 
 **Los certificados caducan y se renuevan solos.** Un cert dura **30 días**. Mientras
@@ -235,10 +235,14 @@ dotrino-vault approve <código>     # aprueba tecleando los 6 dígitos que MUEST
 dotrino-vault reject  <deviceId>   # rechaza un dispositivo pendiente
 dotrino-vault devices              # lista dispositivos enrolados / revocados
 dotrino-vault members              # el acta del perfil: qué llaves son tuyas y qué puede cada una
-dotrino-vault caps <ID> ±permiso   # cambia lo que puede un dispositivo (+firma -guarda +lee …)
+dotrino-vault caps <ID> ±permiso   # cambia lo que puede un dispositivo (+firma -guarda +lee +administra +aprueba …)
 dotrino-vault revoke  <nonce>      # revoca un dispositivo (le ordena autoborrarse)
 dotrino-vault activity [n]         # bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
 dotrino-vault pair --service <ns>  # empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
+dotrino-vault pair --scope <lista>  # los PERMISOS del cert: sign,read,store,secrets:<ns>. Sin esto, sign,read,store.
+dotrino-vault secret policy <ns> approval on|off   # el cajón pide tu aprobación en cada lectura (15 min de ventana)
+                                    # Se combina con --service: `--service eco --scope sign` = un bot que firma
+                                    # como aparato del acta y lee SOLO su cajón. `admin` no se empareja (caps).
 dotrino-vault secret set <ns> <CLAVE> <valor>   # variable del SCOPE: la comparten todos los
                                                 # aparatos que sirven ese namespace
 dotrino-vault secret set <ns> CLAVE=valor CLAVE2=valor2 …   # VARIAS de una vez (un solo aviso)
@@ -313,7 +317,7 @@ dos.
 ```sh
 dotrino-vault secret set web PUBLIC_URL https://ejemplo.com --public
 dotrino-vault secret set web API_KEY sk-…              # sin bandera: privada
-dotrino-vault secret visibility web PUBLIC_URL private # cambiarlo sin tocar el valor
+dotrino-vault secret visibility web PUBLIC_URL private # taparla sin tocar el valor (privada → pública no existe)
 ```
 
 - **Se nace privada.** Y **rotar el valor conserva la visibilidad**: exponer un secreto
@@ -752,6 +756,47 @@ CLI de apoyo: `dotrino-env status` (qué hay enrolado aquí), `dotrino-env check
 los secretos en el entorno de un proceso que no es Node). Primer consumidor:
 `dotrino-proxy` (TURN de Cloudflare).
 
+### Aprobación por uso (el teléfono dice que sí) y la llave SSH en el teléfono
+
+Un cajón puede exigir el **visto bueno de un aparato** en cada lectura: para lo que corre
+en tu PC (un asistente, un script) y no debería llevarse tus claves sin que lo sepas.
+
+```sh
+dotrino-vault caps <ID-del-teléfono> +aprueba       # quién aprueba (no viaja en un QR)
+dotrino-vault secret policy claude approval on       # el cajón «claude» espera el sí
+dotrino-env run --ns claude -- node mi-script.js     # el proceso se queda esperando…
+```
+
+…la bóveda apunta el pedido, avisa al teléfono (cola del proxio → aviso nativo), y solo su
+firma entrega las claves — **al proceso que pidió, en memoria**, con una **ventana de
+15 min** por aparato y cajón para no pedir veinte veces. Lo denegado corta sin reintentos;
+lo que nadie atiende vence a los 5 min; todo queda en `dotrino-vault activity`.
+
+**La llave SSH vive en el teléfono.** El daemon expone un **agente SSH** (protocolo de
+`ssh-agent`, socket en `$XDG_RUNTIME_DIR/dotrino-vault/ssh-agent.sock`) que **no guarda
+ninguna llave privada**: la llave nace en el teléfono (vault.dotrino.com → *Llave SSH de
+este aparato*; WebCrypto no extraíble, `ecdsa-sha2-nistp256`) y cada firma es un pedido
+que apruebas ahí. En el PC no queda nada que copiar.
+
+```sh
+dotrino-vault ssh                 # imprime el export SSH_AUTH_SOCK=… y la receta
+dotrino-vault ssh keys            # las llaves registradas (= ssh-add -L)
+ssh mi-servidor                   # el teléfono pide tu «sí» y firma
+```
+
+**La bóveda puede estar en OTRA máquina** (la de Dotrino en el VPS): en tu PC corre el
+agente **delgado**, que no custodia nada y reenvía cada reto como un pedido a la bóveda
+que enroló ese servicio:
+
+```sh
+dotrino-env enroll --ns claude                   # una vez, contra la bóveda que sea
+dotrino-env ssh-agent --ns claude                # imprime export SSH_AUTH_SOCK=…
+```
+
+Para no aprobar cada comando, reusa la conexión con `ControlMaster auto` +
+`ControlPersist 15m` en `~/.ssh/config`: esa es la ventana de 15 min del SSH.
+`DOTRINO_VAULT_SSH_AGENT=0` apaga el agente.
+
 ## Alcance
 
 - **v1 (este):** daemon headless en Node, **multi-perfil**. En **Linux** queda como

package/lib/README.md

@@ -279,3 +279,10 @@ cert de una máquina vigente: sin esto toda máquina enrolada caducaba a los 30
 | bitácora, cifrado en reposo, candado, multi-perfil | son del daemon; en el navegador dependen de `@dotrino/identity` |
 
 MIT · parte de [Dotrino](https://dotrino.com).
+
+## Agente SSH delgado (`dotrino-env ssh-agent`)
+
+La llave SSH vive en el teléfono del dueño (registrada en su bóveda). En esta máquina solo
+corre un agente `ssh-agent` sin llaves: cada `SIGN_REQUEST` viaja a la bóveda como un
+pedido que el teléfono aprueba firmando. `dotrino-env ssh-agent --ns <ns>` imprime el
+`SSH_AUTH_SOCK`. Como librería: `listSshKeys(args)` y `requestSshSign(args, { keyId, data })`.

package/lib/src/admin.js

@@ -41,6 +41,10 @@ export const ADMIN_OPS = Object.freeze([
   // no debe poder dejar sin configuración a los servicios.
   // `var.setMany` es la MISMA operación con varias variables dentro de un solo sobre: no
   // añade permisos, quita reinicios (ver el enrutado abajo).
+  // Ver un valor, su histórico o volver a una versión NO están, y es a propósito: un
+  // aparato que administra no tiene sobres de lo privado (solo el servicio dueño y la
+  // recuperación). Eso lo hace la bóveda en su máquina (`secret show/history/revert`).
+  // No lo cablees.
   'vars', 'var.set', 'var.setMany'
 ])
 

package/lib/src/enroll.js

@@ -261,9 +261,15 @@ export function createEnrollDesk ({
     pend.dpub = d.dpub
     pend.deviceId = deviceId
     pend.commit = d.commit
-    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave de contenido del
-    // perfil al admitirlo. Sin ella entra, pero no podrá leer lo que haya guardado.
+    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave del cajón al
+    // admitirlo. Un SERVICIO sin ella entraría al acta y no podría leer NUNCA ninguna
+    // variable —las privadas van selladas a esta llave—, así que se corta aquí en vez
+    // de admitirlo y dejar que falle más tarde y en otro sitio. Un dispositivo de
+    // persona sí puede entrar sin ella: no lee variables de servicio.
     if (typeof d.encPub === 'string') pend.encPub = d.encPub
+    if (!pend.encPub && scopeToCn(pend.scope)) {
+      return reply(from, { type: MSG_ERROR, error: 'a service must send its encryption key (update @dotrino/vault on the service)' })
+    }
     // Certificado de continuidad (opcional): lo firma la identidad que se une, con su
     // propia llave. Se comprueba aquí y se guarda con el miembro al aprobar.
     if (d.continuity) {
@@ -335,8 +341,11 @@ export function createEnrollDesk ({
     let record = null
     try {
       if (typeof identity.admitMember === 'function') {
+        // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
+        // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
+        // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
         const cn = scopeToCn(pend.scope)
-        const caps = cn ? ['secrets'] : scopeToCaps(pend.scope)
+        const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
         if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
       }
       record = (await identity.profileActa?.())?.acta || null

package/lib/src/env.js

@@ -98,12 +98,12 @@ let lastApplied = null
  *   `overridden` = las que YA tenían otro valor en el entorno y el vault pisó. Es
  *   el dato que delata un `.env` rancio, así que se reporta en vez de callarse.
  */
-export async function loadEnv ({ ns, dir, override, wait = true, required = [], onRetry } = {}) {
+export async function loadEnv ({ ns, dir, override, wait = true, required = [], onRetry, onPending } = {}) {
   if (override === undefined) override = overrideByDefault()
   ns = resolveNs(ns)
   dir = dir || serviceDir(ns)
   const load = wait ? waitForSecrets : fetchSecrets
-  const secrets = await load({ dir, ns, onRetry })
+  const secrets = await load({ dir, ns, onRetry, onPending })
 
   const missing = required.filter((k) => !(k in secrets))
   if (missing.length) {

package/lib/src/protocol.js

@@ -66,6 +66,16 @@ export const MSG = Object.freeze({
   // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
   // aviso de reinicio sin autenticar ES un ataque de denegación.
   SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  // REPARTIR LA LLAVE DE UN CAJÓN A UN MIEMBRO NUEVO. Lo hace el SERVICIO y no la
+  // bóveda, porque la bóveda no puede abrir la llave sin la frase y el servicio ya la
+  // tiene: re-envolverla no le añade ningún poder. Ver `docs/secretos-sellados.md` §8.11.
+  //
+  // El servicio NO se fía de lo que le manden: comprueba la firma de la maestra, comprueba
+  // el ACTA que viene dentro (también firmada) y saca de ahí la llave pública del
+  // destinatario. Así, ni siquiera una bóveda comprometida puede hacerle envolver la
+  // llave para alguien que la maestra no haya metido en su propio cajón.
+  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, signature }
+  REWRAP_OK: 'vault.rewrap.ok',               // servicio → vault: { data:{op,owner,gen,target,wrap,ts}, signature, cert }
   // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
   // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
   // Admitir y expulsar, nada más: cambiar permisos, traspasar el mando y los secretos
@@ -87,7 +97,8 @@ export const SCOPE = Object.freeze({
   // Consola remota (docs/consola-remota.md): admitir y expulsar miembros a distancia.
   // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
   // de master y sigue siendo local. No se empareja — se concede desde el PC.
-  ADMIN: 'vault:admin'
+  ADMIN: 'vault:admin',
+  APPROVE: 'vault:approve' // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
 })
 
 /**