@dotrino/vaultd 0.122.0 → 0.123.0

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/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.0",
   "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 }
+}

package/src/replica.js

@@ -66,9 +66,44 @@ export function mergeBundle (viejo, nuevo) {
     if (gb > ga) entries[k] = e
     else if (gb === ga && String(e.e?.ct ?? e.pubv ?? '') < String(a.e?.ct ?? a.pubv ?? '')) entries[k] = e
   }
-  const porGen = new Map()
-  for (const w of [...(viejo.wraps || []), ...(nuevo.wraps || [])]) porGen.set(w.gen, w)
-  return { ...viejo, ...nuevo, entries, wraps: [...porGen.values()].sort((x, y) => x.gen - y.gen) }
+  const wraps = mergeWraps(viejo.wraps, nuevo.wraps)
+  // `ns`/`dev` son la envoltura VIGENTE de cada lado, y salen de la lista ya mezclada: con
+  // `{...viejo, ...nuevo}` se quedaba la del empujón aunque su generación fuera menor, o
+  // sea justo lo contrario de lo que decide la lista.
+  return {
+    ...viejo,
+    ...nuevo,
+    entries,
+    wraps,
+    ns: wraps.ns[wraps.ns.length - 1] || null,
+    dev: wraps.dev[wraps.dev.length - 1] || null
+  }
+}
+
+/**
+ * `wraps` es `{ ns: [...], dev: [...] }`, NO una lista.
+ *
+ * Aquí se esparcía como si fuera una lista, así que cada empujón sobre un sobre que ya
+ * existía moría con «(viejo.wraps || []) is not iterable» — y solo en producción: el
+ * primer guardado sale por `if (!viejo) return nuevo` y nunca llega aquí. El replicador de
+ * Cepi lleva así desde que se desplegó, guardando el primer sobre de cada cajón y
+ * rechazando en silencio todas las actualizaciones.
+ *
+ * La forma la fija quien lo produce (`secretsStore.js`, `sealedBundleFor`) y quien lo lee
+ * (`lib/src/service.js`, que recorre `wraps.ns` y `wraps.dev`). Los dos estaban de acuerdo;
+ * el único equivocado era esto. Y de haber funcionado habría sido peor: escribía `wraps`
+ * como lista y el servicio se habría quedado sin envolturas, que es no poder abrir nada.
+ *
+ * Las de cada lado se SUMAN por generación: son de aparatos distintos y ninguna estorba.
+ */
+function mergeWraps (a, b) {
+  const out = {}
+  for (const side of ['ns', 'dev']) {
+    const byGen = new Map()
+    for (const w of [...(a?.[side] || []), ...(b?.[side] || [])]) byGen.set(w.gen, w)
+    out[side] = [...byGen.values()].sort((x, y) => x.gen - y.gen)
+  }
+  return out
 }
 
 /** La clave de un sobre: es POR (cajón, aparato), porque va tallado a quien lo pide. */

package/src/secretsStore.js

@@ -1145,6 +1145,20 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      * decidir si hay que migrarla. Preguntarlo intentando reenvolver un cajón mezcla dos
      * cosas y deja el fallo diciendo «wrong password» sobre el cajón, que no es donde está.
      */
+    /**
+     * ABRE UNA ENVOLTURA DE RECUPERACIÓN y devuelve lo que lleva dentro.
+     *
+     * Es para OTROS almacenes de este mismo perfil —hoy la bóveda de contraseñas—, que
+     * comparten ESTA copia de recuperación en vez de estrenar una segunda. Una segunda
+     * sería otra llave que custodiar, otra que rotar y otra que se queda atrás.
+     *
+     * Sigue siendo la única puerta a un valor en claro, y sigue pidiendo la frase.
+     */
+    async openRecoveryWrap (wrap, adminKey = null) {
+      const priv = await openRecovery(adminKey)
+      return sealer.openWrapWith(priv, wrap)
+    },
+
     async recoveryOpensWith (key) {
       needSealer('check the recovery key')
       if (!data.recovery?.priv) throw new NeedsPassword('this store has no recovery key yet')

package/src/tui/app.js

@@ -403,7 +403,7 @@ function pairModeRows (st, t) {
  * esté nombrado se añade al final: un permiso puede salir en mal sitio, nunca desaparecer.
  * `test/tui-permisos.test.mjs` exige además que todos tengan nombre en los dos idiomas.
  */
-const ORDEN = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica']
+const ORDEN = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica']
 const CAPS_ORDER = [...ORDEN.filter((c) => DEVICE_CAPS.includes(c)),
   ...DEVICE_CAPS.filter((c) => !ORDEN.includes(c))]
 

package/src/tui/i18n.js

@@ -60,6 +60,7 @@ const es = {
     read: 'lee',
     admin: 'administra',
     passwords: 'contrasenas',
+    passkeys: 'passkeys',
     approve: 'aprueba',
     sealer: 'sella',
     unattended: 'desatendido',
@@ -75,6 +76,9 @@ const es = {
     read: 'ver lo que guardaste',
     admin: 'conectar y quitar aparatos desde ahí, sin venir aquí. No puede cambiar permisos',
     passwords: 'pedir una contraseña por sitio, nunca la lista entera',
+    // Una passkey copiada sirve hasta que la borres en cada sitio: de una contraseña, al
+    // menos, se puede cambiar. Por eso es una decisión aparte.
+    passkeys: 'abrir además las passkeys guardadas, que son llaves y no se pueden cambiar. Sin «contrasenas» no hace nada',
     approve: 'dar el visto bueno cuando otro aparato pide claves privadas',
     // Sellar solo significa algo en un aparato que HAGA de bóveda (otra máquina con el
     // daemon, o un navegador que se puso de bóveda). En un teléfono normal se concede y no
@@ -419,6 +423,7 @@ const en = {
     read: 'read',
     admin: 'admin',
     passwords: 'passwords',
+    passkeys: 'passkeys',
     approve: 'approve',
     sealer: 'sealer',
     unattended: 'unattended',
@@ -432,6 +437,7 @@ const en = {
     read: 'see what you saved',
     admin: 'connect and remove devices from there, without coming here. It cannot change permissions',
     passwords: 'ask for one password per site, never the whole list',
+    passkeys: 'also open saved passkeys, which are keys and cannot be changed. Without «passwords» it does nothing',
     approve: 'give the go-ahead when another device asks for private keys',
     sealer: 'admit devices and change permissions on its own when this vault is away. Only useful on another VAULT',
     unattended: 'take private keys without asking you. Off, it must be approved from a device with «approve» every time it starts',

package/src/vault.js

@@ -234,6 +234,25 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   /** Los aparatos que el acta autoriza a pedir credenciales (`caps <ID> +contraseñas`). */
   const passwordDevices = () => (actaCache?.members || []).filter((m) => Acta.memberCan(actaCache, m.pub, 'passwords'))
 
+  /**
+   * A QUIÉN SE LE ENVUELVE LA LLAVE DE UNA CONTRASEÑA — Y LA BÓVEDA NUNCA ESTÁ EN LA LISTA.
+   *
+   * Es la comprobación que sostiene todo el modelo sellado: si la maestra o la llave de
+   * comunicación de esta máquina recibieran envoltura, el demonio volvería a poder leer las
+   * contraseñas y no habríamos arreglado nada —solo lo habríamos escrito más bonito—. Por
+   * eso se filtran explícitamente aquí, que es donde se construye la lista, y no en quien la
+   * consume (`sealed-passwords.md` §2.1).
+   *
+   * `main` son los aparatos con `contraseñas`; `passkeys`, los que además pueden abrir la
+   * privada de una passkey (§2.8). Un miembro sin llave de cifrado no puede recibir nada: se
+   * queda fuera y se ve en `incompleteMembers`.
+   */
+  const noEsLaBoveda = (pub) => pub !== master && pub !== commKey.pub()
+  const passwordRecipients = (kind = 'main') => (actaCache?.members || [])
+    .filter((m) => m.encPub && noEsLaBoveda(m.pub) && Acta.memberCan(actaCache, m.pub, 'passwords'))
+    .filter((m) => kind !== 'passkeys' || Acta.memberCan(actaCache, m.pub, 'passkeys'))
+    .map((m) => ({ pub: m.pub, encPub: m.encPub }))
+
   /**
    * El acta vigente, en caché.
    *
@@ -249,20 +268,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   /**
-   * La llave de la bóveda de contraseñas. Nace con el primer uso y vive cifrada en
-   * reposo, como la identidad: aquí no hace falta envolverla a cada aparato porque
-   * ningún aparato abre la bóveda — piden de a una y el vault responde.
+   * LA LLAVE VIEJA DE LA BÓVEDA DE CONTRASEÑAS, la que había que quitar.
+   *
+   * Vivía DENTRO del mismo archivo que las entradas, cifrada con la llave de la máquina y
+   * no con la contraseña del perfil. O sea: el demonio con el perfil cerrado seguía
+   * descifrando, y una copia del disco las abría todas. Esto ya no la crea — solo la LEE,
+   * y solo para convertir lo que quedó escrito con ella; en cuanto la conversión termina,
+   * `soltarLlaveVieja` la borra del archivo.
    */
-  async function passwordsKey () {
+  async function llaveViejaDeContrasenas () {
     const d = readPasswordsFile()
-    if (d?.cek) {
-      const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
-      return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
-    }
-    const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
-    const raw = new Uint8Array(await crypto.subtle.exportKey('raw', key))
-    writePasswordsFile({ ...(d || { v: 1, data: {} }), cek: Buffer.from(raw).toString('base64') })
-    return key
+    if (!d?.cek) return null
+    const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
+    return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
+  }
+  const soltarLlaveVieja = () => {
+    const d = readPasswordsFile()
+    if (!d?.cek) return
+    delete d.cek
+    writePasswordsFile(d)
+    log('[vault] passwords: the old vault key is gone from the disk')
+    audit('passwords.converted', {})
   }
 
   const approvalsSweeper = setInterval(() => {
@@ -1121,7 +1147,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   async function handleLoginStart (from, p) {
     try {
-      const { lid, response } = logins.loginBegin({ user: p?.user, request: p?.request })
+      const { lid, response } = await logins.loginBegin({ user: p?.user, request: p?.request })
       audit('login.start', { user: String(p?.user || '').slice(0, 32) })
       reply(from, { type: MSG.LOGIN_RESPONSE, lid, response })
     } catch (e) { loginError(from, e) }
@@ -1129,7 +1155,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   async function handleLoginFinish (from, p) {
     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 record = (await identity.profileActa?.().catch(() => null))?.acta || null
       audit('login.ok', { user: r.user, sid: r.sid.slice(0, 8) })
       log('[vault] login: %s entered (session %s)', r.user, r.sid.slice(0, 8))
@@ -1871,7 +1897,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     passwords = createPasswordDesk({
       client,
       store: passwordsStore,
-      cek: await passwordsKey(),
+      // LA BÓVEDA NO TIENE LLAVE. Lo que pone aquí es a quién envolverle las que hacen los
+      // aparatos, y la pública de la copia de recuperación —la que abre la frase del perfil
+      // y es la única forma de volver a repartir una entrada si un día no queda ningún
+      // aparato—. Ninguna de las dos abre nada por sí sola.
+      members: (kind) => passwordRecipients(kind),
+      recoveryPub: () => secrets.recoveryPub(),
+      canWrite: (pub) => !!actaCache && !!pub && Acta.memberCan(actaCache, pub, 'passwords'),
       // UNA sola condición, y es del ACTA: el aparato tiene la capacidad `passwords`.
       // Quitársela —o quitar el aparato— le corta esto en la siguiente pasada, sin
       // que haya una segunda lista que acordarse de tocar.
@@ -3092,6 +3124,64 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
   }
 
+  /**
+   * LAS CONTRASEÑAS, AL FORMATO SELLADO (§2.7) Y CON SUS ENVOLTURAS AL DÍA (§2.5).
+   *
+   * Las dos cosas se hacen aquí, al ABRIR el perfil, porque las dos necesitan lo mismo: la
+   * frase. Convertir hay que hacerlo una vez; repasar las envolturas, cada vez que cambie
+   * quién puede leer — y este es el único momento en que hay con qué.
+   *
+   * La bóveda ve los valores SOLO mientras convierte, que es cuando tiene que reescribirlos.
+   * Después no puede: lo último que hace la conversión es borrar la llave vieja.
+   */
+  async function sealPasswords (adminKey = null) {
+    if (!passwords) return null
+    const recipients = {
+      recoveryPub: secrets.recoveryPub(),
+      main: passwordRecipients('main'),
+      passkeys: passwordRecipients('passkeys')
+    }
+    if (!recipients.recoveryPub) {
+      log('[vault] passwords: no recovery key yet — nothing can be sealed until there is one')
+      return null
+    }
+    const out = {}
+    try {
+      const { convertPasswords } = await import('./passwords.js')
+      const r = await convertPasswords({
+        store: passwordsStore,
+        sealed: passwords.sealed,
+        cek: await llaveViejaDeContrasenas(),
+        recipients,
+        // LA MAESTRA FIRMA LO QUE ESCRIBE, como cualquier aparato que guarda una entrada.
+        // Firmar no es leer: lo que se le envuelve a esta bóveda sigue siendo nada.
+        author: { publickey: master, sign: (body) => identity.signData(body) },
+        dropOldKey: soltarLlaveVieja,
+        log
+      })
+      out.converted = r?.entries || 0
+      if (r?.already) out.converted = 0
+    } catch (e) {
+      log(`[vault] passwords: could not convert to the sealed format (${e.message})`)
+      out.convertError = e.message
+    }
+    try {
+      const r = await passwords.sealed.rewrapAll({
+        openRecovery: (wrap) => secrets.openRecoveryWrap(wrap, adminKey)
+      })
+      out.wrapped = r.wrapped
+      out.dropped = r.dropped
+      if (r.wrapped || r.dropped) {
+        log(`[vault] passwords: keyring rebuilt (${r.wrapped} wrap(s), ${r.dropped} stale one(s) dropped)`)
+      }
+      if (r.failed?.length) log(`[vault] passwords: ${r.failed.length} generation(s) could NOT be rewrapped`)
+    } catch (e) {
+      log(`[vault] passwords: could not rebuild the keyring (${e.message})`)
+      out.rewrapError = e.message
+    }
+    return out
+  }
+
   async function resealAll (adminKey = null) {
     // ANTES de reenvolver nada: si la copia de recuperación se quedó bajo la llave de la
     // máquina, se pasa a la frase. Sin esto, todo lo de abajo falla con «wrong password».
@@ -3558,6 +3648,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * diseño dice que sí (§8.2). Lo de siempre: dos sitios decidiendo lo mismo.
      */
     resealAll,
+    /** Convierte las contraseñas al formato sellado y repasa sus envolturas (§2.5, §2.7). */
+    sealPasswords,
     delegateRewrap,
     incompleteMembers,
     migrateSecrets: (membersOf, adminKey) => secrets.migrate(