@dotrino/identity 0.90.0 → 0.91.0

package/package.json

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