@dotrino/vault 0.66.0 → 0.68.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.66.0",
+  "version": "0.68.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",
@@ -34,6 +34,9 @@
     "./password-logins": {
       "import": "./src/passwordLogins.js"
     },
+    "./login-client": {
+      "import": "./src/loginClient.js"
+    },
     "./admin": {
       "import": "./src/admin.js"
     }
@@ -53,7 +56,7 @@
     "pairing"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.92.0",
+    "@dotrino/identity": ">=0.99.0",
     "@dotrino/proxy-client": ">=0.23.1"
   },
   "license": "MIT",

package/src/index.js

@@ -31,6 +31,10 @@ import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
 // local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
+// El canal donde se anuncia esta cuenta y la huella que lo nombra: la MISMA pieza que usa
+// el daemon y que lee quien entra con usuario y contraseña. Un canal que se escriba distinto
+// en cada bóveda no es el mismo canal.
+import { vaultChannel, accountFingerprint } from './passwordLogins.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
 const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
@@ -100,10 +104,35 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   })()
 
   const selfCert = await getSelfCert()
+
+  /**
+   * ANUNCIARSE EN EL CANAL DE LA CUENTA, igual que el daemon del PC (`src/transport.js`).
+   *
+   * Sin esto, una bóveda-pestaña no existe para quien entra con usuario y contraseña: ese
+   * equipo no tiene ninguna llave, solo el código de la dirección, y el canal es lo único
+   * que puede convertirlo en «con quién hablo». Faltaba, así que quien tenía su bóveda solo
+   * en una pestaña no era encontrable por dirección — y la pestaña sí sabe atender el
+   * inicio de sesión desde que existe `logins`.
+   *
+   * Va DESPUÉS de identificarse y en cada token nuevo, porque el canal guarda el token y el
+   * token cambia con cada reconexión. Y no bloquea el arranque: una bóveda que no consigue
+   * anunciarse sigue sirviendo a sus aparatos, que es casi todo lo que hace.
+   */
+  const announce = async () => {
+    if (!logins || !client.token || typeof client.publish !== 'function') return
+    try {
+      const canal = vaultChannel(await accountFingerprint(identity))
+      await client.publish(canal)
+    } catch (e) {
+      console.warn('[device-vault] could not announce this account on the proxy:', e?.message || e)
+    }
+  }
+
   const identify = async () => {
     if (!client.token) return
     // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
     await client.identifyAs({ publickey: iss, sign: (d) => identity.signData(d), cert: selfCert })
+    await announce()
   }
   await identify()
   client.on('token', () => identify().catch(() => {}))
@@ -365,7 +394,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   async function handleLoginStart (from, p) {
     if (!logins) return noLogins(from)
     try {
-      const { lid, response } = logins.loginBegin({ user: p?.user, request: p?.request })
+      const { lid, response } = await logins.loginBegin({ user: p?.user, request: p?.request })
       send(from, { type: MSG.LOGIN_RESPONSE, lid, response })
     } catch (e) { loginError(from, e) }
   }
@@ -373,7 +402,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   async function handleLoginFinish (from, p) {
     if (!logins) return noLogins(from)
     try {
-      const r = logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
+      const r = await logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
       const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
       send(from, { type: MSG.LOGIN_OK, sid: r.sid, blob: r.blob, cert: r.cert, iss: r.iss || iss, acta })
     } catch (e) { loginError(from, e) }

package/src/loginClient.js

@@ -0,0 +1,216 @@
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA — EL LADO DEL QUE ENTRA.
+ *
+ * La otra mitad de `passwordLogins.js`: allí está la bóveda que atiende, aquí el equipo
+ * prestado que llega sin ninguna llave y solo con una dirección escrita a mano. Diseño en
+ * `dotrino-passmanager/docs/temporary-access.md` §3.2.
+ *
+ *     nombre@AB12-CD34-EF56 + contraseña
+ *     lista el canal del código         ──►  las bóvedas de esa cuenta que estén encendidas
+ *     OPAQUE (inicio)                  ◄──►  comprueba sin ver la contraseña
+ *     abre el paquete de llaves        ◄──   { sid, blob, cert, iss, acta }
+ *     desde aquí es un aparato del acta
+ *
+ * **Vive en el pilar y no en la página** porque lo van a hacer tres sitios distintos —la
+ * pantalla de `profile.dotrino.com`, la extensión del gestor y cualquier app que ofrezca
+ * entrar— y una dirección que se lea distinto, o una comprobación que uno se salte, no es
+ * la misma puerta. Aquí no se abre ninguna conexión: el transporte se INYECTA, como en
+ * `@dotrino/identity/session-flow`.
+ *
+ * QUÉ SE COMPRUEBA, Y EN QUÉ ORDEN (importa):
+ *
+ *   1. **OPAQUE autentica a las DOS partes.** Una bóveda falsa no tiene tu registro, así
+ *      que no puede armar una respuesta que cuadre: `loginFinish` revienta en ESTE lado y
+ *      la contraseña no se le ha dicho a nadie. Por eso mandarle el primer mensaje a un
+ *      desconocido del canal no cuenta nada — es el único orden posible, porque el canal
+ *      solo da tokens y un token no dice de quién es.
+ *   2. **El acta tiene que ser de la cuenta que escribiste**: `pubkeyId(acta.profileId)`
+ *      empieza por el código de la dirección. Esto es lo que ata la respuesta a TU cuenta
+ *      y no a otra bóveda que también sepa contestar.
+ *   3. **El papel y el acta se sostienen entre sí** (`checkVaultReply`).
+ *   4. **La llave que acaba de salir del paquete es la del papel**: se firma un reto y se
+ *      verifica contra `cert.sub`. Sin esto, una bóveda podría devolver el paquete de otro.
+ *
+ * Si algo de eso falla, se PARA con un `code` propio. No hay repliegue: entrar «a medias»
+ * en una cuenta es peor que no entrar.
+ */
+import { client as opaque } from '@dotrino/opaque'
+import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
+import { checkVaultReply } from '@dotrino/identity/acta'
+import { MSG } from './protocol.js'
+import { accountCode, parseLoginAddress, vaultChannel, openDeviceKeys } from './passwordLogins.js'
+
+const err = (code, message, extra = {}) => Object.assign(new Error(message), { code, ...extra })
+
+/** Cuánto se espera a que una bóveda conteste antes de probar con la siguiente. */
+export const REPLY_TIMEOUT_MS = 15_000
+
+/**
+ * Escucha UNA respuesta de un token concreto. El `off` se suelta siempre —también al
+ * agotarse la espera—: un oyente que se queda pegado hace que el segundo intento vea la
+ * respuesta del primero.
+ */
+function waitFor (transport, from, match, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let listo = false
+    const fin = (fn, arg) => { if (!listo) { listo = true; clearTimeout(reloj); quitar(); fn(arg) } }
+    const reloj = setTimeout(() => fin(reject, err('no-answer', 'the vault did not answer in time')), timeoutMs)
+    const oyente = (quien, payload) => {
+      if (from && quien !== from) return
+      const p = typeof payload === 'string' ? parseJson(payload) : payload
+      if (p && match(p)) fin(resolve, p)
+    }
+    const off = transport.on('message', oyente)
+    const quitar = () => {
+      if (typeof off === 'function') return off()
+      transport.off?.('message', oyente)
+    }
+  })
+}
+
+const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null } }
+
+/**
+ * ENTRAR. Devuelve el aparato entero —sus llaves privadas, su papel y el acta— para que
+ * quien llama decida dónde vive eso: en el navegador lo adopta `@dotrino/identity` como una
+ * cuenta más; en la extensión, su propio almacén.
+ *
+ * @param {object} opts
+ * @param {object} opts.transport  cliente de `@dotrino/proxy-client` ya conectado. NO hace
+ *   falta identificarse: quien entra todavía no tiene con qué.
+ * @param {string} opts.address    `nombre@AB12-CD34-EF56`, tal como lo teclea una persona.
+ * @param {string} opts.password
+ * @param {string} [opts.label]    de dónde se entra («el cyber de la esquina»): es lo que
+ *   el dueño va a leer en su consola para decidir si cerrarlo.
+ * @returns {Promise<{user:string,address:string,code:string,sid:string,cert:object,
+ *   iss:string,acta:object,vaultToken:string,publickey:string,encPublickey:(string|null),
+ *   keys:{sign:object,enc:(object|null)}}>}
+ */
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+  if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
+    throw err('no-transport', 'loginWithPassword: a connected transport is required')
+  }
+  if (typeof password !== 'string' || !password) throw err('no-password', 'loginWithPassword: password required')
+  const { user, code, address: dir } = parseLoginAddress(address)
+
+  const tokens = await transport.list(vaultChannel(code))
+  if (!tokens.length) {
+    throw err('no-vault', 'no vault is answering for that address right now: turn yours on, or check the address')
+  }
+
+  // De una en una, y parando en cuanto la contraseña resulte estar mal: cada intento GASTA
+  // uno del freno en la bóveda que lo atiende (`passwordLogins.js`), así que repartir el
+  // mismo error entre las réplicas solo sirve para bloquearse en todas a la vez.
+  let ultimo = null
+  for (const token of tokens) {
+    try {
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+    } catch (e) {
+      // Se para: son cosas del que entra, y probar con otra bóveda no las arregla.
+      if (e?.code === 'login-failed' || e?.code === 'too-many-tries' || e?.code === 'wrong-account' ||
+          e?.code === 'bad-blob' || e?.code === 'bad-keys' || e?.code === 'bad-reply') throw e
+      ultimo = e   // «esa no atiende inicios de sesión», «no contestó»: quizá la siguiente sí
+    }
+  }
+  throw ultimo || err('no-vault', 'none of the vaults on that address could let you in')
+}
+
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs }) {
+  const start = opaque.loginStart({ password })
+  transport.send(token, { type: MSG.LOGIN_START, user, request: start.request })
+  const r1 = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_RESPONSE || p.type === MSG.ERROR, timeoutMs)
+  if (r1.type === MSG.ERROR) throw deVuelta(r1)
+
+  let fin
+  try {
+    fin = opaque.loginFinish({ state: start.state, response: r1.response, password })
+  } catch (_) {
+    // OPAQUE comprueba a las dos partes: aquí se sabe que el otro lado NO conoce el
+    // registro de este usuario. Contraseña equivocada, usuario que no existe o una bóveda
+    // que no es la tuya — y son el mismo error a propósito, porque distinguirlos diría
+    // desde fuera qué usuarios hay.
+    throw err('login-failed', 'wrong address or password')
+  }
+
+  transport.send(token, { type: MSG.LOGIN_FINISH, lid: r1.lid, finalization: fin.finalization, label })
+  const ok = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_OK || p.type === MSG.ERROR, timeoutMs)
+  if (ok.type === MSG.ERROR) throw deVuelta(ok)
+
+  const acta = ok.acta
+  const cert = ok.cert
+  if (!acta || !cert?.sub) throw err('bad-reply', 'the vault let you in without saying which account this is')
+
+  // 2. ¿ES LA CUENTA QUE ESCRIBISTE? Es la única comprobación que ata todo esto a lo que la
+  //    persona tecleó: el canal no prueba nada y el acta viene de quien contesta.
+  if (accountCode((await pubkeyId(acta.profileId)).slice(0, 16)) !== code) {
+    throw err('wrong-account', 'that vault serves a different account than the address says')
+  }
+  // 3. El papel lo firmó esa bóveda, esa bóveda puede sellar esta acta, y el papel vale
+  //    según ella. Una sola llamada, la misma que usa el enrolamiento.
+  const v = await checkVaultReply({ acta, cert, vault: ok.iss, sub: cert.sub })
+  if (!v.ok) throw err('bad-reply', 'the vault reply does not hold together: ' + v.reason)
+
+  const keys = await openDeviceKeys(fin.exportKey, ok.blob)   // `bad-blob` si no es el paquete
+  if (!keys?.sign) throw err('bad-blob', 'the key package does not carry a signing key')
+
+  // 4. La llave que salió del paquete tiene que SER la del papel. Se prueba firmando.
+  const reto = { op: 'login.proof', sub: cert.sub, sid: ok.sid, ts: Date.now() }
+  const { signature } = await signWithDevice({ privateJwk: keys.sign, data: reto })
+  if (!(await verifyDeviceSig({ publickey: cert.sub, data: reto, signature }))) {
+    throw err('bad-keys', 'the keys in the package are not the ones this certificate is for')
+  }
+
+  const member = (acta.members || []).find((m) => m?.pub === cert.sub)
+  if (!member) throw err('bad-reply', 'that certificate names a key the account record does not list')
+
+  return {
+    user,
+    address: dir,
+    code,
+    sid: ok.sid,
+    cert,
+    iss: ok.iss,
+    acta,
+    vaultToken: token,
+    publickey: cert.sub,
+    // La pública de CIFRADO la dice el acta, no el paquete: es lo que los demás miran para
+    // envolverle un secreto a este aparato, y tiene que ser la misma que ellos ven.
+    encPublickey: member.encPub || null,
+    caps: [...(member.caps || [])],
+    keys: { sign: keys.sign, enc: keys.enc || null }
+  }
+}
+
+/** Un error de la bóveda con su `code` intacto: `too-many-tries` se arregla esperando. */
+function deVuelta (p) {
+  const code = p.code || 'login-error'
+  const e = err(code, p.error || 'the vault refused the login')
+  if (typeof p.waitMs === 'number') e.waitMs = p.waitMs
+  return e
+}
+
+/**
+ * SALIR. Va firmado con la llave que acabas de abrir —cerrar el inicio de sesión de otro
+ * sería echarlo de su cuenta— y es lo que suelta la plaza en la bóveda; lo que se borre en
+ * este navegador es cosa de quien llama.
+ *
+ * Es «mejor esfuerzo» a propósito: si la bóveda está apagada, salir de este equipo no puede
+ * quedarse bloqueado esperándola. La sesión sigue abierta allí hasta que se cierre desde la
+ * consola, y eso ya está dicho en el diseño (§3.2).
+ */
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+  if (!transport || typeof transport.send !== 'function') throw err('no-transport', 'closeLogin: transport required')
+  if (!token || !user || !sid || !publickey) throw err('bad-input', 'closeLogin: token, user, sid and publickey are required')
+  const data = { op: 'login.close', publickey, user, sid, ts: Date.now() }
+  const { signature } = await signWithDevice({ privateJwk, privateKey, publickey, data })
+  transport.send(token, { type: MSG.LOGIN_CLOSE, data, signature })
+  try {
+    const r = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_CLOSED || p.type === MSG.ERROR, timeoutMs)
+    if (r.type === MSG.ERROR) return { ok: false, reason: r.code || 'login-error' }
+    return { ok: !!r.ok }
+  } catch (e) {
+    return { ok: false, reason: e?.code || 'no-answer' }
+  }
+}
+
+export default { loginWithPassword, closeLogin, REPLY_TIMEOUT_MS }

package/src/passwordLogins.js

@@ -24,7 +24,8 @@
  * binario, `lib/src/index.js` en la pestaña—. Lo único que no es puro es `registerLogin`, al
  * final, porque hace falta la identidad que firma.
  */
-import { server as opaque, suiteId } from '@dotrino/opaque'
+import { server as opaquePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
+import { pubkeyId } from '@dotrino/identity/capabilities'
 import { deviceIdOf, scopeToCaps, scopeToCn } from './enroll.js'
 import { SCOPE } from './protocol.js'
 import { bytesToB64url, b64urlToBytes } from './b64.js'
@@ -53,6 +54,43 @@ export function accountCode (fingerprint) {
 }
 export const loginAddress = (user, fingerprint) => `${user}@${accountCode(fingerprint)}`
 
+/**
+ * LA HUELLA DE LA CUENTA, que es de la CUENTA y no de la bóveda que la atiende.
+ *
+ * Sale del `profileId` del acta —la llave del génesis, la que no cambia nunca—, y por eso
+ * la dirección sobrevive a que la bóveda se mude, se replique o adopte la cuenta de otro
+ * aparato. Derivarla de la llave de la bóveda daba una dirección distinta en cada réplica
+ * y ninguna en la segunda bóveda de un multivault.
+ *
+ * Es la MISMA cuenta para todas las bóvedas de esa cuenta, que es justo lo que hace que el
+ * canal las junte a todas.
+ */
+export async function accountFingerprint (identity) {
+  const pid = (await identity?.profileActa?.().catch(() => null))?.acta?.profileId
+  if (!pid) throw err('no-acta', 'this vault has no account record yet: there is no address to build')
+  return (await pubkeyId(pid)).slice(0, 16)
+}
+
+/**
+ * Lee `nombre@AB12-CD34-EF56`. Es lo que TECLEA una persona en un equipo prestado, así que
+ * se le perdona el formato —mayúsculas, espacios, guiones de más o de menos— pero no el
+ * contenido: el código son 12 dígitos hexadecimales, ni uno más ni uno menos.
+ *
+ * Lo que NO se perdona tiene su razón: un código corto de menos no es «casi» la dirección,
+ * es otra cuenta con la que se colisiona antes, y aceptarlo sería quitarle los bits que lo
+ * atan a tu cuenta (§3.2 de `temporary-access.md`).
+ */
+export function parseLoginAddress (address) {
+  const raw = String(address || '').trim()
+  const at = raw.lastIndexOf('@')
+  if (at <= 0) throw err('bad-address', 'an address looks like name@AB12-CD34-EF56')
+  const user = raw.slice(0, at).trim().toLowerCase()
+  const hex = raw.slice(at + 1).replace(/[^0-9a-fA-F]/g, '').toUpperCase()
+  if (!isValidUser(user)) throw err('bad-user', 'a user name is lowercase letters, digits, dot, dash or underscore (1-32)')
+  if (hex.length !== ACCOUNT_CODE_HEX) throw err('bad-address', `the account code is ${ACCOUNT_CODE_HEX} hex digits: AB12-CD34-EF56`)
+  return { user, code: accountCode(hex), address: `${user}@${accountCode(hex)}` }
+}
+
 /**
  * EL CANAL DONDE SE ANUNCIA CADA BÓVEDA DE ESA CUENTA, réplicas incluidas.
  *
@@ -143,10 +181,25 @@ export async function openDeviceKeys (exportKey, blob) {
  *   `load()`  devuelve el estado guardado (o `null` la primera vez)
  *   `save(s)` lo guarda
  *   `now()`   el reloj, para poder probar el freno sin esperar una hora
+ *   `opaque`  la mitad de SERVIDOR de OPAQUE. Por defecto la del paquete, que es WASM y
+ *     corre en el mismo hilo. Se puede inyectar OTRA porque en una extensión MV3 el WASM
+ *     vive al otro lado de un `postMessage` —en una página sandbox, para no tener que
+ *     abrirle la CSP a toda la extensión—, y desde allí solo puede contestar una promesa.
+ *
+ * **Por eso los métodos que tocan OPAQUE son ASÍNCRONOS**, también con la implementación de
+ * casa: una firma que cambia según quién la use son dos mostradores, y de eso va la regla
+ * de las tres versiones.
  */
-export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
+export function createLoginDesk ({ load, save, now = () => Date.now(), opaque = opaquePorDefecto } = {}) {
   if (typeof load !== 'function' || typeof save !== 'function') throw new Error('createLoginDesk: load and save are required')
 
+  /**
+   * QUÉ SUITE se está usando, dicha por quien hace el cálculo. Con el OPAQUE de casa es la
+   * del paquete; con uno inyectado, la suya — preguntárselo a él es lo único que no miente,
+   * porque el registro que queda guardado lo hizo él.
+   */
+  const suite = () => (typeof opaque.suiteId === 'function' ? opaque.suiteId() : suitePorDefecto())
+
   /** Intercambios a medias: viven en memoria, y por eso un reinicio los tira. */
   const exchanges = new Map()
 
@@ -157,9 +210,9 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
   }
 
   /** La preparación del servidor nace con el primer usuario y no se toca nunca más. */
-  function setupOf (state) {
+  async function setupOf (state) {
     if (state.setup) return state.setup
-    state.setup = opaque.createSetup()
+    state.setup = await opaque.createSetup()
     return state.setup
   }
 
@@ -196,30 +249,30 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
      * ALTA, primer paso. La contraseña no llega hasta aquí: lo que llega es el mensaje de
      * registro de OPAQUE, que no la lleva ni permite adivinarla.
      */
-    registerBegin ({ user, request, replace = false } = {}) {
+    async registerBegin ({ user, request, replace = false } = {}) {
       const state = read()
       const existing = userOf(state, user)
       if (existing && !replace) throw err('user-exists', `there is already a login called "${user}"`)
       if (!existing && replace) throw err('no-user', `there is no login called "${user}"`)
       if (typeof request !== 'string' || !request) throw err('bad-input', 'request required')
-      const setup = setupOf(state)
-      const response = opaque.registrationResponse({ setup, request, credentialId: user })
+      const setup = await setupOf(state)
+      const response = await opaque.registrationResponse({ setup, request, credentialId: user })
       save(state)
-      return { response, suite: suiteId() }
+      return { response, suite: await suite() }
     },
 
     /**
      * ALTA, segundo paso. `blob` son las llaves privadas del aparato, ya cerradas por quien
      * creó el aparato con la llave que sale de la contraseña: aquí no se abre nunca.
      */
-    registerFinish ({ user, upload, pub, encPub = null, deviceId = null, label = '', blob, replace = false } = {}) {
+    async registerFinish ({ user, upload, pub, encPub = null, deviceId = null, label = '', blob, replace = false } = {}) {
       const state = read()
       const existing = userOf(state, user)
       if (existing && !replace) throw err('user-exists', `there is already a login called "${user}"`)
       if (!existing && replace) throw err('no-user', `there is no login called "${user}"`)
       if (typeof blob !== 'string' || !blob) throw err('bad-input', 'blob required (the device keys, sealed with the password)')
       if (!replace && (typeof pub !== 'string' || !pub)) throw err('bad-input', 'pub required')
-      const record = opaque.registrationFinish({ upload })
+      const record = await opaque.registrationFinish({ upload })
       const t = now()
       state.users[user] = {
         ...(existing || {}),
@@ -229,7 +282,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
         label: label || existing?.label || '',
         record,
         blob,
-        suite: suiteId(),
+        suite: await suite(),
         createdAt: existing?.createdAt || t,
         passwordChangedAt: t,
         // Cambiar la contraseña cierra lo abierto: si alguien entró con la vieja, deja de
@@ -239,7 +292,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
         nextTryAt: 0
       }
       save(state)
-      return { user, suite: suiteId() }
+      return { user, suite: await suite() }
     },
 
     /** El certificado del aparato, que firma la bóveda al admitirlo en el acta. Es público. */
@@ -260,7 +313,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
      * registro inventado: desde fuera no se puede averiguar qué usuarios hay. Y cuenta
      * contra el mismo freno, para que tampoco se pueda medir por el tiempo.
      */
-    loginBegin ({ user, request } = {}) {
+    async loginBegin ({ user, request } = {}) {
       sweepExchanges()
       const state = read()
       if (typeof request !== 'string' || !request) throw err('bad-input', 'request required')
@@ -276,8 +329,8 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
         u.fails = (u.fails || 0) + 1
         u.nextTryAt = t + backoffFor(u.fails)
       }
-      const setup = setupOf(state)
-      const { state: serverState, response } = opaque.loginStart({
+      const setup = await setupOf(state)
+      const { state: serverState, response } = await opaque.loginStart({
         setup,
         record: u?.record || null,
         request,
@@ -294,7 +347,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
      * INICIO DE SESIÓN, segundo paso. Si la contraseña es la buena, devuelve el paquete de
      * llaves —que solo abre esa contraseña—, el certificado y el acta.
      */
-    loginEnd ({ lid, finalization, label = '' } = {}) {
+    async loginEnd ({ lid, finalization, label = '' } = {}) {
       sweepExchanges()
       const x = exchanges.get(lid)
       if (!x) throw err('no-exchange', 'that login is not in flight any more: start again')
@@ -303,7 +356,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
       const u = x.known ? state.users[x.user] : null
 
       try {
-        opaque.loginFinish({ state: x.state, finalization })
+        await opaque.loginFinish({ state: x.state, finalization })
       } catch (e) {
         // Contraseña equivocada, usuario inexistente o mensaje alterado: el MISMO error.
         // Distinguirlos diría qué usuarios existen. El intento ya está contado desde
@@ -400,7 +453,7 @@ export async function registerLogin ({
   scope, unattended = false, replace = false
 } = {}) {
   if (replace) {
-    logins.registerFinish({ user, upload, blob, replace: true })
+    await logins.registerFinish({ user, upload, blob, replace: true })
     return { ok: true, user, replaced: true }
   }
   // PERMISOS, no tipos: los del scope, más `unattended` si quien lo crea lo eligió
@@ -414,7 +467,7 @@ export async function registerLogin ({
     throw Object.assign(new Error('this vault cannot add devices to the account record: no login was created'), { code: 'admit-unavailable' })
   }
   const deviceId = await deviceIdOf(pub)
-  logins.registerFinish({ user, upload, pub, encPub, deviceId, label, blob })
+  await logins.registerFinish({ user, upload, pub, encPub, deviceId, label, blob })
   try {
     const { cert } = await identity.signDelegation(pub, scopes, { label: label || `login:${user}` })
     const cn = scopeToCn(scopes)