@dotrino/vaultd 0.134.0 → 0.135.0

package/lib/src/env.js

@@ -21,7 +21,7 @@
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import { fetchSecrets, waitForSecrets, readServiceIdentity, watchSecretsChanges } from './service.js'
+import { fetchSecrets, waitForSecrets, readServiceIdentity, watchSecretsChanges, lastDigestOf } from './service.js'
 import { isValidSecretsNs } from './protocol.js'
 
 /** Raíz donde viven las identidades de servicio de esta máquina/usuario. */
@@ -276,10 +276,14 @@ export async function watchEnv ({ ns, vault, dir, applied = lastApplied ?? undef
     process.exit(reason === 'revoked' ? 1 : exitCode)
   }
 
+  // La HUELLA de lo que este proceso puso a correr (la trajo el cajón al pedirlo). Con ella la
+  // primera comparación ya detecta un cambio ocurrido entre pedir y escuchar, sin volver a
+  // pedir las claves — que a un servicio con aprobación le hacía sonar el teléfono al dueño.
+  const pub = readServiceIdentity(dir)?.device?.publickey
   return watchSecretsChanges({
     dir,
     ns,
-    applied,
+    digest: applied !== undefined && pub ? lastDigestOf(ns, pub) : null,
     log: say,
     onChange: ({ ts, via }) => (onUpdate ? onUpdate({ ns, ts, reason: 'changed', via }) : exitNow('changed')),
     // Un cert revocado sale con código de FALLO a propósito: si el supervisor lo

package/lib/src/service.js

@@ -581,6 +581,45 @@ export async function storeVars ({ dir, ns, proxyUrl, masterPubkey, device, cert
   } finally { client.close() }
 }
 
+/** La huella del último cajón recibido, por `ns` + aparato (ver `fetchDigest`). */
+const lastDigests = new Map()
+const digestKey = (ns, pub) => ns + String.fromCharCode(0) + pub
+/** La huella del cajón que este proceso recibió por última vez, o `null`. */
+export function lastDigestOf (ns, publickey) { return lastDigests.get(digestKey(ns, publickey)) ?? null }
+
+/**
+ * ¿CAMBIÓ LA CONFIGURACIÓN? Pregunta la HUELLA del cajón —nombres, visibilidad y generación,
+ * ningún valor— y por eso no pide aprobación (dueño, 2026-09-30: «revisa que no se pidan
+ * aprobaciones sin motivo»). Es lo que usa `watchSecretsChanges` al reconectarse; antes
+ * pedía el cajón entero y a un servicio con aprobación le sonaba el teléfono al dueño en
+ * cada despliegue del proxio.
+ * @returns {Promise<string>} la huella
+ */
+export async function fetchDigest ({ dir, ns, proxyUrl, masterPubkey, device, cert, timeoutMs = 20000 } = {}) {
+  const saved = dir ? readServiceIdentity(dir) : null
+  ns = ns || saved?.ns
+  proxyUrl = proxyUrl || saved?.proxy
+  masterPubkey = masterPubkey || saved?.iss
+  device = device || saved?.device
+  cert = cert || saved?.cert
+  if (!isValidSecretsNs(ns)) throw new Error('invalid ns')
+  if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
+  try {
+    await identifyAsService(client, device)
+    const data = { op: 'digest', ns, publickey: device.publickey, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
+    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.digest'), timeoutMs)
+    client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
+    const res = await pending
+    if (res.type === MSG.ERROR) throw vaultError(res)
+    await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
+    if (res.body.ns !== ns || typeof res.body.digest !== 'string') throw new Error('malformed digest reply')
+    if (typeof res.body.ts !== 'number' || Math.abs(Date.now() - res.body.ts) > FRESH_WINDOW_MS) throw new Error('stale digest reply')
+    return res.body.digest
+  } finally { client.close() }
+}
+
 /**
  * Pide los secretos del ns al vault (una petición puntual; lanza si falla).
  * Usa la identidad persistida por `enrollService` salvo que se pase explícita.
@@ -736,7 +775,10 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
       res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
-        .catch((e) => { throw new Error(/timeout/.test(e.message) ? 'approval: nobody approved the request in time' : e.message) })
+        .catch((e) => {
+          if (/timeout/.test(e.message)) throw Object.assign(new Error('approval: nobody approved the request in time'), { code: 'unanswered' })
+          throw e
+        })
       if (res.type === MSG.ERROR) throw vaultError(res)
     }
 
@@ -755,6 +797,9 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
     await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
     anotarActa(payload?.acta)
+    // La huella de lo que se acaba de recibir: con ella se compara después (`fetchDigest`)
+    // sin volver a pedir claves. Ya comprobada: va dentro del cuerpo firmado.
+    if (typeof body.digest === 'string') lastDigests.set(digestKey(ns, device.publickey), body.digest)
 
     // DOS CAPAS DE SOBRE, y hacen cosas distintas:
     //   · la de fuera (`ek` efímera, recién abierta) tapa el TRAMO — el proxio no ve
@@ -1010,11 +1055,10 @@ async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null
  *   `via` dice por dónde se enteró: `notice` (llegó el aviso) o `reconcile` (nadie
  *   avisó y la comparación al reconectar encontró otra configuración).
  * @param {(info:{nonce:string})=>void} [opts.onRevoked]  Cert revocado: apagar YA.
- * @param {Record<string,string>} [opts.applied]  El bundle que el agente tiene EN USO.
- *   Pasarlo es lo que permite detectar un cambio ya en la PRIMERA conexión — el que
- *   ocurrió entre que el agente pidió su configuración y logró ponerse a escuchar. Sin
- *   él no se pierde la protección, solo empieza una conexión más tarde: la primera se
- *   limita a tomar la referencia.
+ * @param {string} [opts.digest]  La huella del cajón EN USO (`lastDigestOf(ns, pub)` tras
+ *   pedirlo). Con ella se detecta ya en la primera conexión un cambio ocurrido entre que el
+ *   agente pidió su configuración y logró ponerse a escuchar; sin ella la primera
+ *   comparación solo toma la referencia.
  * @param {number} [opts.graceMs=30000]      No obedecer avisos durante los primeros N ms.
  *   La comparación también lo respeta, pero **aplazándose** (el aviso sí se descarta):
  *   es lo que impide que un fallo sistemático se convierta en un ciclo de reinicios,
@@ -1030,7 +1074,7 @@ async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null
  *   encontró un cambio.
  */
 export async function watchSecretsChanges ({
-  dir, ns, onChange, onRevoked, applied, graceMs = 30000, minIntervalMs = 60000, jitterMs = 5000,
+  dir, ns, onChange, onRevoked, digest = null, graceMs = 30000, minIntervalMs = 60000, jitterMs = 5000,
   reconcileMinMs = 30000, log = () => {}
 } = {}) {
   const saved = dir ? readServiceIdentity(dir) : null
@@ -1048,7 +1092,10 @@ export async function watchSecretsChanges ({
   let retryTimer = null
   // Huella de la configuración EN USO. Comparar huellas y no valores es lo que permite
   // decir «esto no es lo que está corriendo» sin volver a manejar los secretos.
-  let fingerprint = applied === undefined ? null : fingerprintOf(applied)
+  // La referencia es la HUELLA del cajón que está EN USO (la bóveda la manda con cada entrega:
+  // `lastDigestOf`). La pasa quien sabe qué aplicó; sin ella, la primera comparación solo la
+  // toma. Antes era el bundle entero (`applied`), y compararlo obligaba a volver a pedirlo.
+  let fingerprint = typeof digest === 'string' ? digest : null
   let firstConnection = true
   let lastReconcile = 0
   let reconciling = false
@@ -1206,9 +1253,11 @@ export async function watchSecretsChanges ({
       return false
     }
     reconciling = true
-    let bundle = null
+    let current = null
     try {
-      bundle = await fetchSecrets({ dir, ns })
+      // LA HUELLA, NO EL CAJÓN: preguntar si cambió no es pedir las claves, y no puede
+      // hacer sonar el teléfono de nadie.
+      current = await fetchDigest({ dir, ns })
     } catch (e) {
       // El cert revocado mientras estaba incomunicado: el `REVOKED` firmado se perdió
       // igual que el aviso, y esta es la única otra forma de enterarse. Lo demás (la
@@ -1225,8 +1274,7 @@ export async function watchSecretsChanges ({
       reconciling = false
       lastReconcile = Date.now()
     }
-    const current = fingerprintOf(bundle)
-    if (fingerprint === null) { fingerprint = current; return false }  // primera vez: solo tomar referencia
+    if (fingerprint === null) { fingerprint = current; return false }  // sin referencia: solo tomarla
     if (current === fingerprint) return false
     fingerprint = current
     lastObeyed = Date.now()
@@ -1279,16 +1327,6 @@ export async function watchSecretsChanges ({
   }
 }
 
-/**
- * Huella de un bundle. Las claves van ORDENADAS: el bundle se arma mezclando el cajón
- * del scope con el del aparato, así que el mismo contenido puede llegar en otro orden y
- * un cambio de orden no es un cambio de configuración.
- */
-function fingerprintOf (secrets) {
-  const pairs = Object.entries(secrets || {}).map(([k, v]) => [k, String(v)]).sort((a, b) => (a[0] < b[0] ? -1 : 1))
-  return createHash('sha256').update(JSON.stringify(pairs)).digest('hex')
-}
-
 /**
  * Bucle de arranque de un servicio: pide los secretos y, si el vault no está
  * disponible, REINTENTA para siempre (con backoff hasta `maxRetryMs`). El
@@ -1352,6 +1390,12 @@ export function isFinal (e) {
  * @param {number} approvalTimeoutMs  lo que dura un pedido de aprobación
  * @param {number} now
  */
+/** Cuánto esperar para volver a pedir tras `n` pedidos sin contestar: 0, 5, 10, 20… min, hasta 6 h. */
+export function unansweredDelay (n) {
+  if (!n) return 0
+  return Math.min(6 * 60 * 60 * 1000, 5 * 60 * 1000 * 2 ** (n - 1))
+}
+
 export function retryDelay (backoffMs, rangAt, approvalTimeoutMs = APPROVAL_TIMEOUT_MS, now = Date.now()) {
   if (!rangAt) return backoffMs
   return Math.max(backoffMs, approvalTimeoutMs - (now - rangAt))
@@ -1360,13 +1404,19 @@ export function retryDelay (backoffMs, rangAt, approvalTimeoutMs = APPROVAL_TIME
 export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, approvalTimeoutMs = APPROVAL_TIMEOUT_MS, onRetry, onPending, onCert, publicOnly = false } = {}) {
   let backoff = retryMs
   let rangAt = 0   // cuándo timbró ESTE intento; 0 = no hubo aprobación de por medio
+  let unanswered = 0
   const notePending = (info) => { rangAt = Date.now(); onPending?.(info) }
   for (;;) {
     try {
       return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, approvalTimeoutMs, onPending: notePending, onCert, publicOnly })
     } catch (e) {
       if (isFinal(e)) throw e
-      const wait = retryDelay(backoff, rangAt, approvalTimeoutMs)
+      // UN PEDIDO QUE NADIE CONTESTÓ NO SE REPITE CADA CINCO MINUTOS (dueño, 2026-09-30:
+      // «que no se pidan aprobaciones sin motivo»). Volver a pedir en cuanto vence hacía sonar
+      // el teléfono toda la noche por un servicio que arrancó de madrugada: el dueño ya lo vio
+      // y no lo aprobó. Se espacia —5, 10, 20, 40 min… hasta 6 h— y se sigue esperando.
+      if (e?.code === 'unanswered') unanswered++
+      const wait = Math.max(retryDelay(backoff, rangAt, approvalTimeoutMs), unansweredDelay(unanswered))
       rangAt = 0
       try { onRetry?.(e, wait) } catch (_) {}
       await new Promise((r) => setTimeout(r, wait))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.134.0",
+  "version": "0.135.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {

package/src/vault.js

@@ -1447,6 +1447,50 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * Dos operaciones: `store.recipients` (para quién se sella: solo públicas, nada que ocultar)
    * y `store` (los sobres ya hechos; la bóveda no los abre).
    */
+  /**
+   * LA HUELLA DE UN CAJÓN, tal como lo recibiría este aparato: nombres y GENERACIÓN de cada
+   * variable, sin un solo valor. La visibilidad NO entra: taparla no cambia lo que el servicio
+   * lee (y no sube la generación ni avisa). La generación la sube el almacén al
+   * escribir, así que la huella cambia cuando cambia la configuración y no cuando la
+   * bóveda solo rehace envolturas al abrirse. (Una rotación de llaves —al quitar un
+   * aparato— sí la sube: el servicio se reinicia una vez, que es raro y no hace daño.)
+   */
+  function drawerDigest (ns, devicePub) {
+    const b = secrets.bundleFor(ns, devicePub)
+    const filas = Object.entries(b.entries || {})
+      .map(([k, e]) => [k, b.legacy ? nodeCrypto.createHash('sha256').update(String(e.v)).digest('hex') : (e.gen ?? null)])
+      .sort((a, c) => (a[0] < c[0] ? -1 : 1))
+    return nodeCrypto.createHash('sha256').update(JSON.stringify(filas)).digest('hex')
+  }
+
+  /**
+   * ¿CAMBIÓ MI CONFIGURACIÓN? Sin llevarse nada (dueño, 2026-09-30: «revisa que no se pidan
+   * aprobaciones sin motivo»).
+   *
+   * El servicio lo pregunta al reconectarse, por si se perdió un aviso. Antes lo preguntaba
+   * pidiendo el cajón ENTERO —privadas incluidas— para sacarle una huella, y eso es un
+   * pedido de claves: a un servicio que pide aprobación le sonaba el teléfono al dueño en
+   * cada despliegue del proxio, para aprobar algo que no entregaba nada que el servicio no
+   * tuviera ya. La huella no revela nada, así que no se aprueba: quien pregunta tiene que
+   * ser igualmente el servicio de ese cajón (cert + CN del acta).
+   */
+  async function handleDigest (from, p) {
+    const ns = p.data?.ns
+    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'digest: invalid namespace' })
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: secretsScope(ns), ...(await contextoActa()), revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'digest')
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
+      audit('rejected', { what: 'digest', ns, reason: record ? 'cn' : 'sin-acta' })
+      return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
+    }
+    const body = { op: 'secrets.digest', ns, digest: drawerDigest(ns, chk.device), ts: Date.now() }
+    reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
+  }
+
   const storeNonces = new Map()
   async function handleVarStore (from, p) {
     const ns = p.data?.ns
@@ -1513,6 +1557,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // del servicio y su cert, o sea que ya lee ese namespace. No hay escalada.
     if (p.data?.op === 'enckey') return handleEncKey(from, p)
     if (p.data?.op === 'store.recipients' || p.data?.op === 'store') return handleVarStore(from, p)
+    if (p.data?.op === 'digest') return handleDigest(from, p)
     if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke'].includes(p.data?.op)) return handleApproval(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
@@ -1636,7 +1681,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       }
     }
     const enc = await seal({ ek, payload })
-    const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
+    // La huella va con cada entrega: es la referencia con la que el servicio compara después
+    // (`digest`) sin volver a pedir claves.
+    const body = { op: 'secrets.result', ns, enc, digest: drawerDigest(ns, devicePub), ts: Date.now() }
     // LA MAESTRA NO FIRMA ESTO. Su trabajo es sellar el acta y reenvolver sobres; servir
     // no es suyo. Quien firma es la LLAVE DE SELLADO que el acta nombra (`sealPub`), la
     // misma que ya firma cada sobre — y por eso esto se puede servir con el perfil
@@ -1814,7 +1861,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   async function notifyApprovers (pend, record) {
     try {
-      const body = { ev: 'approval', id: pend.id, ns: pend.ns, deviceId: pend.deviceId, label: pend.label, exp: pend.exp, ts: Date.now() }
+      // `kind` dice QUÉ se pide (llevarse claves, guardar variables, actualizar…): es lo que la
+      // app necesita para que el aviso diga el porqué sin tener que abrir la lista. Los
+      // detalles (comando, carpeta, nombres) NO van aquí: van sellados en la lista.
+      const body = { ev: 'approval', id: pend.id, ns: pend.ns, kind: pend.kind || 'read', deviceId: pend.deviceId, label: pend.label, exp: pend.exp, ts: Date.now() }
       const seal = await sealOrFail(body)
       const who = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).map((m) => m.pub)
       if (!who.length) log(`[vault] ${pend.ns}: nobody can approve (grant it with: dotrino-vault caps <ID> +aprueba)`)