@dotrino/identity 0.117.0 → 0.117.1

package/package.json

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

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

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

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

@@ -0,0 +1,140 @@
+/**
+ * BYTES QUE VIAJAN COMO BYTES (0.35.0).
+ *
+ * Hasta aquí un archivo viajaba dos veces en base64: la app lo metía en base64 en el JSON
+ * del mensaje (×1,33), el sellado cifraba ese JSON y lo volvía a pasar a base64 (×1,33), y
+ * el resultado iba como texto. Medido: 1,78 veces el tamaño del archivo en el cable.
+ *
+ * Ahora una app puede poner `Uint8Array` dentro de lo que manda, y el pilar lo lleva tal
+ * cual: lo empaqueta (`pack`), lo cifra como bytes y lo manda en una trama BINARIA, al
+ * proxio y al canal directo. Lo que no lleva bytes sale exactamente como antes, en texto:
+ * así las piezas que no saben de esto (las apps nativas, las versiones anteriores) siguen
+ * hablando con todos para lo de siempre.
+ *
+ * Dos formatos, y los dos son de este archivo para que no haya una segunda copia:
+ *
+ *   · EL PAQUETE (`pack`/`unpack`): un objeto con bytes dentro.
+ *       [0xB1][u32 largo del JSON][JSON][bytes, uno detrás de otro]
+ *     Cada `Uint8Array` del objeto queda en el JSON como `{"__dotrino_bin":[desde,largo]}`.
+ *
+ *   · LA TRAMA (`encodeFrame`/`decodeFrame`): lo que va por el WebSocket del proxio.
+ *       [0x01][u32 largo de la cabecera][cabecera JSON][cuerpo]
+ *     La cabecera es la trama de texto de siempre sin `message`; el cuerpo es el `message`.
+ *     El proxio lee la cabecera para enrutar y no mira el cuerpo, que va sellado.
+ */
+
+export const BIN_TAG = '__dotrino_bin'
+const PACK_MAGIC = 0xB1
+const FRAME_VERSION = 0x01
+
+const enc = new TextEncoder()
+const dec = new TextDecoder()
+
+function withCode (message, code) {
+  return Object.assign(new Error(message), { code })
+}
+
+/** Bytes, sin importar de qué vista vengan (`Buffer`, `ArrayBuffer`, `Uint8Array`). */
+export function asBytes (v) {
+  if (v instanceof Uint8Array) return v
+  if (v instanceof ArrayBuffer) return new Uint8Array(v)
+  if (ArrayBuffer.isView(v)) return new Uint8Array(v.buffer, v.byteOffset, v.byteLength)
+  return null
+}
+
+/** ¿Lleva bytes este valor, a cualquier profundidad? Es lo que decide texto o binario. */
+export function hasBinary (v) {
+  if (v instanceof Uint8Array || v instanceof ArrayBuffer) return true
+  if (Array.isArray(v)) return v.some(hasBinary)
+  if (v && typeof v === 'object') {
+    for (const k in v) if (hasBinary(v[k])) return true
+  }
+  return false
+}
+
+/** Un objeto con bytes dentro → un solo `Uint8Array`. */
+export function pack (obj) {
+  const blobs = []
+  let off = 0
+  const json = JSON.stringify(obj, function (k, v) {
+    // `this[k]` es el valor antes de `toJSON`: un Buffer de Node se convertiría en
+    // `{ type: 'Buffer', data: [...] }` y aquí lo queremos como bytes.
+    const b = asBytes(this[k])
+    if (!b) return v
+    blobs.push(b)
+    const ref = { [BIN_TAG]: [off, b.byteLength] }
+    off += b.byteLength
+    return ref
+  })
+  const head = enc.encode(json)
+  const out = new Uint8Array(5 + head.length + off)
+  out[0] = PACK_MAGIC
+  new DataView(out.buffer).setUint32(1, head.length)
+  out.set(head, 5)
+  let p = 5 + head.length
+  for (const b of blobs) { out.set(b, p); p += b.byteLength }
+  return out
+}
+
+export const isPacked = (b) => b instanceof Uint8Array && b.length >= 5 && b[0] === PACK_MAGIC
+
+/**
+ * Un paquete → el objeto, con sus bytes como `Uint8Array` (vistas sobre `bytes`, sin copiar).
+ * Lanza con `code: 'bad-pack'` si no es un paquete o una referencia se sale de él.
+ */
+export function unpack (bytes) {
+  const b = asBytes(bytes)
+  if (!isPacked(b)) throw withCode('not a packed message', 'bad-pack')
+  const len = new DataView(b.buffer, b.byteOffset, b.byteLength).getUint32(1)
+  if (5 + len > b.length) throw withCode('packed message is shorter than its header says', 'bad-pack')
+  const area = b.subarray(5 + len)
+  let obj
+  try { obj = JSON.parse(dec.decode(b.subarray(5, 5 + len))) } catch (_) { throw withCode('packed message header is not JSON', 'bad-pack') }
+  const revive = (v) => {
+    if (Array.isArray(v)) return v.map(revive)
+    if (!v || typeof v !== 'object') return v
+    const ref = v[BIN_TAG]
+    if (ref !== undefined) {
+      if (!Array.isArray(ref) || ref.length !== 2 || !Number.isInteger(ref[0]) || !Number.isInteger(ref[1]) ||
+          ref[0] < 0 || ref[1] < 0 || ref[0] + ref[1] > area.length) {
+        throw withCode('packed message points outside itself', 'bad-pack')
+      }
+      return area.subarray(ref[0], ref[0] + ref[1])
+    }
+    const out = {}
+    for (const k of Object.keys(v)) out[k] = revive(v[k])
+    return out
+  }
+  return revive(obj)
+}
+
+/** Une varios trozos de bytes en uno. */
+export function concatBytes (list) {
+  const out = new Uint8Array(list.reduce((a, b) => a + b.byteLength, 0))
+  let p = 0
+  for (const b of list) { out.set(b, p); p += b.byteLength }
+  return out
+}
+
+/** La trama binaria del proxio: la cabecera de texto de siempre, y el `message` en crudo. */
+export function encodeFrame (header, body) {
+  const head = enc.encode(JSON.stringify(header))
+  const out = new Uint8Array(5 + head.length + body.byteLength)
+  out[0] = FRAME_VERSION
+  new DataView(out.buffer).setUint32(1, head.length)
+  out.set(head, 5)
+  out.set(body, 5 + head.length)
+  return out
+}
+
+/** El inverso: `{ header, body }`. Lanza con `code: 'bad-frame'` si no es una trama válida. */
+export function decodeFrame (data) {
+  const b = asBytes(data)
+  if (!b || b.length < 5 || b[0] !== FRAME_VERSION) throw withCode('not a binary frame of a known version', 'bad-frame')
+  const len = new DataView(b.buffer, b.byteOffset, b.byteLength).getUint32(1)
+  if (5 + len > b.length) throw withCode('binary frame is shorter than its header says', 'bad-frame')
+  let header
+  try { header = JSON.parse(dec.decode(b.subarray(5, 5 + len))) } catch (_) { throw withCode('binary frame header is not JSON', 'bad-frame') }
+  if (!header || typeof header !== 'object' || Array.isArray(header)) throw withCode('binary frame header is not an object', 'bad-frame')
+  return { header, body: b.subarray(5 + len) }
+}

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

@@ -1,9 +1,10 @@
 import { buildSignedChannel, getPublicKeyJwk, signData, samePubkey } from './signature.js'
-import { seal, open, isSealed } from './sealing.js'
+import { seal, open, isSealed, isBinSealed, BIN_SEALED, makeMessageKey, encryptBytes, decryptBytes } from './sealing.js'
 import { buildEncPubStatement, readEncPubStatement, isEncPub } from './encpub.js'
 import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection, pinTurnToIPv4 } from './webrtc.js'
 import { TrafficStats, utf8Length, registerTransport, unregisterTransport } from './stats.js'
-import { splitParts, isPart, Reassembler, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS } from './parts.js'
+import { splitParts, splitBinParts, isPart, Reassembler, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS, DIRECT_PART_BYTES, PROXY_PART_BYTES, QUEUE_MAX_BYTES, RELAY_MAX_BYTES } from './parts.js'
+import { pack, unpack, hasBinary, encodeFrame, decodeFrame } from './binpack.js'
 
 /**
  * Error con un `code` estable.
@@ -193,6 +194,9 @@ export class WebSocketProxyClient {
     this._parts = new Reassembler({
       onExpire: (info) => this._emit('error', { type: 'parts_incomplete', code: 'parts-incomplete', ...info })
     })
+    // Las CEK de los mensajes con bytes ya abiertas, por su sobre: todas las partes de un
+    // mensaje traen la misma, y abrirla es una vuelta a la bóveda. Pocas: un mensaje vivo.
+    this._msgKeys = new Map()
     this._traffic = new TrafficStats()
 
     this._rtc = this.enableWebRTC ? new WebRTCManager({
@@ -341,7 +345,7 @@ export class WebSocketProxyClient {
         'unsealed')
     }
     const tokens = Array.isArray(to) ? to : [to]
-    const messageStr = typeof payload === 'string' ? payload : JSON.stringify(payload)
+    const messageStr = this._wire(payload)
     if (!this._rtc) {
       this._sendRaw({ to: tokens, message: messageStr })
       return
@@ -508,18 +512,22 @@ export class WebSocketProxyClient {
   async sendSealed (toPubkeys, payload, { peerEncPub, ...opts } = {}) {
     const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
     // Por pubkey el mensaje puede quedarse ESPERANDO en el proxio, y ahí se deja como mucho
-    // 1 MB (parts.js). Lo que pasa de eso no se manda: se dice, y la app decide.
-    const json = JSON.stringify(payload)
-    if (json.length > QUEUE_MAX_CHARS) {
-      throw errorCon(`sendSealed: ${json.length} chars is more than can wait in the proxy (${QUEUE_MAX_CHARS}); send it by token while both ends are connected`, 'too-big-for-queue')
+    // 8 MB de archivo (parts.js). Lo que pasa de eso no se manda: se dice, y la app decide.
+    const m = this._measure(payload)
+    const queueMax = m.bin ? QUEUE_MAX_BYTES : QUEUE_MAX_CHARS
+    if (m.len > queueMax) {
+      throw errorCon(`sendSealed: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than can wait in the proxy (${queueMax}); send it by token while both ends are connected`, 'too-big-for-queue')
     }
-    const pieces = json.length > PROXY_PART_CHARS ? splitParts(json, PROXY_PART_CHARS) : [payload]
+    // Por pubkey todo va por el proxio: si no admite bytes, se dice antes de mandar nada.
+    if (m.bin) this._needBinaryProxy()
+    const partSize = m.bin ? PROXY_PART_BYTES : PROXY_PART_CHARS
+    const pieces = m.len <= partSize ? [m.bin ? m.whole : payload]
+      : m.bin ? splitBinParts(m.whole, partSize) : splitParts(m.whole, partSize)
     // 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) {
-      for (const piece of pieces) {
-        this._sendByPubkeyRaw(list, await this._seal(piece, peerEncPub, list.length === 1 ? list[0] : undefined), opts)
-      }
+      const sealPiece = await this._sealerFor(m.bin, peerEncPub, list.length === 1 ? list[0] : undefined)
+      for (const piece of pieces) this._sendByPubkeyRaw(list, await sealPiece(piece), opts)
       return
     }
     // Sin ella, se averigua. UNA ENVOLTURA POR DESTINATARIO: cada uno tiene su llave, así
@@ -530,7 +538,8 @@ export class WebSocketProxyClient {
     // 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) {
-      for (const piece of pieces) this._sendByPubkeyRaw([pk], await this._seal(piece, encPub, pk), opts)
+      const sealPiece = await this._sealerFor(m.bin, encPub, pk)
+      for (const piece of pieces) this._sendByPubkeyRaw([pk], await sealPiece(piece), opts)
     }
   }
 
@@ -565,11 +574,15 @@ export class WebSocketProxyClient {
     // Por token los dos están conectados y NO HAY TOPE (parts.js): lo que no cabe en un
     // mensaje del camino que toca sale en partes. El tamaño de parte lo decide el camino
     // de ahora: el canal directo admite mucho menos por mensaje que el proxio.
-    const json = JSON.stringify(payload)
+    const m = this._measure(payload)
     const direct = tokens.length === 1 && !!this._rtc?.isOpen(tokens[0])
-    const size = direct ? DIRECT_PART_CHARS : PROXY_PART_CHARS
-    if (json.length <= size) {
-      const sobre = await this._seal(payload, peerEncPub, peerPubkey)
+    const size = m.bin ? (direct ? DIRECT_PART_BYTES : PROXY_PART_BYTES) : (direct ? DIRECT_PART_CHARS : PROXY_PART_CHARS)
+    const relayMax = m.bin ? RELAY_MAX_BYTES : RELAY_MAX_CHARS
+    const queueMax = m.bin ? QUEUE_MAX_BYTES : QUEUE_MAX_CHARS
+    if (m.bin && !direct) this._needBinaryProxy()
+    const sealPiece = await this._sealerFor(m.bin, peerEncPub, peerPubkey)
+    if (m.len <= size) {
+      const sobre = await sealPiece(m.bin ? m.whole : payload)
       if (tokens.length === 1 && peerPubkey) { this._sendToTokenOrQueue(tokens[0], sobre, peerPubkey); return }
       // Por `send`, no por `_sendRaw`: así sigue prefiriendo el canal directo si lo hay.
       this.send(tokens, sobre)
@@ -577,18 +590,18 @@ export class WebSocketProxyClient {
     }
     // Por el proxio en vivo hay tope (parts.js): lo que pasa de él solo sale por canal
     // directo. Se pide el canal para que el siguiente intento lo encuentre abierto.
-    if (!direct && json.length > RELAY_MAX_CHARS) {
+    if (!direct && m.len > relayMax) {
       this._upgradeDirect(tokens)
-      throw errorCon(`sendSealedTo: ${json.length} chars is more than goes through the proxy live (${RELAY_MAX_CHARS}); it needs a direct channel`, 'too-big-for-relay')
+      throw errorCon(`sendSealedTo: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than goes through the proxy live (${relayMax}); it needs a direct channel`, 'too-big-for-relay')
     }
     // Si el token muere a mitad, lo que quede se iría a la cola por pubkey; solo se permite
     // si el mensaje entero cabe ahí. Si no, se dice (`too-big-for-queue`), no se deja.
-    const queueFallback = json.length <= QUEUE_MAX_CHARS
+    const queueFallback = m.len <= queueMax
     // Y si el canal directo se cae a mitad, el resto va por el proxio en vivo solo si el
     // mensaje entero cabe por ahí; si no, se para y se dice (`direct-lost`).
-    const relayFallback = json.length <= RELAY_MAX_CHARS
-    for (const piece of splitParts(json, size)) {
-      const sobre = await this._seal(piece, peerEncPub, peerPubkey)
+    const relayFallback = m.len <= relayMax
+    for (const piece of (m.bin ? splitBinParts(m.whole, size) : splitParts(m.whole, size))) {
+      const sobre = await sealPiece(piece)
       if (tokens.length === 1 && peerPubkey) await this._sendPiece(tokens[0], sobre, peerPubkey, queueFallback, relayFallback)
       else this.send(tokens, sobre)
     }
@@ -620,10 +633,11 @@ export class WebSocketProxyClient {
    * una pausa corta entre partes, para no chocar con su límite de mensajes por segundo.
    */
   async _sendPiece (token, sobre, peerPubkey, queueFallback, relayFallback = true) {
-    if (this._rtc && await this._rtc.sendDirect(token, JSON.stringify(sobre))) return
+    if (this._rtc && await this._rtc.sendDirect(token, this._wire(sobre))) return
     if (!relayFallback) {
       throw errorCon('the direct channel closed in the middle of a message too big for the proxy', 'direct-lost')
     }
+    if (sobre instanceof Uint8Array) this._needBinaryProxy()
     this._sendToTokenOrQueue(token, sobre, peerPubkey, { queueFallback, skipDirect: true })
     await new Promise((r) => setTimeout(r, 20))
   }
@@ -664,7 +678,7 @@ export class WebSocketProxyClient {
     if (this.requireSealed && !this._isSealed(sobre)) {
       throw errorCon('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
     }
-    const messageStr = JSON.stringify(sobre)
+    const messageStr = this._wire(sobre)
     if (!skipDirect && this._rtc && this._rtc.trySend(token, messageStr)) return
     const id = `msg_${this._nextId++}`
     const timer = setTimeout(() => this._tokenWatch.delete(id), 15000)
@@ -763,6 +777,62 @@ export class WebSocketProxyClient {
       : seal(payload, peerEncPub)
   }
 
+  /**
+   * Quién sella las piezas de UN mensaje hacia UN destinatario. Con bytes (sealing.js): una
+   * CEK para el mensaje entero, sellada una vez con el sellado de siempre, y cada pieza
+   * cifrada como bytes con ella. Sin bytes, el sobre de texto de siempre por pieza.
+   */
+  async _sealerFor (bin, peerEncPub, peerPubkey) {
+    if (!bin) return (piece) => this._seal(piece, peerEncPub, peerPubkey)
+    const cek = await makeMessageKey()
+    const k = await this._seal({ cek }, peerEncPub, peerPubkey)
+    return async (bytes) => {
+      const { iv, ct } = await encryptBytes(cek, bytes)
+      return pack({ bv: BIN_SEALED, k, iv, ct })
+    }
+  }
+
+  /** Lo que mide un mensaje para sus topes: su paquete si lleva bytes, su JSON si no. */
+  _measure (payload) {
+    if (hasBinary(payload)) {
+      const whole = pack(payload)
+      return { bin: true, whole, len: whole.byteLength }
+    }
+    const whole = JSON.stringify(payload)
+    return { bin: false, whole, len: whole.length }
+  }
+
+  /** Cómo va por el cable: los bytes tal cual, el texto tal cual, y un objeto en JSON (o empaquetado, si lleva bytes). */
+  _wire (payload) {
+    if (typeof payload === 'string' || payload instanceof Uint8Array) return payload
+    if (hasBinary(payload)) return pack(payload)
+    return JSON.stringify(payload)
+  }
+
+  /** Un mensaje con bytes por el proxio necesita uno que admita tramas binarias (websocket-proxy ≥ 1.6.0). */
+  _needBinaryProxy () {
+    if (!Array.isArray(this.caps) || !this.caps.includes('binary')) {
+      throw errorCon('this proxy does not take binary frames (it needs websocket-proxy >= 1.6.0)', 'no-binary-support')
+    }
+  }
+
+  /** La CEK de un mensaje con bytes, abriendo su sobre una vez por mensaje. */
+  _openMessageKey (k, meta) {
+    const id = JSON.stringify(k)
+    let p = this._msgKeys.get(id)
+    if (!p) {
+      p = (async () => {
+        const o = this.sealing ? await this.sealing.open(k, meta) : await open(k, this.myEncPrivateKey)
+        if (!o || typeof o.cek !== 'string') throw errorCon('the sealed key of a message has no key inside', 'bad-pack')
+        return o.cek
+      })()
+      this._msgKeys.set(id, p)
+      if (this._msgKeys.size > 64) this._msgKeys.delete(this._msgKeys.keys().next().value)
+      p.catch(() => this._msgKeys.delete(id))
+    }
+    return p
+  }
+
   // ---------- llaves de cifrado ajenas ----------
 
   /**
@@ -859,6 +929,11 @@ export class WebSocketProxyClient {
   }
 
   _isSealed (msg) {
+    if (msg instanceof Uint8Array) {
+      let env
+      try { env = unpack(msg) } catch (_) { return false }
+      return isBinSealed(env) && this._isSealed(env.k)
+    }
     return this.sealing ? this.sealing.isSealed(msg) : isSealed(msg)
   }
 
@@ -881,6 +956,33 @@ export class WebSocketProxyClient {
    * into the app.
    */
   async _deliver (from, payload, meta) {
+    // BYTES (binpack.js): un paquete. Si es un sobre binario se abre aquí; si no, es un
+    // objeto con bytes sin sellar, y decide `requireSealed` igual que con el texto.
+    if (payload instanceof Uint8Array) {
+      let env
+      try { env = unpack(payload) } catch (e) {
+        this._emit('error', { type: 'bad_pack', from, code: e.code || 'bad-pack', error: e })
+        return
+      }
+      if (isBinSealed(env)) {
+        if (!this.sealing && !this.myEncPrivateKey) {
+          this._emit('error', { type: 'unsealed', reason: 'no_encryption_key', from })
+          return
+        }
+        let opened
+        try {
+          if (!this._isSealed(env.k)) throw errorCon('the key of a sealed message is not sealed', 'bad-pack')
+          opened = unpack(await decryptBytes(await this._openMessageKey(env.k, meta), env))
+        } catch (e) {
+          this._emit('error', { type: 'undecipherable', from, error: e })
+          return
+        }
+        const senderEncPub = this.sealing?.senderOf?.(env.k) || null
+        this._handOpened(from, opened, { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) })
+        return
+      }
+      payload = env
+    }
     if (this._isSealed(payload)) {
       if (!this.sealing && !this.myEncPrivateKey) {
         this._emit('error', { type: 'unsealed', reason: 'no_encryption_key', from })
@@ -893,16 +995,7 @@ export class WebSocketProxyClient {
         // Quién selló (la llave de cifrado), si el sobre lo dice: es lo que autentica al
         // remitente, porque solo quien tiene esa privada pudo armarlo.
         const senderEncPub = this.sealing?.senderOf?.(payload) || null
-        const fullMeta = { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) }
-        if (isPart(opened)) {
-          // Se agrupa por quien selló: solo esa llave pudo armar cada parte.
-          let whole
-          try { whole = this._parts.add(senderEncPub || meta.fromPubkey || from || '', opened) }
-          catch (e) { this._emit('error', { type: 'bad_part', from, code: e.code || 'bad-part', error: e }); return }
-          if (whole !== null) this._emit('message', from, whole, { ...fullMeta, parts: opened.__dotrino_part.n })
-          return
-        }
-        this._emit('message', from, opened, fullMeta)
+        this._handOpened(from, opened, { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) })
       } catch (e) {
         // Sealed to somebody else, or tampered with. Staying quiet is the point.
         this._emit('error', { type: 'undecipherable', from, error: e })
@@ -917,11 +1010,24 @@ export class WebSocketProxyClient {
     this._emit('message', from, payload, { ...meta, sealed: false })
   }
 
+  /** Lo ya abierto a la app: entero, o a rearmar si es una parte (parts.js). */
+  _handOpened (from, opened, fullMeta) {
+    if (isPart(opened)) {
+      // Se agrupa por quien selló: solo esa llave pudo armar cada parte.
+      let whole
+      try { whole = this._parts.add(fullMeta.senderEncPub || fullMeta.fromPubkey || from || '', opened) }
+      catch (e) { this._emit('error', { type: 'bad_part', from, code: e.code || 'bad-part', error: e }); return }
+      if (whole !== null) this._emit('message', from, whole, { ...fullMeta, parts: opened.__dotrino_part.n })
+      return
+    }
+    this._emit('message', from, opened, fullMeta)
+  }
+
   _sendByPubkeyRaw (toPubkeys, payload, opts = {}) {
     const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
     const msg = {
       to_publickey: list,
-      message: typeof payload === 'string' ? payload : JSON.stringify(payload)
+      message: this._wire(payload)
     }
     if (opts.ephemeral) msg.ephemeral = true
     if (opts.quiet) msg.quiet = true
@@ -1347,6 +1453,9 @@ export class WebSocketProxyClient {
       try { prev.close() } catch (_) {}
     }
     const ws = new WebSocket(this.url)
+    // Las tramas binarias (binpack.js) llegan como ArrayBuffer: un Blob obligaría a leerlas
+    // de forma asíncrona y desordenaría lo que llega detrás.
+    try { ws.binaryType = 'arraybuffer' } catch (_) {}
     this.ws = ws
     const openTimer = this.connectTimeout > 0 ? setTimeout(() => this._onConnectTimeout(ws), this.connectTimeout) : null
     openTimer?.unref?.()
@@ -1484,9 +1593,20 @@ export class WebSocketProxyClient {
 
   _handleFrame (raw) {
     let data
-    try { data = JSON.parse(raw) } catch (e) {
-      this._emit('error', { type: 'parse_error', error: e })
-      return
+    if (typeof raw === 'string') {
+      try { data = JSON.parse(raw) } catch (e) {
+        this._emit('error', { type: 'parse_error', error: e })
+        return
+      }
+    } else {
+      // Trama binaria: la cabecera de siempre y el `message` en crudo.
+      try {
+        const { header, body } = decodeFrame(raw)
+        data = { ...header, message: body }
+      } catch (e) {
+        this._emit('error', { type: 'parse_error', code: e.code || 'bad-frame', error: e })
+        return
+      }
     }
     const { type } = data
     switch (type) {
@@ -1619,6 +1739,14 @@ export class WebSocketProxyClient {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       throw errorCon('WebSocket not connected', 'NOT_CONNECTED')
     }
+    if (frame.message instanceof Uint8Array) {
+      this._needBinaryProxy()
+      const { message, ...header } = frame
+      const bytes = encodeFrame(header, message)
+      this.ws.send(bytes)
+      this._countOut(frame, bytes)
+      return
+    }
     const texto = JSON.stringify(frame)
     this.ws.send(texto)
     this._countOut(frame, texto)
@@ -1627,7 +1755,7 @@ export class WebSocketProxyClient {
   /** Cuenta un frame que sale por el proxio, y a quién iba. */
   _countOut (frame, texto) {
     this._traffic.frame('out', utf8Length(texto))
-    if (typeof frame.message !== 'string') return
+    if (typeof frame.message !== 'string' && !(frame.message instanceof Uint8Array)) return
     const bytes = utf8Length(frame.message)
     for (const token of Array.isArray(frame.to) ? frame.to : []) {
       this._traffic.peer('out', 'proxy', { token, pubkey: this._tokenPubkeys.get(token) || null }, bytes)

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

@@ -11,7 +11,8 @@ export {
 } from './encpub.js'
 
 export { listTransports, routeOf } from './stats.js'
-export { PART_TAG, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS } from './parts.js'
+export { PART_TAG, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS, DIRECT_PART_BYTES, PROXY_PART_BYTES, QUEUE_MAX_BYTES, RELAY_MAX_BYTES } from './parts.js'
+export { pack, unpack, hasBinary, encodeFrame, decodeFrame } from './binpack.js'
 export { logStats, formatStats, netReport, splitPeers } from './stats-log.js'
 
 import { WebSocketProxyClient } from './client.js'

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

@@ -22,6 +22,8 @@
  * llave que selló: nadie más puede colar una parte en el mensaje de otro.
  */
 
+import { pack, unpack, concatBytes } from './binpack.js'
+
 export const PART_TAG = '__dotrino_part'
 
 /** Parte por el canal directo: por debajo de los 64 KiB que acepta libwebrtc, ya sellada. */
@@ -36,6 +38,21 @@ export const QUEUE_MAX_CHARS = 11 * 1024 * 1024
 /** Lo más que pasa por el proxio EN VIVO: 25 MB de archivo son ~33,4 MB en base64. */
 export const RELAY_MAX_CHARS = 34 * 1024 * 1024
 
+/**
+ * LOS MISMOS TOPES PARA UN MENSAJE CON BYTES (0.35.0), medidos sobre su paquete (binpack.js),
+ * que ocupa lo que el archivo más unos pocos bytes: 8 MB y 25 MB de archivo, con 64 KB de
+ * margen para el texto que va alrededor (nombre, tipo, pie de foto).
+ */
+export const QUEUE_MAX_BYTES = 8 * 1024 * 1024 + 64 * 1024
+export const RELAY_MAX_BYTES = 25 * 1024 * 1024 + 64 * 1024
+/**
+ * Parte binaria por el canal directo: bajo los 64 KiB de libwebrtc, con sitio para el sobre
+ * de la llave, que la bóveda envuelve para cada aparato del destinatario.
+ */
+export const DIRECT_PART_BYTES = 48 * 1024
+/** Parte binaria por el proxio: cabe en su trama de 1 MB con la cabecera y el sobre. */
+export const PROXY_PART_BYTES = 768 * 1024
+
 /** Rearmado: lo que se acepta guardar a medias, y cuánto se espera a la parte siguiente. */
 const RECV_MAX_CHARS = 512 * 1024 * 1024
 const RECV_IDLE_MS = 5 * 60 * 1000
@@ -57,6 +74,18 @@ export function splitParts (json, size) {
   return out
 }
 
+/**
+ * Las partes de un paquete de `bytes.length` > `size`, cada una ya empaquetada (lista para
+ * cifrar como bytes). El rearmado une los trozos y desempaqueta el resultado.
+ */
+export function splitBinParts (bytes, size) {
+  const n = Math.ceil(bytes.byteLength / size)
+  const id = partId()
+  const out = []
+  for (let i = 0; i < n; i++) out.push(pack({ [PART_TAG]: { id, i, n }, d: bytes.subarray(i * size, (i + 1) * size) }))
+  return out
+}
+
 export const isPart = (o) => !!(o && typeof o === 'object' && o[PART_TAG])
 
 /**
@@ -77,25 +106,26 @@ export class Reassembler {
     const d = part.d
     if (!p || typeof p.id !== 'string' || p.id.length > 64 ||
         !Number.isInteger(p.n) || !Number.isInteger(p.i) || p.n < 2 || p.n > MAX_PARTS ||
-        p.i < 0 || p.i >= p.n || typeof d !== 'string') {
+        p.i < 0 || p.i >= p.n || (typeof d !== 'string' && !(d instanceof Uint8Array))) {
       throw Object.assign(new Error('malformed message part'), { code: 'bad-part' })
     }
     const key = `${sender}|${p.id}`
     let a = this._open.get(key)
     if (!a) {
-      a = { n: p.n, got: new Array(p.n), count: 0, chars: 0, timer: null }
+      a = { n: p.n, bin: d instanceof Uint8Array, got: new Array(p.n), count: 0, chars: 0, timer: null }
       this._open.set(key, a)
     }
-    if (a.n !== p.n) {
+    if (a.n !== p.n || a.bin !== (d instanceof Uint8Array)) {
       this._drop(key)
-      throw Object.assign(new Error('message parts disagree on their count'), { code: 'bad-part' })
+      throw Object.assign(new Error('message parts disagree on their count or kind'), { code: 'bad-part' })
     }
     if (a.got[p.i] === undefined) {
       if (this._chars + d.length > RECV_MAX_CHARS) {
         this._drop(key)
         throw Object.assign(new Error('too much of a message in parts is pending'), { code: 'parts-too-big' })
       }
-      a.got[p.i] = d
+      // Una copia: `d` es una vista sobre la trama entera, y guardarla retendría la trama.
+      a.got[p.i] = a.bin ? d.slice() : d
       a.count++
       a.chars += d.length
       this._chars += d.length
@@ -103,8 +133,8 @@ export class Reassembler {
     if (a.timer) clearTimeout(a.timer)
     if (a.count === a.n) {
       this._drop(key)
-      try { return JSON.parse(a.got.join('')) }
-      catch (_) { throw Object.assign(new Error('a message in parts did not join into JSON'), { code: 'bad-part' }) }
+      try { return a.bin ? unpack(concatBytes(a.got)) : JSON.parse(a.got.join('')) }
+      catch (_) { throw Object.assign(new Error('a message in parts did not join into a message'), { code: 'bad-part' }) }
     }
     a.timer = setTimeout(() => {
       const missing = a.n - a.count

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

@@ -164,3 +164,45 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
     isSealed: (m) => !!m && m.app === app && !!m.sealed,
   }
 }
+
+/**
+ * SELLAR BYTES (0.35.0). Un archivo no pasa por el sellado de texto —que lo volvería a
+ * base64—: se cifra con una CEK nueva (`encryptBytesWithCek` de `@dotrino/identity/content`,
+ * AES-GCM) y lo que se sella con el sellado de siempre es SOLO la CEK. Así la bóveda del
+ * navegador ve una llave de 44 caracteres y no los megas, y no hay cripto nueva: la misma
+ * envoltura de siempre más el AES-GCM del pilar de identidad.
+ *
+ * El sobre binario es un paquete (`binpack.js`) con `{ bv: 1, k, iv, ct }`:
+ *   · `k`  el sobre de siempre (del sellado propio o de la bóveda) con `{ cek }` dentro
+ *   · `iv`, `ct`  los bytes cifrados, como bytes
+ *
+ * Una CEK vale para todas las partes de un mensaje (cada parte con su `iv`, que es lo que
+ * AES-GCM exige), así que la bóveda sella una vez por mensaje y no una por parte.
+ */
+export const BIN_SEALED = 1
+
+export function isBinSealed (env) {
+  return !!env && env.bv === BIN_SEALED && !!env.k && typeof env.k === 'object' &&
+    env.iv instanceof Uint8Array && env.ct instanceof Uint8Array
+}
+
+/** Una CEK nueva para un mensaje con bytes. */
+export async function makeMessageKey () {
+  const { makeContentKey } = await crypto_()
+  if (typeof makeContentKey !== 'function') throw errorCon('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  return makeContentKey()
+}
+
+/** Cifra `bytes` con la CEK y devuelve los campos del sobre (`iv`, `ct`). */
+export async function encryptBytes (cek, bytes) {
+  const { encryptBytesWithCek } = await crypto_()
+  if (typeof encryptBytesWithCek !== 'function') throw errorCon('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  return encryptBytesWithCek({ cek, bytes })
+}
+
+/** Descifra el `ct` de un sobre binario con su CEK ya abierta. */
+export async function decryptBytes (cek, env) {
+  const { decryptBytesWithCek } = await crypto_()
+  if (typeof decryptBytesWithCek !== 'function') throw errorCon('opening bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  return decryptBytesWithCek({ cek, iv: env.iv, ct: env.ct })
+}

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

@@ -351,6 +351,8 @@ export class WebRTCManager {
 
   _attachDC (peer, dc) {
     peer.dc = dc
+    // Los bytes como ArrayBuffer: un Blob se lee de forma asíncrona y desordenaría las partes.
+    try { dc.binaryType = 'arraybuffer' } catch (_) {}
     dc.onopen = () => {
       // Por dónde salió: directo o por TURN. Por detrás, sin retrasar a nadie.
       this.probeRoute(peer).catch(() => {})
@@ -367,10 +369,13 @@ export class WebRTCManager {
     }
     dc.onmessage = (ev) => {
       let parsed = null
-      const raw = ev.data
+      let raw = ev.data
       this.count?.('in', peer.remote, utf8Length(raw), peer.route || 'webrtc')
       if (typeof raw === 'string') {
         try { parsed = JSON.parse(raw) } catch (_) { parsed = null }
+      } else if (raw instanceof ArrayBuffer) {
+        // Un mensaje con bytes (binpack.js). En Node llega ya como Buffer, que es un Uint8Array.
+        raw = new Uint8Array(raw)
       }
       this.deliverMessage(peer.remote, parsed ?? raw, { raw, timestamp: Date.now(), via: 'webrtc' })
     }

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.86.0 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/blocked,core/browserDisk,core/commKey,core/disk,core/libVersion,core/machines,core/notices,core/notifiable,core/passwords,core/sealKey,core/sealer,core/sealers,core/secretsStore,core/sha256,core/store,core/subacta,core/threadStore,core/transport,core/vault,enroll,index,loginClient,passwordLogins,procContext,protocol,revocation,sealed}.js).
+Copia vendorizada de @dotrino/vault@0.86.1 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/blocked,core/browserDisk,core/commKey,core/disk,core/libVersion,core/machines,core/notices,core/notifiable,core/passwords,core/sealKey,core/sealer,core/sealers,core/secretsStore,core/sha256,core/store,core/subacta,core/threadStore,core/transport,core/vault,enroll,index,loginClient,passwordLogins,procContext,protocol,revocation,sealed}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 browser.js es la bóveda de esta pestaña: el MISMO núcleo que el binario (core/), con
 el disco en IndexedDB. Importa @dotrino/{compat,roadmap,passmanager,store/core} y