@dotrino/identity 0.89.1 → 0.91.0

package/package.json

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

package/src/index.d.ts

@@ -165,6 +165,11 @@ export class Identity {
   vaultStatus (): Promise<any>
   vaultUnpair (): Promise<any>
   vaultSign (payload: any): Promise<{ signature: string; publickey: string }>
+  /**
+   * El almacén de hilos EN la bóveda, cifrado de punta a punta con la clave de contenido del
+   * perfil. Sin esa clave lanza `code: 'no-content-key'` en vez de mandarlo en claro (≥ 0.91.0);
+   * sin emparejar, `not-paired`; si la bóveda no contesta, `vault-no-reply`.
+   */
   vaultStore (method: string, args?: any): Promise<any>
   listVaultDevices (): Promise<{ devices: any[]; revoked: any[] }>
   /**

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/core.js

@@ -2575,27 +2575,29 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     /**
      * Store DELEGADO, CIFRADO de punta a punta. Los argumentos y el resultado viajan
      * cifrados con la clave de contenido del perfil: el proxy transporta pero no ve nada
-     * de lo que guardas. Si todavía no tengo la clave (nadie me la ha envuelto), va en
-     * claro como antes — y se dice en el resultado en vez de fallar en silencio.
+     * de lo que guardas.
+     *
+     * Sin la clave NO se manda nada. Antes iba en claro «como antes», y eso era dejar que
+     * el proxio leyera el almacén entero justo en el aparato al que todavía no le habían
+     * envuelto la clave. Ahora falla con `no-content-key`, que se arregla entrando al
+     * perfil desde un aparato que ya la tenga — y se ve, en vez de viajar a la vista.
+     * Por lo mismo, una respuesta sin cifrar tampoco se acepta.
      */
     async vaultStore ({ method, args }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
+      if (!v?.cert || !device) throw Object.assign(new Error('this device is not paired with a vault'), { code: 'not-paired' })
       maybeRenewVaultCert()
-      const mine = await myCek().catch(() => null)
-      let payload = { method, args }
-      if (mine) {
-        payload = { method, enc: await Content.encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: JSON.stringify(args ?? {}) }) }
-      }
+      const mine = await myCek()
+      if (!mine) throw Object.assign(new Error('this device does not hold the profile content key yet'), { code: 'no-content-key' })
+      const enc = await Content.encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: JSON.stringify(args ?? {}) })
       try {
-        const res = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: payload.method, args: payload.args, enc: payload.enc, onRevoked: wipeVaultLink })
-        // La respuesta vuelve cifrada con la misma clave si la bóveda pudo.
-        if (res && typeof res === 'object' && res.__enc && mine) {
-          return JSON.parse(await Content.decryptWithKeyring({
-            envelope: res.__enc, keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
-          }))
+        const res = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, enc, onRevoked: wipeVaultLink })
+        if (!res || typeof res !== 'object' || !res.__enc) {
+          throw Object.assign(new Error('the vault replied to the store without encrypting it'), { code: 'vault-reply-unsealed' })
         }
-        return res
+        return JSON.parse(await Content.decryptWithKeyring({
+          envelope: res.__enc, keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
+        }))
       } catch (e) { return handleVaultError(e) }
     },
 

package/vault/remote.js

@@ -306,7 +306,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
           cleanup(); reject(vaultError(p))
         }
       })
-      const t = setTimeout(() => { cleanup(); reject(new Error('the vault did not reply (is it running?)')) }, timeoutMs)
+      const t = setTimeout(() => { cleanup(); reject(Object.assign(new Error('the vault did not reply (is it running?)'), { code: 'vault-no-reply' })) }, timeoutMs)
       const cleanup = () => { off(); clearTimeout(t); clearTimeout(graceTimer) }
     })
     client.sendByPubkey(master, { type: sendType, data: signed, signature, cert })

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.22.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'
 
 /**
@@ -12,6 +13,15 @@ import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, re
  * @param {string} code
  * @returns {Error & { code: string }}
  */
+/**
+ * EL SALUDO: «este token es de esta identidad».
+ *
+ * Es una trama de CONTROL del transporte, como la señalización de WebRTC, y por eso va
+ * en claro y no la para `requireSealed`: lo único que lleva es una llave PÚBLICA que el
+ * proxio ya tiene atada a esta conexión desde `identify`. Nada del usuario viaja aquí.
+ */
+const HELLO_TAG = '__cc_hello__'
+
 function errorCon (mensaje, code) {
   const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
   e.code = code
@@ -32,6 +42,7 @@ function errorCon (mensaje, code) {
  *   - 'channel_joined'    (channel, token)            : new peer joined the channel
  *   - 'channel_left'      (channel, token)            : peer unpublished
  *   - 'peer_disconnected' (token, channel?)           : peer dropped (with channel if it was published there)
+ *   - 'peer_identity'     (token, publickey)          : that token said whose it is (helloTo)
  *   - 'reconnecting'      (attempt, max)
  *   - 'reconnect_failed'  (attempts)
  */
@@ -58,6 +69,57 @@ 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()
+
+    /**
+     * QUIÉN ESTÁ AL OTRO LADO DE CADA TOKEN (token → publickey), aprendido del saludo.
+     *
+     * Un token es una dirección del proxio y no dice de quién es. Hasta que alguien lo
+     * diga, a ese token no se le puede sellar nada: no se sabe a qué identidad, y por lo
+     * tanto tampoco a qué llave de cifrado. Es el hueco por el que una sala de
+     * desconocidos seguía hablando en claro aunque el sellado ya existiera.
+     *
+     * Se vacía al reconectar: los tokens se reparten por conexión y los de antes ya no
+     * son de nadie.
+     */
+    this._tokenPubkeys = new Map()
+    this._helloSent = new Set()
+
+    /** Mi propia identidad en el cable, la que `identify` dejó atada a este token. */
+    this.myPublickey = null
+
+    /**
+     * 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 +249,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 +274,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 +443,215 @@ 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) {
+      // Si la app no lo dice, lo dice el SALUDO: `helloTo` dejó apuntado de quién es
+      // cada token. Con más de uno no se adivina —cada identidad tiene su llave y un
+      // solo sobre solo lo abriría una—, así que ahí se exige decirlo.
+      if (!peerPubkey && tokens.length === 1) peerPubkey = this.pubkeyOfToken(tokens[0])
+      if (!peerPubkey) {
+        throw errorCon(
+          'sendSealedTo: nobody has said whose this token is — greet it (helloTo) or pass peerPubkey',
+          'no-peer-identity')
+      }
+      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)
+  }
+
+  // ---------- el saludo: de quién es este token ----------
+
+  /**
+   * SALUDAR: decirle a uno o varios tokens quién soy.
+   *
+   * Un token es una dirección del proxio y no dice de quién es, así que sin esto no hay
+   * a quién sellarle: una sala de desconocidos se queda muda o —lo que pasaba— hablando
+   * en claro. El saludo lleva SOLO mi llave pública, la misma que el proxio ya tiene
+   * atada a esta conexión desde `identify`; no hay nada del usuario dentro y por eso no
+   * necesita sobre.
+   *
+   * Quien lo recibe contesta el suyo una vez, así que basta con que salude UNA de las
+   * dos puntas y la app no tiene que coreografiar nada.
+   *
+   * **No autentica, y no hace falta que lo haga.** Mentir sobre la propia identidad solo
+   * consigue que te sellen a una llave que no puedes abrir: el embustero se queda sin
+   * leer, y nadie se queda suplantado. Quién firma de verdad lo dice el reto de la app,
+   * o el `from_publickey` que pone el proxio cuando se enruta por pubkey.
+   */
+  helloTo (to) {
+    if (!this.myPublickey) {
+      throw errorCon('helloTo: identify first — a greeting with no identity says nothing', 'not-identified')
+    }
+    const tokens = Array.isArray(to) ? to : [to]
+    for (const t of tokens) {
+      if (!t || t === this.token) continue
+      this._helloSent.add(t)
+      this._proxySendOne(t, { t: HELLO_TAG, publickey: this.myPublickey })
+    }
+  }
+
+  /** De quién es este token, si alguien lo ha dicho. `null` es «todavía no lo sé». */
+  pubkeyOfToken (token) {
+    return this._tokenPubkeys.get(token) || null
+  }
+
+  /** Olvidar un token (se fue, o se quiere volver a preguntar). Sin argumento, todos. */
+  forgetToken (token) {
+    if (token == null) { this._tokenPubkeys.clear(); this._helloSent.clear(); return }
+    this._tokenPubkeys.delete(token)
+    this._helloSent.delete(token)
+  }
+
+  _onHello (from, msg) {
+    if (typeof msg.publickey !== 'string' || !msg.publickey) return
+    const antes = this._tokenPubkeys.get(from)
+    // UN TOKEN NO CAMBIA DE DUEÑO: la conexión ES la identidad, y el proxio no recicla
+    // tokens. Un segundo saludo con otra identidad es un intento de que le sellemos a
+    // otro; manda el primero y esto se dice en voz alta en vez de pisarlo.
+    if (antes && !samePubkey(antes, msg.publickey)) {
+      this._emit('error', { type: 'hello_conflict', from, code: 'hello-conflict' })
+      return
+    }
+    this._tokenPubkeys.set(from, msg.publickey)
+    // Contestar UNA vez: el saludo queda simétrico sin rebotar para siempre.
+    if (!this._helloSent.has(from) && this.myPublickey) this.helloTo(from)
+    this._emit('peer_identity', from, msg.publickey)
+  }
+
+  /** 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) {
@@ -530,9 +806,28 @@ export class WebSocketProxyClient {
     // escribirle a la PERSONA llega a cualquiera de sus dispositivos. Ver acta-de-perfil.md.
     if (acta) msg.acta = acta
     const done = this._request(msg, 'identified')
+    // Mi identidad en el cable, para poder decirla en el saludo sin que la app la
+    // repita. Se apunta al pedirlo y no al confirmarlo: si la identificación falla,
+    // el saludo tampoco sale (el proxio no reparte a una conexión sin identidad).
+    this.myPublickey = data.publickey
     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 +1200,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
@@ -925,6 +1226,13 @@ export class WebSocketProxyClient {
           this._rtc.handleIncoming(from, parsed)
           break
         }
+        // El saludo se atiende AQUÍ, antes de `_deliver`: es del transporte y no sube a
+        // la app, así que `requireSealed` no lo ve pasar ni tiene que hacerle una
+        // excepción.
+        if (parsed && parsed.t === HELLO_TAG) {
+          this._onHello(from, parsed)
+          break
+        }
         this._deliver(from, parsed ?? message, {
           raw: message, timestamp, via: 'proxy',
           fromPubkey: from_publickey || null,
@@ -934,6 +1242,9 @@ export class WebSocketProxyClient {
         break
       }
       case 'disconnected':
+        // El token muere con la conexión y no se recicla: lo aprendido de él deja de
+        // valer en el acto. Guardarlo «por si vuelve» sería sellarle a quien ya no está.
+        this.forgetToken(data.token)
         this._emit('peer_disconnected', data.token, data.channel || null)
         if (this._rtc && data.token) this._rtc.closePeer(data.token)
         this._resolvePending(data, 'token')
@@ -963,6 +1274,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,
+  setSealingPrimitives, identitySealing,
 } 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/sealing.js

@@ -16,6 +16,14 @@
  */
 
 const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+
+/** Un error con `code`: quien llama decide por el código, nunca por la frase. */
+function errorCon (mensaje, code) {
+  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
+  e.code = code
+  return e
+}
+
 const VERSION = 1
 
 let primitives = null
@@ -75,3 +83,74 @@ export async function open (envelope, myEncPrivateKey) {
 export function isSealed (msg) {
   return !!msg && msg.v === VERSION && !!msg.sealed?.ct && !!msg.sealed?.epk
 }
+
+/**
+ * EL PUENTE DE LA BÓVEDA: sellar y abrir cuando la llave privada NO está aquí.
+ *
+ * En un aparato headless la privada de cifrado es suya y basta con `myEncPrivateKey`. En
+ * el navegador no: la privada vive dentro del iframe de la bóveda y no sale nunca, así
+ * que sellar y abrir se le delegan a `@dotrino/identity` (`encrypt` / `decrypt`), que es
+ * la MISMA cripto —ECDH P-256 efímero + AES-GCM— y no cripto nueva.
+ *
+ * Estaba escrito en el gestor de contraseñas, que fue la primera app que selló de verdad,
+ * y sube aquí porque son las dos puntas del MISMO sobre: si una cambia de forma, la otra
+ * deja de abrirlo, y ese fallo no hace ruido —la petición sale, al otro lado «no es para
+ * mí», y desde fuera se ve como que nadie contestó—. Con una sola pieza no hay dos formas.
+ *
+ * Dos DIALECTOS de identidad, porque no son el mismo objeto y los dos son correctos:
+ *   · la clase `Identity` (la que habla con el iframe): `getEncryptionPubkey()` y
+ *     `decrypt(remitente, miToken, sobre)` que devuelve `{ plaintext }`
+ *   · el núcleo que corre dentro de un service worker: `encryptionPubkey()` y
+ *     `decrypt(remitente, sobre)` que devuelve la cadena
+ *
+ * `app` es la MARCA del sobre: quien recibe lo que no es suyo lo descarta por aquí. Es
+ * estable por app y no se cambia a la ligera — cambiarla es dejar de abrir lo de la
+ * versión anterior.
+ *
+ * @param {any} identity cualquiera de los dos dialectos
+ * @param {{ app?: string }} [opts]
+ * @returns {{ seal:Function, open:Function, isSealed:Function }}
+ */
+export function identitySealing (identity, { app = 'dotrino' } = {}) {
+  // El dialecto se decide UNA vez, por lo que el objeto expone, y no por el resultado de
+  // cada llamada: así, si llega un tercero que no es ninguno de los dos, revienta aquí y
+  // con nombre, en vez de devolver sobres que nadie abre.
+  const iframe = typeof identity?.getEncryptionPubkey === 'function'
+  if (!iframe && typeof identity?.encryptionPubkey !== 'function') {
+    throw new Error('identitySealing: this identity exposes neither getEncryptionPubkey() nor encryptionPubkey()')
+  }
+  if (typeof identity?.encrypt !== 'function' || typeof identity?.decrypt !== 'function') {
+    throw new Error('identitySealing: this identity does not expose encrypt()/decrypt()')
+  }
+
+  const myEncPub = () => (iframe ? identity.getEncryptionPubkey() : identity.encryptionPubkey())
+  const openEnvelope = async (from, envelope) => {
+    const r = iframe
+      ? await identity.decrypt(from, null, envelope)
+      : await identity.decrypt(from, envelope)
+    // Un dialecto devuelve `{ plaintext }` y el otro la cadena. Nada más se admite: un
+    // `?? ''` aquí sería un sobre vacío haciéndose pasar por un mensaje.
+    if (typeof r === 'string') return r
+    if (typeof r?.plaintext === 'string') return r.plaintext
+    throw new Error('identitySealing: decrypt returned neither a string nor { plaintext }')
+  }
+
+  return {
+    async seal (msg, peerEncPub) {
+      if (!peerEncPub) throw errorCon('no encryption key for the other side', 'unsealed')
+      // Destinatarios como OBJETOS: `encrypt` expande cada uno a todos los aparatos de
+      // esa persona, y una llave suelta se le cae sin envolver nada.
+      const sealed = await identity.encrypt([{ encryptionPubkey: peerEncPub }], JSON.stringify(msg))
+      // Y SE COMPRUEBA QUE ENVOLVIÓ A ALGUIEN. `encrypt` se salta en silencio al
+      // destinatario cuya llave no puede importar, y devuelve un sobre con el llavero
+      // VACÍO: cifrado de verdad, y que no abre nadie. Eso no es un sobre, es un mensaje
+      // perdido con cara de enviado.
+      if (!sealed || !sealed.wrap || Object.keys(sealed.wrap).length === 0) {
+        throw errorCon('identitySealing: the vault wrapped the message for nobody', 'unsealed')
+      }
+      return { app, sealed, from: await myEncPub() }
+    },
+    async open (env) { return JSON.parse(await openEnvelope(env.from, env.sealed)) },
+    isSealed: (m) => !!m && m.app === app && !!m.sealed,
+  }
+}

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.
  */