@dotrino/vault 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye 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",
@@ -42,7 +42,7 @@
     "pairing"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.17.0",
+    "@dotrino/identity": ">=0.24.0",
     "@dotrino/proxy-client": ">=0.6.0"
   },
   "license": "MIT",

package/src/enroll.js

@@ -0,0 +1,269 @@
+/**
+ * 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'
+
+/** 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' }
+export const scopeToCaps = (scope) =>
+  (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
+
+/** 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 })
+
+    // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
+    // credencial y el acta es la política, y no tiene sentido emitir una sin la otra.
+    // Las capacidades salen del scope que se pidió al emparejar (cert ∩ acta, §2.3).
+    let acta = null
+    try {
+      if (typeof identity.admitMember === 'function') {
+        const caps = scopeToCaps(pend.scope)
+        if (caps.length) await identity.admitMember({ pub: pend.dpub, label: pend.label || '', caps, cert })
+      }
+      acta = (await identity.profileActa?.())?.acta || null
+    } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }
+
+    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.
+    // 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 })
+    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/src/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 (_) {} }

package/src/service.js

@@ -22,7 +22,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import {
   makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig,
-  makePairingCode, pubkeyId
+  makePairingCode, commitCode, pubkeyId
 } from '@dotrino/identity/capabilities'
 import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
@@ -144,7 +144,10 @@ export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeou
     // Código ALEATORIO generado AQUÍ: el vault no lo conoce; solo puede echarlo
     // de vuelta si el dueño lo tipeó (= tiene esta pantalla a la vista).
     const code = makePairingCode()
-    const data = { op: 'enroll', dpub: device.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
+    // El COMPROMISO del código (nunca el código): la bóveda lo recompone con lo que
+    // tipeas y solo entonces firma el cert → aprobar exige haber leído esta pantalla.
+    const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
+    const data = { op: 'enroll', dpub: device.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {