@dotrino/identity 0.37.1 → 0.39.0

package/vault/vault.js

@@ -119,7 +119,11 @@ import { pubkeyId } from './capabilities.js'
     listDelegations: () => handlers.listDelegations({}),
     revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
     admitMember: (m) => handlers.admitMember(m),
-    profileActa: () => handlers.profileActa({})
+    profileActa: () => handlers.profileActa({}),
+    // Camino A (`mode: 'adopt'`): la bóveda se queda con la cuenta que trae el aparato,
+    // y para eso tiene que poder ENTRAR en su acta. Sin esto, adoptar fallaba con un
+    // «no es una función» en vez de con un error del protocolo.
+    joinProfile: (acta) => handlers.joinProfile({ acta })
   }
 
   async function startSelfDaemon () {
@@ -216,7 +220,7 @@ import { pubkeyId } from './capabilities.js'
       return { ok: true, enabled: !!enabled }
     },
     selfVaultPairing: async (opts) => {
-      if (!daemon) throw new Error('esta pestaña no es la bóveda activa; ábrela como pestaña visible')
+      if (!daemon) throw new Error('this tab is not the active vault; open it as a visible tab')
       return daemon.startPairing(opts)
     },
     selfVaultPending: async () => (daemon ? daemon.listPending() : []),
@@ -226,11 +230,11 @@ import { pubkeyId } from './capabilities.js'
       return issued || []
     },
     selfVaultApprove: async ({ deviceId, code }) => {
-      if (!daemon) throw new Error('esta pestaña no es la bóveda activa')
+      if (!daemon) throw new Error('this tab is not the active vault')
       return daemon.approve(deviceId, code)
     },
     selfVaultReject: async ({ deviceId }) => {
-      if (!daemon) throw new Error('esta pestaña no es la bóveda activa')
+      if (!daemon) throw new Error('this tab is not the active vault')
       daemon.reject(deviceId)
       return { ok: true }
     },

package/vault/vendor/vault/VERSION.txt

@@ -1,6 +1,6 @@
-Copia vendorizada de @dotrino/vault@0.7.0 (lib/src/{index,enroll}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.18.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
 El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
-resuelve en el navegador sin bundler. index.js importa ./enroll.js (relativo, se
-vendoriza tambien) y @dotrino/identity/capabilities (=../../capabilities.js) y
-@dotrino/proxy-client (=../proxy-client/), ambos via el import map de index.html.
-Re-vendorizar AMBOS archivos al subir @dotrino/vault.
+resuelve en el navegador sin bundler. index.js importa ./enroll.js y ./protocol.js
+(relativos, se vendorizan tambien) y @dotrino/identity/capabilities (=../../capabilities.js)
+y @dotrino/proxy-client (=../proxy-client/), ambos via el import map de index.html.
+Re-vendorizar LOS TRES archivos al subir @dotrino/vault.

package/vault/vendor/vault/enroll.js

@@ -39,14 +39,20 @@ export const FRESH_WINDOW_MS = 5 * 60 * 1000
 /** Vida por defecto del cert de un dispositivo (tope duro de `MAX_DELEGATION_MS`). */
 export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 
+export const MSG_HELLO = 'vault.hello'
+export const MSG_HELLO_OK = 'vault.hello.ok'
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
+// --- camino A: la cuenta del aparato pasa a vivir en la bóveda ---
+export const MSG_ENROLL_ADOPT = 'vault.enroll.adopt'
+export const MSG_ACTA_SEALED = 'vault.acta.sealed'
+export const MSG_ACTA_ADOPTED = 'vault.acta.adopted'
 export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
 /** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
-const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read' }
+const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin' }
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 
@@ -63,12 +69,22 @@ export function scopeToCn (scope) {
   return null
 }
 
-/** Token aleatorio de 128 bits en hex. */
-export function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
+/**
+ * Token aleatorio en hex (16 bytes = 128 bits por defecto).
+ *
+ * El emparejamiento pide 12 (96 bits): son de un solo uso, valen 5 minutos y hay
+ * UNA sesión viva a la vez, así que adivinarlo es 2^95 intentos contra una bóveda
+ * que además exige el código de 6 dígitos. A cambio, cada byte de menos son ~1,4
+ * caracteres menos en el QR — y el QR se mide en filas de terminal.
+ */
+export function randToken (bytes = 16) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes))
   return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/** Tamaño del token/nonce de una sesión de emparejamiento (ver `randToken`). */
+const PAIR_TOKEN_BYTES = 12
+
 /** deviceId legible (p. ej. `C440-AC0E`) a partir de una pubkey JWK. */
 export async function deviceIdOf (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -94,27 +110,65 @@ export async function deviceIdOf (pub) {
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {},
-  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
+  // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
+  // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
+  encPub = null, vaultLabel = '',
+  // Token de CONEXIÓN de esta bóveda en el proxy (4 chars): su dirección. Es lo
+  // único que necesita el QR corto para que el aparato le hable punto a punto.
+  connToken = null
 } = {}) {
-  if (!identity) throw new Error('createEnrollDesk: falta identity')
-  if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
+  if (!identity) throw new Error('createEnrollDesk: missing identity')
+  if (!iss) throw new Error('createEnrollDesk: missing iss (master pubkey)')
 
   // token -> { token, exp, scope, ttlMs, label, sn, state, dpub?, deviceId?, commit?, from? }
   // state: 'AWAITING_ENROLL' -> 'PENDING_CONFIRM'
   const pending = new Map()
 
   const fire = (fn, arg) => { try { fn(arg) } catch (_) {} }
-  const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) } }
+  const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] could not reply:', e.message) } }
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
 
-  /** Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía. */
-  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '' } = {}) {
+  /**
+   * Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía.
+   *
+   * `mode` y `account` son LO QUE LA BÓVEDA DECLARA que va a pasar, y viajan en el QR
+   * para que el aparato pueda **decirlo antes de hacerlo** en vez de emparejar a
+   * ciegas (decisión V9 de `docs/vinculacion-de-cuentas.md`: pregunta el vault, el
+   * dispositivo muestra el proceso y sus consecuencias):
+   *
+   *   · `mode: 'join'`  → el dispositivo estrena una cuenta suya y entra a la de la
+   *                       bóveda. Es lo único que existe hoy.
+   *   · `mode: 'adopt'` → la bóveda se quedaría con la cuenta que trae el aparato
+   *                       (camino A). Reservado: todavía no hay protocolo.
+   *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
+   *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
+   *                       identidad de verdad de la cuenta es `iss`.
+   */
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
-    const token = randToken()
-    const sn = randToken()
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, state: 'AWAITING_ENROLL' })
-    return { token, qr: { v: 2, iss, proxy, token, sn }, expiresInMs: PAIRING_TTL_MS }
+    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
+    // aparato por la red presentando el `sn`. El nonce hace de identificador de
+    // sesión: no hace falta un token de emparejamiento aparte.
+    //
+    // `conn` es una CITA del proxio (6 caracteres, un solo uso, caduca en
+    // minutos), no la dirección de la conexión: esa pasó a ser una instancia de
+    // 24 caracteres, que ni entra cómoda en un QR ni tiene por qué quedar impresa
+    // en algo que circula. Por eso se pide una nueva por emparejamiento, y por
+    // eso esto es asíncrono.
+    const conn = typeof connToken === 'function' ? await connToken() : connToken
+    if (conn) {
+      const sn = randToken(8)
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
+    }
+    const token = randToken(PAIR_TOKEN_BYTES)
+    const sn = randToken(PAIR_TOKEN_BYTES)
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+    return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
   function stopPairing (token) { pending.delete(token) }
@@ -132,6 +186,28 @@ export function createEnrollDesk ({
     return null
   }
 
+  /**
+   * «¿Quién eres?» — la respuesta al QR corto. Solo se contesta a quien presente el
+   * `sn` de una sesión VIVA: el token de conexión son 4 caracteres y se puede acertar
+   * a ciegas, el `sn` no. Fuera de un emparejamiento no hay ninguna sesión y por lo
+   * tanto no hay respuesta: la puerta solo está abierta mientras dura el `pair`.
+   */
+  async function handleHello (from, p) {
+    const pend = pending.get(String(p?.sn || ''))
+    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' })
+    }
+    // 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
+    // de otra bóveda. Lo que NO hace es demostrar que sea TU bóveda —cualquiera puede
+    // firmar con una llave suya—; eso solo lo demuestra el código de 6 dígitos.
+    const body = { op: 'hello', sn: pend.sn, iss, proxy, acct: pend.account || '', m: pend.mode || 'join', ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    reply(from, { type: MSG_HELLO_OK, body, signature })
+    return { ok: true }
+  }
+
   /**
    * ENROLL: el dispositivo prueba posesión de `D` firmando el sobre y deja el
    * COMPROMISO de su código. Todavía NO se firma ningún cert.
@@ -139,31 +215,42 @@ 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: 'enroll inválido' })
+      return reply(from, { type: MSG_ERROR, error: 'invalid enroll' })
     }
     const pend = pending.get(d.token)
     if (!pend || pend.state === 'DONE' || Date.now() > pend.exp) {
-      return reply(from, { type: MSG_ERROR, error: 'token de emparejamiento inválido o expirado' })
+      return reply(from, { type: MSG_ERROR, error: 'invalid or expired pairing token' })
+    }
+    if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'invalid session' })
+    // 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 })
+    }
+    if (intent !== (pend.mode || 'join')) {
+      audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
+      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
     }
-    if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'sesión inválida' })
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
-      return reply(from, { type: MSG_ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
+      return reply(from, { type: MSG_ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
     // 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: 'firma de dispositivo inválida' })
+      return reply(from, { type: MSG_ERROR, error: 'invalid device signature' })
     }
     // 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: 'este dispositivo usa una versión antigua del emparejamiento (no envía el compromiso del código). Actualízalo y vuelve a intentarlo.' })
+      return reply(from, { type: MSG_ERROR, error: 'this device speaks an old pairing version (no code commitment). Update it and try again.' })
     }
     // 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: 'ya hay un dispositivo usando este emparejamiento' })
+      return reply(from, { type: MSG_ERROR, error: 'another device is already using this pairing session' })
     }
 
     const deviceId = await deviceIdOf(d.dpub)
@@ -182,9 +269,12 @@ export function createEnrollDesk ({
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
+    // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
+    // 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 })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -199,16 +289,16 @@ export function createEnrollDesk ({
    */
   async function approve (code, { deviceId } = {}) {
     code = String(code || '').trim()
-    if (!code) throw new Error('falta el código (los dígitos que muestra el dispositivo)')
+    if (!code) throw new Error('missing code (the digits shown by the device)')
 
     let pend
     if (deviceId) {
       pend = findPending(deviceId)
-      if (!pend) throw new Error('no hay ninguna máquina esperando aprobación con ese identificador')
+      if (!pend) throw new Error('no device awaiting approval with that id')
     } else {
       const waiting = [...pending.values()].filter((p) => p.state === 'PENDING_CONFIRM' && p.dpub)
-      if (waiting.length === 0) throw new Error('no hay ningún dispositivo esperando aprobación')
-      if (waiting.length > 1) throw new Error('hay más de un emparejamiento en curso; reinícialo con dotrino-vault pair')
+      if (waiting.length === 0) throw new Error('no device awaiting approval')
+      if (waiting.length > 1) throw new Error('more than one pairing in flight; restart it with dotrino-vault pair')
       pend = waiting[0]
     }
 
@@ -216,8 +306,22 @@ export function createEnrollDesk ({
     const expected = await commitCode({ code, dpub: pend.dpub, sn: pend.sn })
     if (expected !== pend.commit) {
       audit('rejected', { what: 'approve', device: pend.deviceId, reason: 'bad-code' })
-      log('[vault] código incorrecto para %s: no se emitió ningún certificado', pend.deviceId)
-      throw new Error('el código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Vuelve a mirarlo y prueba otra vez.')
+      log('[vault] wrong code for %s: no certificate was issued', pend.deviceId)
+      throw new Error('code does not match the one shown by the device: no certificate was issued. Check it and try again.')
+    }
+
+    // CAMINO A · aquí la bóveda no entrega un cert: entrega SU IDENTIDAD para que el
+    // aparato la meta en el acta de la cuenta que le está pasando. El código de vuelta es
+    // la misma defensa de siempre, en el otro sentido: el aparato solo hace caso a una
+    // bóveda que demuestre que un humano la aprobó.
+    if ((pend.mode || 'join') === 'adopt') {
+      audit('adopt-approve', { device: pend.deviceId, profile: pend.profileId || null })
+      pend.state = 'AWAITING_ACTA'
+      pend.approvedAt = Date.now()
+      reply(pend.from, { type: MSG_ENROLL_ADOPT, code, pub: iss, encPub: encPub || null, label: vaultLabel || '' })
+      log('[vault] adoption approved for %s: waiting for the sealed record', pend.deviceId)
+      fire(onPendingChange)
+      return { ok: true, deviceId: pend.deviceId, adopting: true }
     }
 
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
@@ -247,13 +351,67 @@ export function createEnrollDesk ({
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
+  /**
+   * CAMINO A · paso 6: llega el acta que el aparato acaba de sellar, con la bóveda dentro
+   * como miembro, la clave de contenido envuelta para ella y el mando ya traspasado.
+   *
+   * Lo que se comprueba antes de guardar nada (y por qué):
+   *   · que el sellador sea ESTA bóveda — si no, no es un traspaso, es un acta ajena;
+   *   · que la selle el aparato que estaba en este emparejamiento — cierra que un tercero
+   *     que vea pasar el mensaje cuele la suya;
+   *   · que sea la cuenta que ese aparato declaró al enrolarse (`profileId`) — cierra el
+   *     cambiazo de cuenta entre el anuncio que leyó el humano y lo que llega después.
+   *
+   * Adoptar la cuenta de otro solo procede sobre un perfil que **nació para eso** (la marca
+   * de `prepareForAdoption`). Es la misma regla del navegador: sin la marca, adoptar sería
+   * pisar una cuenta con datos, y eso no puede pasar por accidente.
+   */
+  async function handleActaSealed (from, p) {
+    const acta = 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 (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'that record does not name this vault as the sealer' })
+    }
+    if (acta.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' })
+    }
+    if (pend.profileId && acta.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' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'could not adopt')
+      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
+      // dos quedan en la misma versión.
+      const mia = (await identity.profileActa?.())?.acta || acta
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      pend.state = 'DONE'
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
+      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+    } catch (e) {
+      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not adopt the account: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   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: 'emparejamiento rechazado' })
+    reply(pend.from, { type: MSG_ERROR, error: 'pairing rejected' })
     pending.delete(pend.token)
     audit('reject', { device: pend.deviceId })
     fire(onPendingChange)
@@ -270,7 +428,7 @@ export function createEnrollDesk ({
     const body = { op: 'revoke', sub: dpub, nonce, iat: Date.now(), exp: Date.now() + DEVICE_TTL_MS }
     const { signature } = await identity.signData(body)
     try { sendByPubkey(dpub, { type: MSG_REVOKED, body, signature }) }
-    catch (e) { log('[vault] no se pudo emitir revoke:', e.message) }
+    catch (e) { log('[vault] could not emit revoke:', e.message) }
   }
 
   /** Revoca una delegación por `nonce` y avisa al dispositivo para que se autoborre. */
@@ -284,7 +442,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, handleHello, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/vault/vendor/vault/index.js

@@ -27,16 +27,13 @@
  */
 import { verifyChain } from '@dotrino/identity/capabilities'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
+// Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
+// local se queda corta, el dispositivo deja de atender mensajes sin que nadie lo note.
+import { MSG, SCOPE } from './protocol.js'
 
-const SIGN_SCOPE = 'vault:sign'
+const SIGN_SCOPE = SCOPE.SIGN
 const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
-
-const MSG = {
-  ENROLL: 'vault.enroll',
-  DEVICES: 'vault.devices',
-  DEVICES_RESULT: 'vault.devices.result',
-  ERROR: 'vault.error'
-}
+const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
 
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
 export { deviceIdOf }
@@ -49,10 +46,11 @@ export { deviceIdOf }
  *   `me.publickey`, `signData`, `signDelegation`, `listDelegations`, `revokeDelegation`.
  * @param {object} [opts]
  * @param {string} [opts.proxyUrl='wss://proxy.dotrino.com']
- * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, approve, reject,
- *   listPending, listMachines, revoke, getSelfCert, onPendingChange, close }
+ * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, stopPairing,
+ *   approve, reject, listPending, listMachines, revoke, getSelfCert, onPendingChange,
+ *   onAdopted, close }
  */
-export async function startDeviceVault (identity, { proxyUrl } = {}) {
+export async function startDeviceVault (identity, { proxyUrl, client: injectedClient } = {}) {
   const iss = identity.me?.publickey
   if (!iss) throw new Error('sin identidad: crea/desbloquea tu identidad antes de usar el dispositivo como bóveda')
   const proxy = proxyUrl || 'wss://proxy.dotrino.com'
@@ -67,12 +65,17 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     return cert
   }
 
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({
-    url: proxy, enableWebRTC: false, autoReconnect: true,
-    maxReconnectAttempts: 100000, reconnectDelay: 4000
-  })
-  await client.connect()
+  // `client` inyectado: solo para las pruebas (transporte de mentira). En producción se
+  // levanta el del ecosistema — no hay otro transporte.
+  const client = injectedClient || await (async () => {
+    const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+    const c = new WebSocketProxyClient({
+      url: proxy, enableWebRTC: false, autoReconnect: true,
+      maxReconnectAttempts: 100000, reconnectDelay: 4000
+    })
+    await c.connect()
+    return c
+  })()
 
   const selfCert = await getSelfCert()
   const identify = async () => {
@@ -87,6 +90,7 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
   const send = (to, obj) => { try { client.send(to, obj) } catch (_) {} }
 
   let _onPendingChange = () => {}
+  let _onAdopted = () => {}
 
   // ENROLL / aprobación / revocación: núcleo COMPARTIDO con el daemon del PC y con la
   // copia vendorizada del iframe (`lib/src/enroll.js`). Un solo sitio donde vive el
@@ -99,9 +103,49 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     sendByPubkey: (pub, obj) => { try { client.sendByPubkey(pub, obj) } catch (_) {} },
     defaultScope: [SIGN_SCOPE],
     defaultTtlMs: DEVICE_TTL_MS,
+    // Camino A (la cuenta del aparato pasa a vivir aquí): sin la llave de cifrado, esta
+    // bóveda entraría mandando una cuenta cuyo contenido no puede abrir.
+    encPub: identity.me?.encryptionPubkey || null,
+    vaultLabel: 'bóveda',
+    // Cita del proxio para la invitación corta (QR). Si el proxio es viejo y no las
+    // conoce, el desk se cae solo a la invitación larga.
+    connToken: async () => {
+      try { return (await client.requestPairingCode())?.code || null }
+      catch (_) { return null }
+    },
+    onAdopted: (info) => { try { _onAdopted(info) } catch (_) {} },
     onPendingChange: () => _onPendingChange()
   })
 
+  /** Nonces revocados, para que un cert revocado no pase ningún `verifyChain`. */
+  async function revocationSet () {
+    const { revoked } = await identity.listDelegations()
+    return new Set((revoked || []).map((r) => r.nonce || r))
+  }
+
+  /**
+   * RENOVACIÓN automática (igual que `dotrino-vault#handleRenew`): un dispositivo con
+   * cert VIGENTE y no revocado pide uno fresco —misma sub-clave y scope— sin QR ni
+   * aprobación: sigue siendo el mismo dispositivo, solo extiende la ventana. Un cert
+   * vencido o revocado NO se renueva (ahí toca re-emparejar con aprobación).
+   *
+   * Sin esto, toda máquina enrolada contra un dispositivo-bóveda caduca a los 30 días.
+   */
+  async function handleRenew (from, p) {
+    const d = p?.data
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
+      return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
+    }
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss, revoked: await revocationSet() })
+    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+    // Reusar el label del cert original (si sigue registrado en delegations).
+    const { issued } = await identity.listDelegations()
+    const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
+    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
+    send(from, { type: MSG.RENEWED, cert })
+  }
+
   // Consulta de revocaciones (igual que `vault.devices` del daemon): responde la lista
   // de dispositivos enrolados + revocados para que el dispositivo refresque su set. Y si
   // QUIEN consulta es una máquina ya revocada (reapareció), le re-emite el REVOKED firmado.
@@ -124,7 +168,12 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
 
   client.on('message', (_from, p) => {
     if (!p || typeof p !== 'object') return
-    if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    // El QR corto no lleva la llave: el aparato la pide con un HELLO presentando el `sn`.
+    if (p.type === MSG.HELLO) Promise.resolve(desk.handleHello(_from, p)).catch(() => {})
+    else if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    // Camino A: el aparato devuelve su acta sellada admitiendo a esta bóveda.
+    else if (p.type === MSG.ACTA_SEALED) Promise.resolve(desk.handleActaSealed(_from, p)).catch(() => {})
+    else if (p.type === MSG.RENEW) handleRenew(_from, p).catch(() => {})
     else if (p.type === MSG.DEVICES) handleDevices(_from, p).catch(() => {})
   })
 
@@ -148,6 +197,7 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
   return {
     iss, proxy, client,
     startPairing: desk.startPairing,
+    stopPairing: desk.stopPairing,
     // Aprueba TIPEANDO el código que muestra la máquina: el núcleo compartido recompone
     // el compromiso `SHA-256(code‖dpub‖sn)` y solo firma el cert si coincide.
     approve: (deviceId, code) => desk.approve(code, { deviceId }),
@@ -159,6 +209,8 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },
+    /** Camino A: la cuenta del aparato quedó adoptada por esta bóveda. */
+    onAdopted (fn) { _onAdopted = fn || (() => {}) },
     close () { try { client.close() } catch (_) {} }
   }
 }

package/vault/vendor/vault/protocol.js

@@ -0,0 +1,93 @@
+/**
+ * Protocolo de mensajes entre un dispositivo y el vault (viajan por el proxy,
+ * direccionados por pubkey con `sendByPubkey`). El cuerpo va JSON-serializado en
+ * el campo `message` del sobre del proxy; el cliente lo entrega ya parseado.
+ *
+ * Emparejamiento ENDURECIDO (ver dotrino-vault/docs/pairing-protocol.md):
+ *   1. dispositivo → vault   ENROLL { data:{op,dpub,token,sn,label,ts}, signature }
+ *      (la firma es del dispositivo con su llave D = PRUEBA DE POSESION; un token
+ *       robado ya NO basta para enrolar).
+ *   2. vault → dispositivo   ENROLL_CHALLENGE { deviceId, sas }   (aun NO firma cert)
+ *   3. el dueño compara el SAS (pantalla del dispositivo ↔ del PC) y APRUEBA en el PC
+ *   4. vault → dispositivo   ENROLLED { cert, iss, sas }   (recien aqui firma el cert)
+ *   5. el dispositivo VALIDA la cadena: cert.iss === el iss que vio, cert.sub === D.
+ *
+ * Revocacion (robo): el vault envia REVOKED { body, signature } FIRMADO por la
+ * maestra → el dispositivo se autoborra SOLO si la firma valida contra la maestra
+ * pineada (cierra el wipe-DoS; un ERROR plano jamas borra).
+ */
+export const MSG = Object.freeze({
+  // La invitación corta no lleva la llave: el aparato la pide presentando el `sn` de
+  // la sesión. Una pública es pública — esto no la esconde, solo evita abrirle la
+  // puerta a quien acertó el token de conexión a ciegas.
+  HELLO: 'vault.hello',                       // dispositivo → vault: { sn }
+  HELLO_OK: 'vault.hello.ok',                 // vault → dispositivo: { iss, acct }
+  ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
+  ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
+  ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
+  REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
+  SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
+  SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }
+  GET: 'vault.get',                           // dispositivo → vault: { data, signature, cert }
+  DATA: 'vault.data',                         // vault → dispositivo: { id, node }
+  STORE: 'vault.store',                       // dispositivo → vault: { data:{method,args,publickey,ts}, signature, cert }
+  STORE_RESULT: 'vault.store.result',         // vault → dispositivo: { method, result }
+  DEVICES: 'vault.devices',                   // dispositivo → vault: { data:{publickey,ts}, signature, cert }
+  DEVICES_RESULT: 'vault.devices.result',     // vault → dispositivo: { devices, revoked }
+  RENEW: 'vault.renew',                       // dispositivo → vault: { data:{op,publickey,ts}, signature, cert }
+  RENEWED: 'vault.renewed',                   // vault → dispositivo: { cert }  (cert fresco, misma sub-clave/scope)
+  SECRETS: 'vault.secrets',                   // servicio → vault: { data:{op,ns,ek,publickey,ts}, signature, cert }
+  SECRETS_RESULT: 'vault.secrets.result',     // vault → servicio: { body:{op,ns,enc,ts}, signature } (enc SELLADO a ek; body firmado por la maestra)
+  // AVISO DE CAMBIO (no lleva valores): la bóveda dice «la configuración del ns
+  // cambió». El agente no la recarga en caliente — SALE limpio y su supervisor lo
+  // levanta. Dos razones, y la segunda es la de peso:
+  //   · Lee todo fresco. Recargar en caliente exige que cada sitio que leyó una
+  //     variable sepa releerla, y esa lista hay que mantenerla para siempre.
+  //   · BORRA DE MEMORIA EL VALOR VIEJO. En JavaScript un secreto no se puede
+  //     borrar: los strings son inmutables, no hay zeroize, y el valor queda en el
+  //     heap hasta que al recolector le apetezca — más lo que capturó cada closure
+  //     y cada caché derivada. Una llave se rota casi siempre PORQUE SE FILTRÓ, así
+  //     que dejarla viva en el proceso anula la razón de rotarla. Un proceso nuevo
+  //     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 }
+  // --- 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
+  // NO se exponen aquí, y no es un olvido — es el límite (§2 del diseño).
+  ADMIN: 'vault.admin',                       // admin → vault: { data:{op,…,ts,nonce}, signature, cert }
+  ADMIN_RESULT: 'vault.admin.result',         // vault → admin: { op, result }
+  // 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 }
+  ERROR: 'vault.error'                        // vault → dispositivo: { error }
+})
+
+/** Capacidades que puede llevar un `cert` (scope). Mínimo por defecto. */
+export const SCOPE = Object.freeze({
+  SIGN: 'vault:sign',   // pedir a la maestra que firme datos (identidad)
+  READ: 'vault:read',   // leer nodos del árbol de contenidos
+  STORE: 'vault:store', // leer/escribir el store de hilos + aperturas del usuario
+  // 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'
+})
+
+/**
+ * Scope de SECRETOS por namespace de servicio: un cert con `vault:secrets:proxy`
+ * solo puede leer los secretos del ns `proxy` — un VPS comprometido no puede
+ * pedir los de otro servicio. ns válido: [a-z0-9-]{1,32}.
+ */
+export const SECRETS_SCOPE_PREFIX = 'vault:secrets:'
+export const secretsScope = (ns) => SECRETS_SCOPE_PREFIX + ns
+export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,32}$/.test(ns)