@dotrino/vaultd 0.52.0 → 0.56.0

package/src/vault.js

@@ -19,15 +19,20 @@ import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.j
 import { createAdminDesk } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
 import { createTransport, masterPubkeyOf } from './transport.js'
+import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar } from './secretsStore.js'
-import { createApprovals } from './approvals.js'
+// `PENDING_TTL_MS` se usa abajo, al esperar la firma del aprobador: sin importarlo, esa
+// espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
+// llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
+// que lo recorriera hasta que la hubo (dotrino-test, smoke:demonio, 2026-08-30).
+import { createApprovals, PENDING_TTL_MS } from './approvals.js'
 import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { seal } from '../lib/src/sealed.js'
 import { dataDir, ensureDir } from './paths.js'
-import { atRestFor, machineKey, migrateFile } from './atrest.js'
+import { atRestFor, kekFor, migrateFile } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
 
 /**
@@ -56,10 +61,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // máquina (puede leer el mismo material); es subir el listón, no una imposibilidad.
   // La migración verifica antes de reemplazar: si algo falla, el original queda intacto.
   try {
-    const r = migrateFile(path.join(dir, 'identity.json'), machineKey(dir))
+    const r = migrateFile(path.join(dir, 'identity.json'), kekFor(dir))
     if (r === 'migrado') log('[vault] identity encrypted at rest (bound to this machine)')
   } catch (e) { log('[vault] could not encrypt the identity at rest:', e.message) }
   const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
+  // ESTE DIRECTORIO ES DE ESTA LLAVE. Es lo único que hay que proteger cuando varias
+  // bóvedas viven en un mismo disco: cada una con el suyo, para que nunca se mezclen.
+  assertKeyOwnsDir(dir, identity.me?.publickey || null)
   if (!identity.me?.publickey) await identity.setMyNickname('')
   // CAMINO A: este perfil nació para adoptar la cuenta de un aparato. La identidad se crea
   // igual (su llave es la que entrará como miembro), pero se marca para que `joinProfile`
@@ -168,7 +176,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     recipients: (owner) => recipientsOf(owner),
     // La FIRMA del sobre: dice que salió de esta bóveda y con qué acta (§8.8).
     signer: (body) => signSeal(body),
-    defaultKey: () => new Uint8Array(machineKey(dir))
+    defaultKey: () => new Uint8Array(kekFor(dir))
   })
   // SIN CONTRASEÑA NO HAY SECRETO. Escribir no la pide (sellar solo necesita públicas,
   // §8.1), pero la copia de recuperación —la que deja al dueño VER sus valores— se cierra
@@ -629,8 +637,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('secrets.pending', { device: deviceId, ns, id: pend.id })
       log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
       const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
-      const { signature } = await identity.signData(body)
-      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+      // El acta viaja también aquí: es con lo que el agente sabe qué llave podía firmar
+      // esto. En `secrets.result` va dentro del sobre; en un «pendiente» no hay sobre.
+      reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record || null })
       await notifyApprovers(pend, record)
       return
     }
@@ -654,13 +663,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `seq` con el que se firmaron—. No es un dato secreto: el acta es pública dentro
     // del perfil y el agente ya es miembro. Sin ella podría abrir igual, pero no sabría
     // de dónde salió lo que abre.
+    // El acta va en LOS DOS caminos, también en el v3 heredado: ya no sirve solo para
+    // decir de dónde salieron los sobres, sino para saber qué llave podía firmar esta
+    // respuesta. Sin ella el agente no puede comprobar quién le contestó.
     const payload = b.legacy
-      ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])) }
+      ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])), acta: record || null }
       : { sealed: b, acta: record || null }
     const enc = await seal({ ek, payload })
     const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
-    const { signature } = await identity.signData(body)
-    return { body, signature }
+    // 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
+    // bloqueado, y algún día desde una réplica que no tiene la maestra ni debe tenerla.
+    return { body, seal: await sealOrFail(body) }
+  }
+
+  /**
+   * Firma con la llave de sellado, o revienta. No hay repliegue a la maestra: si el acta
+   * no nombra una llave de sellado que sea nuestra, esta bóveda no está en condiciones de
+   * servir, y decirlo es mejor que servir firmado por quien no toca.
+   */
+  async function sealOrFail (body) {
+    const s = await signSeal(body)
+    if (!s) throw new Error('this vault has no sealing key named by the record: it cannot serve')
+    return s
   }
 
   /**
@@ -684,8 +710,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const by = await deviceIdOf(chk.device).catch(() => null)
     const answer = async (body) => {
       body = { ...body, 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) })
     }
     if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
     const id = typeof p.data?.id === 'string' ? p.data.id : ''
@@ -748,11 +773,34 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.REWRAP_OK) return await handleRewrapOk(payload)
       if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
       if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
+      if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
   })
 
+  /**
+   * AVISO DE OTRA BÓVEDA de la misma cuenta (multivault). Trae el acta nueva y aquí se
+   * ADOPTA, que es lo que hace que conceder un permiso surta efecto en la otra máquina en
+   * vez de esperar a que renueve su cert.
+   *
+   * No se comprueba quién lo manda y no hace falta: `adoptActa` aplica §2.4.1 —firma,
+   * encadenado, `seq` que no baja y desempate— así que un acta ajena o vieja se rechaza
+   * sola. Fiarse del remitente sería la comprobación débil; fiarse del acta es la fuerte.
+   */
+  async function handleAdminEvent (payload) {
+    const acta = payload?.acta
+    if (!acta || typeof acta !== 'object') return
+    try {
+      const r = await identity.adoptActa?.(acta)
+      if (r?.adopted) log(`[vault] adopted record #${acta.seq} announced by another vault (${r.reason})`)
+      // Y el RECHAZO también se dice. Callarlo dejaría el peor fallo de todos: se concede
+      // un permiso en una máquina, la otra no se entera, y no hay una sola línea que lo
+      // explique — que es exactamente lo que costó encontrar esto.
+      else log(`[vault] IGNORED the record #${acta.seq} announced by another vault: ${r?.reason || 'no reason given'}`)
+    } catch (e) { log('[vault] could not adopt the announced record:', e.message) }
+  }
+
   // ----- LA BÓVEDA DE CONTRASEÑAS -----
   //
   // Se monta al final y envuelto: es una pieza opcional y un fallo suyo no puede tumbar
@@ -961,17 +1009,45 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     try {
       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
+      // no puede sellar, porque su copia del acta no lo dice todavía.
+      // No es un dato secreto (es pública dentro del perfil y estos son sus miembros), y
+      // quien la recibe la adopta por las reglas de §2.4.1, así que una vieja o ajena no
+      // hace daño: se rechaza sola.
+      const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
       const { issued } = await identity.listDelegations()
+      // A QUIÉN SE AVISA: a los MIEMBROS DEL ACTA, no solo a quien esta bóveda enroló.
+      //
+      // Esto avisaba únicamente por `issued` —las delegaciones que emitió esta bóveda—, y
+      // eso deja fuera exactamente el caso del multivault: la segunda bóveda entró por
+      // `join`, así que la delegación la emitió la PRIMERA. Cuando la segunda sellaba un
+      // acta nueva (admitir un aparato con su permiso `sella`), su lista de emitidas no
+      // tenía a la primera dentro y el cambio no llegaba a ninguna parte: las dos bóvedas
+      // quedaban con actas distintas y la del dueño sin enterarse de nada.
+      //
+      // El acta es la lista de quién es del perfil: esa es la lista correcta. `issued` se
+      // suma porque cubre a quien tiene cert y todavía no aparece ahí.
+      const miembros = (await identity.profileMembers?.().catch(() => null))?.members || []
+      const yo = identity.me?.publickey || null
       // UNO POR LLAVE, no uno por delegación: renovar emite una delegación nueva para la
       // MISMA sub-clave, así que un aparato que lleve tiempo enrolado aparece varias veces
       // y recibía el mismo aviso repetido —una vez por renovación acumulada—. Mismo
       // cuidado que en `notifyNsChange`.
       const seen = new Set()
-      for (const d of issued || []) {
-        if (!d.sub || seen.has(d.sub)) continue
-        seen.add(d.sub)
-        try { client.sendByPubkey(d.sub, { type: MSG.ADMIN_EVENT, body, signature }) } catch (_) {}
+      const avisar = (pub) => {
+        if (!pub || pub === yo || seen.has(pub)) return
+        seen.add(pub)
+        // El fallo NO se traga. Que un aviso no salga es exactamente lo que deja a dos
+        // bóvedas con actas distintas sin que nadie se entere, y encontrarlo sin una línea
+        // de log cuesta días (la última vez, tres).
+        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature, acta }) }
+        catch (e) { log(`[vault] could not notify ${pub.slice(0, 24)}… of "${ev}": ${e.message}`) }
       }
+      for (const m of miembros) avisar(m.pub)
+      for (const d of issued || []) avisar(d.sub)
+      log(`[vault] notified ${seen.size} member(s) of "${ev}" (record #${acta?.seq ?? '?'})`)
     } catch (e) { log('[vault] could not notify members of the change:', e.message) }
   }
 
@@ -1150,7 +1226,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * pero NO es equivalente, y por eso la consola lo dice en voz alta (§2.3 del
    * diseño). Prometer una protección que no está puesta es peor que no tenerla.
    */
-  const adminKeyOr = (adminKey) => adminKey || new Uint8Array(machineKey(dir))
+  const adminKeyOr = (adminKey) => adminKey || new Uint8Array(kekFor(dir))
 
   // `adminKey` es la llave derivada de la contraseña del perfil, y va POR OPERACIÓN: se
   // usa para sellar y se suelta. Solo hace falta para escribir una privada — servir,
@@ -1231,18 +1307,48 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const rewrapWaiters = new Set()
   const onRewrapOk = (fn) => { rewrapWaiters.add(fn); return () => rewrapWaiters.delete(fn) }
 
+  /**
+   * LAS OTRAS BÓVEDAS —los miembros con el permiso `sella`— entran en TODOS los cajones,
+   * también en los que tienen dueño. Decidido por el dueño el 2026-08-30.
+   *
+   * Y no contradice la regla de agosto —«un cajón con dueño no se envuelve para quien
+   * administra»—, porque un cosellador **no es quien administra**: es un master. Aquella
+   * regla saca a los aparatos de consola (un navegador, un portátil con la sesión puesta),
+   * cuyo compromiso es probable y cuya necesidad es comodidad. Una segunda bóveda existe
+   * justamente para poder REGENERAR los sobres el día que la primera no esté, y regenerar
+   * exige abrir: dejarla fuera la haría inútil para el único desastre que viene a cubrir.
+   *
+   * El precio, que se dice y no se esconde: a partir de aquí son DOS los discos cuya
+   * captura abre ese cajón. Eso es exactamente lo que cuesta sobrevivir a perder uno.
+   */
+  async function cosealerMembers () {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (!record) return []
+    // Sin `encPub` no hay a dónde envolver: se queda en deuda y se ve como `sinLlave`,
+    // igual que cualquier otro miembro incompleto.
+    return (record.members || []).filter((m) =>
+      m.pub !== master && m.encPub && Acta.memberCan(record, m.pub, 'sealer'))
+  }
+
+  /** Sin duplicar: un cosellador puede ser además el dueño del cajón. */
+  const conCoselladores = (base, co) => {
+    const vistos = new Set(base.map((m) => m.pub))
+    return [...base, ...co.filter((m) => !vistos.has(m.pub))]
+  }
+
   async function recipientsOf (owner) {
+    const co = await cosealerMembers()
     if (owner.startsWith('ns:')) {
       const owned = await nsMembers(owner.slice(3))
       // Sin dueño (un cajón personal, o uno cuyo servicio ya no está) sí entra quien
       // administra: si no, no quedaría nadie que pudiera abrirlo sin la frase.
-      return owned.length ? owned : await adminDevices()
+      return conCoselladores(owned.length ? owned : await adminDevices(), co)
     }
     const pub = owner.slice(owner.indexOf(':') + 1)
     const m = await memberOf(pub)
     // El cajón propio de un aparato de SERVICIO es tan suyo como el de su ns.
-    if (m?.cn) return [m]
-    return [...(m ? [m] : []), ...await adminDevices()]
+    if (m?.cn) return conCoselladores([m], co)
+    return conCoselladores([...(m ? [m] : []), ...await adminDevices()], co)
   }
 
   /**
@@ -1818,6 +1924,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     isMaster: () => identity.isMaster(),
     setCaps: async (pub, caps) => {
       const r = await identity.setCaps(pub, caps)
+      // ¿SE QUEDÓ ALGUNO POR EL CAMINO? El acta tiene una lista CERRADA de permisos y
+      // `cleanCaps` descarta los que no conoce — correcto al recibir un acta ajena, y
+      // pésimo aquí: conceder `+sella` con una versión del pilar que no sabe qué es
+      // devolvía «Listo», resellaba el acta y no concedía nada. Costó una tarde en un
+      // contenedor, porque la imagen traía la versión de npm y el árbol local otra.
+      try {
+        const quedaron = new Set((await identity.profileMembers()).members.find((m) => m.pub === pub)?.caps || [])
+        const perdidos = caps.filter((c) => !quedaron.has(c))
+        if (perdidos.length) {
+          log(`[vault] WARNING these permissions were DROPPED: ${perdidos.join(', ')} — this build's @dotrino/identity does not know them (record unchanged for those)`)
+        }
+      } catch (_) { /* comprobar es un extra: si falla, no rompe el cambio */ }
       audit('caps', { device: await deviceIdOf(pub).catch(() => null), caps })
       await notifyMembers('caps', { deviceId: await deviceIdOf(pub).catch(() => null), caps })
       return r