@dotrino/vaultd 0.135.0 → 0.137.0

package/lib/src/protocol.js

@@ -65,7 +65,7 @@ export const MSG = Object.freeze({
   //     empieza con el heap limpio.
   // 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 }
+  SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, seal, acta }
   // 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.
@@ -74,7 +74,7 @@ export const MSG = Object.freeze({
   // 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: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, seal }
   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.
@@ -85,7 +85,7 @@ export const MSG = Object.freeze({
   // Aviso a TODOS los miembros de que el perfil cambió (alguien entró o salió). Es la
   // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
   // invisible para el resto de tus dispositivos.
-  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, acta } (pedidos: + seal)
   // RÉPLICAS: la principal empuja lo que hay que servir (el acta y los sobres, que van
   // firmados de antes y no se pueden falsificar) y la réplica acusa hasta qué `seq` tiene.
   REPLICA_PUSH: 'vault.replica.push',         // master → réplica: { body:{seq,acta,secrets,ts}, signature }

package/lib/src/service.js

@@ -1137,8 +1137,9 @@ export async function watchSecretsChanges ({
    * NO SE FÍA DE LO QUE LE MANDAN, y esto es lo que hace que sea seguro incluso si la
    * bóveda estuviera comprometida:
    *
-   *  · la petición va firmada por la MAESTRA;
-   *  · el acta viaja dentro y se comprueba aparte (también la firma la maestra);
+   *  · la petición la firma la llave de SELLADO que nombra el acta (`verifyResponder`), no la
+   *    maestra: esto tiene que funcionar con la bóveda cerrada;
+   *  · el acta viaja dentro y la selló la maestra que este agente conoce;
    *  · **la llave pública del destinatario se saca del ACTA, nunca del mensaje** — si
    *    se cogiera del mensaje, quien lo mandara podría hacer que este agente envolviera
    *    la llave para una pública suya;
@@ -1150,9 +1151,9 @@ export async function watchSecretsChanges ({
     if (!body || body.op !== 'rewrap') return
     const mineOwners = [`ns:${ns}`, `dev:${saved.device.publickey}`]
     if (!mineOwners.includes(body.owner)) return log('[vault] rewrap for a drawer that is not mine: ignored')
-    if (!(await verifyDeviceSig({ publickey: master, data: body, signature: payload.signature }))) {
-      return log('[vault] rewrap request BADLY SIGNED: ignored')
-    }
+    try {
+      await verifyResponder({ body, seal: payload.seal, acta: body.acta, masterPubkey: master, knownSeq: readServiceIdentity(dir)?.actaSeq ?? null })
+    } catch (e) { return log(`[vault] rewrap request BADLY SIGNED: ignored (${e.message})`) }
     const acta = body.acta
     if (!acta || acta.sealedBy !== master || !(await verifyActa({ acta })).ok) {
       return log('[vault] rewrap request without a valid record: ignored')
@@ -1192,11 +1193,15 @@ export async function watchSecretsChanges ({
     // que un aviso falso con fecha lejana no pueda dejar fuera a los de verdad.
     if (inFlight.has(body.ts)) return
     inFlight.add(body.ts)
-    let valid = false
+    // FIRMADO COMO TODO LO QUE SIRVE LA BÓVEDA: la llave de sellado que nombra el acta, con
+    // el acta al lado. Lo firmaba la maestra, y la bóveda vive CERRADA: el aviso reventaba
+    // con «vault locked» antes de salir y el servicio no se enteraba de ningún cambio
+    // (la maestra solo firma el acta y reenvuelve sobres, CLAUDE.md).
+    let bad = null
     try {
-      valid = await verifyDeviceSig({ publickey: master, data: body, signature: payload.signature })
-    } finally { inFlight.delete(body.ts) }
-    if (!valid) return log('[vault] change notice BADLY SIGNED: ignored (not from your vault)')
+      await verifyResponder({ body, seal: payload.seal, acta: payload.acta, masterPubkey: master, knownSeq: readServiceIdentity(dir)?.actaSeq ?? null })
+    } catch (e) { bad = e } finally { inFlight.delete(body.ts) }
+    if (bad) return log(`[vault] change notice BADLY SIGNED: ignored (${bad.message})`)
     if (body.ts <= lastTs) return
     lastTs = body.ts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.135.0",
+  "version": "0.137.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

@@ -1420,9 +1420,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         await spreadKey(owner, (esPublica) => recipientsOf(owner, { public: esPublica }))
           .catch((e) => log(`[vault] ${owner}: could not hand it the key: ${e.message}`))
       }
+      // Con la llave de sellado, como todo lo que sirve la bóveda: la maestra no firma con la
+      // bóveda cerrada, y esto tiene que funcionar cerrada.
       const body = { op: 'secrets.result', ns, enc: null, ok: true, ts: Date.now() }
-      const { signature } = await identity.signData(body)
-      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+      reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: 'enckey: ' + e.message })
     }
@@ -2080,10 +2081,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
       // El teléfono: se apunta el pedido, se le avisa y esta promesa espera su firma.
       // Es el mismo camino que ya recorren los cajones de secretos.
-      approve: async ({ pubkey, op }) => {
+      // EL PEDIDO DICE QUÉ SE QUIERE LEER (dueño, 2026-09-30: «es importante que se sepa el
+      // porqué»). Antes salía como `read` sin contexto, y el teléfono enseñaba «pide tus claves
+      // de passwords · no dice qué está ejecutando», que parece un servicio desconocido cuando
+      // es tu extensión pidiendo una contraseña. Ahora es `kind: 'passwords'` con la operación y
+      // los CAMPOS (`password`, `totp`…) — nunca la entrada ni el sitio, que no se ven aquí.
+      // Va sellado al que aprueba, como el comando de un pedido de claves.
+      approve: async ({ pubkey, op, payload }) => {
         let resolve
         const espera = new Promise((r) => { resolve = r })
-        await awaitApproval({ device: pubkey, ns: 'passwords', kind: 'read', what: 'passwords', op, onAnswer: resolve })
+        const fields = Array.isArray(payload?.keys) ? payload.keys.slice(0, 12).map((k) => String(k).slice(0, 40)) : null
+        await awaitApproval({
+          device: pubkey, ns: 'passwords', kind: 'passwords', what: 'passwords', op,
+          ctx: { op: String(op || '').replace(/^pm2\./, ''), fields }, onAnswer: resolve
+        })
         return espera
       },
       audit,
@@ -2147,10 +2158,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     } catch (e) { return log('[vault] could not list who to notify:', e.message) }
     if (!targets.length) return
 
+    // FIRMA LA LLAVE DE SELLADO, con el acta al lado (el servicio lo comprueba con
+    // `verifyResponder`). Firmaba la maestra, y con la bóveda cerrada —que es como vive— el
+    // aviso reventaba antes de salir: el servicio no se enteraba de ningún cambio.
     const body = { op: 'secrets.changed', ns, ts: Date.now() }
-    const { signature } = await identity.signData(body)
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const seal = await sealOrFail(body)
     for (const d of targets) {
-      try { client.sendByPubkey(d.sub, { type: MSG.SECRETS_CHANGED, body, signature }) } catch (_) {}
+      try { client.sendByPubkey(d.sub, { type: MSG.SECRETS_CHANGED, body, seal, acta }) } catch (_) {}
     }
     audit('secrets.changed', { ns, notified: targets.length })
     log(`[vault] config for "${ns}" changed: notified ${targets.length} agent(s)`)
@@ -2164,14 +2179,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   async function notifyDeviceChange (pub) {
     let cn = null
+    let record = null
     try {
-      const record = (await identity.profileActa?.().catch(() => null))?.acta
+      record = (await identity.profileActa?.().catch(() => null))?.acta
       cn = (record?.members || []).find((m) => m.pub === pub)?.cn || null
     } catch (e) { return log('[vault] could not look up who to notify:', e.message) }
     if (!cn) return
     const body = { op: 'secrets.changed', ns: cn, ts: Date.now() }
-    const { signature } = await identity.signData(body)
-    try { client.sendByPubkey(pub, { type: MSG.SECRETS_CHANGED, body, signature }) } catch (_) {}
+    const seal = await sealOrFail(body)
+    try { client.sendByPubkey(pub, { type: MSG.SECRETS_CHANGED, body, seal, acta: record }) } catch (_) {}
     const device = await deviceIdOf(pub).catch(() => null)
     audit('secrets.changed', { ns: cn, device, notified: 1 })
     log(`[vault] config for device ${device} ("${cn}") changed: notified it`)
@@ -2225,8 +2241,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   async function notifyMembers (ev, info = {}) {
     try {
+      // SIN FIRMA, y no falta nada: quien lo usa es el ACTA que viaja al lado, que se
+      // autentica sola (otra bóveda la adopta por `canAdopt`; el teléfono solo refresca y
+      // pregunta). Lo firmaba la maestra, que no firma con la bóveda cerrada: el aviso
+      // reventaba antes de salir y el acta nueva no llegaba a nadie.
       const body = { ev, ...info, ts: Date.now() }
-      const { signature } = await identity.signData(body)
       // EL ACTA VIAJA CON EL AVISO. Sin esto, un miembro se enteraba de que «algo cambió»
       // pero no de QUÉ, y no veía el acta nueva hasta renovar su cert — hasta 30 días.
       // Para un aparato eso era lento; para OTRA BÓVEDA es fatal: se le concede `sella` y
@@ -2264,7 +2283,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // el perfil cambió puede esperar a que el aparato abra solo; timbrar por él hacía
         // sonar el teléfono con «alguien pide tus claves» sin ningún pedido detrás.
         // El timbre es para los pedidos (`notifyApprovers`), que sí esperan una mano.
-        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature, acta }, { quiet: true }) }
+        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, acta }, { quiet: true }) }
         catch (e) { log(`[vault] could not notify ${pub.slice(0, 24)}… of "${ev}": ${e.message}`) }
       }
       for (const m of miembros) avisar(m.pub)
@@ -3112,8 +3131,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
     let done = 0
     for (const gen of pending) {
+      // La llave de sellado firma (el servicio lo comprueba con `verifyResponder`): esto
+      // tiene que funcionar con la bóveda cerrada, y la maestra entonces no firma.
       const body = { op: 'rewrap', owner, gen: gen.gen, wrap: gen.mine, target: targetPub, acta: record, ts: Date.now() }
-      const { signature } = await identity.signData(body)
+      const seal = await sealOrFail(body)
       const answer = new Promise((resolve) => {
         const off = onRewrapOk((d) => {
           if (d.owner !== owner || d.gen !== gen.gen || d.target !== targetPub) return
@@ -3121,7 +3142,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         })
         setTimeout(() => { off(); resolve(null) }, timeoutMs).unref?.()
       })
-      try { client.sendByPubkey(helpers[0].pub, { type: MSG.REWRAP, body, signature }) } catch (e) {
+      try { client.sendByPubkey(helpers[0].pub, { type: MSG.REWRAP, body, seal }) } catch (e) {
         log(`[vault] ${owner}: could not ask for the key to be handed out (${e.message})`)
         continue
       }