@dotrino/vaultd 0.121.0 → 0.123.0

package/lib/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/lib/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/lib/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)

package/package.json

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

@@ -15,7 +15,7 @@ import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain as verifyChainRaw, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
-import { createLoginDesk, registerLogin, vaultChannel } from '../lib/src/passwordLogins.js'
+import { createLoginDesk, registerLogin, vaultChannel, accountFingerprint } from '../lib/src/passwordLogins.js'
 import * as ActaPilar from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, scopeToCaps, scopeToCn } from '../lib/src/enroll.js'
 import { createAdminDesk, authorBody } from '../lib/src/admin.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(() => {
@@ -300,7 +326,17 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   } catch (_) {}
 
   const master = await masterPubkeyOf(identity)
-  const fp = (await pubkeyId(master)).slice(0, 16)
+  /**
+   * LA HUELLA DE LA CUENTA, no la de esta bóveda. Sale del `profileId` del acta (la pieza
+   * compartida la calcula), y con ella se arman la dirección `nombre@AB12-CD34-EF56` y el
+   * canal donde se anuncia esta cuenta.
+   *
+   * Antes salía de la llave de ESTA bóveda. Coinciden mientras la cuenta haya nacido aquí,
+   * y dejan de coincidir en cuanto hay una réplica o la bóveda adoptó la cuenta de otro
+   * aparato: cada bóveda daba entonces una dirección distinta para la misma cuenta, y el
+   * canal las separaba justo cuando lo que hace falta es que se junten.
+   */
+  const fp = await accountFingerprint(identity)
 
   /**
    * El acta tiene que nombrar una llave de sellado QUE SEA NUESTRA. Si no nombra ninguna
@@ -1111,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) }
@@ -1119,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))
@@ -1861,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.
@@ -3082,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».
@@ -3548,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(