@dotrino/identity 0.114.1 → 0.116.0

package/vault/vendor/passmanager/sealed/entry.js

@@ -0,0 +1,209 @@
+// UNA ENTRADA SELLADA POR CAMPO (`sealed-passwords.md` §2.2 y §2.4).
+//
+// La diferencia con el formato de siempre (`../model.js`) no es criptográfica sino de
+// QUIÉN PUEDE ABRIR: allí una sola llave de la bóveda cifraba todo, así que la bóveda leía
+// las contraseñas —abierta o cerrada—. Aquí la bóveda guarda sobres dirigidos a los
+// aparatos y **no tiene con qué abrir ninguno**.
+//
+// Tres consecuencias que cambian la forma del dato, y las tres están en el diseño:
+//
+//   · **La vista pública se GUARDA sellada**, no se calcula. Antes la calculaba quien tenía
+//     la llave; ahora la escribe quien escribe la entrada.
+//   · **Cada campo va en su propio sobre.** Es lo que permite entregar solo los campos
+//     pedidos sin abrir la entrada, y lo que deja poner la privada de una passkey en un
+//     sobre con OTROS destinatarios (§2.8).
+//   · **Lo único en claro son huellas**: las del sitio, para poder buscar, y los resúmenes
+//     para comparar. Ni un nombre de dominio.
+//
+// Este módulo es PURO: recibe las llaves ya resueltas y no sabe de red, de almacén ni de
+// quién es miembro de nada.
+
+import { encryptWithCek, decryptWithCek } from '@dotrino/identity/content'
+import { normalizeFields, fieldKey, entryFieldKeys, privateKeysOf, entryDigestValues } from '../fields.js'
+import { newEntry, normalizeSites, entryWho } from '../model.js'
+import { siteIndex, fieldIndex, passkeyIndex, valueDigest } from './keys.js'
+
+/** La privada de una passkey es el único campo que va a OTROS destinatarios (§2.8). */
+export const PASSKEY_FIELD = 'wa.privateKey'
+
+/**
+ * Los campos de siempre. Su NOMBRE viaja en claro a propósito: es un vocabulario cerrado,
+ * idéntico en todas las entradas de todo el mundo, así que no dice nada de nadie — y es lo
+ * que deja a la bóveda saber que una contraseña es privada sin fiarse de ninguna lista.
+ */
+export const FIXED = ['name', 'username', 'secret', 'totp', 'notes']
+
+const sealV = async (cek, gen, value) => encryptWithCek({ cek, gen, plaintext: String(value) })
+
+/**
+ * SELLA UNA ENTRADA ENTERA.
+ *
+ * @param {object} o
+ *   `plain`  la entrada en claro (la misma forma de `newEntry`)
+ *   `main`   `{ gen, cek }` la generación para todo lo normal
+ *   `passkeys` `{ gen, cek }` la generación de la privada de la passkey. Solo hace falta
+ *              si la entrada lleva una; si falta y la lleva, se para: guardar esa llave
+ *              con los destinatarios de las contraseñas es justo lo que §2.8 prohíbe
+ *   `keys`   `{ kidx, kcmp }` las llaves del perfil
+ * @returns {Promise<object>} la entrada tal como se guarda
+ */
+export async function sealEntry ({ plain, main, passkeys = null, keys }) {
+  if (!main?.cek || typeof main.gen !== 'number') throw new Error('sealEntry: missing the main generation')
+  if (!keys?.kidx || !keys?.kcmp) throw new Error('sealEntry: missing the profile keys')
+  const e = newEntry(plain)
+  const campos = (() => {
+    if (Array.isArray(e.fields)) return normalizeFields(e.fields)
+    try { return normalizeFields(JSON.parse(e.fields || '[]')) } catch { return [] }
+  })()
+  const abierta = { ...e, fields: JSON.stringify(campos) }
+
+  const fields = {}
+  for (const f of FIXED) if (e[f]) fields[f] = await sealV(main.cek, main.gen, e[f])
+  for (const f of campos) {
+    if (!f?.value) continue
+    // LA MARCA DE PRIVADO ES DEL SOBRE, con su valor (dueño, 2026-09-19). No es metadato
+    // suelto: dice qué es ese dato, y separarla dejaba el sobre incompleto —quien lo abre
+    // solo no sabría si es privado— y dos verdades que se pueden desincronizar. Lo que va
+    // en la vista y en el índice de la bóveda son COPIAS derivadas, que se rehacen al
+    // escribir.
+    //
+    // El precio, y se asume: cambiar la marca obliga a re-sellar el campo, o sea a tenerlo
+    // delante. Marcar uno público como privado no cuesta aprobación (leerlo es gratis);
+    // quitársela a uno privado sí la cuesta — y está bien, porque vas a exponerlo.
+    fields['f:' + await fieldIndex(keys.kidx, fieldKey(f))] = await sealV(main.cek, main.gen, JSON.stringify(f))
+  }
+
+  if (e.webauthn) {
+    if (e.webauthn.userHandle) fields['wa.userHandle'] = await sealV(main.cek, main.gen, e.webauthn.userHandle)
+    if (e.webauthn.privateKey) {
+      if (!passkeys?.cek || typeof passkeys.gen !== 'number') {
+        throw Object.assign(
+          new Error('this entry carries a passkey: it needs its own generation, wrapped only to devices with `passkeys`'),
+          { code: 'passkeys-generation-missing' })
+      }
+      fields[PASSKEY_FIELD] = await sealV(passkeys.cek, passkeys.gen, e.webauthn.privateKey)
+    }
+  }
+
+  // LA VISTA: lo que ve quien puede abrir la entrada pero no pidió ningún valor. Lleva los
+  // NOMBRES de los campos y cuáles son privados —nunca sus valores—, que es lo que deja
+  // ofrecer «rellenar el número de socio» sin sacar nada.
+  const view = {
+    type: e.type,
+    title: e.title,
+    sites: e.sites,
+    hint: entryWho(abierta),
+    fieldKeys: entryFieldKeys(abierta),
+    privateKeys: [...privateKeysOf(abierta)],
+    has: {
+      secret: !!e.secret, totp: !!e.totp, notes: !!e.notes,
+      fields: campos.length > 0, webauthn: !!e.webauthn
+    },
+    ...(e.webauthn
+      ? { webauthn: { rpId: e.webauthn.rpId, credentialId: e.webauthn.credentialId, signCount: e.webauthn.signCount || 0 } }
+      : {})
+  }
+
+  // LOS RESÚMENES, con la clave por huella igual que los sobres: los guarda la bóveda y
+  // tampoco tiene por qué saber de qué campo son. Lo que se resume sigue siendo el NOMBRE
+  // de verdad más el valor —es lo que compara quien escribe, que lo tiene delante.
+  const digests = {}
+  for (const f of entryDigestValues(abierta)) {
+    const clave = FIXED.includes(f.key) || f.key.startsWith('wa.') ? f.key : 'f:' + await fieldIndex(keys.kidx, f.key)
+    digests[clave] = await valueDigest(keys.kcmp, e.id, f.key, f.value)
+  }
+
+  return {
+    id: e.id,
+    createdAt: e.createdAt,
+    updatedAt: e.updatedAt,
+    // Sin sitios = sirve en cualquier parte, que es lo que ha significado siempre.
+    idx: await Promise.all(normalizeSites(e.sites).map((s) => siteIndex(keys.kidx, s))),
+    wa: e.webauthn
+      ? {
+          rp: await passkeyIndex(keys.kidx, 'rp', e.webauthn.rpId),
+          cred: await passkeyIndex(keys.kidx, 'cred', e.webauthn.credentialId)
+        }
+      : null,
+    view: await sealV(main.cek, main.gen, JSON.stringify(view)),
+    fields,
+    digests,
+    // QUÉ CLAVES SON PRIVADAS, para que la bóveda sepa cuándo pedir un dedo encima. Es un
+    // ÍNDICE derivado de las marcas de los sobres, no la fuente.
+    //
+    // Y va con las mismas huellas que las claves: de un campo libre, la bóveda ve
+    // `f:<huella>` y no «cédula». Las fijas (`secret`, `totp`, …) sí van por su nombre, que
+    // es un vocabulario cerrado e igual para todo el mundo — y son las que le dejan aplicar
+    // su propia regla sin fiarse de esta lista, que la escribe el aparato.
+    priv: await Promise.all([...privateKeysOf(abierta)].map(async (k) =>
+      (FIXED.includes(k) || k.startsWith('wa.') ? k : 'f:' + await fieldIndex(keys.kidx, k))))
+  }
+}
+
+/** Abre la vista de una entrada. `open({ envelope })` lo pone quien tiene la llave. */
+export async function openView (sealed, open) {
+  const v = JSON.parse(await open({ envelope: sealed.view }))
+  return {
+    id: sealed.id,
+    type: v.type,
+    title: v.title,
+    sites: v.sites || [],
+    hint: v.hint || '',
+    fieldKeys: v.fieldKeys || [],
+    privateKeys: v.privateKeys || [],
+    hasSecret: !!v.has?.secret,
+    hasTotp: !!v.has?.totp,
+    hasNotes: !!v.has?.notes,
+    hasFields: !!v.has?.fields,
+    hasWebauthn: !!v.has?.webauthn,
+    ...(v.webauthn ? { webauthn: v.webauthn } : {}),
+    updatedAt: sealed.updatedAt,
+    digests: sealed.digests || {}
+  }
+}
+
+/**
+ * ABRE LOS CAMPOS QUE VINIERON y los devuelve con la forma de siempre, para que la interfaz
+ * no tenga que aprender un formato nuevo.
+ *
+ * Lo que no vino, no está: pedir el usuario y recibir la entrada entera es justo lo que se
+ * quitó. `withheld` dice qué se quedó fuera —porque no se pidió, o porque este aparato no
+ * puede abrirlo (una passkey sin el permiso)— para que la pantalla lo diga en vez de
+ * enseñar un hueco.
+ */
+export async function openFields ({ sealed, envelopes, open, view = null }) {
+  const out = {
+    id: sealed?.id || view?.id,
+    type: view?.type || 'login',
+    title: view?.title || '',
+    sites: view?.sites || [],
+    name: '', username: '', secret: '', totp: '', notes: '',
+    fields: '[]',
+    webauthn: null,
+    createdAt: sealed?.createdAt,
+    updatedAt: sealed?.updatedAt || view?.updatedAt
+  }
+  const libres = []
+  let wa = view?.webauthn ? { ...view.webauthn, userHandle: '', privateKey: '' } : null
+  for (const [k, envelope] of Object.entries(envelopes || {})) {
+    const valor = await open({ envelope, field: k })
+    if (FIXED.includes(k)) { out[k] = valor; continue }
+    if (k.startsWith('f:')) {
+      // El campo viene entero: su etiqueta, su clase, su valor y su marca. La clave con la
+      // que la bóveda lo guarda es una huella y no hace falta para nada aquí — el nombre
+      // sale del propio sobre.
+      try { libres.push(JSON.parse(valor)) } catch (_) {}
+      continue
+    }
+    if (k === 'wa.userHandle') { wa = { ...(wa || {}), userHandle: valor }; continue }
+    if (k === PASSKEY_FIELD) { wa = { ...(wa || {}), privateKey: valor }; continue }
+  }
+  out.fields = JSON.stringify(libres)
+  out.webauthn = wa
+  return out
+}
+
+/** Qué claves de campo lleva una entrada sellada. Sin abrir nada: son los nombres. */
+export const fieldNames = (sealed) => Object.keys(sealed?.fields || {})
+
+export default { sealEntry, openView, openFields, fieldNames, PASSKEY_FIELD }

package/vault/vendor/passmanager/sealed/index.js

@@ -0,0 +1,20 @@
+// CONTRASEÑAS SELLADAS POR APARATO — la puerta del subpath `@dotrino/passmanager/sealed`.
+//
+// Va por su propio subpath y NO desde el índice del paquete: esto arrastra
+// `@dotrino/identity/content` (la cripto de los sobres) y no todo el que usa el gestor
+// necesita cargarla. Quien sella, la pide.
+//
+// Las tres piezas, y quién usa cada una:
+//
+//   · `SealedStore` — la BÓVEDA (el demonio, la pestaña, la extensión cuando hace de
+//     bóveda, `serve`). Guarda sobres que no puede abrir y comprueba destinatarios.
+//   · `buildSealedEntry` / `openSealedEntry` — el APARATO que pide. Cifra, envuelve, firma;
+//     y al leer, abre con su envoltura.
+//   · `profileKeys` y las huellas — las dos puntas: con ellas se busca por sitio y se
+//     compara sin abrir.
+export * from './store.js'
+export * from './device.js'
+export * from './entry.js'
+export * from './keys.js'
+export * from './recovery.js'
+export * from './convert.js'

package/vault/vendor/passmanager/sealed/keys.js

@@ -0,0 +1,120 @@
+// LA LLAVE DEL PERFIL PARA LAS CONTRASEÑAS, y las dos que salen de ella.
+//
+// `sealed-passwords.md` §2.6. Una sola llave aleatoria, sellada a los aparatos con
+// `passwords` como cualquier otro valor, y de ella se DERIVAN dos:
+//
+//   · `kidx` — el índice de sitios. La bóveda busca por huellas, no por dominios, así que
+//     una copia de su disco no dice en qué sitios tienes cuenta.
+//   · `kcmp` — comparar sin abrir. El gestor sabe si lo que acabas de escribir ya está
+//     guardado igual sin pedir una autorización para mirarlo.
+//
+// **Son dos y no una**, y el motivo es que un uso no sirva para el otro: con una sola,
+// quien viera un índice de sitios podría fabricar resúmenes de valores, y al revés. Salen
+// de HKDF con etiquetas distintas, que es lo que separa dos llaves de una.
+//
+// Lo que NO protegen, dicho como en el diseño: un aparato que tenga `kcmp` puede adivinar
+// un valor muy corto (un PIN de cuatro cifras) probando resúmenes. Por eso los resúmenes no
+// salen del aparato que los calcula.
+
+const subtle = () => {
+  const c = globalThis.crypto
+  if (!c?.subtle) throw new Error('webcrypto unavailable')
+  return c.subtle
+}
+
+const enc = new TextEncoder()
+
+const b64 = (bytes) => {
+  let s = ''
+  for (const b of new Uint8Array(bytes)) s += String.fromCharCode(b)
+  return btoa(s)
+}
+const unb64 = (str) => {
+  const bin = atob(str)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+/** La llave base del perfil, en base64. Es lo que se sella y se reparte. */
+export async function makePasswordKey () {
+  return b64(globalThis.crypto.getRandomValues(new Uint8Array(32)))
+}
+
+/**
+ * Deriva una de las dos llaves de uso. HKDF-SHA256 con `info` distinto por uso: es la
+ * forma estándar de que dos usos no compartan llave aunque compartan origen.
+ */
+async function derive (base, use) {
+  const material = await subtle().importKey('raw', unb64(base), 'HKDF', false, ['deriveKey'])
+  return subtle().deriveKey(
+    { name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(0), info: enc.encode('dotrino-passmanager/v2/' + use) },
+    material,
+    { name: 'HMAC', hash: 'SHA-256', length: 256 },
+    false,
+    ['sign']
+  )
+}
+
+/**
+ * Las dos llaves de uso, listas para firmar. Se derivan UNA vez por sesión: hacerlo en
+ * cada huella multiplica el coste de abrir el gestor sin ganar nada.
+ */
+export async function profileKeys (base) {
+  if (typeof base !== 'string' || !base) throw new Error('profileKeys: missing the profile password key')
+  const [kidx, kcmp] = await Promise.all([derive(base, 'idx'), derive(base, 'cmp')])
+  return { kidx, kcmp, base }
+}
+
+/** 128 bits: de sobra para no colisionar, y la mitad de bytes que el SHA-256 entero. */
+async function hmac (key, text) {
+  const sig = await subtle().sign('HMAC', key, enc.encode(text))
+  return b64(new Uint8Array(sig).slice(0, 16))
+}
+
+/**
+ * LA HUELLA DE UN SITIO. Lo que la bóveda guarda en claro de cada entrada, y con lo que
+ * contesta «tengo algo para esto» sin saber para qué.
+ *
+ * El sitio se normaliza aquí y en un solo sitio: si quien guarda y quien pregunta lo
+ * escriben distinto (`Google.com` y `google.com`), la huella no casa y la entrada no
+ * aparece — un fallo mudo de los caros.
+ */
+export function siteIndex (kidx, site) {
+  return hmac(kidx, 'site ' + String(site || '').trim().toLowerCase())
+}
+
+/**
+ * LA HUELLA DEL NOMBRE DE UN CAMPO LIBRE.
+ *
+ * El nombre que el usuario le pone a un campo es SUYO —«cédula», «número de socio»— y decía
+ * demasiado guardado en claro: la bóveda tiene que poder emparejar la clave que le piden con
+ * el sobre que guarda, pero no tiene por qué saber de qué se trata. Compara huellas, como
+ * con los sitios.
+ *
+ * Los campos FIJOS (`username`, `secret`, `totp`, `notes`, `wa.*`) no pasan por aquí a
+ * propósito: son un vocabulario cerrado, iguales en todas las entradas y de todo el mundo, y
+ * son los que dejan a la bóveda aplicar su propia regla —la contraseña es privada siempre—
+ * sin fiarse de una lista que escribe el aparato.
+ */
+export function fieldIndex (kidx, key) {
+  return hmac(kidx, 'field ' + String(key || ''))
+}
+
+/** La huella de una passkey: por el sitio que la pide y por el id de la credencial. */
+export function passkeyIndex (kidx, kind, value) {
+  return hmac(kidx, 'wa.' + kind + ' ' + String(value || ''))
+}
+
+/**
+ * EL RESUMEN DE UN VALOR, para comparar sin abrir.
+ *
+ * El `id` de la entrada va DENTRO: así el mismo valor en dos entradas da dos resúmenes
+ * distintos y un resumen no delata una contraseña repetida. Y el nombre del campo también,
+ * para que el resumen de un usuario no se pueda comparar con el de una contraseña.
+ */
+export function valueDigest (kcmp, id, field, value) {
+  return hmac(kcmp, `${id} ${field} ${value}`)
+}
+
+export default { makePasswordKey, profileKeys, siteIndex, fieldIndex, passkeyIndex, valueDigest }

package/vault/vendor/passmanager/sealed/recovery.js

@@ -0,0 +1,136 @@
+// LA COPIA DE RECUPERACIÓN DE UNA BÓVEDA QUE NO PUEDE LEER LO SUYO.
+//
+// `SealedStore` exige que toda entrada lleve la envoltura `#recovery` (`store.js`), y con
+// razón: sin ella, el día que no quede ningún aparato con `passwords` esas contraseñas no
+// las abre nadie — tampoco su dueño. La bóveda publica la PÚBLICA de ese par para que los
+// aparatos envuelvan; la privada solo hace falta para repartir de nuevo cuando cambia
+// quién puede leer.
+//
+// De dónde sale esa privada es lo que distingue a cada bóveda, y el dueño lo decidió el
+// 2026-09-20: **de una contraseña, en las cuatro**.
+//
+//   · el binario (`dotrino-vault`) usa la contraseña del PERFIL — ya la tenía;
+//   · `dotrino-passmanager serve` usa la contraseña de su bóveda — ya la tenía;
+//   · la pestaña (`vault.dotrino.com/vault`) y la bóveda de dentro de la extensión no
+//     tenían ninguna, y por eso la piden al convertir.
+//
+// Lo que esto NO hace, y se dice porque es la mitad del trato: la contraseña **no se puede
+// recuperar**. Es la misma promesa que ya hace `passmanager serve` al crear su bóveda, y
+// es lo que hace que la copia sirva de algo — una que se pudiera reponer desde el propio
+// navegador no sería una copia de recuperación, sería una segunda llave del mismo llavero.
+//
+// Por qué una pieza y no cuatro: la regla de las tres versiones (`sealed-passwords.md`
+// §2.7) dice que lo que escribe una lo abre otra. Si cada una derivara su llave a su
+// manera —otro número de vueltas, otra sal, otro formato— el sobre `#recovery` de una no
+// lo abriría la de al lado, y eso no falla al escribir: falla el día que hace falta.
+
+import { deriveKeyFromPassword, makeSalt, makeVerifier, checkVerifier, sealValue, openValue, toBase64, fromBase64 } from '../crypto.js'
+
+/** El formato de lo guardado. Sube si cambia la derivación o el sobre. */
+export const RECOVERY_VERSION = 1
+
+const subtle = () => {
+  const c = globalThis.crypto
+  if (!c?.subtle) throw new Error('webcrypto unavailable')
+  return c.subtle
+}
+
+const err = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * El par de recuperación. ECDH P-256, como el de los cajones del binario
+ * (`dotrino-vault/src/sealer.js`): es la misma curva que espera `wrapForMember`, y usar
+ * otra haría que el sobre de una bóveda no lo abriera la de al lado.
+ */
+async function makePair () {
+  const pair = await subtle().generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey', 'deriveBits'])
+  return {
+    pub: JSON.stringify(await subtle().exportKey('jwk', pair.publicKey)),
+    priv: await subtle().exportKey('jwk', pair.privateKey)
+  }
+}
+
+/**
+ * CREA la copia de recuperación de esta bóveda a partir de una contraseña.
+ *
+ * Devuelve lo que hay que GUARDAR (`record`) y la pública, que es lo único que sale de
+ * aquí en claro. La privada se va con la función: quien la quiera, que abra con la
+ * contraseña.
+ *
+ * @param {object} o
+ *   `password` la contraseña que abrirá la copia. Mínimo 12: quien tenga el archivo puede
+ *     probar contraseñas contra el verificador sin límite y sin que nadie se entere, así
+ *     que lo único que aguanta es su longitud (mismo criterio que los inicios de sesión).
+ */
+export async function makeRecovery ({ password, minLength = 12 } = {}) {
+  if (typeof password !== 'string' || password.length < minLength) {
+    throw err('weak-password', `the recovery password must be at least ${minLength} characters`)
+  }
+  const salt = makeSalt()
+  const key = await deriveKeyFromPassword(password, salt)
+  const pair = await makePair()
+  return {
+    pub: pair.pub,
+    record: {
+      v: RECOVERY_VERSION,
+      salt: toBase64(salt),
+      // El verificador prueba que la contraseña ABRE esto, no que coincide con un hash:
+      // es lo que deja decir «esa no es» sin tener que intentar descifrar la privada.
+      verifier: await makeVerifier(key),
+      pub: pair.pub,
+      priv: await sealValue(key, JSON.stringify(pair.priv), 'recovery')
+    }
+  }
+}
+
+/** La pública de una copia ya creada. Es lo que la bóveda publica a los aparatos. */
+export function recoveryPubOf (record) {
+  return record?.pub || null
+}
+
+/** ¿Hay copia de recuperación? Lo pregunta quien tiene que crearla al convertir. */
+export const hasRecovery = (record) => !!record?.pub && !!record?.priv
+
+/**
+ * ABRE la copia con su contraseña y devuelve la privada como `CryptoKey` de ECDH, que es
+ * lo que quiere `openWrap`.
+ *
+ * Se distingue «esa contraseña no es» de «esto está roto», y no es un detalle: la primera
+ * se arregla escribiendo bien y la segunda no se arregla de ninguna manera, así que
+ * confundirlas manda al usuario a intentarlo cien veces contra un archivo corrupto.
+ */
+export async function openRecovery ({ record, password } = {}) {
+  if (!hasRecovery(record)) throw err('no-recovery', 'this vault has no recovery copy yet')
+  const key = await deriveKeyFromPassword(password, fromBase64(record.salt))
+  if (!(await checkVerifier(key, record.verifier))) throw err('wrong-password', 'that password does not open the recovery copy')
+  let jwk
+  try { jwk = JSON.parse(await openValue(key, record.priv, 'recovery')) }
+  catch (_) { throw err('bad-recovery', 'the recovery copy is there but cannot be read') }
+  // `key_ops` se quita: dice para qué la generó quien la creó, y aquí hace falta además
+  // `deriveKey`. Es lo mismo que hace `adoptLogin` al adoptar una llave de cifrado.
+  const { key_ops: _o, ext: _e, ...limpio } = jwk
+  return subtle().importKey('jwk', limpio, { name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveKey', 'deriveBits'])
+}
+
+/**
+ * CAMBIA la contraseña de la copia sin tocar el par: los sobres que ya existen siguen
+ * valiendo. Hace falta la vieja, porque hay que abrirla para volver a cerrarla.
+ */
+export async function changeRecoveryPassword ({ record, oldPassword, newPassword, minLength = 12 } = {}) {
+  if (typeof newPassword !== 'string' || newPassword.length < minLength) {
+    throw err('weak-password', `the recovery password must be at least ${minLength} characters`)
+  }
+  const vieja = await deriveKeyFromPassword(oldPassword, fromBase64(record.salt))
+  if (!(await checkVerifier(vieja, record.verifier))) throw err('wrong-password', 'that password does not open the recovery copy')
+  const priv = await openValue(vieja, record.priv, 'recovery')
+  const salt = makeSalt()
+  const key = await deriveKeyFromPassword(newPassword, salt)
+  return {
+    ...record,
+    salt: toBase64(salt),
+    verifier: await makeVerifier(key),
+    priv: await sealValue(key, priv, 'recovery')
+  }
+}
+
+export default { makeRecovery, openRecovery, recoveryPubOf, hasRecovery, changeRecoveryPassword, RECOVERY_VERSION }