@dotrino/identity 0.89.1 → 0.90.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.89.1",
+  "version": "0.90.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/vault/acta.js

@@ -1025,6 +1025,44 @@ export function memberScopes (acta, pub, extraRenounces = []) {
 /** ¿Es un servicio (tiene CN) o un dispositivo del usuario? */
 export const isService = (acta, pub) => !!(acta?.members || []).find((x) => x.pub === pub)?.cn
 
+/**
+ * ¿SON LA MISMA LLAVE? Nunca `===` sobre el JWK serializado: no es canónico, así que la
+ * misma llave escrita por dos piezas distintas da dos strings distintos y `===` dice que
+ * no. Lo que identifica a una P-256 es el punto (`kty`, `crv`, `x`, `y`); lo demás del
+ * JWK es cómo se usa, no cuál es.
+ */
+export function samePubkey (a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string') return false
+  if (a === b) return true
+  try {
+    const x = JSON.parse(a)
+    const y = JSON.parse(b)
+    return !!x && !!y && x.kty === y.kty && x.crv === y.crv && x.x === y.x && x.y === y.y
+  } catch (_) {
+    return false
+  }
+}
+
+/**
+ * LA LLAVE DE CIFRADO DE UN MIEMBRO, que es lo que hace falta para sellarle algo.
+ *
+ * Existía el dato —cada aparato la publica al enrolarse y queda escrita en el acta— pero
+ * no la función, así que cada consumidor repetía el `.find()` a mano y cada copia
+ * comparaba pubkeys con `===`. Esto es esa lectura, una vez y en el pilar.
+ *
+ * Devuelve `null` cuando no la hay, y eso NO es un repliegue: es el dato que falta dicho
+ * en voz alta. Quien llama tiene que parar ahí, no mandar en claro — un miembro sin
+ * `encPub` (un acta vieja, un servicio) simplemente no puede recibir nada sellado.
+ *
+ * @param {any} acta
+ * @param {string} pub
+ * @returns {string|null}
+ */
+export function memberEncPub (acta, pub) {
+  const m = (acta?.members || []).find((x) => samePubkey(x?.pub, pub))
+  return m?.encPub || null
+}
+
 /** ¿Puede este miembro hacer `cap` según el acta? (con el cert se cruza aparte: cert ∩ acta). */
 export function memberCan (acta, pub, cap, extraRenounces = []) {
   return effectiveCaps(acta, pub, extraRenounces).includes(cap)
@@ -1183,5 +1221,6 @@ export default {
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
-  effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
+  effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt,
+  samePubkey, memberEncPub
 }

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

@@ -1,4 +1,6 @@
-Copia vendorizada de @dotrino/proxy-client@0.19.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.20.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,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.
+encpub.js (≥ 0.20) es el anuncio firmado de la llave de cifrado; no importa nada de
+fuera, solo ./signature.js y ./canonical.js de esta misma copia.

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

@@ -1,5 +1,6 @@
-import { buildSignedChannel, getPublicKeyJwk, signData } from './signature.js'
+import { buildSignedChannel, getPublicKeyJwk, signData, samePubkey } from './signature.js'
 import { seal, open, isSealed } from './sealing.js'
+import { buildEncPubStatement, readEncPubStatement, isEncPub } from './encpub.js'
 import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection } from './webrtc.js'
 
 /**
@@ -58,6 +59,40 @@ export class WebSocketProxyClient {
     this.requireSealed = options.requireSealed === true
     this.myEncPrivateKey = options.myEncPrivateKey || null
 
+    /**
+     * MI llave de cifrado, la pública. Con ella puesta, `identify` anuncia al proxio
+     * —firmado— que esta identidad se abre por aquí, y cualquiera que sepa mi pubkey puede
+     * averiguarla y sellarme sin habernos emparejado nunca. Sin ella, los demás no tienen
+     * de dónde sacarla y `sendSealed` hacia mí no sale: falla en vez de ir en claro.
+     *
+     * En un aparato headless es `(await makeEncKeypair()).encPub`; en el navegador,
+     * `await identity.getEncryptionPubkey()` — ahí la privada vive en la bóveda y no se
+     * pasa, se delega en `sealing`.
+     */
+    this.myEncPub = options.myEncPub || null
+
+    /**
+     * Llaves de cifrado ajenas YA VERIFICADAS (pubkey → encpub). Solo entra aquí lo que
+     * pasó por `readEncPubStatement`, así que lo de dentro está atado a su identidad.
+     * No se cachean los fallos: «hoy no la tengo» no es un hecho, es un momento.
+     */
+    this._encPubs = new Map()
+    this._encPubInflight = new Map()
+
+    /**
+     * QUIEN YA SABE LA RESPUESTA, QUE NO PREGUNTE. Los aparatos de un mismo dueño llevan su
+     * llave de cifrado escrita en el ACTA (`memberEncPub` de `@dotrino/identity`), firmada
+     * por el master: eso es más fuerte que el anuncio y no hace falta ir al proxio a por
+     * ello. Una app con acta enchufa aquí
+     * `encPubResolver: (pub) => memberEncPub(acta, pub)`.
+     *
+     * Devolver `null` significa «yo no sé», y entonces se pregunta al proxio. No es un
+     * repliegue: si no lo sabe nadie, no se manda nada — se sigue fallando cerrado.
+     *
+     * @type {((publickey:string)=>Promise<string|null>|string|null)|null}
+     */
+    this.encPubResolver = typeof options.encPubResolver === 'function' ? options.encPubResolver : null
+
     /**
      * Who does the sealing. Two worlds, and only one of them holds the key:
      *
@@ -187,6 +222,8 @@ export class WebSocketProxyClient {
     // perderla.
     if (options.sealing) this.sealing = options.sealing
     if (options.myEncPrivateKey) this.myEncPrivateKey = options.myEncPrivateKey
+    if (options.myEncPub) this.myEncPub = options.myEncPub
+    if (typeof options.encPubResolver === 'function') this.encPubResolver = options.encPubResolver
 
     // Se puede ENCENDER, no apagar. Bajar la exigencia en caliente dejaría que
     // cualquier otro módulo de la app la desactivara sin querer, y no hay ningún
@@ -210,6 +247,15 @@ export class WebSocketProxyClient {
    * The payload is JSON-stringified into the envelope's `message` field.
    */
   send (to, payload) {
+    // `requireSealed` vale para los DOS caminos dirigidos, no solo para el de pubkey
+    // (CONVENCIONES §4.1 nombra `sendByPubkey` / `send`). Guardar uno y dejar el otro
+    // abierto es no guardar ninguno: la app manda por donde le sale y el proxio lo lee
+    // igual. Para sellar por token está `sendSealedTo`.
+    if (this.requireSealed && !this._isSealed(payload)) {
+      throw errorCon(
+        'requireSealed: refusing to send a directed message in the clear — use sendSealedTo()',
+        'unsealed')
+    }
     const tokens = Array.isArray(to) ? to : [to]
     const messageStr = typeof payload === 'string' ? payload : JSON.stringify(payload)
     if (!this._rtc) {
@@ -370,12 +416,150 @@ export class WebSocketProxyClient {
    * should use for anything that is not meant for the proxy's eyes.
    */
   async sendSealed (toPubkeys, payload, { peerEncPub, ...opts } = {}) {
-    if (this.sealing) {
-      this._sendByPubkeyRaw(toPubkeys, await this.sealing.seal(payload, peerEncPub), opts)
+    const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
+    // Con la llave puesta a mano se respeta tal cual: quien la pasa está diciendo que ya
+    // sabe de quién es (se emparejaron), y un sobre vale para todos los destinatarios.
+    if (peerEncPub) {
+      this._sendByPubkeyRaw(list, await this._seal(payload, peerEncPub), opts)
       return
     }
-    if (!peerEncPub) throw Object.assign(new Error('sendSealed: missing peerEncPub'), { code: 'unsealed' })
-    this._sendByPubkeyRaw(toPubkeys, await seal(payload, peerEncPub), opts)
+    // Sin ella, se averigua. UNA ENVOLTURA POR DESTINATARIO: cada uno tiene su llave, así
+    // que un solo sobre solo lo abriría uno.
+    //
+    // Y SE RESUELVEN TODAS ANTES DE MANDAR NADA. Enviar a los que se pudo y fallar por el
+    // resto deja a la app creyendo que el mensaje salió, con la mitad de la sala sin él y
+    // sin forma de saber cuál mitad.
+    const llaves = await Promise.all(list.map(async (pk) => [pk, await this.encPubOf(pk)]))
+    for (const [pk, encPub] of llaves) {
+      this._sendByPubkeyRaw([pk], await this._seal(payload, encPub), opts)
+    }
+  }
+
+  /**
+   * Sellar y mandar POR TOKEN, que es como hablan entre sí los de una sala (y lo único
+   * que puede subir a WebRTC, §transporte: el camino más directo).
+   *
+   * `peerPubkey` no es un adorno: el token es una dirección del proxio y no dice de quién
+   * es. Quien puede afirmar «este token es de esta identidad» es la app —lo sabe por el
+   * canal, por el saludo de la sala o por la invitación—, así que lo dice ella y aquí se
+   * sella a esa identidad. Sin ese dato no hay a quién sellarle y no se manda nada.
+   *
+   * @param {string|string[]} toTokens
+   * @param {any} payload
+   * @param {{ peerPubkey?:string, peerEncPub?:string }} opts
+   */
+  async sendSealedTo (toTokens, payload, { peerPubkey, peerEncPub } = /** @type {any} */ ({})) {
+    const tokens = Array.isArray(toTokens) ? toTokens : [toTokens]
+    if (!peerEncPub) {
+      if (!peerPubkey) {
+        throw errorCon('sendSealedTo: missing peerPubkey — a token does not say whose it is', 'unsealed')
+      }
+      peerEncPub = await this.encPubOf(peerPubkey)
+    }
+    const sobre = await this._seal(payload, peerEncPub)
+    // Por `send`, no por `_sendRaw`: así sigue prefiriendo el canal directo si lo hay.
+    this.send(tokens, sobre)
+  }
+
+  /** Sella con lo que haya: la bóveda de la app (`sealing`) o las primitivas del pilar. */
+  async _seal (payload, peerEncPub) {
+    if (!peerEncPub) throw errorCon('seal: missing peerEncPub', 'unsealed')
+    return this.sealing ? this.sealing.seal(payload, peerEncPub) : seal(payload, peerEncPub)
+  }
+
+  // ---------- llaves de cifrado ajenas ----------
+
+  /**
+   * ANUNCIAR MI LLAVE DE CIFRADO. Una frase firmada por la misma identidad con la que me
+   * identifico; el proxio la guarda y se la da a quien pregunte, y quien pregunta la
+   * verifica contra mi pubkey. El proxio es el buzón, no la autoridad.
+   *
+   * Lo llama `identify` solo cuando el cliente tiene `myEncPub`. Se expone aparte para el
+   * caso de anunciar una llave nueva sin reconectar.
+   */
+  async announceEncPub ({ publickey, encPub, sign } = /** @type {any} */ ({})) {
+    const statement = await buildEncPubStatement({ publickey, encPub, sign })
+    await this._request({ type: 'encpub', ...statement }, 'encpub-announced')
+    // Lo mío también va a la caché: si una app se escribe a sí misma (otro aparato del
+    // mismo perfil no, ése tiene otra llave) no hace falta preguntar por ello.
+    this._encPubs.set(publickey, encPub)
+    return encPub
+  }
+
+  /**
+   * LA LLAVE DE CIFRADO DE UNA IDENTIDAD, verificada. Devuelve la llave o LANZA:
+   *
+   *   · `no-encpub`          nadie ha anunciado llave para esa identidad — se arregla
+   *                          cuando el otro lado actualice; esperar no sirve
+   *   · `encpub-unverified`  llegó una llave que NO firmó esa identidad. Es el caso que
+   *                          importa: significa que alguien intentó ponerte la suya
+   *   · `no-encpub-support`  este proxio no sabe de esto (es viejo)
+   *
+   * Nunca devuelve `null` y nunca cae a «manda igual»: si no se puede sellar, no se manda.
+   */
+  async encPubOf (publickey) {
+    if (typeof publickey !== 'string' || !publickey) {
+      throw errorCon('encPubOf: missing publickey', 'encpub-shape')
+    }
+    const cacheada = this._encPubs.get(publickey)
+    if (cacheada) return cacheada
+    // Una pregunta en vuelo por llave: una sala de ocho manda ocho mensajes a la vez y
+    // preguntaría ocho veces por lo mismo.
+    const enVuelo = this._encPubInflight.get(publickey)
+    if (enVuelo) return enVuelo
+    const promesa = this._lookupEncPub(publickey)
+      .finally(() => this._encPubInflight.delete(publickey))
+    this._encPubInflight.set(publickey, promesa)
+    return promesa
+  }
+
+  async _lookupEncPub (publickey) {
+    // EL CAMINO MÁS DIRECTO PRIMERO. Si la app comparte acta con el destinatario, la llave
+    // ya la tiene en la mano y firmada por el master: preguntársela a un servidor sería
+    // dar la vuelta para llegar a lo que ya está aquí.
+    if (this.encPubResolver) {
+      const propia = await this.encPubResolver(publickey)
+      if (propia) {
+        if (!isEncPub(propia)) {
+          throw errorCon('encPubResolver returned something that is not a P-256 public JWK', 'encpub-unverified')
+        }
+        this._encPubs.set(publickey, propia)
+        return propia
+      }
+    }
+    // SI EL PROXIO DICE QUE NO SABE DE ESTO, se dice con su propio código en vez de
+    // esperar diez segundos a un timeout. Un proxio que no manda `caps` es de antes de
+    // que esto existiera y no se sabe: se pregunta igual, y contesta la pregunta.
+    if (Array.isArray(this.caps) && !this.caps.includes('encpub')) {
+      throw errorCon(
+        `este proxio (${this.url}) no sirve llaves de cifrado: hace falta websocket-proxy >= 1.1.0`,
+        'no-encpub-support')
+    }
+    const res = await this._request({ type: 'enc-lookup', publickeys: [publickey] }, 'enc-lookup')
+    // `samePubkey`, no `===`: el proxio guarda el string exacto con el que se anunció, y
+    // la app puede tener el mismo JWK escrito de otra forma.
+    const statement = (res.keys || []).find((k) => samePubkey(k?.data?.publickey, publickey))
+    if (!statement) {
+      throw errorCon('no encryption key announced for that identity — it cannot be sealed to yet', 'no-encpub')
+    }
+    // AQUÍ ES DONDE EL PROXIO DEJA DE IMPORTAR: la firma se comprueba contra la pubkey a
+    // la que vamos a escribir. Si cambió la llave por la suya, esto lanza.
+    const encPub = await readEncPubStatement(statement, { publickey })
+    this._encPubs.set(publickey, encPub)
+    return encPub
+  }
+
+  /** Guardar una llave que ya viene firmada por su dueño (de un canal, de una invitación). */
+  async learnEncPub (statement, { publickey } = /** @type {any} */ ({})) {
+    const encPub = await readEncPubStatement(statement, { publickey })
+    this._encPubs.set(publickey, encPub)
+    return encPub
+  }
+
+  /** Olvidar lo aprendido de una identidad (rotó su llave, o se quiere volver a preguntar). */
+  forgetEncPub (publickey) {
+    if (publickey == null) this._encPubs.clear()
+    else this._encPubs.delete(publickey)
   }
 
   _isSealed (msg) {
@@ -533,6 +717,21 @@ export class WebSocketProxyClient {
     if (this._rtc && typeof sign === 'function' && data.publickey) {
       done.then(() => this.enableTurn({ publicKey: data.publickey, sign })).catch(() => {})
     }
+    // ANUNCIAR LA LLAVE DE CIFRADO, y por detrás. Identificarse es lo que da dirección a
+    // esta identidad; anunciar su llave es lo que hace que alguien pueda sellarle sin
+    // haberla emparejado antes. Va después y sin bloquear, como TURN: esperar a esto
+    // retrasaría el primer mensaje para ganar algo que solo hace falta cuando el OTRO
+    // quiera escribirnos.
+    if (typeof sign === 'function' && data.publickey && this.myEncPub) {
+      done
+        .then(() => this.announceEncPub({ publickey: data.publickey, encPub: this.myEncPub, sign }))
+        .catch((e) => {
+          // Se dice en voz alta: sin anuncio nadie podrá sellarnos, y el síntoma llega
+          // días después y del otro lado («no puedo escribirte»). Callarlo es justo el
+          // fallo mudo que el ecosistema paga caro.
+          this._emit('error', { type: 'encpub_announce_failed', error: e, code: e?.code || null })
+        })
+    }
     return done
   }
 
@@ -905,6 +1104,12 @@ export class WebSocketProxyClient {
         // de salas): se pregunta en cada nodo y se mezcla, en vez de designar a
         // uno como árbitro. Son públicos: van en cada instancia y en /peers.
         this.peers = Array.isArray(data.peers) ? data.peers : []
+        // QUÉ SABE HACER ESTE PROXIO, dicho por él al conectar (§14: una incompatibilidad
+        // que no se anuncia se vive como silencio). `caps` ausente = proxio anterior a que
+        // esto existiera: no se da por hecho nada, se pregunta igual y contesta la
+        // pregunta.
+        this.protocol = Number.isInteger(data.protocol) ? data.protocol : null
+        this.caps = Array.isArray(data.caps) ? data.caps : null
         /** Este nodo + los que conoce, sin repetidos. */
         this.knownNodes = [this.node, ...this.peers].filter((n, i, a) => n && a.indexOf(n) === i)
         this.token = this.instance
@@ -963,6 +1168,8 @@ export class WebSocketProxyClient {
       case 'turn-credentials':
       case 'pair-code':
       case 'pair-redeem':
+      case 'encpub-announced':
+      case 'enc-lookup':
         this._resolvePending(data, type)
         break
       case 'error':

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

@@ -0,0 +1,121 @@
+/**
+ * LA LLAVE DE CIFRADO DE UN DESCONOCIDO, Y DE QUIÉN ES.
+ *
+ * Sellar un mensaje dirigido necesita la llave de cifrado del otro lado. Hasta ahora el
+ * pilar la exigía (`sendSealed({ peerEncPub })`) y no ofrecía ninguna forma de
+ * conseguirla, así que solo podían sellar dos puntas que se hubieran emparejado antes y
+ * se la hubieran intercambiado a mano. Todo lo demás —una sala, una invitación, un acuse
+ * a alguien que está apagado— viajaba en claro, que es exactamente lo que el proxio ve.
+ *
+ * Lo que hay aquí es el ANUNCIO: una frase corta, firmada por la misma llave con la que
+ * uno se identifica en el cable, que dice «mi llave de cifrado es ésta».
+ *
+ *     { v:1, op:'encpub', aud:'dotrino:encpub', publickey, encpub, ts }  + signature
+ *
+ * LO IMPORTANTE NO ES DÓNDE SE GUARDA, ES QUIÉN LO FIRMA. El proxio hace de buzón: se lo
+ * queda y se lo da a quien pregunte. Pero quien pregunta **no se fía de él**: verifica la
+ * firma contra la pubkey a la que va a escribir, que es la misma que el proxio usa para
+ * enrutar y la misma que `identify` comprueba. Si el proxio cambia la llave por la suya
+ * para poder leer, la firma no cuadra y no sale nada — ni sellado ni en claro.
+ *
+ * De ahí sale la regla dura de este módulo: **`readEncPubStatement` no devuelve nunca
+ * `null`.** O devuelve una llave verificada o lanza con un `code`. Un valor por defecto
+ * aquí sería una llave de cifrado que no es de nadie.
+ *
+ * `aud` es un propósito y no una URL a propósito: el mismo anuncio vale en cualquier nodo
+ * de la malla, y con la URL del proxio delante un anuncio hecho en `proxy1` no se podría
+ * verificar desde `proxy2`.
+ */
+import { canonicalStringify } from './canonical.js'
+import { verifyData, samePubkey } from './signature.js'
+
+export const ENCPUB_V = 1
+
+/** Para quién vale este anuncio: un propósito, no un servidor. */
+export const ENCPUB_AUD = 'dotrino:encpub'
+
+/** Cuerpo canónico del anuncio. Lo que se firma, ni un campo más. */
+export function encPubBody ({ publickey, encPub, ts = Date.now() }) {
+  return { v: ENCPUB_V, op: 'encpub', aud: ENCPUB_AUD, publickey, encpub: encPub, ts }
+}
+
+/**
+ * ¿Es esto una llave de cifrado P-256 y no cualquier string? Se comprueba de verdad
+ * —igual que hace el acta— porque una llave mal formada no falla al guardarla: falla
+ * mucho después, al intentar sellarle algo a alguien.
+ */
+export function isEncPub (v) {
+  if (typeof v !== 'string' || !v) return false
+  try {
+    const j = JSON.parse(v)
+    return j?.kty === 'EC' && j?.crv === 'P-256' && typeof j?.x === 'string' && typeof j?.y === 'string'
+  } catch (_) {
+    return false
+  }
+}
+
+/**
+ * @param {string} mensaje
+ * @param {string} code
+ * @returns {Error & { code: string }}
+ */
+function errorCon (mensaje, code) {
+  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
+  e.code = code
+  return e
+}
+
+/**
+ * Firma el anuncio con lo que firma la identidad (`identity.signData`, o la llave local
+ * del cliente). No genera llaves ni cifra nada: solo dice de quién es la que ya tienes.
+ *
+ * @param {{ publickey:string, encPub:string, sign:(data:any)=>Promise<string|{signature:string}> }} args
+ * @returns {Promise<{data:any, signature:string}>}
+ */
+export async function buildEncPubStatement ({ publickey, encPub, sign } = /** @type {any} */ ({})) {
+  if (typeof publickey !== 'string' || !publickey) throw errorCon('buildEncPubStatement: missing publickey', 'encpub-shape')
+  if (!isEncPub(encPub)) throw errorCon('buildEncPubStatement: encPub is not a P-256 public JWK', 'encpub-shape')
+  if (typeof sign !== 'function') throw errorCon('buildEncPubStatement: missing sign(data)', 'encpub-shape')
+  const data = encPubBody({ publickey, encPub })
+  const firmado = await sign(data)
+  const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+  // «No pude firmar» no es «se cayó la red», y aquí es donde se separan: quien llama
+  // decide una cosa u otra según el `code`, nunca según la frase.
+  if (typeof signature !== 'string') throw errorCon('buildEncPubStatement: sign() returned no signature', 'no-signature')
+  return { data, signature }
+}
+
+/**
+ * Abre un anuncio ajeno y devuelve la llave de cifrado, o LANZA.
+ *
+ * `publickey` es a quién le vas a escribir, y es el ancla entera: se comprueba que el
+ * anuncio hable de ESA llave y que lo haya firmado ESA llave. Sin ese argumento esto
+ * solo diría «alguien firmó esto», que no sirve para decidir a quién le sellas.
+ *
+ * @param {{data:any, signature:string}} statement
+ * @param {{ publickey:string }} expected
+ * @returns {Promise<string>} la `encpub` verificada
+ */
+export async function readEncPubStatement (statement, { publickey } = /** @type {any} */ ({})) {
+  if (typeof publickey !== 'string' || !publickey) {
+    throw errorCon('readEncPubStatement: missing the publickey to check against', 'encpub-shape')
+  }
+  const data = statement?.data
+  const signature = statement?.signature
+  if (!data || typeof signature !== 'string') throw errorCon('encpub statement: malformed', 'encpub-unverified')
+  if (data.v !== ENCPUB_V || data.op !== 'encpub') throw errorCon('encpub statement: not an encpub announcement', 'encpub-unverified')
+  if (data.aud !== ENCPUB_AUD) throw errorCon('encpub statement: wrong audience', 'encpub-unverified')
+  // `samePubkey` y no `===`: un JWK serializado no es canónico y la misma llave escrita
+  // por dos piezas distintas da dos strings distintos.
+  if (!samePubkey(data.publickey, publickey)) throw errorCon('encpub statement: announces another identity', 'encpub-unverified')
+  if (!isEncPub(data.encpub)) throw errorCon('encpub statement: not a P-256 public JWK', 'encpub-unverified')
+  // Se verifica con la llave que ANUNCIA el sobre, que ya se comprobó que es la misma que
+  // la pedida: así el texto firmado y la llave que lo comprueba salen del mismo sitio.
+  if (!(await verifyData(data.publickey, data, signature))) {
+    throw errorCon('encpub statement: bad signature — the key is not bound to that identity', 'encpub-unverified')
+  }
+  return data.encpub
+}
+
+/** Lo firmado, en texto canónico. Mismo orden en las dos puntas o las firmas no cuadran. */
+export const encPubSigningText = (data) => canonicalStringify(data)

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

@@ -1,10 +1,14 @@
 export { WebSocketProxyClient } from './client.js'
 export { canonicalStringify } from './canonical.js'
-export { getPublicKeyJwk, signData, buildSignedChannel, setKeypairStore } from './signature.js'
+export { getPublicKeyJwk, signData, verifyData, samePubkey, buildSignedChannel, setKeypairStore } from './signature.js'
 export {
   seal, open, isSealed, makeEncKeypair, importEncPrivate, exportEncPrivate,
   setSealingPrimitives,
 } from './sealing.js'
+export {
+  ENCPUB_V, ENCPUB_AUD, encPubBody, isEncPub,
+  buildEncPubStatement, readEncPubStatement,
+} from './encpub.js'
 
 import { WebSocketProxyClient } from './client.js'
 

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

@@ -194,12 +194,87 @@ export async function signData (data) {
   return bufferToBase64(new Uint8Array(signature))
 }
 
+/**
+ * ¿SON LA MISMA LLAVE? Nunca `===` sobre el JWK serializado.
+ *
+ * Es trampa conocida del ecosistema: un JWK serializado NO es canónico, así que la misma
+ * llave escrita por dos piezas distintas —o guardada por una tabla vieja y otra nueva— da
+ * dos strings diferentes y `===` dice que no son la misma. Lo que identifica a una P-256
+ * es el punto: `kty`, `crv`, `x` e `y`. Lo demás del JWK (`ext`, `key_ops`, `alg`, `use`)
+ * es cómo se usa, no cuál es.
+ *
+ * Ojo con lo que esto NO cambia: el proxio enruta por el STRING exacto, así que la
+ * dirección a la que se escribe sigue siendo la que te dio la app. Esto es para DECIDIR
+ * si dos referencias hablan de la misma identidad, no para reemplazar una por otra.
+ */
+export function samePubkey (a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string') return false
+  if (a === b) return true
+  try {
+    const x = JSON.parse(a)
+    const y = JSON.parse(b)
+    return !!x && !!y && x.kty === y.kty && x.crv === y.crv && x.x === y.x && x.y === y.y
+  } catch (_) {
+    return false
+  }
+}
+
+/**
+ * Verifica una firma ajena sobre el JSON canónico de `data`.
+ *
+ * POR QUÉ VIVE AQUÍ Y NO SE IMPORTA DE `@dotrino/identity`, que tiene la misma función
+ * (`verifyDeviceSig` en `/capabilities`): esa ruta arrastra `vault/core.js` entero —tres
+ * mil líneas de bóveda, con el acta, el contenido y el cliente remoto detrás— por un
+ * `crypto.subtle.verify` de tres líneas, y este paquete lo importan ~30 PWAs. La capa de
+ * firma de este cliente ya era deliberadamente sin dependencias (mira `signData` justo
+ * arriba: tampoco usa el pilar); esto es su operación inversa, no un esquema nuevo.
+ *
+ * Que no se separen no se deja a la buena fe: `test/encpub.test.mjs` firma con
+ * `@dotrino/identity` y verifica con esto, y al revés. Si el pilar cambiara de algoritmo
+ * o de canonicalización, esa prueba se pone roja el mismo día.
+ *
+ * Devuelve `false` ante una clave ilegible o una firma corrupta — no lanza. Es la
+ * respuesta correcta a «¿esto lo firmó él?» cuando lo que llega es basura.
+ *
+ * @param {string} publickeyJwkStr  JWK público serializado (lo mismo que viaja en el cable)
+ * @param {any} data
+ * @param {string} signatureB64
+ * @returns {Promise<boolean>}
+ */
+export async function verifyData (publickeyJwkStr, data, signatureB64) {
+  if (typeof publickeyJwkStr !== 'string' || typeof signatureB64 !== 'string') return false
+  try {
+    const jwk = JSON.parse(publickeyJwkStr)
+    const key = await crypto.subtle.importKey(
+      'jwk', jwk,
+      { name: 'ECDSA', namedCurve: 'P-256' },
+      false, ['verify']
+    )
+    const bytes = new TextEncoder().encode(canonicalStringify(data))
+    return crypto.subtle.verify(
+      { name: 'ECDSA', hash: { name: 'SHA-256' } },
+      key,
+      base64ToBuffer(signatureB64),
+      bytes
+    )
+  } catch (e) {
+    return false
+  }
+}
+
 function bufferToBase64 (bytes) {
   let binary = ''
   for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i])
   return btoa(binary)
 }
 
+function base64ToBuffer (b64) {
+  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
+}
+
 /**
  * Build the {data, signature} envelope for a channel name.
  */