@dotrino/vault 0.10.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.10.0",
+  "version": "0.12.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",

package/src/enroll.js

@@ -39,9 +39,15 @@ 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'
 
@@ -104,8 +110,14 @@ 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)')
@@ -136,9 +148,19 @@ export function createEnrollDesk ({
    */
   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 acct = String(account || '').slice(0, 40)
+    // INVITACIÓN CORTA: si sabemos nuestra dirección en el proxy, el QR lleva solo
+    // eso y el nonce de la sesión (13 bytes). 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.
+    const conn = typeof connToken === 'function' ? 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)
-    const acct = String(account || '').slice(0, 40)
     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 }
   }
@@ -158,6 +180,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 hay ningún emparejamiento abierto con ese código' })
+    }
+    // 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.
@@ -172,6 +216,17 @@ export function createEnrollDesk ({
       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' })
+    // 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: 'intención desconocida: ' + 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 (!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)' })
@@ -208,9 +263,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 }
   }
@@ -246,6 +304,20 @@ export function createEnrollDesk ({
       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.')
     }
 
+    // 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] adopción aprobada para %s: esperando el acta sellada', 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 })
 
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
@@ -273,6 +345,60 @@ 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 hay ninguna adopción esperando un acta' })
+    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'acta ausente o ilegible' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no nombra a esta bóveda como quien manda' })
+    }
+    if (acta.sealedBy !== pend.dpub) {
+      audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no la selló el dispositivo de este emparejamiento' })
+    }
+    if (pend.profileId && acta.profileId !== pend.profileId) {
+      audit('rejected', { what: 'adopt', reason: 'other-profile' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta es de otra cuenta distinta a la que anunció el dispositivo' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'no se pudo adoptar')
+      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: 'la bóveda no pudo adoptar la cuenta: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   function reject (deviceId) {
     const pend = deviceId
@@ -310,7 +436,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/src/invite.js

@@ -49,6 +49,18 @@
 export const FMT_JSON = 'j'
 export const FMT_B64 = 'b'
 export const FMT_COMPACT = 'c'
+/**
+ * `t` — la invitación CORTA: solo la dirección y el nonce de la sesión. La llave
+ * maestra ya no viaja; el aparato se la pide a la bóveda por la red presentando el
+ * `sn`, y la comprueba con la firma del certificado y con el código de 6 dígitos,
+ * que es lo único que de verdad decide. Esconderla no aportaba nada —una pública es
+ * pública— y ocupaba 44 de los ~100 caracteres.
+ *
+ * `token` aquí NO es el de la sesión de emparejamiento: es el **token de conexión**
+ * que el proxy le da a la bóveda (4 caracteres), o sea su dirección. Con eso el
+ * aparato le habla directo, punto a punto, sin resolver nada.
+ */
+export const FMT_SHORT = 't'
 
 /** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
 export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
@@ -266,6 +278,57 @@ function compactDecode (text) {
 // API
 // ---------------------------------------------------------------------------
 
+/**
+ * Blob de la forma CORTA (`t`): cabecera(1) ‖ token de conexión(4 ASCII) ‖ sn(8)
+ * ‖ [len+proxy].
+ *   bits 0-2  versión · bit 3  modo (join/adopt) · bit 4  lleva proxy propio
+ *
+ * Sin llave y sin nombre de cuenta: eso llega en la respuesta de la bóveda, así que
+ * un nombre largo ya no agranda el QR. 13 bytes → 18 caracteres.
+ *
+ * El PROXY sí viaja cuando no es el del ecosistema, y no es opcional: el token de
+ * conexión solo tiene sentido **en el proxy donde se emitió**. Quitarlo hacía que un
+ * aparato se conectara al proxy público y le hablara a un token de otro servidor —
+ * el mensaje no llegaba a ninguna parte y el emparejamiento se quedaba esperando.
+ * Le pasa a cualquiera con proxy propio (y lo cazó el E2E de secretos, que levanta
+ * uno local).
+ */
+const CONN_TOKEN_LEN = 4
+
+function shortEncode (qr) {
+  if (!qr || qr.v !== 2) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const conn = String(qr.conn || '')
+  if (conn.length !== CONN_TOKEN_LEN || !/^[\x21-\x7e]+$/.test(conn)) return null
+  if (!/^[0-9a-f]{16}$/.test(qr.sn || '')) return null // 8 bytes
+  const known = new Set(['v', 'conn', 'sn', 'm', 'proxy'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+  const ownProxy = qr.proxy && qr.proxy !== DEFAULT_PROXY
+  const proxy = ownProxy ? utf8(String(qr.proxy)) : null
+  if (proxy && proxy.length > 255) return null
+  const out = [qr.v | (mode << 3) | (ownProxy ? 0x10 : 0), ...[...conn].map((c) => c.charCodeAt(0)), ...hexToBytes(qr.sn)]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function shortDecode (text) {
+  const b = b64urlToBytes(text)
+  if (!b || b.length < 1 + CONN_TOKEN_LEN + 8) return null
+  const head = b[0]
+  if (head & 0xe0) return null
+  let i = 1 + CONN_TOKEN_LEN + 8
+  let proxy = DEFAULT_PROXY
+  if (head & 0x10) {
+    if (i >= b.length) return null
+    const n = b[i]; i += 1
+    if (i + n !== b.length) return null
+    proxy = fromUtf8(b.subarray(i, i + n)); i += n
+  } else if (i !== b.length) return null
+  const conn = String.fromCharCode(...b.subarray(1, 1 + CONN_TOKEN_LEN))
+  return { v: head & 7, conn, sn: bytesToHex(b.subarray(1 + CONN_TOKEN_LEN, 1 + CONN_TOKEN_LEN + 8)), m: MODES[(head >> 3) & 1], proxy }
+}
+
 /** Comparación por contenido, sin depender del orden de las claves. */
 const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
 
@@ -278,6 +341,11 @@ const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
  */
 export function encodeInvite (qr, fmt = FMT_COMPACT) {
   const json = JSON.stringify(qr)
+  // La forma corta se emite cuando el QR trae dirección en vez de llave.
+  if (qr && qr.conn) {
+    const t = shortEncode(qr)
+    if (t) { const back = shortDecode(t); if (back && canon(back) === canon(qr)) return FMT_SHORT + t }
+  }
   if (fmt === FMT_JSON) return FMT_JSON + json
   if (fmt === FMT_COMPACT) {
     const c = compactEncode(qr)
@@ -320,6 +388,7 @@ export function parseInvite (text) {
 
   const marca = payload[0]
   const resto = payload.slice(1)
+  if (marca === FMT_SHORT) { const o = shortDecode(resto); if (o) return o }
   if (marca === FMT_COMPACT) { const o = compactDecode(resto); if (o) return o }
   if (marca === FMT_JSON) { const o = parse(undoUrl(resto)) || parse(resto); if (o) return o }
   if (marca === FMT_B64) { const s = b64urlDecodeStr(resto); const o = s && parse(s); if (o) return o }
@@ -331,4 +400,4 @@ export function parseInvite (text) {
   return s ? parse(s) : null
 }
 
-export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, FMT_SHORT, PAIR_URL, DEFAULT_PROXY }

package/src/protocol.js

@@ -17,9 +17,21 @@
  * 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 }

package/src/service.js

@@ -60,6 +60,23 @@ function installNodeGlobals () {
   }
 }
 
+
+/**
+ * La respuesta al `hello` va firmada y con el `sn` DENTRO de lo firmado. Comprobarlo
+ * ata la respuesta a ESTA sesión: no vale la de otro emparejamiento ni la de otra
+ * bóveda. Ojo con lo que NO prueba: cualquiera puede firmar con una llave suya, así
+ * que esto no dice que sea TU bóveda — eso lo dice el código de 6 dígitos, que solo
+ * aprende la bóveda donde tú lo tecleas.
+ */
+async function verificarHola (p, sn) {
+  const b = p?.body
+  if (!b?.iss || b.sn !== sn) throw new Error('la bóveda contestó a otro emparejamiento')
+  if (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
+    throw new Error('la respuesta de la bóveda no está bien firmada')
+  }
+  return b
+}
+
 async function freshClient (proxyUrl, connectTimeoutMs = 20000) {
   installNodeGlobals()
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
@@ -132,12 +149,25 @@ function writeServiceIdentity (dir, obj) {
  */
 export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeoutMs = 180000 } = {}) {
   if (typeof qr === 'string') { try { qr = JSON.parse(qr) } catch (_) { throw new Error('qr inválido: no es JSON') } }
-  if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
+  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('qr inválido: falta la bóveda o el nonce')
   if (!isValidSecretsNs(ns)) throw new Error('ns inválido (usa [a-z0-9-]{1,32}, p.ej. "proxy")')
   if (!dir) throw new Error('falta dir (dónde persistir la identidad del servicio)')
   label = label || 'servicio:' + ns
 
-  const client = await freshClient(qr.proxy)
+  const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
+  // QR CORTO: se le pregunta a la bóveda quién es, punto a punto, presentando el `sn`.
+  if (!qr.iss) {
+    const hola = await new Promise((resolve, reject) => {
+      const off = client.on('message', (_f, p) => {
+        if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then(resolve, reject) }
+        else if (p?.type === MSG.ERROR) { fin(); reject(new Error(p.error)) }
+      })
+      const t = setTimeout(() => { fin(); reject(new Error('la bóveda no contestó: ese código pudo caducar')) }, 15000)
+      const fin = () => { off(); clearTimeout(t) }
+      try { client.send(qr.conn, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
+    })
+    qr = { ...qr, iss: hola.iss, proxy: hola.proxy || qr.proxy }
+  }
   try {
     const device = await makeDeviceKey({ label })
     const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
@@ -147,7 +177,7 @@ export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeou
     // 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 data = { op: 'enroll', dpub: device.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {