@dotrino/vaultd 0.122.0 → 0.123.1

package/lib/src/index.js

@@ -394,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) }
   }
@@ -402,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/lib/src/loginClient.js

@@ -34,7 +34,7 @@
  * 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 { client as opaquePorDefecto } from '@dotrino/opaque'
 import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
 import { checkVaultReply } from '@dotrino/identity/acta'
 import { MSG } from './protocol.js'
@@ -82,11 +82,16 @@ const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null
  * @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.
+ * @param {object} [opts.opaque]   el OPAQUE a usar. Por defecto el de casa, que va en este
+ *   mismo hilo. Se inyecta porque en una EXTENSIÓN el WASM vive en una página sandbox, al
+ *   otro lado de un `postMessage`, y entonces sus métodos devuelven promesas — igual que en
+ *   `createLoginDesk`, y por el mismo motivo. Aquí se espera siempre: esperar a algo que no
+ *   es una promesa no cuesta nada, y dos firmas serían dos clientes.
  * @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 } = {}) {
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS, opaque = opaquePorDefecto } = {}) {
   if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
     throw err('no-transport', 'loginWithPassword: a connected transport is required')
   }
@@ -104,7 +109,7 @@ export async function loginWithPassword ({ transport, address, password, label =
   let ultimo = null
   for (const token of tokens) {
     try {
-      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs, opaque })
     } 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' ||
@@ -115,15 +120,15 @@ export async function loginWithPassword ({ transport, address, password, label =
   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 })
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs, opaque }) {
+  const start = await 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 })
+    fin = await 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
@@ -198,11 +203,26 @@ function deVuelta (p) {
  * 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 } = {}) {
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, sign, 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 })
+  // CON LA LLAVE O CON QUIEN LA TIENE. `sign(data)` es lo normal en el ecosistema —el
+  // transporte se identifica con `identity.signData` y no con una llave suelta— y aquí hace
+  // falta de verdad: en una extensión la llave vive en el service worker y quien tiene el
+  // socket es la página, así que o se firma a distancia o la llave privada tendría que
+  // cruzar para nada. Sin ninguna de las dos no se firma, y salir no se puede fingir.
+  //
+  // Se comprueba ANTES de firmar: sin nada con qué hacerlo, WebCrypto revienta con un error
+  // suyo que no dice qué falta («code: 0»), y el de arriba es el que se puede buscar.
+  if (typeof sign !== 'function' && !privateJwk && !privateKey) {
+    throw err('no-signature', 'closeLogin: give it the device key (privateJwk/privateKey) or a sign(data)')
+  }
+  const firmado = typeof sign === 'function'
+    ? await sign(data)
+    : await signWithDevice({ privateJwk, privateKey, publickey, data })
+  const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+  if (typeof signature !== 'string') throw err('no-signature', 'closeLogin: sign(data) returned no signature')
   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)

package/lib/src/passwordLogins.js

@@ -24,7 +24,7 @@
  * 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'
@@ -181,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()
 
@@ -195,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
   }
 
@@ -234,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 || {}),
@@ -267,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
@@ -277,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. */
@@ -298,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')
@@ -314,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,
@@ -332,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')
@@ -341,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
@@ -438,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ó
@@ -452,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.122.0",
+  "version": "0.123.1",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -24,7 +24,7 @@
     "@dotrino/compat": "0.4.0",
     "@dotrino/identity": "0.92.0",
     "@dotrino/opaque": "0.1.0",
-    "@dotrino/passmanager": "^0.10.1",
+    "@dotrino/passmanager": "0.12.0",
     "@dotrino/proxy-client": "0.23.1",
     "@dotrino/roadmap": "0.3.3",
     "@dotrino/store": "0.11.0",

package/src/ctl.js

@@ -676,6 +676,42 @@ async function findMember (id) {
  *   dotrino-vault caps <ID> -desatendido    ← vuelve a pedir permiso (el defecto)
  */
 
+/**
+ * LAS PALABRAS DE LOS PERMISOS, en un solo sitio.
+ *
+ * Las usa `caps <ID> ±permiso` y también `logins add`, que da de alta un aparato que se abre
+ * con usuario y contraseña: los dos hablan de lo mismo, así que tienen que llamarlo igual.
+ * Tenerlo dos veces es cómo se acaba aceptando `+aprueba` en un comando y no en el otro.
+ */
+const CAP_BY_WORD = {
+  firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
+  // `sella`: SELLAR EL ACTA. Es lo que convierte a otra bóveda en respaldo de esta —
+  // podrá admitir aparatos y cambiar permisos si esta se pierde. No es un traspaso:
+  // quien manda sigue mandando. Como `administra`, no se empareja: se concede aquí.
+  sella: 'sealer', sealer: 'sealer',
+  // `replica`: reparte los sobres que esta bóveda ya firmó, cuando ella no está. No
+  // tiene maestra y no puede abrir nada. A diferencia de `sella`, SÍ se empareja.
+  replica: 'replica', replicador: 'replica',
+  // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
+  // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
+  contrasenas: 'passwords', 'contraseñas': 'passwords',
+  // `passkeys`: además de las contraseñas, puede abrir la LLAVE PRIVADA de una passkey.
+  // Va aparte porque una passkey copiada sirve hasta que la borres en cada sitio donde
+  // la registraste — de una contraseña, al menos, se puede cambiar
+  // (`dotrino-passmanager/docs/sealed-passwords.md` §2.8). Sin `contraseñas` no
+  // significa nada: la passkey vive en una entrada de contraseñas.
+  passkeys: 'passkeys', llaves: 'passkeys',
+  // `desatendido`: RECIBE CLAVES PRIVADAS SIN QUE NADIE APRUEBE. Sin él, la bóveda no
+  // entrega nada hasta que un aparato con `aprueba` lo firme (una vez por arranque).
+  //
+  // No se llama `permiso` —como la marca local de antes— a propósito: aquella significaba
+  // «este aparato PIDE permiso» y esta significa lo contrario. Reusar la palabra con el
+  // sentido invertido es la clase de trampa que se paga una madrugada.
+  desatendido: 'unattended', unattended: 'unattended',
+  sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve',
+  passwords: 'passwords'
+}
+
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
   const [id, ...changes] = args
@@ -683,28 +719,6 @@ async function cmdCaps (args = []) {
     console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+sella|-sella|+desatendido|-desatendido')
     process.exit(2)
   }
-  const CAP_BY_WORD = {
-    firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
-    // `sella`: SELLAR EL ACTA. Es lo que convierte a otra bóveda en respaldo de esta —
-    // podrá admitir aparatos y cambiar permisos si esta se pierde. No es un traspaso:
-    // quien manda sigue mandando. Como `administra`, no se empareja: se concede aquí.
-    sella: 'sealer', sealer: 'sealer',
-    // `replica`: reparte los sobres que esta bóveda ya firmó, cuando ella no está. No
-    // tiene maestra y no puede abrir nada. A diferencia de `sella`, SÍ se empareja.
-    replica: 'replica', replicador: 'replica',
-    // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
-    // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
-    contrasenas: 'passwords', 'contraseñas': 'passwords',
-    // `desatendido`: RECIBE CLAVES PRIVADAS SIN QUE NADIE APRUEBE. Sin él, la bóveda no
-    // entrega nada hasta que un aparato con `aprueba` lo firme (una vez por arranque).
-    //
-    // No se llama `permiso` —como la marca local de antes— a propósito: aquella significaba
-    // «este aparato PIDE permiso» y esta significa lo contrario. Reusar la palabra con el
-    // sentido invertido es la clase de trampa que se paga una madrugada.
-    desatendido: 'unattended', unattended: 'unattended',
-    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve',
-    passwords: 'passwords'
-  }
   const s = requireDaemon()
   const m = await findMember(id)
 
@@ -1558,7 +1572,9 @@ async function loginHere (opaqueClient, user, password) {
 const LOGINS_USAGE = `uso: dotrino-vault logins <orden>
 
   logins [ls]                 los aparatos que se abren con usuario y contraseña
-  logins add <usuario> [nombre del equipo]
+  logins add <usuario> [nombre del equipo] [±permiso …]
+                              permisos como en «caps» (+aprueba, -guarda, +desatendido…).
+                              Sin decir nada: firma, lee y guarda
   logins passwd <usuario>     cambia la contraseña (cierra lo que estuviera abierto)
   logins close <usuario> [sid]  cierra una sesión abierta (sin sid, todas)
   logins unblock <usuario>    quita la espera de los intentos fallidos
@@ -1924,7 +1940,9 @@ function help () {
   revoke <ID|nonce>   quita un dispositivo (con el ID, todos sus certificados)
   logins              los aparatos que se abren con usuario y contraseña (para un equipo
                       prestado, donde no puedes emparejar nada)
-  logins add <usuario> [nombre del equipo]
+  logins add <usuario> [nombre del equipo] [±permiso …]
+                              permisos como en «caps» (+aprueba, -guarda, +desatendido…).
+                              Sin decir nada: firma, lee y guarda
                       crea uno. La contraseña se teclea aquí y no sale de esta terminal:
                       la bóveda guarda un paquete de llaves que solo ella abre
   logins passwd <usuario>       cambia la contraseña (cierra lo que estuviera abierto)

package/src/daemon.js

@@ -467,6 +467,15 @@ export async function runDaemon () {
             for (const f of r.failed) console.error('[vault] %s: could not reseal (%s)', f.owner, f.error)
             note += ` · ⚠ ${r.failed.length} cajón(es) NO se pudieron reenvolver (${r.failed.map((f) => f.owner).join(', ')}): sus aparatos no podrán leerlos`
           }
+          // Y LAS CONTRASEÑAS, por lo mismo y en el mismo momento: convertirlas al formato
+          // sellado es un acto único que necesita la frase, y repasar sus envolturas hace
+          // falta cada vez que cambia quién puede leer. Un aparato que entró después de
+          // guardada una contraseña no puede abrirla hasta que alguien se la envuelva, y
+          // con la bóveda cerrada nadie puede.
+          const p = await mgr.get(id)?.sealPasswords?.(ak)
+          if (p?.converted) note += ` · ${p.converted} contraseña(s) pasadas al formato sellado`
+          if (p?.wrapped || p?.dropped) note += ` · contraseñas: llavero al día${p.dropped ? ` (${p.dropped} envoltura(s) retirada(s))` : ''}`
+          if (p?.convertError) note += ` · ⚠ las contraseñas NO se pudieron convertir (${p.convertError})`
         } catch (e) {
           console.error('[vault] could not rebuild the keyring on unlock:', e.message)
           note += ` · ⚠ el llavero NO se pudo rehacer (${e.message}): los aparatos no podrán leer sus cajones`

package/src/passwords.js

@@ -1,97 +1,155 @@
 /**
- * LA BÓVEDA DE CONTRASEÑAS del dueño, atendida por el vault.
+ * LA BÓVEDA DE CONTRASEÑAS del dueño, atendida por el vault — Y QUE EL VAULT NO PUEDE LEER.
  *
- * `dotrino-passmanager serve` es la versión mínima: bóveda propia, aprobación por
- * consola, bitácora propia. Esto es lo mismo pero dentro del vault, que ya tiene lo
- * que allí había que improvisar:
+ * Hasta 0.122 esto tenía una llave propia (`passwordsKey()`) guardada **dentro del mismo
+ * archivo que las entradas**, cifrada con la llave de la máquina. O sea: el demonio con el
+ * perfil CERRADO seguía descifrando contraseñas, y cualquiera con una copia del disco las
+ * leía todas. Era el mismo esquema que tuvo la maestra hasta que se selló.
  *
- *   · el ACTA dice qué aparatos existen y qué puede cada uno
- *   · la APROBACIÓN ya sabe avisar al teléfono y esperar su firma (`caps +aprueba`)
- *   · la BITÁCORA ya existe y es la misma que audita firmas y enrolamientos
+ * Ahora la bóveda es un cartero también para las contraseñas
+ * (`dotrino-passmanager/docs/sealed-passwords.md`): guarda sobres dirigidos a los aparatos
+ * y envolturas que no puede abrir. Lo que sí hace, y es lo que sostiene el modelo:
  *
- * Lo que NO cambia es el protocolo: un aparato pide una credencial por dominio y
- * recibe esa sola. `list` sigue sin existir en remoto.
+ *   · dice A QUIÉN hay que envolver cada llave —sale del acta, y **la bóveda nunca está en
+ *     esa lista**: ni su maestra, ni su llave de comunicación;
+ *   · comprueba que quien escribe sea un aparato del acta con `passwords`, por su firma;
+ *   · filtra por destinatario al entregar, y decide si hace falta un dedo encima.
  *
- * Módulo aislado a propósito: recibe todo lo que necesita y no toca el núcleo. Un
- * fallo aquí no puede tumbar la CA.
+ * Lo que SIGUE igual: el protocolo es de a una credencial, `list` no existe en remoto, y la
+ * aprobación es la misma del resto del vault (`caps +aprueba`).
  */
 
-import { LocalVault, VaultResponder } from '@dotrino/passmanager'
+import { SealedStore, SealedResponder } from '@dotrino/passmanager'
+import { verifyDeviceSig } from '@dotrino/identity/capabilities'
 
 export const PASSWORDS_CAP = 'passwords'
+export const PASSKEYS_CAP = 'passkeys'
 
 /**
  * @param {object} opts
  *   `client`      cliente del proxio del vault, ya identificado
- *   `store`       `{ get(k), set(k,v) }` donde viven las entradas cifradas
- *   `cek`         la llave de la bóveda de contraseñas (CryptoKey AES-GCM)
- *   `isAllowed(pubkey)`   qué aparatos pueden pedir — lo decide el acta, no esto
- *   `encPubOf(pubkey)`    su llave de cifrado, para sellarle la respuesta
- *   `needsApproval(pubkey)`  (async) si ese aparato tiene que pedir aprobación según el
- *                            ACTA (`unattended`). Se compone con el
- *                        criterio del propio protocolo: solo lo PRIVADO pregunta
+ *   `store`       `{ get(k), set(k,v) }` donde viven los sobres
+ *   `members(kind)`  → `[{ pub, encPub }]` a quién envolverle cada llave (`main`/`passkeys`),
+ *                  SIN la bóveda. Lo pone `vault.js`, que es quien lee el acta.
+ *   `recoveryPub()`  la pública de la copia de recuperación (la que abre la frase)
+ *   `canWrite(pubkey)`  ¿ese aparato puede ESCRIBIR contraseñas? (acta: `passwords`)
+ *   `isAllowed(pubkey)` ¿puede pedir? — lo decide el acta, no esto
+ *   `encPubOf(pubkey)`  su llave de cifrado, para sellarle la respuesta
+ *   `needsApproval(pubkey)`  (async) si ese aparato tiene que pedir aprobación (`unattended`)
  *   `approve({ pubkey, op })`  pide el visto bueno (el teléfono) y espera
- *   `devices()` / `unlink(pubkey)`   administración, opcional
  *   `audit(op, info)`  la bitácora del vault
  */
 export function createPasswordDesk (opts = {}) {
   const {
-    client, store, cek,
+    client, store,
+    members = () => [],
+    recoveryPub = () => null,
+    canWrite = () => false,
     isAllowed = () => false,
     encPubOf = () => null,
     needsApproval = () => true,
     approve = async () => false,
-    devices = null,
-    unlink = null,
     audit = () => {},
     log = () => {},
   } = opts
 
-  const vault = new LocalVault(store)
-  if (cek) vault.unlock(cek)
+  const sealed = new SealedStore(store, {
+    recipients: (kind) => members(kind),
+    /**
+     * ¿LA FIRMÓ QUIEN DICE, Y PUEDE ESCRIBIR? Es lo único que la bóveda puede comprobar
+     * sobre una entrada cuyo contenido no ve. Las dos mitades importan: la firma ata el
+     * sobre a una llave, y el acta dice si esa llave tiene algo que hacer aquí.
+     */
+    verifyAuthor: async ({ body, author }) => {
+      if (!canWrite(author?.pub)) return false
+      return verifyDeviceSig({ publickey: author.pub, data: body, signature: author.sig })
+    },
+  })
 
-  const responder = new VaultResponder({
+  const responder = new SealedResponder({
     client,
-    vault,
+    store: sealed,
+    recipients: async () => ({
+      recoveryPub: recoveryPub(),
+      main: await members('main'),
+      passkeys: await members('passkeys'),
+    }),
     isAllowed,
     encPubOf,
-    // Dos condiciones, y las dos tienen que darse:
-    //
-    //   · que ese APARATO esté marcado para aprobar (la política del vault: se pide una
-    //     vez y dura mientras el vault siga encendido, igual que los cajones de secretos);
-    //   · y que lo que pide sea PRIVADO — una contraseña, un código de dos pasos, o un
-    //     campo que el usuario marcó. Rellenar un nombre no es sacar un secreto, y pedir
-    //     permiso para todo enseña a decir que sí sin mirar.
-    //
-    // El segundo criterio se toma del propio responder (`wantsPrivate`) en vez de
-    // reescribirlo aquí: si cada bóveda tuviera su idea de qué es privado, serían tres
-    // bóvedas distintas otra vez.
-    needsApproval: async (op, payload, pubkey) =>
-      // `await` OBLIGATORIO: `needsApproval` pasó a ser asíncrona (lee el acta en vivo), y
-      // una promesa SIEMPRE es verdadera. Sin el await esto decía «sí, pide aprobación»
-      // para todo el mundo, y en el otro sentido —si algún día devuelve false— diría que
-      // no hace falta. Un `&&` sobre una promesa es una comprobación que no comprueba.
-      await needsApproval(pubkey) && await responder.wantsPrivate(op, payload),
+    // Dos condiciones, y las dos tienen que darse: que ese APARATO esté marcado para
+    // aprobar, y que lo que pide sea PRIVADO. Rellenar un nombre no es sacar un secreto, y
+    // pedir permiso para todo enseña a decir que sí sin mirar.
+    needsApproval: async (pubkey) => await needsApproval(pubkey),
     approve,
-    admin: devices && unlink ? { devices, unlink } : null,
     onRequest: (r) => {
-      // La bitácora NO lleva qué credencial se pidió: eso es contenido del usuario y
-      // el criterio del vault es apuntar la operación, no el payload.
+      // La bitácora NO lleva qué credencial se pidió: eso es contenido del usuario.
       audit('passwords', { op: r.op, outcome: r.outcome, device: (r.from || '').slice(0, 24) })
-      if (r.outcome !== 'served') {
-        log(`[vault] passwords: ${r.op} ${r.outcome}`)
-      }
+      if (r.outcome !== 'ok') log(`[vault] passwords: ${r.op} ${r.outcome}`)
     },
   })
 
   return {
     start () { responder.start(); return this },
     stop () { responder.stop() },
-    /** Al bloquear el perfil, la bóveda de contraseñas se cierra con él. */
-    lock () { vault.lock() },
-    unlock (nuevaCek) { vault.unlock(nuevaCek) },
-    /** Para la consola local: aquí SÍ se puede listar, porque aquí está la llave. */
-    vault,
+    /**
+     * EL CANDADO DEL PERFIL YA NO PINTA NADA AQUÍ, y eso es la noticia: esta bóveda no
+     * tiene ninguna llave que cerrar. Se conserva el método porque quien lo llama no tiene
+     * por qué saberlo, y porque decirlo en la bitácora ayuda a entender el cambio.
+     */
+    lock () { audit('passwords.lock', { sealed: true }) },
+    unlock () {},
+    /** Para la consola local y las pruebas. Aquí tampoco se abre nada. */
+    sealed,
     responder,
   }
 }
+
+/**
+ * CONVERTIR LO QUE HAY (§2.7). Es un acto único y es **segundo trabajo de la maestra**: se
+ * hace al ABRIR la bóveda, que es cuando la frase está a mano y hay con qué reescribirlo
+ * todo.
+ *
+ * Durante este paso —y solo durante este paso— la bóveda ve los valores: los tiene que
+ * abrir con la llave vieja para volver a cerrarlos uno por uno, con una llave por escritura
+ * envuelta a los aparatos. Después ya no puede, y por eso lo último que hace es **borrar la
+ * llave vieja**: mientras siga ahí, el agujero sigue abierto.
+ *
+ * @param {object} o
+ *   `store`   el almacén con las entradas viejas y donde irán los sobres
+ *   `sealed`  la `SealedStore` de esta bóveda
+ *   `cek`     la llave vieja (`CryptoKey`), o `null` si ya no hay nada que convertir
+ *   `recipients` `{ recoveryPub, main, passkeys }`
+ *   `author`  `{ publickey, sign(body) }` — la maestra, que firma lo que escribe
+ *   `dropOldKey()`  borra la llave vieja del disco. Se llama AL FINAL y solo si todo salió
+ */
+export async function convertPasswords ({ store, sealed, cek, recipients, author, dropOldKey, log = () => {} } = {}) {
+  const { openEntry } = await import('@dotrino/passmanager')
+  const { buildSealedEntry, buildProfileKey } = await import('@dotrino/passmanager/sealed')
+
+  const viejas = (await store.get('passmanager/entries/v1')) || []
+  if (await sealed.sealed()) return { already: true, entries: 0 }
+
+  // 1. La llave del perfil, de la que salen el índice de sitios y los resúmenes.
+  const pk = await buildProfileKey({ recipients })
+  await sealed.setProfile({ envelope: pk.envelope, wraps: pk.wraps })
+  const { profileKeys } = await import('@dotrino/passmanager/sealed')
+  const keys = await profileKeys(pk.base)
+
+  // 2. Cada entrada, reescrita: un sobre por campo, la vista sellada, sus huellas.
+  let hechas = 0
+  for (const vieja of viejas) {
+    if (!cek) break
+    const abierta = await openEntry(cek, vieja)
+    const sobre = await buildSealedEntry({ plain: abierta, keys, recipients, author })
+    await sealed.putSealed(sobre)
+    hechas++
+  }
+
+  // 3. Y se va lo viejo: las entradas con la llave que las abría, y la llave misma.
+  if (hechas === viejas.length) {
+    await store.set('passmanager/entries/v1', [])
+    await dropOldKey?.()
+  }
+  log(`[vault] passwords: ${hechas} entries converted to the sealed format`)
+  return { already: false, entries: hechas }
+}