@dotrino/vault 0.91.1 → 0.93.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.91.1",
+  "version": "0.93.0",
   "description": "La bóveda de Dotrino como librería: el MISMO núcleo que el binario corriendo en el navegador (`@dotrino/vault/browser`), el mostrador de emparejamiento y el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",

package/src/atrest.js

@@ -169,18 +169,18 @@ export function atRestFor (dir, { password = '' } = {}) {
 /**
  * Cifra AHORA un archivo que esté en claro, verificando antes de reemplazar: se escribe a un
  * temporal, se vuelve a leer y descifrar, se compara, y solo entonces se renombra encima.
- * Devuelve 'ya-cifrado' | 'migrado' | 'sin-archivo'.
+ * Devuelve 'already-encrypted' | 'migrated' | 'no-file'.
  */
 export function migrateFile (file, key) {
   let text
-  try { text = fs.readFileSync(file, 'utf8') } catch (_) { return 'sin-archivo' }
-  if (isEncrypted(text)) return 'ya-cifrado'
+  try { text = fs.readFileSync(file, 'utf8') } catch (_) { return 'no-file' }
+  if (isEncrypted(text)) return 'already-encrypted'
   const blob = encryptText(text, key)
   if (decryptText(blob, key) !== text) throw new Error('at-rest: verification failed, the original is untouched')
   const tmp = file + '.atrest.tmp'
   fs.writeFileSync(tmp, blob, { mode: 0o600 })
   fs.renameSync(tmp, file)
-  return 'migrado'
+  return 'migrated'
 }
 
 /** Los archivos de este directorio que están cifrados por nosotros. */

package/src/core/libVersion.js

@@ -5,4 +5,4 @@
  * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
  * que no anunciar ninguna.
  */
-export const LIB_VERSION = '0.91.1'
+export const LIB_VERSION = '0.93.0'

package/src/core/subacta.js

@@ -75,12 +75,12 @@ export function openSubacta (disk) {
      * aparatos se cuentan lo mismo.
      */
     async add (e) {
-      if (!(await isAcceptable(e))) return { ok: false, reason: 'no-aceptable' }
+      if (!(await isAcceptable(e))) return { ok: false, reason: 'not-acceptable' }
       const id = idOf(e)
-      if (data.entries.some((x) => idOf(x) === id)) return { ok: false, reason: 'ya-estaba' }
+      if (data.entries.some((x) => idOf(x) === id)) return { ok: false, reason: 'already-present' }
       data.entries = [...data.entries, e]
       guardar()
-      return { ok: true, reason: 'nueva' }
+      return { ok: true, reason: 'new' }
     },
 
     /**

package/src/core/vault.js

@@ -872,13 +872,13 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // acta falta justo cuando algo se rompió (un archivo a medias, un `catch` que devolvió
     // null), que es cuando menos hay que fiarse. Toda cuenta tiene acta desde hace versiones.
     if (!record) {
-      audit('rejected', { what, reason: 'sin-acta' })
+      audit('rejected', { what, reason: 'no-record' })
       reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
       return false
     }
     if (Acta.memberCanScope(record, chk.device, scope)) return true
-    audit('rejected', { what, reason: 'acta' })
-    reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
+    audit('rejected', { what, reason: 'record' })
+    reply(from, { type: MSG.ERROR, error: 'unauthorized: record — this member no longer has that permission' })
     return false
   }
 
@@ -976,14 +976,14 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
           const t = Date.now()
           for (const [n, v] of aperturas) if (v.exp <= t) aperturas.delete(n)
           const eph = await makeEphemeralKey()
-          aperturas.set('pendiente', { privateKey: eph.privateKey, exp: t + EPHEMERAL_TTL_MS })
+          aperturas.set('pending', { privateKey: eph.privateKey, exp: t + EPHEMERAL_TTL_MS })
           audit('unlock.begin', { by })
           return { ...params, ek: eph.ek }
         },
 
         async open ({ nonce, enc, by }) {
-          const guardada = aperturas.get('pendiente')
-          aperturas.delete('pendiente')
+          const guardada = aperturas.get('pending')
+          aperturas.delete('pending')
           if (!guardada || guardada.exp <= Date.now()) {
             return { ok: false, error: 'unlock: ask for a key first, and use it within a minute' }
           }
@@ -992,7 +992,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
           // EL NONCE VA DENTRO DEL SOBRE. Si fuera solo por fuera, un sobre capturado se
           // reenvía con un nonce nuevo y el candado del nonce no sirve de nada.
           if (!payload || payload.nonce !== nonce || typeof payload.key !== 'string') {
-            audit('rejected', { what: 'unlock', by, reason: 'sobre' })
+            audit('rejected', { what: 'unlock', by, reason: 'envelope' })
             return { ok: false, error: 'unlock: the envelope does not check out' }
           }
           const derivada = b64ToBytes(payload.key)
@@ -1314,10 +1314,10 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     const { issued, revoked } = await identity.listDelegations()
     if (!puedeVerTodo) {
       if (!record) {
-        audit('rejected', { what: 'devices', reason: 'sin-acta' })
+        audit('rejected', { what: 'devices', reason: 'no-record' })
         return reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
       }
-      audit('devices', { device: await deviceIdOf(chk.device).catch(() => null), solo: 'revocaciones' })
+      audit('devices', { device: await deviceIdOf(chk.device).catch(() => null), only: 'revocations' })
       return reply(from, { type: MSG.DEVICES_RESULT, devices: [], revoked, blocked: blocked.pubs(), acta: record, sealerChain: await sealerChainOf() })
     }
     // El acta viaja con la lista: así cada dispositivo se entera de los cambios de
@@ -1401,7 +1401,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // Sin acta no se renueva: caer al scope del papel viejo es reconceder a ciegas lo que
     // el acta ya no dice. Un repliegue así no protege de nada, tapa.
     if (!record) {
-      audit('rejected', { what: 'renew', device: await deviceIdOf(p.cert.sub), reason: 'sin-acta' })
+      audit('rejected', { what: 'renew', device: await deviceIdOf(p.cert.sub), reason: 'no-record' })
       return reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
     }
     const scope = Acta.memberScopes(record, p.cert.sub)
@@ -1460,7 +1460,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // que se cerró en `handleSign`, en otro mostrador.
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: 'enckey', ns, reason: record ? 'cn' : 'sin-acta' })
+      audit('rejected', { what: 'enckey', ns, reason: record ? 'cn' : 'no-record' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
     try {
@@ -1545,7 +1545,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     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' })
+      audit('rejected', { what: 'digest', ns, reason: record ? 'cn' : 'no-record' })
       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() }
@@ -1578,8 +1578,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     if (!chk.ok) return denyChain(from, chk, p, 'update-ask')
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     if (!record || !(record.members || []).some((m) => m.pub === chk.device)) {
-      audit('rejected', { what: 'update-ask', reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
+      audit('rejected', { what: 'update-ask', reason: record ? 'record' : 'no-record' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: record — this device is not in the record' })
     }
     const product = cut(p.data?.product, 128)
     const version = cut(p.data?.version, 64)
@@ -1656,8 +1656,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     const member = (record?.members || []).find((m) => m.pub === chk.device)
     if (!member) {
-      audit('rejected', { what: op, reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
+      audit('rejected', { what: op, reason: record ? 'record' : 'no-record' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: record — this device is not in the record' })
     }
     const product = cut(p.data?.product, 128)
     const version = cut(p.data?.version, 64)
@@ -1685,7 +1685,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     if (!chk.ok) return denyChain(from, chk, p, op)
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: op, ns, reason: record ? 'cn' : 'sin-acta' })
+      audit('rejected', { what: op, ns, reason: record ? 'cn' : 'no-record' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
     const deviceId = await deviceIdOf(chk.device).catch(() => null)
@@ -1756,7 +1756,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // llave del proxy no ve nada que no sea del proxy, y está escrito donde se puede comprobar.
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: 'secrets', ns, reason: record ? 'cn' : 'sin-acta' })
+      audit('rejected', { what: 'secrets', ns, reason: record ? 'cn' : 'no-record' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
     // APROBACIÓN: si este APARATO está marcado (`dotrino-vault approval <ID> on`), liberarle
@@ -1908,8 +1908,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     if (!chk.ok) return denyChain(from, chk, p, 'approval')
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     if (!record || !Acta.memberCan(record, chk.device, 'approve')) {
-      audit('rejected', { what: 'approval', reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member does not approve' })
+      audit('rejected', { what: 'approval', reason: record ? 'record' : 'no-record' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: record — this member does not approve' })
     }
     const by = await deviceIdOf(chk.device).catch(() => null)
     const answer = async (body) => {
@@ -2157,8 +2157,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     if (!chk.ok) return denyChain(from, chk, p, 'incident')
     const record = await refreshActa()
     if (!record || !Acta.memberCan(record, chk.device, 'sign')) {
-      audit('rejected', { what: 'incident', reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member cannot report incidents' })
+      audit('rejected', { what: 'incident', reason: record ? 'record' : 'no-record' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: record — this member cannot report incidents' })
     }
     const d = p.data || {}
     const kind = typeof d.kind === 'string' ? d.kind.slice(0, 32) : ''
@@ -2913,7 +2913,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
         return chk
       }
       const record = (await identity.profileActa?.().catch(() => null))?.acta
-      if (!record || !Acta.memberCan(record, chk.device, 'admin')) return { ok: false, reason: record ? 'acta' : 'sin-acta' }
+      if (!record || !Acta.memberCan(record, chk.device, 'admin')) return { ok: false, reason: record ? 'record' : 'no-record' }
       return chk
     }
   })
@@ -2949,12 +2949,12 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // la fecha de la última renuncia por miembro y rechace las que no sean posteriores.
     const actual = (await identity.profileActa?.().catch(() => null))?.acta || null
     if (!actual) {
-      audit('rejected', { what: 'renounce', reason: 'sin-acta' })
+      audit('rejected', { what: 'renounce', reason: 'no-record' })
       return reply(from, { type: MSG.ERROR, error: 'renounce: this vault has no record to apply it to' })
     }
     const tiene = new Set(Acta.effectiveCaps(actual, record.member) || [])
     if (!(record.caps || []).some((c) => tiene.has(c))) {
-      audit('rejected', { what: 'renounce', reason: 'nada-que-quitar' })
+      audit('rejected', { what: 'renounce', reason: 'nothing-to-remove' })
       return reply(from, { type: MSG.ERROR, error: 'renounce: that member no longer holds any of those capabilities' })
     }
     try {
@@ -2963,8 +2963,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
       // de la maestra, y con el perfil cerrado la renuncia se perdía con un error — en el
       // único momento en que de verdad hace falta.
       const guardada = await subacta.add(record)
-      if (!guardada.ok && guardada.reason === 'no-aceptable') {
-        audit('rejected', { what: 'renounce', reason: 'no-aceptable' })
+      if (!guardada.ok && guardada.reason === 'not-acceptable') {
+        audit('rejected', { what: 'renounce', reason: 'not-acceptable' })
         return reply(from, { type: MSG.ERROR, error: 'renounce: the entry is not one this vault accepts' })
       }
       const device = await deviceIdOf(record.member).catch(() => null)

package/src/enroll.js

@@ -143,6 +143,23 @@ export function createEnrollDesk ({
 
   const fire = (fn, arg) => { try { fn(arg) } catch (_) {} }
   const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] could not reply:', e.message) } }
+  /**
+   * LO QUE LA BÓVEDA LE DICE AL APARATO MIENTRAS SE EMPAREJA VA FIRMADO CON LA MAESTRA, y
+   * con el `sn` de la sesión dentro. Lo que va a la cuenta lo reciben todas sus bóvedas y
+   * cualquiera que lo vea pasar puede contestar; sin firma, un `vault.error` de cualquiera
+   * tumbaba el alta (el iPhone, haciendo de bóveda, lo hacía sin querer, 2026-10-18). El
+   * aparato solo obedece lo que verifica contra la `iss` de su invitación (`fromMyVault`).
+   */
+  // Lo firmado va en un bloque aparte (`signed`), como en el hello: quien envía estampa lo suyo
+  // en el sobre (versión, protocolo) y la firma tiene que cubrir exactamente lo que se verifica.
+  // Los campos de arriba (`error`, `deviceId`) son los de siempre, para quien los lee.
+  const tell = async (to, obj, sn) => {
+    const signed = { ...obj, sn: sn || null, iss, ts: Date.now() }
+    let signature
+    try { ({ signature } = await identity.signData(signed)) } catch (e) { log('[vault] could not sign the reply:', e.message); return }
+    reply(to, { ...obj, signed, vsig: signature })
+  }
+  const fail = (to, error, sn) => tell(to, { type: MSG_ERROR, error }, sn)
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
 
   /**
@@ -182,7 +199,9 @@ export function createEnrollDesk ({
       if (!caps.length && !cn) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
       caps = [...new Set(caps)]
     }
-    pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
+    // Uno a la vez: una sesión nueva supersede a la anterior. Las que se quitan se recuerdan
+    // como MÍAS: a un aparato que llegue con una de esas sí se le contesta que ya no vale.
+    for (const k of pending.keys()) forget(k)
     const acct = String(account || '').slice(0, 40)
     // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
     // nonce de la sesión. La llave, el proxy y el nombre de la cuenta los pide el
@@ -206,7 +225,21 @@ export function createEnrollDesk ({
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
-  function stopPairing (token) { pending.delete(token) }
+  function stopPairing (token) { forget(token) }
+
+  /**
+   * Las sesiones que ESTA bóveda abrió y ya no valen (superadas, paradas o gastadas), por
+   * su token y su `sn`. Distingue «la abrí yo y ya no vale» (se contesta con el error) de
+   * «no sé nada de esa invitación» (se calla: la abrió otra bóveda de la cuenta).
+   */
+  const gone = new Set()
+  function forget (key) {
+    const pend = pending.get(key)
+    pending.delete(key)
+    if (!pend) return
+    gone.add(pend.token); if (pend.sn) gone.add(pend.sn)
+    while (gone.size > 200) gone.delete(gone.values().next().value)
+  }
 
   function listPending () {
     return [...pending.values()]
@@ -229,9 +262,18 @@ export function createEnrollDesk ({
    */
   async function handleHello (from, p) {
     const pend = pending.get(String(p?.sn || ''))
+    // UNA INVITACIÓN QUE NO ES MÍA NO SE CONTESTA. Una cuenta tiene varias bóvedas a la vez
+    // (la del VPS, la pestaña, el teléfono que hace de bóveda), y lo que va a la cuenta les
+    // llega a todas. Si la que no abrió el emparejamiento contesta «no hay sesión», ese
+    // error le gana a la respuesta buena y el aparato se queda fuera (2026-10-18: el iPhone
+    // tumbaba cada alta de un servicio). Se anota y se calla: la que la abrió, contesta.
+    if (!pend && !gone.has(String(p?.sn || ''))) {
+      audit('ignored', { what: 'hello', reason: 'not-mine' })
+      return { ignored: true }
+    }
     if (!pend || Date.now() > pend.exp) {
-      audit('rejected', { what: 'hello', reason: 'sin-sesion' })
-      return reply(from, { type: MSG_ERROR, error: 'no pairing session open for that code' })
+      audit('rejected', { what: 'hello', reason: 'no-session' })
+      return fail(from, 'no pairing session open for that code', String(p?.sn || ''))
     }
     // La respuesta va FIRMADA por la maestra y el `sn` va dentro de lo firmado. Eso ata
     // la respuesta a ESTA sesión: no se puede reutilizar la de otro emparejamiento ni la
@@ -250,42 +292,48 @@ export function createEnrollDesk ({
   async function handleEnroll (from, p) {
     const d = p?.data
     if (!d || typeof d.dpub !== 'string' || typeof p.signature !== 'string') {
-      return reply(from, { type: MSG_ERROR, error: 'invalid enroll' })
+      return fail(from, 'invalid enroll', p?.data?.sn)
     }
     const pend = pending.get(d.token)
+    // Lo mismo que en el hello: una sesión que esta bóveda no abrió no es suya para
+    // rechazarla. Solo contesta por las que conoce (gastada o vencida).
+    if (!pend && !gone.has(String(d.token || ''))) {
+      audit('ignored', { what: 'enroll', reason: 'not-mine' })
+      return { ignored: true }
+    }
     if (!pend || pend.state === 'DONE' || Date.now() > pend.exp) {
-      return reply(from, { type: MSG_ERROR, error: 'invalid or expired pairing token' })
+      return fail(from, 'invalid or expired pairing token', d.sn)
     }
-    if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'invalid session' })
+    if (d.sn !== pend.sn) return fail(from, 'invalid session', d.sn)
     // V7 · la INTENCIÓN viaja firmada y tiene que coincidir con el modo con el que ESTA
     // bóveda abrió el emparejamiento. Es lo que garantiza que lo que pasa es lo que el
     // humano vio anunciado en las dos pantallas, y no algo que se decidió a mitad de camino.
     const intent = d.intent || 'join'
     if (intent !== 'join' && intent !== 'adopt') {
-      return reply(from, { type: MSG_ERROR, error: 'unknown intent: ' + intent })
+      return fail(from, 'unknown intent: ' + intent, d.sn)
     }
     if (intent !== (pend.mode || 'join')) {
       audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
-      return reply(from, { type: MSG_ERROR, error: `this pairing was opened for "${pend.mode || 'join'}" and the device asked for "${intent}"` })
+      return fail(from, `this pairing was opened for "${pend.mode || 'join'}" and the device asked for "${intent}"`, d.sn)
     }
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
-      return reply(from, { type: MSG_ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
+      return fail(from, 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)', d.sn)
     }
     // PRUEBA DE POSESIÓN: la firma de `data` debe verificar contra `dpub`.
     if (!(await verifyDeviceSig({ publickey: d.dpub, data: d, signature: p.signature }))) {
       audit('rejected', { what: 'enroll', reason: 'bad-device-signature' })
-      return reply(from, { type: MSG_ERROR, error: 'invalid device signature' })
+      return fail(from, 'invalid device signature', d.sn)
     }
     // El COMPROMISO del código es obligatorio: sin él no se puede comprobar al aprobar
     // y volveríamos a emitir certs a ciegas. Un cliente viejo cae acá con un mensaje claro.
     if (typeof d.commit !== 'string' || !/^[0-9a-f]{64}$/.test(d.commit)) {
       audit('rejected', { what: 'enroll', reason: 'no-commit' })
-      return reply(from, { type: MSG_ERROR, error: 'this device speaks an old pairing version (no code commitment). Update it and try again.' })
+      return fail(from, 'this device speaks an old pairing version (no code commitment). Update it and try again.', d.sn)
     }
     // Un solo dispositivo a la vez esperando su código (así aprobar no es ambiguo).
     if (pend.state === 'PENDING_CONFIRM' && pend.dpub && pend.dpub !== d.dpub) {
-      return reply(from, { type: MSG_ERROR, error: 'another device is already using this pairing session' })
+      return fail(from, 'another device is already using this pairing session', d.sn)
     }
 
     const deviceId = await deviceIdOf(d.dpub)
@@ -300,7 +348,7 @@ export function createEnrollDesk ({
     // 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)' })
+      return fail(from, 'a service must send its encryption key (update @dotrino/vault on the service)', d.sn)
     }
     // 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.
@@ -322,7 +370,7 @@ export function createEnrollDesk ({
     // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
     if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
-    reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
+    await tell(from, { type: MSG_ENROLL_CHALLENGE, deviceId }, pend.sn)
     fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', machine: pend.machine || null, mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
@@ -410,8 +458,8 @@ export function createEnrollDesk ({
         log('[vault] could not revoke the undelivered certificate %s: %s', cert.nonce, re.message)
       }
       audit('rejected', { what: 'approve', device: pend.deviceId, reason: 'admit-failed' })
-      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not add this device to the account: pairing failed, try again' })
-      pending.delete(pend.token)
+      await fail(pend.from, 'the vault could not add this device to the account: pairing failed, try again', pend.sn)
+      forget(pend.token)
       fire(onPendingChange)
       log('[vault] could not add %s to the record, no certificate was delivered: %s', pend.deviceId, e.message)
       throw Object.assign(
@@ -427,7 +475,7 @@ export function createEnrollDesk ({
     // El acta viaja con el cert: el dispositivo ya sabe de quién es el perfil al que entra.
     reply(pend.from, { type: MSG_ENROLLED, code, cert, iss, acta: record })
     pend.state = 'DONE'
-    pending.delete(pend.token)
+    forget(pend.token)
     fire(onPendingChange)
     log(`[vault] device approved: ${pend.deviceId}`)
     return { ok: true, deviceId: pend.deviceId, cert }
@@ -451,22 +499,22 @@ export function createEnrollDesk ({
   async function handleActaSealed (from, p) {
     const record = p?.acta
     const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
-    if (!pend) return reply(from, { type: MSG_ERROR, error: 'no adoption awaiting a record' })
-    if (!record || typeof record !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
+    if (!pend) return fail(from, 'no adoption awaiting a record', pend?.sn)
+    if (!record || typeof record !== 'object') return fail(from, 'record missing or unreadable', pend?.sn)
     // Ya no hay campo `sealer`: se le pregunta al PERMISO. Es la misma comprobación —«¿me
     // nombra a mí la que me mandan?»— dicha en el idioma nuevo, y con varios selladores la
     // respuesta puede ser que sí para más de uno, que es lo correcto.
     if (!canSeal(record, iss)) {
       audit('rejected', { what: 'adopt', reason: 'not-sealer' })
-      return reply(from, { type: MSG_ERROR, error: 'that record does not let this vault seal it' })
+      return fail(from, 'that record does not let this vault seal it', pend?.sn)
     }
     if (record.sealedBy !== pend.dpub) {
       audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
-      return reply(from, { type: MSG_ERROR, error: 'that record was not sealed by the device of this pairing' })
+      return fail(from, 'that record was not sealed by the device of this pairing', pend?.sn)
     }
     if (pend.profileId && record.profileId !== pend.profileId) {
       audit('rejected', { what: 'adopt', reason: 'other-profile' })
-      return reply(from, { type: MSG_ERROR, error: 'that record belongs to an account other than the one the device announced' })
+      return fail(from, 'that record belongs to an account other than the one the device announced', pend?.sn)
     }
 
     try {
@@ -478,26 +526,26 @@ export function createEnrollDesk ({
       const mine = (await identity.profileActa?.())?.acta || record
       reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mine })
       pend.state = 'DONE'
-      pending.delete(pend.token)
+      forget(pend.token)
       fire(onPendingChange)
       fire(onAdopted, { deviceId: pend.deviceId, profileId: record.profileId, seq: mine.seq })
       log('[vault] account adopted from device %s (profile %s)', pend.deviceId, record.profileId?.slice(0, 12))
       return { ok: true, adopted: true, profileId: record.profileId, seq: mine.seq }
     } catch (e) {
       log('[vault] could not adopt the account: %s', e.message)
-      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not adopt the account: ' + e.message })
+      fail(pend.from, 'the vault could not adopt the account: ' + e.message, pend.sn)
       return { ok: false, error: e.message }
     }
   }
 
   /** Rechaza un enrolamiento pendiente. */
-  function reject (deviceId) {
+  async function reject (deviceId) {
     const pend = deviceId
       ? findPending(deviceId)
       : [...pending.values()].find((p) => p.state === 'PENDING_CONFIRM')
     if (!pend) return { ok: false }
-    reply(pend.from, { type: MSG_ERROR, error: 'pairing rejected' })
-    pending.delete(pend.token)
+    await fail(pend.from, 'pairing rejected', pend.sn)
+    forget(pend.token)
     audit('reject', { device: pend.deviceId })
     fire(onPendingChange)
     log('[vault] dispositivo rechazado: %s', pend.deviceId)

package/src/index.js

@@ -261,7 +261,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (expectedScope) {
       const record = (await identity.profileActa?.().catch(() => null))?.acta || null
       if (record && !memberCanScope(record, chk.device, expectedScope)) {
-        send(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
+        send(from, { type: MSG.ERROR, error: 'unauthorized: record — this member no longer has that permission' })
         return null
       }
     }
@@ -356,7 +356,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (p.type === MSG.HELLO) handle('hello', desk.handleHello(_from, p), _from)
     else if (p.type === MSG.ENROLL) handle('enroll', desk.handleEnroll(_from, p), _from)
     // Camino A: el aparato devuelve su acta sellada admitiendo a esta bóveda.
-    else if (p.type === MSG.ACTA_SEALED) handle('acta', desk.handleActaSealed(_from, p), _from)
+    else if (p.type === MSG.ACTA_SEALED) handle('record-sealed', desk.handleActaSealed(_from, p), _from)
     else if (p.type === MSG.RENEW) handle('renew', handleRenew(_from, p), _from)
     else if (p.type === MSG.DEVICES) handle('devices', handleDevices(_from, p), _from)
     // Lo que faltaba para que un aparato enrolado aquí pueda hacer lo mismo que contra

package/src/passwordLogins.js

@@ -67,7 +67,7 @@ export const loginAddress = (user, fingerprint) => `${user}@${accountCode(finger
  */
 export async function accountFingerprint (identity) {
   const pid = (await identity?.profileActa?.().catch(() => null))?.acta?.profileId
-  if (!pid) throw err('no-acta', 'this vault has no account record yet: there is no address to build')
+  if (!pid) throw err('no-record', 'this vault has no account record yet: there is no address to build')
   return (await pubkeyId(pid)).slice(0, 16)
 }
 

package/src/service.js

@@ -307,15 +307,29 @@ function writeServiceIdentity (dir, obj) {
  * Devuelve el mismo `qr` con `iss`, `proxy` y `acct` puestos. Con un QR largo no pregunta
  * nada: ya los trae.
  */
+/**
+ * ¿LO DICE MI BÓVEDA, DE ESTA SESIÓN? Lo que va a la cuenta lo reciben todas sus bóvedas y
+ * cualquiera que lo vea pasar puede contestar. Un reto o un error solo cuentan si vienen
+ * firmados con la maestra de la invitación (`iss`) y con el `sn` de esta sesión; lo demás
+ * se descarta, venga de quien venga. Sin esto, un `vault.error` de cualquiera tumbaba el alta.
+ */
+export async function fromMyVault (p, qr) {
+  const b = p?.signed
+  if (!p?.vsig || !b || typeof b !== 'object' || !qr?.iss) return false
+  if (b.iss !== qr.iss || b.sn !== qr.sn || b.type !== p.type) return false
+  try { return await verifyDeviceSig({ publickey: qr.iss, data: b, signature: p.vsig }) } catch (_) { return false }
+}
+
 export async function sayHello (client, qr) {
   if (qr.iss) return qr
   const target = await resolveAppointment(client, qr.conn)
   const hello = await new Promise((resolve, reject) => {
+    // Un error aquí no se puede verificar (todavía no se sabe quién es la bóveda), así que no
+    // se le hace caso: o llega el hello firmado, o se agota el plazo.
     const off = client.on('message', (_f, p) => {
       if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
-      else if (p?.type === MSG.ERROR) { finish(); reject(vaultError(p)) }
     })
-    const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
+    const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired or be someone else\'s')) }, 15000)
     const finish = () => { off(); clearTimeout(t) }
     try { client.send(target, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { finish(); reject(e) }
   })
@@ -382,8 +396,11 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
-      const off = client.on('message', (_from, p) => {
+      const off = client.on('message', async (_from, p) => {
         if (!p || typeof p !== 'object') return
+        // El reto y los errores solo valen firmados por MI bóveda para ESTA sesión; el resto
+        // (otra bóveda de la cuenta, o cualquiera que viera pasar el alta) se descarta.
+        if ((p.type === MSG.ENROLL_CHALLENGE || p.type === MSG.ERROR) && !await fromMyVault(p, qr)) return
         if (p.type === MSG.ENROLL_CHALLENGE) {
           const show = onCode || (({ deviceId, code }) => console.log(`[vault] device ${deviceId} · approve it on the vault:  dotrino-vault approve ${code}`))
           show({ deviceId, code })