@dotrino/identity 0.90.0 → 0.92.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.90.0",
+  "version": "0.92.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

@@ -35,7 +35,7 @@
  * Módulo PURO: sin kv, sin red, sin disco. Cripto de `./capabilities.js`.
  */
 import { canonicalStringify } from './core.js'
-import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
+import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
 
 export const ACTA_V = 5
 
@@ -649,6 +649,52 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
   return mal ? { ok: false, reason: mal } : { ok: true }
 }
 
+/**
+ * ¿ES DE FIAR LO QUE CONTESTA LA BÓVEDA CON LA QUE TE EMPAREJASTE? El papel y el acta que
+ * llegan al enrolarse o al renovar, juzgados contra la llave de ESA bóveda (`vault`: la
+ * `iss` del QR, o la que quedó guardada al enrolarse).
+ *
+ * Antes cada cliente comparaba `acta.profileId` con esa llave. Eso solo es verdad en una
+ * cuenta de una bóveda que además nació en ella: el `profileId` es la llave del GÉNESIS, y
+ * en una cuenta que la bóveda ADOPTÓ, o en la SEGUNDA bóveda de un multivault, la llave de
+ * la bóveda es otra. Ahí ningún aparato podía entrar ni renovar. Y encima no protegía: el
+ * acta no se verificaba, así que bastaba con escribir ese `profileId` en una inventada.
+ *
+ * Lo que se comprueba ahora, y por qué alcanza:
+ *   1. el acta está bien firmada por quien dice haberla sellado;
+ *   2. esa bóveda PUEDE SELLAR esta acta — es de la cuenta, con el permiso, y una llave
+ *      está en una sola cuenta, así que esto también fija la cuenta;
+ *   3. el papel lo firmó ESA bóveda y no otra selladora: la respuesta es suya, porque nadie
+ *      por el camino puede firmar con su llave;
+ *   4. y el papel vale según esa acta (para esta llave, este permiso, un `seq` que no viene
+ *      del futuro).
+ *
+ * `justSealed` es para el ENROLAMIENTO: aprobar es admitir al aparato, así que el acta que
+ * vuelve la acaba de sellar esa misma bóveda. Exigirlo ata el acta a su llave y no solo el
+ * papel — el llavero que el aparato va a usar viaja ahí dentro. Al RENOVAR no se pide: la
+ * última acta pudo sellarla otra selladora de la cuenta.
+ *
+ * @returns {Promise<{ok:true}|{ok:false, reason:string}>}
+ */
+export async function checkVaultReply ({ acta, cert, vault, sub, scope = null, justSealed = false } = {}) {
+  if (!acta) return { ok: false, reason: 'sin-acta' }
+  if (!isPub(vault)) return { ok: false, reason: 'sin-boveda' }
+  // Para QUÉ llave es el papel no es opcional: sin ella `verifyDelegation` no lo mira, y un
+  // papel emitido para otra llave pasaría por bueno.
+  if (!isPub(sub)) return { ok: false, reason: 'sin-llave-del-aparato' }
+  const v = await verifyActa({ acta })
+  if (!v.ok) return { ok: false, reason: 'acta:' + v.reason }
+  if (!canSeal(acta, vault)) return { ok: false, reason: 'boveda-no-sella' }
+  if (justSealed && !samePubkey(acta.sealedBy, vault)) return { ok: false, reason: 'acta-de-otra-selladora' }
+  if (!cert || !samePubkey(cert.iss, vault)) return { ok: false, reason: 'papel-de-otra-llave' }
+  const d = await verifyDelegation({
+    cert, expectedSub: sub, actaSeq: acta.seq, sealers: sealersOf(acta),
+    ...(scope ? { expectedScope: scope } : {})
+  })
+  if (!d.ok) return { ok: false, reason: 'papel:' + d.reason }
+  return { ok: true }
+}
+
 /**
  * Aplica cambios y devuelve el acta SIGUIENTE, **sin firmar** (hay que `sealActa`).
  * `by` es quien va a sellar: si no es el sellador vigente, se rechaza (regla 1).
@@ -1218,7 +1264,7 @@ export async function canAdopt ({ candidate, current }) {
 
 export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain, verifySignedBy,
-  sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
+  sealActa, verifyActa, checkVaultReply, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
   effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt,

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

@@ -13,8 +13,8 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
-import { sealersOf } from './acta.js'
+import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
+import { checkVaultReply } from './acta.js'
 
 const MSG = {
   HELLO: 'vault.hello',
@@ -218,14 +218,12 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // (Aquí vivía el margen de reloj: el cert lo sellaba la bóveda con SU reloj y lo validaba
     // este aparato con el suyo, y 850 ms de diferencia bastaban para no poder enrolarse. Sin
     // vencimiento no hay ventana que ajustar y el problema no puede volver.)
-    if (!res.acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    if (res.acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw')
-    const v = await verifyDelegation({
-      cert: res.cert, expectedSub: dev.publickey,
-      actaSeq: res.acta.seq, sealers: sealersOf(res.acta)
-    })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.sub !== dev.publickey) throw new Error('cert issued for a different device')
+    //
+    // Se juzga contra la llave de LA BÓVEDA con la que hablas, no contra el `profileId`:
+    // eso solo coincidía en una cuenta que nació en esa bóveda, y dejaba fuera a quien se
+    // emparejaba con una segunda bóveda o con una que adoptó la cuenta (`checkVaultReply`).
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: qr.iss, sub: dev.publickey, justSealed: true })
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
     return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
   } finally { try { client.close() } catch (_) {} }
 }
@@ -306,7 +304,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 })
@@ -381,12 +379,17 @@ export async function requestDevices ({ master, proxy, device, cert, sinceSeq, o
  */
 export async function requestRenew ({ master, proxy, device, cert, onRevoked } = {}) {
   const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
-  if (!res.cert || res.cert.sub !== device.publickey) throw new Error('invalid renewed cert')
   // EL ACTA VIAJA CON EL PAPEL y hay que dejarla pasar: quien lo recibe la necesita para
   // comprobar que lo firmó una SELLADORA de este perfil. Aquí se comparaba `cert.iss` con
   // la maestra y se tiraba el acta, así que arriba no había con qué juzgar y la renovación
   // fallaba con «the vault did not send its record» — con el papel correcto en la mano.
-  return { cert: res.cert, acta: res.acta || null }
+  //
+  // Y se juzga AQUÍ, en el pilar: antes lo hacía cada cliente por su cuenta —uno comparando
+  // el `profileId`, que con dos bóvedas no vale, y el navegador guardando el papel sin mirar
+  // nada—. `master` es la bóveda a la que se le pidió.
+  const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: master, sub: device.publickey })
+  if (!chk.ok) throw new Error('invalid renewed cert: ' + chk.reason)
+  return { cert: res.cert, acta: res.acta }
 }
 
 /**

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

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.20.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,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.

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

@@ -13,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
@@ -33,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)
  */
@@ -79,6 +89,23 @@ export class WebSocketProxyClient {
     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
@@ -451,8 +478,14 @@ export class WebSocketProxyClient {
   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: missing peerPubkey — a token does not say whose it is', 'unsealed')
+        throw errorCon(
+          'sendSealedTo: nobody has said whose this token is — greet it (helloTo) or pass peerPubkey',
+          'no-peer-identity')
       }
       peerEncPub = await this.encPubOf(peerPubkey)
     }
@@ -461,6 +494,65 @@ export class WebSocketProxyClient {
     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')
@@ -714,6 +806,10 @@ 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(() => {})
     }
@@ -1130,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,
@@ -1139,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')

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

@@ -3,7 +3,7 @@ export { canonicalStringify } from './canonical.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,

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,
+  }
+}