@dotrino/identity 0.22.1 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -319,11 +319,11 @@ export class Identity {
   }
 
   // ----- Self-vault: ESTE dispositivo actúa como su propia bóveda/CA -----
-  // El daemon device-vault vive dentro del iframe (no requiere el binario del PC ni
-  // vault.dotrino.com/pair). Cualquier app puede activarlo, generar códigos de
-  // emparejamiento, aprobar SAS y revocar máquinas — todo por RPC al iframe.
-  // El daemon sólo corre en una pestaña visible a la vez (navigator.locks), pero los
-  // getters (status/pending/machines) y revoke sirven desde cualquier pestaña.
+  // El daemon device-vault vive dentro del iframe (no requiere el binario del PC).
+  // Se gestiona desde profile.dotrino.com/#myvault. Cualquier app puede activarlo,
+  // generar códigos de emparejamiento, aprobar SAS y revocar máquinas — todo por RPC
+  // al iframe. El daemon sólo corre en una pestaña visible a la vez (navigator.locks),
+  // pero los getters (status/pending/machines) y revoke sirven desde cualquier pestaña.
   /** { enabled, running }: si el modo self está activado y si esta pestaña sostiene el daemon. */
   async selfVaultStatus () { return this._call('selfVaultStatus') }
   /** Activa/desactiva el modo self-vault en este dispositivo. */

package/vault/core.js

@@ -249,23 +249,69 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // ----- delegaciones de capacidad emitidas + revocaciones (kv-backed) -----
 
   function loadJson (key) { try { return JSON.parse(kv.getItem(key) || '{}') || {} } catch (_) { return {} } }
-  const loadDelegations = () => loadJson(DELEGATIONS_STORAGE)
+
+  // PODA (los dos registros crecían para siempre): la renovación automática firma un cert
+  // nuevo cada 30 días, así que sin podar cada dispositivo dejaba 12 entradas muertas al año.
+  // Se tira lo que YA NO PUEDE SERVIR, nunca lo vivo:
+  //   · delegación → cuando su `exp` ya pasó (un cert vencido no autoriza nada).
+  //     OJO: no se poda «la anterior del mismo dispositivo» al renovar, porque el cert
+  //     viejo SIGUE VIGENTE hasta su exp y hay que poder revocarlo si te roban el aparato.
+  //   · revocación → 30 días después de revocar: para entonces el cert al que apunta está
+  //     vencido seguro (el tope duro de vida es `MAX_DELEGATION_MS`, y exp ≤ iat + 30 días
+  //     ≤ revokedAt + 30 días), y un cert vencido ya falla por `expired` sin mirar la lista.
+  const DELEGATION_MAX_LIFE_MS = 30 * 24 * 60 * 60 * 1000 // espejo de MAX_DELEGATION_MS (capabilities.js)
+
+  function loadDelegations () {
+    const o = loadJson(DELEGATIONS_STORAGE)
+    const now = Date.now()
+    let changed = false
+    for (const k of Object.keys(o)) {
+      const exp = o[k]?.exp
+      if (typeof exp === 'number' && exp < now) { delete o[k]; changed = true }
+    }
+    if (changed) kv.setItem(DELEGATIONS_STORAGE, JSON.stringify(o))
+    return o
+  }
   const saveDelegations = (o) => kv.setItem(DELEGATIONS_STORAGE, JSON.stringify(o))
-  const loadRevocations = () => loadJson(REVOCATIONS_STORAGE)
+
+  function loadRevocations () {
+    const o = loadJson(REVOCATIONS_STORAGE)
+    const now = Date.now()
+    let changed = false
+    for (const k of Object.keys(o)) {
+      const at = o[k]
+      if (typeof at === 'number' && now - at > DELEGATION_MAX_LIFE_MS) { delete o[k]; changed = true }
+    }
+    if (changed) kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
+    return o
+  }
   const saveRevocations = (o) => kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
 
   // ----- emparejamiento con el vault del usuario (este dispositivo enrolado) -----
-  // Canal de eventos 'vault' (p.ej. el SAS a comparar durante el emparejamiento).
+  // Canal de eventos 'vault' (p.ej. el código a tipear durante el emparejamiento).
   const vaultListeners = new Set()
   const emitVault = (p) => { for (const fn of vaultListeners) { try { fn(p) } catch (_) {} } }
-  // Si el vault RECHAZA por cert revocado, este dispositivo perdió el acceso: limpiamos el
-  // cert local (ya no sirve) y emitimos 'revoked' → @dotrino/store borra SOLO el store de
-  // ESTE perfil (los demás perfiles quedan intactos). Cualquier otro error se propaga igual.
+
+  /**
+   * BORRADO por revocación. Solo lo dispara un `vault.revoked` FIRMADO por la maestra
+   * pineada (lo verifica `remote.js` antes de llamar aquí). Emite 'revoked' →
+   * `@dotrino/store` borra el store de ESTE perfil (los demás quedan intactos).
+   */
+  const wipeVaultLink = () => {
+    try { kv.removeItem(VAULT_CERT_STORAGE); kv.removeItem(VAULT_DEVICE_STORAGE) } catch (_) {}
+    emitVault({ phase: 'revoked' })
+  }
+
+  /**
+   * El vault RECHAZÓ una petición diciendo «revocado». Ese mensaje NO va firmado: lo
+   * puede falsificar cualquiera que conozca la pubkey de este dispositivo, así que
+   * **jamás borra nada** (sería un wipe-DoS: destruir datos ajenos con un mensaje suelto,
+   * prohibido por `dotrino-vault/docs/pairing-protocol.md §2.3`). Lo único que hacemos es
+   * DEGRADAR: avisar a la app de que la bóveda nos está rechazando, y que sea el usuario
+   * quien decida. El borrado real llega por `vault.revoked` firmado (ver `wipeVaultLink`).
+   */
   const handleVaultError = (e) => {
-    if (e && /\brevoked\b/.test(e.message || '')) {
-      try { kv.removeItem(VAULT_CERT_STORAGE); kv.removeItem(VAULT_DEVICE_STORAGE) } catch (_) {}
-      emitVault({ phase: 'revoked' })
-    }
+    if (e && /\brevoked\b/.test(e.message || '')) emitVault({ phase: 'rejected', reason: e.message })
     throw e
   }
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
@@ -305,7 +351,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (v.cert.exp <= now || v.cert.exp - now > RENEW_WINDOW_MS) return
       if (now - renewLastTry < RENEW_RETRY_MS) return
       renewLastTry = now
-      remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert }).then(({ cert }) => {
+      remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink }).then(({ cert }) => {
         kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ ...v, cert, renewedAt: Date.now() }))
         emitVault({ phase: 'renewed', exp: cert.exp })
       }).catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
@@ -870,7 +916,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload }) }
+      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
     },
 
@@ -880,7 +926,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args }) }
+      try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
     },
 
@@ -889,7 +935,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert }) }
+      try { return await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
     },
 

package/vault/remote.js

@@ -5,22 +5,49 @@
  * —cuya privada NUNCA sale de la identidad—, hace el emparejamiento ENDURECIDO por el
  * proxy (ver dotrino-vault/docs/pairing-protocol.md) y devuelve el cert ya validado.
  *
- * Flujo: firma el ENROLL con D (prueba de posesión) → recibe el reto y computa SU
- * propio SAS (que el usuario compara con el del PC) → al ser aprobado en el PC, recibe
- * el cert y lo valida (firmado por la maestra que vio en el QR, y para SU clave).
+ * Flujo: genera un código de 6 dígitos, lo MUESTRA y manda solo su COMPROMISO dentro del
+ * ENROLL firmado con D (prueba de posesión) → el dueño tipea el código en la bóveda, que
+ * lo comprueba contra el compromiso y solo entonces firma → el dispositivo acepta el cert
+ * si le ECHAN su código y lo valida (firmado por la maestra que vio en el QR, y para SU clave).
  *
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, makePairingCode, pubkeyId } from './capabilities.js'
+import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
 
 const MSG = {
   ENROLL: 'vault.enroll',
   ENROLL_CHALLENGE: 'vault.enroll.challenge',
   ENROLLED: 'vault.enrolled',
+  REVOKED: 'vault.revoked',
   ERROR: 'vault.error'
 }
 
+/**
+ * ¿Es AUTÉNTICO este `vault.revoked`? Solo lo es si va firmado por la maestra PINEADA al
+ * emparejar, es para ESTE dispositivo y no ha caducado. Es la única puerta al autoborrado:
+ * un `vault.error` con la palabra «revocado» no borra nada (cierra el wipe-DoS, ver
+ * `dotrino-vault/docs/pairing-protocol.md §2.3`).
+ */
+export async function isAuthenticRevoke ({ body, signature, master, devicePubkey }) {
+  if (!body || body.op !== 'revoke' || typeof signature !== 'string') return false
+  if (body.sub !== devicePubkey) return false
+  if (typeof body.exp === 'number' && Date.now() > body.exp) return false
+  return verifyDeviceSig({ publickey: master, data: body, signature })
+}
+
+/**
+ * Identifica la conexión bajo la pubkey de este dispositivo. Además de hacerlo
+ * direccionable, es lo que hace que el proxy le entregue lo que tenía ENCOLADO (24 h) —
+ * entre otras cosas, un `vault.revoked` emitido mientras estaba apagado.
+ */
+async function identifyAsDevice (client, device) {
+  if (!client.token) return
+  const data = { op: 'identify', publickey: device.publickey, token: client.token, ts: Date.now() }
+  const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
+  await client.identify({ data, signature })
+}
+
 /**
  * @param {Object} opts
  * @param {{v:number, iss:string, proxy:string, token:string, sn:string}} opts.qr  QR v2 del vault.
@@ -43,9 +70,12 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     // El DISPOSITIVO genera el código y manda solo su COMPROMISO (no el código). El vault
     // aprende el código únicamente cuando vos lo tipeás en el PC → aprobar exige tener el dispositivo.
     const code = makePairingCode()
-    // NO se manda el código ni un compromiso: el vault lo aprende SOLO cuando lo tipeás, y al
-    // ECHARLO de vuelta el dispositivo confía. Un vault falso no conoce el código → no empareja.
-    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
+    // Se manda el COMPROMISO del código, nunca el código. El vault lo aprende solo cuando lo
+    // tipeas, recompone el compromiso y únicamente entonces firma el cert → aprobar exige
+    // haber leído el código de ESTA pantalla. Y al ECHARLO de vuelta, el dispositivo confía:
+    // una bóveda falsa no conoce el código y no puede enrolarlo.
+    const commit = await commitCode({ code, dpub: dev.publickey, sn: qr.sn })
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -78,41 +108,39 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
  * firma. Requiere que el vault esté online.
  * @returns {Promise<{ signature:string, publickey:string }>}  publickey = la maestra.
  */
-export async function requestSign ({ master, proxy, device, cert, payload, timeoutMs = 15000 } = {}) {
-  if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
-  await client.connect()
-  try {
-    const data = { op: 'sign', payload, publickey: device.publickey, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
-    const pending = new Promise((resolve, reject) => {
-      const off = client.on('message', (_f, p) => {
-        if (!p || typeof p !== 'object') return
-        if (p.type === 'vault.signed') { cleanup(); resolve(p) }
-        else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
-      })
-      const t = setTimeout(() => { cleanup(); reject(new Error('el vault no respondió (¿está encendido?)')) }, timeoutMs)
-      const cleanup = () => { off(); clearTimeout(t) }
-    })
-    client.sendByPubkey(master, { type: 'vault.sign', data, signature, cert })
-    const res = await pending
-    return { signature: res.signature, publickey: res.publickey }
-  } finally { try { client.close() } catch (_) {} }
+export async function requestSign ({ master, proxy, device, cert, payload, onRevoked, timeoutMs = 15000 } = {}) {
+  const res = await vaultRpc({
+    master, proxy, device, cert, onRevoked, timeoutMs,
+    sendType: 'vault.sign', okType: 'vault.signed', data: { op: 'sign', payload }
+  })
+  return { signature: res.signature, publickey: res.publickey }
 }
 
-/** Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`. */
-async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, timeoutMs = 15000 }) {
+/**
+ * Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`.
+ *
+ * Se identifica al conectar para que el proxy entregue lo ENCOLADO: si mientras el
+ * dispositivo estaba apagado la bóveda emitió un `vault.revoked` firmado, llega aquí y se
+ * ejecuta el autoborrado (`onRevoked`) tras verificar la firma contra la maestra pineada.
+ */
+async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
   if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
   try {
+    try { await identifyAsDevice(client, device) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
     const signed = { ...data, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data: signed })
     const pending = new Promise((resolve, reject) => {
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
+        if (p.type === MSG.REVOKED) {
+          isAuthenticRevoke({ body: p.body, signature: p.signature, master, devicePubkey: device.publickey })
+            .then((ok) => { if (ok) { try { onRevoked?.() } catch (_) {} } })
+            .catch(() => {})
+          return
+        }
         if (p.type === okType) { cleanup(); resolve(p) }
         else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
       })
@@ -125,14 +153,14 @@ async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data,
 }
 
 /** Lee/escribe el store de hilos+aperturas EN el vault (con el cert del dispositivo). */
-export async function requestStore ({ master, proxy, device, cert, method, args } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.store', okType: 'vault.store.result', data: { op: 'store', method, args: args || {} } })
+export async function requestStore ({ master, proxy, device, cert, method, args, onRevoked } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.store', okType: 'vault.store.result', data: { op: 'store', method, args: args || {} } })
   return res.result
 }
 
 /** Lista (solo lectura) los dispositivos enrolados en tu vault. */
-export async function requestDevices ({ master, proxy, device, cert } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
+export async function requestDevices ({ master, proxy, device, cert, onRevoked } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
   return { devices: res.devices || [], revoked: res.revoked || [] }
 }
 
@@ -141,8 +169,8 @@ export async function requestDevices ({ master, proxy, device, cert } = {}) {
  * el vault firma uno fresco para la misma sub-clave y scope, sin QR ni aprobación.
  * @returns {Promise<{ cert: object }>}
  */
-export async function requestRenew ({ master, proxy, device, cert } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
+export async function requestRenew ({ master, proxy, device, cert, onRevoked } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
   if (!res.cert || res.cert.sub !== device.publickey || res.cert.iss !== master) throw new Error('cert renovado inválido')
   return { cert: res.cert }
 }

package/vault/vendor/vault/VERSION.txt

@@ -1,5 +1,6 @@
-Copia vendorizada de @dotrino/vault@0.3.0 (lib/src/index.js, sin dependencias).
-El iframe de identity se sirve estático (vanilla, sin build); así startDeviceVault
-resuelve en el navegador sin bundler. Importa @dotrino/identity/capabilities
-(=../../capabilities.js) y @dotrino/proxy-client (=../proxy-client/), ambos vía
-el import map de index.html. Re-vendorizar al subir @dotrino/vault.
+Copia vendorizada de @dotrino/vault@0.3.0 (lib/src/{index,enroll}.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.

package/vault/vendor/vault/enroll.js

@@ -0,0 +1,250 @@
+/**
+ * enroll.js — núcleo del LADO BÓVEDA del emparejamiento endurecido.
+ *
+ * Fuente ÚNICA del flujo `vault.enroll` → `vault.enroll.challenge` → `vault.enrolled`
+ * y de la revocación firmada. Lo consumen los tres sitios que hacen de bóveda:
+ *   · el daemon del PC            (`dotrino-vault/src/vault.js`)
+ *   · «este dispositivo es bóveda» (`lib/src/index.js#startDeviceVault`)
+ *   · la copia vendorizada del iframe de identidad (`dotrino-identity/vault/vendor/vault/`)
+ *
+ * Módulo PURO: sin `node:*`, sin red, sin disco. Recibe la identidad (que firma), un
+ * transporte (`send`/`sendByPubkey`) y callbacks de log/auditoría. Así el binario Node
+ * lo embebe al compilar (SEA), el navegador lo importa y el iframe lo vendoriza sin
+ * bundler.
+ *
+ * EL CÓDIGO DE APROBACIÓN, en detalle (esto es lo que hace seguro el emparejamiento):
+ *   1. El DISPOSITIVO genera un código aleatorio de 6 dígitos, lo MUESTRA en su pantalla
+ *      y manda solo su COMPROMISO `SHA-256(code‖dpub‖sn)` dentro del `data` firmado.
+ *      El código en sí NUNCA viaja.
+ *   2. La bóveda no conoce el código: lo aprende cuando un humano lo TIPEA al aprobar.
+ *   3. Al aprobar, la bóveda RECOMPUTA el compromiso con el código tipeado y solo firma
+ *      el cert si coincide → aprobar exige haber ido a leer el código del dispositivo.
+ *   4. La bóveda ECHA el código junto al cert; el dispositivo lo acepta solo si es el
+ *      suyo → una bóveda falsa (que nunca vio el código) no puede enrolarlo.
+ *
+ * Qué cierra y qué NO (sin exagerar): cierra que se emita un cert sin que quien aprueba
+ * tenga el código del dispositivo — antes se firmaba igual y la defensa vivía solo en el
+ * cliente honesto, así que un cliente malicioso se quedaba con un cert válido. NO cierra
+ * el phishing en el que alguien le DICTA el código al dueño por otro canal: contra eso
+ * está la copy de advertencia y que el dueño reconozca el `deviceId` (residual A1/A2 de
+ * `docs/pairing-protocol.md`).
+ */
+import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
+
+/** Un token de emparejamiento vale 5 min. */
+export const PAIRING_TTL_MS = 5 * 60 * 1000
+/** Ventana anti-replay del ENROLL (±5 min), mismo criterio que el identify del proxy. */
+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_ENROLL = 'vault.enroll'
+export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
+export const MSG_ENROLLED = 'vault.enrolled'
+export const MSG_REVOKED = 'vault.revoked'
+export const MSG_ERROR = 'vault.error'
+
+/** Token aleatorio de 128 bits en hex. */
+export function randToken () {
+  const b = crypto.getRandomValues(new Uint8Array(16))
+  return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
+}
+
+/** 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()
+  return id.slice(0, 4) + '-' + id.slice(4, 8)
+}
+
+/**
+ * Crea el «mostrador» de emparejamiento de una bóveda.
+ *
+ * @param {Object} opts
+ * @param {Object} opts.identity        firma: `signData`, `signDelegation`, `listDelegations`, `revokeDelegation`.
+ * @param {string} opts.iss             pubkey de la maestra de ESTA bóveda (va en el QR).
+ * @param {string} opts.proxy           URL del proxy (va en el QR).
+ * @param {(to:string, obj:object)=>void} opts.send            responder por el token de la conexión.
+ * @param {(pub:string, obj:object)=>void} opts.sendByPubkey   dirigir por pubkey (cola offline 24 h).
+ * @param {(op:string, info?:object)=>void} [opts.audit]
+ * @param {(...a:any[])=>void} [opts.log]
+ * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
+ * @param {()=>void} [opts.onPendingChange]
+ * @param {string[]} [opts.defaultScope]
+ * @param {number} [opts.defaultTtlMs]
+ */
+export function createEnrollDesk ({
+  identity, iss, proxy, send, sendByPubkey,
+  audit = () => {}, log = () => {},
+  onChallenge = () => {}, onPendingChange = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+} = {}) {
+  if (!identity) throw new Error('createEnrollDesk: falta identity')
+  if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
+
+  // 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 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 = '' } = {}) {
+    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 }
+  }
+
+  function stopPairing (token) { pending.delete(token) }
+
+  function listPending () {
+    return [...pending.values()]
+      .filter((p) => p.state === 'PENDING_CONFIRM')
+      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope }))
+  }
+
+  function findPending (deviceId) {
+    for (const p of pending.values()) {
+      if (p.state === 'PENDING_CONFIRM' && p.deviceId === deviceId) return p
+    }
+    return null
+  }
+
+  /**
+   * 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.
+   */
+  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' })
+    }
+    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' })
+    }
+    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)' })
+    }
+    // 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' })
+    }
+    // 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.' })
+    }
+    // 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' })
+    }
+
+    const deviceId = await deviceIdOf(d.dpub)
+    pend.state = 'PENDING_CONFIRM'
+    pend.dpub = d.dpub
+    pend.deviceId = deviceId
+    pend.commit = d.commit
+    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)
+
+    reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onPendingChange)
+    return { deviceId }
+  }
+
+  /**
+   * Aprueba TIPEANDO el código que muestra el dispositivo. Recompone el compromiso
+   * `SHA-256(code‖dpub‖sn)` y solo firma el cert si coincide con el que llegó en el
+   * ENROLL — es decir, solo si de verdad fuiste a leer el código del dispositivo.
+   *
+   * @param {string} code
+   * @param {{deviceId?: string}} [opts]  cuál aprobar cuando hay varios pendientes.
+   */
+  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)')
+
+    let pend
+    if (deviceId) {
+      pend = findPending(deviceId)
+      if (!pend) throw new Error('no hay ninguna máquina esperando aprobación con ese identificador')
+    } 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')
+      pend = waiting[0]
+    }
+
+    // COMPROBACIÓN DEL CÓDIGO — antes de firmar nada.
+    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.')
+    }
+
+    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
+    audit('enroll', { device: pend.deviceId, label: pend.label || '', scope: pend.scope })
+    // Echamos el código tipeado junto al cert: el DISPOSITIVO acepta solo si coincide
+    // con el que generó → una bóveda falsa (que no lo conoce) no puede enrolarlo.
+    reply(pend.from, { type: MSG_ENROLLED, code, cert, iss })
+    pend.state = 'DONE'
+    pending.delete(pend.token)
+    fire(onPendingChange)
+    log('[vault] dispositivo aprobado: %s', pend.deviceId)
+    return { ok: true, deviceId: pend.deviceId, cert }
+  }
+
+  /** 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' })
+    pending.delete(pend.token)
+    audit('reject', { device: pend.deviceId })
+    fire(onPendingChange)
+    log('[vault] dispositivo rechazado: %s', pend.deviceId)
+    return { ok: true, deviceId: pend.deviceId }
+  }
+
+  /**
+   * Emite un REVOKED FIRMADO por la maestra para que el dispositivo se autoborre. El
+   * borrado remoto SOLO se dispara con esta firma (nunca con un error cualquiera →
+   * cierra el wipe-DoS). Va por `sendByPubkey`: si está apagado, el proxy lo encola 24 h.
+   */
+  async function emitRevoke (dpub, nonce) {
+    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) }
+  }
+
+  /** Revoca una delegación por `nonce` y avisa al dispositivo para que se autoborre. */
+  async function revoke (nonce) {
+    audit('revoke', { nonce })
+    const { issued } = await identity.listDelegations()
+    const dele = (issued || []).find((d) => d.nonce === nonce)
+    const res = await identity.revokeDelegation(nonce)
+    if (dele?.sub) await emitRevoke(dele.sub, nonce)
+    return res
+  }
+
+  return {
+    startPairing, stopPairing, handleEnroll, approve, reject,
+    listPending, findPending, emitRevoke, revoke,
+    get pendingCount () { return pending.size }
+  }
+}
+
+export default { createEnrollDesk, deviceIdOf, randToken }

package/vault/vendor/vault/index.js

@@ -17,37 +17,29 @@
  *     → una bóveda falsa (que nunca vio el código) no puede enrolar el dispositivo, y
  *     aprobar "a ciegas" (sin ir a leer el código del dispositivo) tampoco enrola nada.
  *
- * Cripto 100% de `@dotrino/identity/capabilities` (verifyDeviceSig/verifyChain/pubkeyId)
- * + firma con la identidad P (`identity.signDelegation`). Transporte: `@dotrino/proxy-client`
- * (import perezoso). No reimplementa nada del ecosistema.
+ * El flujo de enrolamiento en sí (incluida la comprobación del código antes de firmar) vive
+ * en `./enroll.js`, COMPARTIDO con el daemon del PC y con la copia vendorizada del iframe:
+ * un solo sitio donde se decide a quién se le emite un certificado.
+ *
+ * Cripto 100% de `@dotrino/identity/capabilities`; firma con la identidad P
+ * (`identity.signDelegation`). Transporte: `@dotrino/proxy-client` (import perezoso).
+ * No reimplementa nada del ecosistema.
  */
-import { verifyDeviceSig, verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
+import { verifyChain } from '@dotrino/identity/capabilities'
+import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 
 const SIGN_SCOPE = 'vault:sign'
-const PAIRING_TTL_MS = 5 * 60 * 1000           // un emparejamiento (token) vale 5 min
-const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000 // vida de un cert de dispositivo (30 días)
 const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
-const FRESH_WINDOW_MS = 5 * 60 * 1000          // ventana anti-replay del enroll (±5 min)
 
 const MSG = {
   ENROLL: 'vault.enroll',
-  ENROLL_CHALLENGE: 'vault.enroll.challenge',
-  ENROLLED: 'vault.enrolled',
   DEVICES: 'vault.devices',
   DEVICES_RESULT: 'vault.devices.result',
-  REVOKED: 'vault.revoked',
   ERROR: 'vault.error'
 }
 
-function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
-  return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
-}
-
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
-export function deviceIdOf (pub) {
-  return pubkeyId(pub).then((id) => id.slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
-}
+export { deviceIdOf }
 
 /**
  * Levanta la bóveda de este dispositivo: se conecta al proxy identificado como P y
@@ -94,49 +86,21 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
 
   const send = (to, obj) => { try { client.send(to, obj) } catch (_) {} }
 
-  // token -> { exp, sn, scope, ttlMs, label, state, dpub?, deviceId?, from? }
-  const pending = new Map()
   let _onPendingChange = () => {}
 
-  async function handleEnroll (from, p) {
-    const d = p?.data
-    if (!d || typeof d.dpub !== 'string' || typeof p.signature !== 'string') {
-      return send(from, { type: MSG.ERROR, error: 'enroll inválido' })
-    }
-    const pend = pending.get(d.token)
-    if (!pend || Date.now() > pend.exp) {
-      return send(from, { type: MSG.ERROR, error: 'token de emparejamiento inválido o expirado' })
-    }
-    if (d.sn !== pend.sn) return send(from, { type: MSG.ERROR, error: 'sesión inválida' })
-    if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
-      return send(from, { type: MSG.ERROR, error: 'enroll vencido (posible replay, o el reloj desfasado)' })
-    }
-    // PRUEBA DE POSESIÓN: la firma de `data` debe verificar contra `dpub`.
-    const ok = await verifyDeviceSig({ publickey: d.dpub, data: d, signature: p.signature })
-    if (!ok) return send(from, { type: MSG.ERROR, error: 'firma de dispositivo inválida' })
-    // Un solo dispositivo a la vez esperando su código (así `approve` no es ambiguo).
-    if (pend.state === 'PENDING_CONFIRM' && pend.dpub && pend.dpub !== d.dpub) {
-      return send(from, { type: MSG.ERROR, error: 'ya hay un dispositivo usando este emparejamiento' })
-    }
-    const deviceId = await deviceIdOf(d.dpub)
-    pend.state = 'PENDING_CONFIRM'
-    pend.dpub = d.dpub
-    pend.deviceId = deviceId
-    pend.from = from // esta bóveda NO conoce el código (no viaja): el dispositivo lo MUESTRA
-    if (d.label) pend.label = String(d.label).slice(0, 60)
-    _onPendingChange()
-    send(from, { type: MSG.ENROLL_CHALLENGE, deviceId })
-  }
-
-  // Emite un REVOKED FIRMADO por la maestra a la máquina revocada para que se
-  // auto-borre. Va por `sendByPubkey` → si está offline, el proxy lo encola 24 h; y
-  // si reaparece más tarde, `handleDevices` lo re-emite en su siguiente consulta.
-  // El auto-borrado remoto SOLO se dispara con esta firma (no con un error cualquiera).
-  async function emitRevoke (dpub, nonce) {
-    const body = { op: 'revoke', sub: dpub, nonce, iat: Date.now(), exp: Date.now() + DEVICE_TTL_MS }
-    const { signature } = await identity.signData(body)
-    try { client.sendByPubkey(dpub, { type: MSG.REVOKED, body, signature }) } catch (_) {}
-  }
+  // 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
+  // flujo → y por lo tanto un solo sitio donde se comprueba el código antes de firmar.
+  const desk = createEnrollDesk({
+    identity,
+    iss,
+    proxy,
+    send,
+    sendByPubkey: (pub, obj) => { try { client.sendByPubkey(pub, obj) } catch (_) {} },
+    defaultScope: [SIGN_SCOPE],
+    defaultTtlMs: DEVICE_TTL_MS,
+    onPendingChange: () => _onPendingChange()
+  })
 
   // 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
@@ -155,62 +119,15 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
     const mine = (issued || []).find((x) => x.sub === chk.device && x.revokedAt)
-    if (mine) emitRevoke(chk.device, mine.nonce)
+    if (mine) desk.emitRevoke(chk.device, mine.nonce)
   }
 
   client.on('message', (_from, p) => {
     if (!p || typeof p !== 'object') return
-    if (p.type === MSG.ENROLL) handleEnroll(_from, p).catch(() => {})
+    if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
     else if (p.type === MSG.DEVICES) handleDevices(_from, p).catch(() => {})
   })
 
-  /**
-   * Abre un emparejamiento: devuelve el QR/JSON v2 que el dispositivo consume para
-   * enrolarse. `scope`/`ttlMs`/`label` fijan lo que otorgará el cert al aprobar.
-   */
-  function startPairing ({ scope = [SIGN_SCOPE], ttlMs = DEVICE_TTL_MS, label = '' } = {}) {
-    pending.clear()
-    const token = randToken()
-    const sn = randToken()
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, sn, scope, ttlMs, label, state: 'AWAITING_ENROLL' })
-    return { qr: { v: 2, iss, proxy, token, sn }, expiresInMs: PAIRING_TTL_MS }
-  }
-
-  function listPending () {
-    return [...pending.values()]
-      .filter((p) => p.state === 'PENDING_CONFIRM')
-      .map((p) => ({ deviceId: p.deviceId, label: p.label }))
-  }
-  function findPending (deviceId) {
-    for (const [, p] of pending) if (p.state === 'PENDING_CONFIRM' && p.deviceId === deviceId) return p
-    return null
-  }
-
-  /**
-   * Aprueba una máquina pendiente TIPEANDO el código que ella muestra. Esta bóveda NO
-   * conoce/valida el código: firma el cert y ECHA el código tipeado; la máquina lo acepta
-   * solo si coincide con el que generó. (Modelo `dotrino-vault#approveDevice`.)
-   */
-  async function approve (deviceId, code) {
-    const pend = findPending(deviceId)
-    if (!pend || !pend.dpub) throw new Error('no hay ninguna máquina esperando aprobación')
-    code = String(code || '').trim()
-    if (!code) throw new Error('escribe el código que muestra la máquina')
-    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
-    send(pend.from, { type: MSG.ENROLLED, code, cert, iss })
-    pending.delete(pend.token)
-    _onPendingChange()
-    return { ok: true, deviceId }
-  }
-
-  function reject (deviceId) {
-    const pend = findPending(deviceId)
-    if (!pend) return
-    send(pend.from, { type: MSG.ERROR, error: 'emparejamiento rechazado' })
-    pending.delete(pend.token)
-    _onPendingChange()
-  }
-
   /**
    * Máquinas enroladas bajo esta identidad (P), vigentes, con scope de firma y label
    * propio (excluye navegadores enrolados con label 'cli', que no atienden peticiones).
@@ -228,20 +145,18 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     return Promise.all([...bySub.values()].map(async (x) => ({ ...x, deviceId: await deviceIdOf(x.sub) })))
   }
 
-  async function revoke (nonce) {
-    // Deja el registro persistente (revokedAt en la delegación) y AVISA a la máquina
-    // con un REVOKED firmado para que se auto-borre (ahora si está online, o al
-    // reaparecer vía handleDevices). Ver emitRevoke.
-    const { issued } = await identity.listDelegations()
-    const dele = (issued || []).find((d) => d.nonce === nonce)
-    const res = await identity.revokeDelegation(nonce)
-    if (dele?.sub) await emitRevoke(dele.sub, nonce)
-    return res
-  }
-
   return {
     iss, proxy, client,
-    startPairing, approve, reject, listPending, listMachines, revoke,
+    startPairing: desk.startPairing,
+    // 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 }),
+    reject: (deviceId) => desk.reject(deviceId),
+    listPending: desk.listPending,
+    listMachines,
+    // Revoca y AVISA a la máquina con un REVOKED firmado para que se auto-borre (ahora si
+    // está online, o al reaparecer vía handleDevices).
+    revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },
     close () { try { client.close() } catch (_) {} }