@dotrino/identity 0.115.0 → 0.116.0

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

@@ -0,0 +1,362 @@
+// LA BÓVEDA SELLADA, VISTA DESDE EL APARATO.
+//
+// Cumple el MISMO contrato que `RemoteVault` (`./interface.js`: find/get/put/patch/search/
+// sites/remove) para que la interfaz no tenga que aprender nada nuevo. Lo que cambia está
+// debajo: al otro lado ya no hay una bóveda que abre entradas, hay una que guarda sobres.
+// Así que todo lo que antes hacía ella lo hace esto, aquí:
+//
+//   · **buscar por sitio** — se calculan las huellas de la URL que hay delante y la bóveda
+//     compara cadenas. El emparejamiento de verdad (subdominios, comodines) se rehace aquí
+//     con `match.js` sobre las vistas ya abiertas, así que la regla no cambia;
+//   · **abrir** — cada sobre con la envoltura de este aparato;
+//   · **escribir** — cifrar, envolver a los destinatarios que dice el acta y firmar;
+//   · **buscar por texto** — la bóveda no ve ningún texto: se piden las vistas y se busca
+//     aquí (§2.2). Son vistas, no valores.
+//
+// Lo que este aparato no puede abrir se dice en `withheld` en vez de aparecer vacío.
+
+import { SEALED_OPS } from '../transport/protocol.js'
+import { VaultError, CODES } from './errors.js'
+import { hostOf, registrableDomain, findForUrl } from '../match.js'
+import { profileKeys, siteIndex, fieldIndex, passkeyIndex, valueDigest } from '../sealed/keys.js'
+import { buildSealedEntry, buildSealedPatch, buildProfileKey, openSealedEntry, makeOpener } from '../sealed/device.js'
+import { openView, PASSKEY_FIELD } from '../sealed/entry.js'
+import { fieldKey, normalizeFields } from '../fields.js'
+
+/** Las claves de campo de la interfaz, tal como las pide `get(id, { keys })`. */
+const FIXED = ['name', 'username', 'secret', 'totp', 'notes']
+
+/**
+ * DE LA CLAVE QUE USA LA INTERFAZ A LA QUE GUARDA LA BÓVEDA.
+ *
+ * Las fijas viajan por su nombre —vocabulario cerrado, igual para todo el mundo— y las
+ * libres por HUELLA: «cédula» es del usuario y la bóveda no tiene por qué leerlo. La
+ * traducción vive aquí y en un solo sitio; si quien guarda y quien pide la hicieran
+ * distinta, el sobre no se encontraría y no habría forma de verlo.
+ */
+const esFija = (k) => FIXED.includes(k) || k.startsWith('wa.')
+
+export class SealedVault {
+  /**
+   * @param {object} transport `{ request(op, payload) }` — el mismo de `RemoteVault`
+   * @param {object} opts
+   *   `identity` `{ publickey, sign(body), openSealed({ wrap, envelope }) }`. La privada de
+   *     cifrado no sale de donde viva: aquí solo se pide abrir.
+   *   `needsApproval` si lo privado exige un dedo encima al otro lado (solo informativo)
+   */
+  constructor (transport, { identity, needsApproval = true } = {}) {
+    if (!transport?.request) throw new Error('SealedVault: missing transport')
+    if (typeof identity?.sign !== 'function' || typeof identity?.openSealed !== 'function') {
+      throw new Error('SealedVault: identity needs { publickey, sign(body), openSealed({wrap,envelope}) }')
+    }
+    this.transport = transport
+    this.identity = identity
+    this.needsApproval = needsApproval
+    this._keys = null
+    this._recipients = null
+  }
+
+  get capabilities () {
+    return { canWrite: true, canList: false, needsApproval: this.needsApproval, sealed: true }
+  }
+
+  /** Lo que se cachea muere al dormirse el worker, que es justo cuando hay que releerlo. */
+  forget () { this._keys = null; this._recipients = null }
+
+  async #request (op, payload) {
+    if (!SEALED_OPS.includes(op)) throw new VaultError(CODES.NOT_ALLOWED, 'operación desconocida: ' + op)
+    try {
+      return await this.transport.request(op, payload)
+    } catch (e) {
+      if (e instanceof VaultError) throw e
+      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no hay bóveda al otro lado')
+    }
+  }
+
+  /**
+   * LAS LLAVES DEL PERFIL. Sin ellas no se puede ni buscar (el índice va con huella) ni
+   * comparar, así que es lo primero que pide este aparato al despertar.
+   */
+  async keys () {
+    if (this._keys) return this._keys
+    const { envelope, wrap } = await this.#request('pm2.profile', {})
+    const base = await this.identity.openSealed({ wrap, envelope })
+    this._keys = await profileKeys(base)
+    return this._keys
+  }
+
+  /** A quién hay que envolverle cada llave. La lista sale del acta y la sabe la bóveda. */
+  async recipients () {
+    if (this._recipients) return this._recipients
+    this._recipients = await this.#request('pm2.recipients', {})
+    return this._recipients
+  }
+
+  async #sealedKey (k) {
+    if (esFija(k)) return k
+    const { kidx } = await this.keys()
+    return 'f:' + await fieldIndex(kidx, k)
+  }
+
+  #opener (wraps) {
+    return makeOpener({ wraps, openSealed: (x) => this.identity.openSealed(x) })
+  }
+
+  async #openView (v) {
+    const abierta = await openView(
+      { id: v.id, updatedAt: v.updatedAt, view: v.view, digests: v.digests },
+      this.#opener({ [v.view.gen]: v.wrap })
+    )
+    // `fieldHashes` conserva el nombre que ya usa la interfaz para comparar. Dos cosas
+    // cambian debajo: los resúmenes están GUARDADOS (antes era un HMAC con un nonce de la
+    // respuesta), y su clave viaja por huella — así que aquí se traducen de vuelta a los
+    // nombres de verdad, que la vista sí lleva porque va sellada.
+    const fieldHashes = {}
+    for (const k of [...abierta.fieldKeys, 'notes']) {
+      const clave = await this.#sealedKey(k)
+      if (abierta.digests[clave] !== undefined) fieldHashes[k] = abierta.digests[clave]
+    }
+    return { ...abierta, fieldHashes }
+  }
+
+  /**
+   * LAS HUELLAS DE LA URL QUE HAY DELANTE. El sitio guardado puede ser el dominio y la URL
+   * un subdominio suyo (`empresa.com` vale en `login.empresa.com`), así que se calculan las
+   * huellas de CADA variante: el host, sus padres hasta el dominio registrable, y las de
+   * comodín. La bóveda solo compara cadenas.
+   */
+  async #hashesFor (url) {
+    const { kidx } = await this.keys()
+    const host = hostOf(url)
+    if (!host) return []
+    const base = registrableDomain(host)
+    const variantes = new Set([host])
+    let actual = host
+    while (actual.includes('.') && actual !== base) {
+      actual = actual.slice(actual.indexOf('.') + 1)
+      variantes.add(actual)
+    }
+    const out = []
+    for (const v of variantes) {
+      out.push(await siteIndex(kidx, v))
+      out.push(await siteIndex(kidx, '*.' + v))
+    }
+    return out
+  }
+
+  /**
+   * QUÉ HAY PARA ESTE SITIO. Las huellas son un filtro previo; el emparejamiento de verdad
+   * —el que decide si `empresa.com` vale aquí— se rehace con `match.js` sobre las vistas ya
+   * abiertas, para que la regla siga siendo UNA y no dos que se desincronizan.
+   */
+  async find (url) {
+    const hits = await this.#request('pm2.find', { idx: await this.#hashesFor(url) })
+    const vistas = []
+    for (const v of hits) vistas.push(await this.#openView(v))
+    return findForUrl(vistas, url).map((x) => x.entry)
+  }
+
+  /** La passkey que este sitio pide, o la que tiene ese id de credencial. */
+  async findPasskey ({ rpId = null, credentialId = null } = {}) {
+    const { kidx } = await this.keys()
+    const hits = await this.#request('pm2.passkey', {
+      ...(rpId ? { rp: await passkeyIndex(kidx, 'rp', rpId) } : {}),
+      ...(credentialId ? { cred: await passkeyIndex(kidx, 'cred', credentialId) } : {})
+    })
+    const out = []
+    for (const v of hits) out.push(await this.#openView(v))
+    return out
+  }
+
+  /** UNA credencial, y solo los campos pedidos. */
+  async get (id, opts = {}) {
+    const keys = Array.isArray(opts.keys) ? await Promise.all(opts.keys.map((k) => this.#sealedKey(k))) : null
+    const got = await this.#request('pm2.get', { id, ...(keys ? { keys } : {}) })
+    return openSealedEntry({ got, openSealed: (x) => this.identity.openSealed(x) })
+  }
+
+  async put (plain) {
+    const [keys, recipients] = await Promise.all([this.keys(), this.recipients()])
+    const sobre = await buildSealedEntry({ plain, keys, recipients, author: this.#author() })
+    await this.#request('pm2.put', sobre)
+    // La vista se devuelve ARMADA AQUÍ: quien guardó ya la tiene en claro, y pedírsela a la
+    // bóveda sería un viaje para que nos devuelva lo que acabamos de sellar.
+    return this.#viewOf(plain)
+  }
+
+  /**
+   * CAMBIAR unos campos sin leer los demás (§2.4).
+   *
+   * La vista se rehace aquí con lo que ya se sabe: los NOMBRES de los campos y cuáles son
+   * privados viven en ella, no en los sobres, así que marcar un teléfono como privado no
+   * saca el teléfono de la bóveda.
+   */
+  async patch (id, changes = {}) {
+    const [keys, recipients] = await Promise.all([this.keys(), this.recipients()])
+    const actual = await this.#viewById(id)
+    if (!actual) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+
+    const values = {}
+    const drop = []
+    for (const k of FIXED) if (typeof changes[k] === 'string') values[k] = { name: k, value: changes[k] }
+    if (typeof changes.title === 'string') actual.title = changes.title
+
+    const campos = normalizeFields(Array.isArray(changes.fields) ? changes.fields : [])
+    for (const f of campos) {
+      const k = fieldKey(f)
+      // LA MARCA VA DENTRO DEL SOBRE, así que cambiarla es reescribir el campo — y para eso
+      // hay que tener su valor. Quien edita lo tiene: si solo trae la marca, hay que leerlo
+      // primero. Leer uno PÚBLICO no cuesta aprobación; quitarle la marca a uno privado sí,
+      // y está bien, porque vas a exponerlo.
+      let valor = f.value
+      if (typeof valor !== 'string' || !valor) {
+        if (f.private === undefined) continue
+        const leido = await this.get(id, { keys: [k] })
+        valor = (JSON.parse(leido.fields || '[]').find((x) => fieldKey(x) === k) || {}).value || ''
+        if (!valor) continue
+      }
+      values[await this.#sealedKey(k)] = {
+        name: k,
+        value: JSON.stringify({ label: f.label, value: valor, kind: f.kind, ...(f.private ? { private: true } : {}) })
+      }
+      const privados = new Set(actual.privateKeys)
+      if (f.private) privados.add(k); else if (f.private === false) privados.delete(k)
+      actual.privateKeys = [...privados]
+      if (!actual.fieldKeys.includes(k)) actual.fieldKeys.push(k)
+    }
+    for (const k of (changes.removeFields || [])) {
+      drop.push(await this.#sealedKey(k))
+      actual.fieldKeys = actual.fieldKeys.filter((x) => x !== k)
+      actual.privateKeys = actual.privateKeys.filter((x) => x !== k)
+    }
+    for (const k of FIXED) {
+      if (typeof changes[k] !== 'string') continue
+      if (changes[k]) { if (!actual.fieldKeys.includes(k) && k !== 'name') actual.fieldKeys.push(k) } else {
+        drop.push(k)
+        actual.fieldKeys = actual.fieldKeys.filter((x) => x !== k)
+      }
+    }
+    // Los sitios: la lista entera manda, y `addSite` solo suma si ya tenía alguno — una
+    // entrada sin sitios sirve en cualquier parte y atarla al primer formulario donde se
+    // usó sería cambiarle el sentido.
+    let sites = null
+    if (Array.isArray(changes.sites)) sites = changes.sites
+    else if (changes.addSite && actual.sites.length) sites = [...new Set([...actual.sites, changes.addSite])]
+    if (sites) actual.sites = sites
+
+    if (typeof changes.name === 'string' || typeof changes.username === 'string') {
+      actual.hint = changes.name || actual.hint
+    }
+
+    const vista = {
+      type: actual.type,
+      title: actual.title,
+      sites: actual.sites,
+      hint: actual.hint,
+      fieldKeys: actual.fieldKeys,
+      privateKeys: actual.privateKeys,
+      has: {
+        secret: drop.includes('secret') ? false : (actual.hasSecret || !!values.secret),
+        totp: drop.includes('totp') ? false : (actual.hasTotp || !!values.totp),
+        notes: drop.includes('notes') ? false : (actual.hasNotes || !!values.notes),
+        fields: actual.fieldKeys.some((k) => !FIXED.includes(k)),
+        webauthn: actual.hasWebauthn
+      },
+      ...(actual.webauthn ? { webauthn: actual.webauthn } : {})
+    }
+    const idx = sites ? await Promise.all(sites.map((s) => siteIndex(keys.kidx, s))) : null
+    const parche = await buildSealedPatch({
+      id, view: vista, values, drop,
+      priv: await Promise.all(vista.privateKeys.map((k) => this.#sealedKey(k))),
+      ...(idx ? { idx } : {}), keys, recipients, author: this.#author()
+    })
+    await this.#request('pm2.patch', parche)
+    return { id, ...vista, updatedAt: Date.now() }
+  }
+
+  /** Buscar por texto: la bóveda no ve ninguno, así que se busca aquí sobre las vistas. */
+  async search (q, opts = {}) {
+    const termino = String(q || '').trim().toLowerCase()
+    if (!termino) return []
+    const limite = Number(opts.limit) > 0 ? Number(opts.limit) : 20
+    const out = []
+    for (const v of await this.#views()) {
+      const texto = [v.title, v.hint, ...(v.sites || [])].join(' ').toLowerCase()
+      if (texto.includes(termino)) out.push(v)
+      if (out.length >= limite) break
+    }
+    return out
+  }
+
+  /** En qué sitios hay algo. Los nombres salen de abrir las vistas, no de la bóveda. */
+  async sites () {
+    const cuenta = new Map()
+    for (const v of await this.#views()) {
+      for (const s of v.sites || []) cuenta.set(s, (cuenta.get(s) || 0) + 1)
+    }
+    return [...cuenta].map(([site, count]) => ({ site, count })).sort((a, b) => a.site.localeCompare(b.site))
+  }
+
+  async remove (id) {
+    await this.#request('pm2.remove', { id })
+  }
+
+  /**
+   * LA BÓVEDA ENTERA, ABIERTA AQUÍ. No es `list` de la bóveda: son las VISTAS, que no
+   * llevan ningún valor, y las abre este aparato con su llave. Es lo que sustituye a
+   * buscar dentro de la bóveda (§2.2), y por eso existe donde antes no podía existir.
+   */
+  async list () {
+    return this.#views()
+  }
+
+  /** El resumen de un valor, para decir si ya está guardado igual sin abrir nada (§2.6). */
+  async digest (id, key, value) {
+    const { kcmp } = await this.keys()
+    return valueDigest(kcmp, id, key, String(value))
+  }
+
+  async #views () {
+    const crudas = await this.#request('pm2.views', {})
+    const out = []
+    for (const v of crudas) out.push(await this.#openView(v))
+    return out
+  }
+
+  async #viewById (id) {
+    return (await this.#views()).find((v) => v.id === id) || null
+  }
+
+  #author () {
+    return { publickey: this.identity.publickey, sign: (body) => this.identity.sign(body) }
+  }
+
+  /** La vista de lo que se acaba de guardar, con la forma que espera la interfaz. */
+  #viewOf (plain) {
+    const campos = normalizeFields(Array.isArray(plain.fields) ? plain.fields : [])
+    return {
+      id: plain.id,
+      type: plain.type || 'login',
+      title: plain.title || '',
+      sites: plain.sites || [],
+      hasSecret: !!plain.secret,
+      hasTotp: !!plain.totp,
+      hasNotes: !!plain.notes,
+      hasFields: campos.length > 0,
+      hasWebauthn: !!plain.webauthn,
+      updatedAt: Date.now()
+    }
+  }
+
+  /** Estrenar la llave del perfil. Solo al convertir: después ya está y se pide. */
+  async initProfileKey () {
+    const recipients = await this.recipients()
+    const pk = await buildProfileKey({ recipients })
+    await this.#request('pm2.profile', { set: { envelope: pk.envelope, wraps: pk.wraps } })
+    this._keys = await profileKeys(pk.base)
+    return this._keys
+  }
+}
+
+export { PASSKEY_FIELD }
+export default SealedVault

package/vault/vendor/passmanager/webauthn.js

@@ -0,0 +1,221 @@
+// Passkeys: crear una credencial WebAuthn y firmar con ella.
+//
+// Chrome NO expone API de proveedor de credenciales a las extensiones (Android 14+ e
+// iOS 17+ sí). En el escritorio la única vía es la que usan todos: reemplazar
+// `navigator.credentials.create/get` en el contexto de la página. Como la llave la
+// generamos nosotros y la firma la producimos nosotros, la assertion es válida y el
+// sitio no distingue.
+//
+// Este módulo es la parte que NO toca el DOM: qué se guarda y cómo se firma. El parche
+// vive en la extensión.
+//
+// Referencia: WebAuthn Level 2, §6.3 (authenticatorMakeCredential) y §6.3.3
+// (authenticatorGetAssertion). El formato importa hasta el bit: un `authenticatorData`
+// mal armado lo rechaza el servidor sin decir por qué.
+
+const subtle = () => globalThis.crypto.subtle
+const enc = new TextEncoder()
+
+export const AAGUID = new Uint8Array(16) // ceros: sin atestación, como todo proveedor de software
+
+export function b64urlEncode (bytes) {
+  let s = ''
+  for (const b of new Uint8Array(bytes)) s += String.fromCharCode(b)
+  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+export function b64urlDecode (str) {
+  const b64 = String(str).replace(/-/g, '+').replace(/_/g, '/')
+  const bin = atob(b64)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+function concat (...arrays) {
+  const total = arrays.reduce((n, a) => n + a.length, 0)
+  const out = new Uint8Array(total)
+  let i = 0
+  for (const a of arrays) { out.set(a, i); i += a.length }
+  return out
+}
+
+async function sha256 (bytes) {
+  return new Uint8Array(await subtle().digest('SHA-256', bytes))
+}
+
+/** Banderas del authenticatorData. UP = presencia, UV = verificación, AT = trae credencial. */
+export const FLAGS = { UP: 0x01, UV: 0x04, AT: 0x40 }
+
+/**
+ * `authenticatorData`: hash del rpId + banderas + contador (+ la credencial al crear).
+ * El orden y los tamaños son fijos; aquí no hay margen de interpretación.
+ */
+export async function makeAuthenticatorData ({ rpId, flags, signCount, attested = null }) {
+  const rpIdHash = await sha256(enc.encode(rpId))
+  const counter = new Uint8Array(4)
+  new DataView(counter.buffer).setUint32(0, signCount >>> 0, false) // big-endian
+  const header = concat(rpIdHash, new Uint8Array([flags]), counter)
+  return attested ? concat(header, attested) : header
+}
+
+/** COSE_Key de una pública P-256 (kty 2, alg -7, crv 1). Es lo que el servidor guarda. */
+export function coseFromJwk (jwk) {
+  const x = b64urlDecode(jwk.x)
+  const y = b64urlDecode(jwk.y)
+  // CBOR a mano: un mapa de 5 entradas con claves enteras. La alternativa era arrastrar
+  // una librería de CBOR entera para escribir 77 bytes de forma fija.
+  return concat(
+    new Uint8Array([0xa5]),                    // map(5)
+    new Uint8Array([0x01, 0x02]),              // 1 (kty): 2 (EC2)
+    new Uint8Array([0x03, 0x26]),              // 3 (alg): -7 (ES256)
+    new Uint8Array([0x20, 0x01]),              // -1 (crv): 1 (P-256)
+    new Uint8Array([0x21, 0x58, 0x20]), x,     // -2 (x): bytes(32)
+    new Uint8Array([0x22, 0x58, 0x20]), y,     // -3 (y): bytes(32)
+  )
+}
+
+/** `attestedCredentialData`: aaguid + size + id + la pública en COSE. */
+export function attestedCredentialData (credentialId, coseKey) {
+  const size = new Uint8Array(2)
+  new DataView(size.buffer).setUint16(0, credentialId.length, false)
+  return concat(AAGUID, size, credentialId, coseKey)
+}
+
+/**
+ * Crea una passkey para un sitio. Devuelve lo que se guarda en la bóveda y lo que hay
+ * que devolverle a la página.
+ */
+export async function createCredential ({ rpId, userHandle, userName = '', origin, challenge }) {
+  const pair = await subtle().generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+  const jwkPriv = await subtle().exportKey('jwk', pair.privateKey)
+  const jwkPub = await subtle().exportKey('jwk', pair.publicKey)
+
+  const credentialId = globalThis.crypto.getRandomValues(new Uint8Array(32))
+  const attested = attestedCredentialData(credentialId, coseFromJwk(jwkPub))
+  const authData = await makeAuthenticatorData({
+    rpId,
+    // UV va puesto porque el usuario abre su bóveda para esto: hay verificación real.
+    flags: FLAGS.UP | FLAGS.UV | FLAGS.AT,
+    signCount: 0,
+    attested,
+  })
+
+  const clientDataJSON = enc.encode(JSON.stringify({
+    type: 'webauthn.create',
+    challenge: typeof challenge === 'string' ? challenge : b64urlEncode(challenge),
+    origin,
+    crossOrigin: false,
+  }))
+
+  return {
+    // Lo que se guarda (la privada va cifrada por el modelo, como cualquier secreto).
+    entry: {
+      credentialId: b64urlEncode(credentialId),
+      rpId,
+      userHandle: userHandle ? b64urlEncode(userHandle) : '',
+      userName,
+      privateKey: JSON.stringify(jwkPriv),
+      signCount: 0,
+    },
+    // Lo que se le devuelve a la página, ya en base64url.
+    response: {
+      id: b64urlEncode(credentialId),
+      rawId: b64urlEncode(credentialId),
+      type: 'public-key',
+      response: {
+        clientDataJSON: b64urlEncode(clientDataJSON),
+        // `attestationObject` sin atestación: fmt "none", attStmt vacío.
+        attestationObject: b64urlEncode(concat(
+          new Uint8Array([0xa3]),                                            // map(3)
+          new Uint8Array([0x63]), enc.encode('fmt'),                         // "fmt"
+          new Uint8Array([0x64]), enc.encode('none'),                        // "none"
+          new Uint8Array([0x67]), enc.encode('attStmt'),                     // "attStmt"
+          new Uint8Array([0xa0]),                                            // {}
+          new Uint8Array([0x68]), enc.encode('authData'),                    // "authData"
+          new Uint8Array([0x59]), lengthBytes(authData.length), authData,    // bytes(len)
+        )),
+        publicKeyAlgorithm: -7,
+      },
+    },
+  }
+}
+
+function lengthBytes (n) {
+  const b = new Uint8Array(2)
+  new DataView(b.buffer).setUint16(0, n, false)
+  return b
+}
+
+/**
+ * Firma un reto con una passkey guardada: `sign(authenticatorData || sha256(clientDataJSON))`.
+ * Devuelve también el contador nuevo, que hay que guardar.
+ */
+export async function signAssertion ({ entry, origin, challenge }) {
+  const jwk = JSON.parse(entry.privateKey)
+  const key = await subtle().importKey('jwk', jwk, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign'])
+
+  const signCount = (entry.signCount || 0) + 1
+  const authData = await makeAuthenticatorData({
+    rpId: entry.rpId,
+    flags: FLAGS.UP | FLAGS.UV,
+    signCount,
+  })
+
+  const clientDataJSON = enc.encode(JSON.stringify({
+    type: 'webauthn.get',
+    challenge: typeof challenge === 'string' ? challenge : b64urlEncode(challenge),
+    origin,
+    crossOrigin: false,
+  }))
+
+  const signed = concat(authData, await sha256(clientDataJSON))
+  const raw = new Uint8Array(await subtle().sign(
+    { name: 'ECDSA', hash: 'SHA-256' }, key, signed))
+
+  return {
+    signCount,
+    response: {
+      id: entry.credentialId,
+      rawId: entry.credentialId,
+      type: 'public-key',
+      response: {
+        authenticatorData: b64urlEncode(authData),
+        clientDataJSON: b64urlEncode(clientDataJSON),
+        // WebAuthn pide la firma en DER, no en el crudo de WebCrypto.
+        signature: b64urlEncode(rawSignatureToDer(raw)),
+        userHandle: entry.userHandle || null,
+      },
+    },
+  }
+}
+
+/**
+ * WebCrypto firma ECDSA como `r || s` de 32 bytes cada uno; WebAuthn espera DER
+ * (SEQUENCE de dos INTEGER). Sin esta conversión el servidor rechaza la firma sin
+ * decir por qué, que es de los fallos más caros de diagnosticar.
+ */
+export function rawSignatureToDer (raw) {
+  const r = derInteger(raw.slice(0, 32))
+  const s = derInteger(raw.slice(32, 64))
+  return concat(new Uint8Array([0x30, r.length + s.length]), r, s)
+}
+
+function derInteger (bytes) {
+  let i = 0
+  while (i < bytes.length - 1 && bytes[i] === 0) i++   // sin ceros a la izquierda
+  let v = bytes.slice(i)
+  if (v[0] & 0x80) v = concat(new Uint8Array([0]), v)  // positivo: byte de relleno
+  return concat(new Uint8Array([0x02, v.length]), v)
+}
+
+/** ¿Sirve esta passkey para el sitio que la pide? */
+export function credentialMatches (entry, rpId, allowCredentials) {
+  if (!entry?.webauthn) return false
+  if (entry.webauthn.rpId !== rpId) return false
+  if (!allowCredentials?.length) return true
+  return allowCredentials.some(c => {
+    const id = typeof c.id === 'string' ? c.id : b64urlEncode(c.id)
+    return id === entry.webauthn.credentialId
+  })
+}

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.32.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.js).
+Copia vendorizada de @dotrino/proxy-client@0.32.2 (dotrino-proxy-client/src/{canonical,client,encpub,index,sealing,signature,stats-log,stats,webrtc}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/proxy-client/client.js

@@ -67,6 +67,12 @@ export class WebSocketProxyClient {
     this.autoReconnect = options.autoReconnect !== false
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5
     this.reconnectDelay = options.reconnectDelay ?? 3000
+    // UN SOCKET QUE NO ABRE NI FALLA. El WebSocket de Node (y el del navegador) no tiene
+    // tope para el saludo: si el TCP entra y nadie contesta el upgrade, se queda en
+    // CONNECTING sin disparar `open`, `error` ni `close`. Como el siguiente reintento solo
+    // se programa desde esos eventos, la cadena de reconexión se paraba ahí, en silencio.
+    // Se abandona el intento pasado este tiempo y cuenta como un fallo más.
+    this.connectTimeout = options.connectTimeout ?? 15000
     this.enableWebRTC = options.enableWebRTC !== false
     this.iceServers = options.iceServers || null
 
@@ -225,6 +231,8 @@ export class WebSocketProxyClient {
   connect () {
     return new Promise((resolve, reject) => {
       if (this._connected) return resolve(this.token)
+      // Un reintento que estaba esperando su turno sobra: este `connect()` ya abre uno.
+      if (this._reconnectTimer) { clearTimeout(this._reconnectTimer); this._reconnectTimer = null }
       this._connectResolve = resolve
       this._connectReject = reject
       this._open()
@@ -1242,11 +1250,21 @@ export class WebSocketProxyClient {
 
   _open () {
     registerTransport(this)
+    // El intento anterior, si sigue a medio abrir, se suelta: sus eventos tardíos ya se
+    // ignoran (`ws !== this.ws`), pero el socket quedaría abierto sin dueño.
+    const prev = this.ws
+    if (prev && prev.readyState === 0 /* CONNECTING */) {
+      this.ws = null   // antes de cerrarlo: su `close` ya no es de este cliente
+      try { prev.close() } catch (_) {}
+    }
     const ws = new WebSocket(this.url)
     this.ws = ws
+    const openTimer = this.connectTimeout > 0 ? setTimeout(() => this._onConnectTimeout(ws), this.connectTimeout) : null
+    openTimer?.unref?.()
     // `ws !== this.ws` ⇒ es un socket que ya abandonamos (p.ej. por heartbeat
     // muerto). Ignoramos sus eventos tardíos para no disparar reconexiones dobles.
     ws.addEventListener('open', () => {
+      if (openTimer) clearTimeout(openTimer)
       if (ws !== this.ws) return
       this._connected = true
       this._reconnectAttempts = 0
@@ -1269,6 +1287,7 @@ export class WebSocketProxyClient {
       }
     })
     ws.addEventListener('close', (ev) => {
+      if (openTimer) clearTimeout(openTimer)
       if (ws !== this.ws) return
       this._stopHeartbeat()
       const wasConnected = this._connected
@@ -1301,6 +1320,23 @@ export class WebSocketProxyClient {
     })
   }
 
+  // El intento no abrió ni falló a tiempo: se suelta y se trata como un cierre fallido.
+  _onConnectTimeout (ws) {
+    if (ws !== this.ws || this._connected) return
+    this.ws = null   // a partir de acá, los eventos tardíos de `ws` se ignoran
+    try { ws.close() } catch (_) {}
+    const err = errorCon(`could not open the connection to ${this.url} in ${Math.round(this.connectTimeout / 1000)}s`, 'CONNECT_TIMEOUT')
+    this._emit('error', { type: 'connect_timeout', error: err })
+    if (this._connectReject) {
+      this._connectReject(err)
+      this._connectResolve = null
+      this._connectReject = null
+    }
+    // Lo mismo que en `close`: se sigue reintentando solo si esto ya era un reintento. Un
+    // `connect()` inicial que no abre se rechaza y ya.
+    if (this._reconnectAttempts > 0 && this.autoReconnect) this._scheduleReconnect()
+  }
+
   // ---------- heartbeat ----------
 
   _startHeartbeat () {

package/vault/vendor/roadmap/VERSION.txt

@@ -0,0 +1,3 @@
+Copia vendorizada de @dotrino/roadmap@0.4.13 (dotrino-roadmap/src/{index,manifests}.js).
+NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
+El registro de versiones rotas que viaja con cada versión. Importa @dotrino/compat/ranges.