@dotrino/identity 0.115.0 → 0.117.0

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

@@ -0,0 +1,211 @@
+// EL LADO DEL APARATO: construir los sobres y abrirlos.
+//
+// La bóveda ya no puede hacer nada de esto —no tiene ninguna llave— así que lo hace quien
+// pide: cifra lo que guarda, lo envuelve a cada destinatario y firma el conjunto; y al
+// leer, abre su envoltura y con ella el sobre. Es lo mismo que `buildSealedVar` hace con
+// una variable de un cajón (`@dotrino/vault/admin`), con una diferencia: una entrada tiene
+// muchos campos y **dos juegos de destinatarios** (§2.8), no uno.
+//
+// QUIÉN FIRMA VA COMO FUNCIÓN, no como llave, por el mismo motivo que allí: en un navegador
+// la privada del aparato vive dentro del iframe de identidad y no sale. Aquí se pide la
+// firma, no la llave.
+
+// ESTÁTICO, no `import()`: un service worker MV3 no admite el import dinámico (lo prohíbe
+// la especificación), y esta pieza corre justamente ahí — dentro de la extensión del gestor.
+import { makeContentKey, wrapForMember, encryptWithCek } from '@dotrino/identity/content'
+import { sealEntry, openView, openFields, PASSKEY_FIELD } from './entry.js'
+import { RECOVERY } from './store.js'
+import { makePasswordKey, profileKeys, valueDigest } from './keys.js'
+
+/**
+ * LO QUE FIRMA EL AUTOR. Un solo sitio: quien firma y quien comprueba miran exactamente lo
+ * mismo, o la comprobación pasa a ser decorativa.
+ *
+ * Va lo que identifica el contenido —los criptogramas, no los valores— y las huellas: si la
+ * bóveda cambiara un sobre por otro, o el índice de sitios de una entrada, la firma deja de
+ * cuadrar. Lo que NO va es la generación, que la pone el almacén después.
+ */
+export function entryAuthorBody (entry, ts) {
+  return {
+    op: 'pm.entry',
+    id: entry.id,
+    idx: [...(entry.idx || [])].sort(),
+    wa: entry.wa || null,
+    view: entry.view.iv + '.' + entry.view.ct,
+    fields: Object.keys(entry.fields).sort().map((k) => k + ':' + entry.fields[k].iv + '.' + entry.fields[k].ct),
+    digests: entry.digests || {},
+    ts
+  }
+}
+
+/**
+ * LO QUE FIRMA QUIEN CAMBIA UNOS CAMPOS. Cubre exactamente lo que el parche pide hacer —
+ * qué sobres entran, cuáles se van y con qué vista queda— y nada más: lo que no se toca
+ * ya lo firmó quien lo escribió.
+ */
+export function patchAuthorBody ({ id, view, fields = {}, drop = [], digests = {}, priv = null, idx = null, wa }, ts) {
+  return {
+    op: 'pm.patch',
+    id,
+    view: view.iv + '.' + view.ct,
+    fields: Object.keys(fields).sort().map((k) => k + ':' + fields[k].iv + '.' + fields[k].ct),
+    drop: [...drop].sort(),
+    digests,
+    priv: Array.isArray(priv) ? [...priv].sort() : null,
+    idx: Array.isArray(idx) ? [...idx].sort() : null,
+    wa: wa === undefined ? null : (wa || null),
+    ts
+  }
+}
+
+// `recoveryPub: null` es «la cuenta aún no tiene copia de recuperación» y se sella solo a
+// los aparatos; `undefined` es que nadie preguntó a quién, y eso es un error.
+const wrapAll = async (cek, { recoveryPub, members }) => {
+  if (recoveryPub === undefined) throw new Error('sealed: ask the vault for the recipients first')
+  const wraps = recoveryPub ? { [RECOVERY]: await wrapForMember({ cek, memberEncPub: recoveryPub }) } : {}
+  for (const m of members || []) wraps[m.pub] = await wrapForMember({ cek, memberEncPub: m.encPub })
+  return wraps
+}
+
+/**
+ * UNA ENTRADA LISTA PARA GUARDAR: cifrada, envuelta a quien toca y firmada.
+ *
+ * @param {object} o
+ *   `plain`       la entrada en claro
+ *   `keys`        las llaves del perfil (`profileKeys`)
+ *   `recipients`  `{ recoveryPub, main: [{pub,encPub}], passkeys: [{pub,encPub}] }`, tal
+ *                 como las contesta la bóveda: la lista sale del acta y la sabe ella.
+ *   `author`      `{ publickey, sign(body) }`
+ */
+export async function buildSealedEntry ({ plain, keys, recipients, author } = {}) {
+  if (typeof author?.sign !== 'function' || typeof author?.publickey !== 'string') {
+    throw new Error('buildSealedEntry: author needs { publickey, sign(body) }')
+  }
+  const cek = await makeContentKey()
+  // La privada de la passkey va con SU llave y sus destinatarios. Se estrena solo si la
+  // entrada lleva una: repartir una llave que nadie va a usar es ruido en el llavero.
+  const llevaPasskey = !!plain?.webauthn?.privateKey
+  const cekPk = llevaPasskey ? await makeContentKey() : null
+
+  // `gen: 0` a propósito: la generación DE VERDAD la pone el almacén al guardar, como en
+  // los cajones. Aquí solo hace falta un número para que el sobre tenga forma.
+  const entry = await sealEntry({
+    plain,
+    main: { gen: 0, cek },
+    ...(cekPk ? { passkeys: { gen: 0, cek: cekPk } } : {}),
+    keys
+  })
+  const ts = Date.now()
+  const { signature } = await author.sign(entryAuthorBody(entry, ts))
+  return {
+    entry: { ...entry, author: { pub: author.publickey, sig: signature, ts } },
+    main: { wraps: await wrapAll(cek, { recoveryPub: recipients?.recoveryPub, members: recipients?.main }) },
+    ...(cekPk
+      ? { passkeys: { wraps: await wrapAll(cekPk, { recoveryPub: recipients?.recoveryPub, members: recipients?.passkeys }) } }
+      : {})
+  }
+}
+
+/** La llave del perfil, estrenada y envuelta. Se hace una vez, al convertir. */
+export async function buildProfileKey ({ recipients } = {}) {
+  const base = await makePasswordKey()
+  const cek = await makeContentKey()
+  return {
+    base,
+    envelope: await encryptWithCek({ cek, gen: 0, plaintext: base }),
+    wraps: await wrapAll(cek, { recoveryPub: recipients?.recoveryPub, members: recipients?.main })
+  }
+}
+
+/**
+ * EL ABRIDOR de este aparato: con su envoltura saca la llave y con ella el sobre.
+ *
+ * `openSealed({ wrap, envelope })` es `identity.openSealedValue`: la privada de cifrado no
+ * sale del iframe (ni del núcleo, en la extensión). Aquí solo se empareja cada sobre con la
+ * envoltura de su generación.
+ */
+export function makeOpener ({ wraps, openSealed }) {
+  if (typeof openSealed !== 'function') throw new Error('makeOpener: missing openSealed({ wrap, envelope })')
+  return async ({ envelope }) => {
+    const wrap = wraps?.[envelope?.gen]
+    if (!wrap) {
+      throw Object.assign(new Error('this device has no key for that content generation'), { code: 'no-wrap' })
+    }
+    return openSealed({ wrap, envelope })
+  }
+}
+
+/** La vista de una entrada, abierta con las envolturas que vinieron con ella. */
+export async function openSealedView ({ view, wrap, id, updatedAt, digests, openSealed }) {
+  const open = makeOpener({ wraps: { [view.gen]: wrap }, openSealed })
+  return openView({ id, updatedAt, view, digests }, open)
+}
+
+/** Los campos que vinieron de `get`, con la forma de siempre. */
+export async function openSealedEntry ({ got, openSealed, view = null }) {
+  const open = makeOpener({ wraps: got.wraps, openSealed })
+  const vista = view || await openView({ id: got.id, updatedAt: got.updatedAt, view: got.view, digests: got.digests }, open)
+  const abierta = await openFields({
+    sealed: { id: got.id, updatedAt: got.updatedAt },
+    envelopes: got.envelopes,
+    open,
+    view: vista
+  })
+  return { ...abierta, withheld: got.withheld || [] }
+}
+
+/**
+ * UN PARCHE LISTO PARA MANDAR: los campos que cambian, cifrados y envueltos, y la vista
+ * nueva. Lo que no viene aquí se queda en la bóveda como estaba, sin abrirse.
+ *
+ * @param {object} o
+ *   `id`, `view`   la entrada y su vista NUEVA en claro (la arma quien cambia, que ya la
+ *                  tenía abierta: la vista no es un valor)
+ *   `values`       solo lo que cambia: `{ <clave que guarda la bóveda>: { name, value } }`.
+ *                  La clave de un campo libre es una HUELLA y el `name` es su nombre de
+ *                  verdad — hace falta porque el RESUMEN se calcula sobre el nombre, no
+ *                  sobre la huella, o dejaría de casar con lo que escribió quien creó la
+ *                  entrada.
+ *   `drop`         las claves que se van (ya traducidas)
+ *   `keys`, `recipients`, `author`  como en `buildSealedEntry`
+ */
+export async function buildSealedPatch ({ id, view, values = {}, drop = [], priv = null, idx = null, wa, keys, recipients, author } = {}) {
+  if (typeof author?.sign !== 'function') throw new Error('buildSealedPatch: author needs { publickey, sign(body) }')
+  const cek = await makeContentKey()
+  const hayPasskey = Object.prototype.hasOwnProperty.call(values, PASSKEY_FIELD)
+  const cekPk = hayPasskey ? await makeContentKey() : null
+
+  const fields = {}
+  const digests = {}
+  for (const [k, v] of Object.entries(values)) {
+    const { name, value } = (v && typeof v === 'object') ? v : { name: k.replace(/^f:/, ''), value: v }
+    const conQue = k === PASSKEY_FIELD ? cekPk : cek
+    fields[k] = await encryptWithCek({ cek: conQue, gen: 0, plaintext: String(value) })
+    // El resumen es del VALOR y del NOMBRE, con el id de la entrada dentro (§2.6). La
+    // privada de una passkey no se compara nunca: no se teclea, así que no hay nada que
+    // cotejar.
+    if (k !== PASSKEY_FIELD) digests[k] = await valueDigest(keys.kcmp, id, name, String(value))
+  }
+  const vista = await encryptWithCek({ cek, gen: 0, plaintext: JSON.stringify(view) })
+  const ts = Date.now()
+  const cuerpo = patchAuthorBody({ id, view: vista, fields, drop, digests, priv, idx, wa }, ts)
+  const { signature } = await author.sign(cuerpo)
+  return {
+    id,
+    view: vista,
+    fields,
+    drop,
+    digests,
+    ...(Array.isArray(priv) ? { priv } : {}),
+    ...(Array.isArray(idx) ? { idx } : {}),
+    ...(wa === undefined ? {} : { wa }),
+    author: { pub: author.publickey, sig: signature, ts },
+    main: { wraps: await wrapAll(cek, { recoveryPub: recipients?.recoveryPub, members: recipients?.main }) },
+    ...(cekPk
+      ? { passkeys: { wraps: await wrapAll(cekPk, { recoveryPub: recipients?.recoveryPub, members: recipients?.passkeys }) } }
+      : {})
+  }
+}
+
+export { PASSKEY_FIELD, profileKeys }
+export default { buildSealedEntry, buildSealedPatch, buildProfileKey, openSealedEntry, openSealedView, makeOpener, entryAuthorBody, patchAuthorBody }

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 }