@dotrino/identity 0.25.1 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.25.1",
+  "version": "0.27.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -24,6 +24,9 @@
     "./vault/remote.js": "./vault/remote.js",
     "./acta": {
       "import": "./vault/acta.js"
+    },
+    "./content": {
+      "import": "./vault/content.js"
     }
   },
   "files": [

package/src/index.js

@@ -299,6 +299,14 @@ export class Identity {
 
   /** Adopta un acta recibida de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
   async adoptActa (acta) { return this._call('adoptActa', { acta }) }
+  /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
+  async contentKey () { return this._call('contentKey') }
+  /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */
+  async sealContent (plaintext) { return this._call('sealContent', { plaintext }) }
+  /** Abre un sobre de contenido con el llavero del perfil. */
+  async openContent (envelope) { return this._call('openContent', { envelope }) }
+  /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
+  async rotateContentKey () { return this._call('rotateContentKey') }
 
   // ----- Emparejar ESTE navegador/dispositivo con el vault del usuario (Fase 1) -----
 

package/src/node.js

@@ -162,6 +162,14 @@ export class Identity {
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
   absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
   adoptActa (acta) { return this._h('adoptActa', { acta }) }
+  /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
+  contentKey () { return this._h('contentKey') }
+  /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */
+  sealContent (plaintext) { return this._h('sealContent', { plaintext }) }
+  /** Abre un sobre de contenido con el llavero del perfil. */
+  openContent (envelope) { return this._h('openContent', { envelope }) }
+  /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
+  rotateContentKey () { return this._h('rotateContentKey') }
   // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
   enrollDevice (qr) { return this._h('vaultPair', { qr }) }
   vaultStatus () { return this._h('vaultStatus') }

package/vault/acta.js

@@ -80,6 +80,9 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     members: [{ pub, encPub, label: String(label || '').slice(0, 60), caps: [...CAPS], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
+    // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
+    // a cada miembro (ver content.js). Envuelto es público: solo lo abre su destinatario.
+    keyring: [],
     updatedAt: now
   }
 }
@@ -150,6 +153,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
     members: acta.members.map((m) => ({ ...m, caps: [...m.caps] })),
     revoked: [...(acta.revoked || [])],
     renounced: [...(acta.renounced || [])],
+    keyring: (acta.keyring || []).map((g) => ({ ...g, wraps: { ...g.wraps } })),
     updatedAt: now
   }
   delete next.sig
@@ -184,7 +188,13 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         const i = next.members.findIndex((m) => m.pub === ch.pub)
         if (i < 0) throw new Error('remove: ese miembro no está en el acta')
         if (next.members[i].pub === next.sealer) throw new Error('remove: no puedes expulsar al master; primero traspasa el sellado')
-        next.members.splice(i, 1)
+        const fuera = next.members.splice(i, 1)[0]
+        // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
+        // acceso al contenido FUTURO se corta rotando, ver content.js; lo ya leído no vuelve.)
+        next.keyring = next.keyring.map((g) => {
+          const { [fuera.pub]: _, ...resto } = g.wraps || {}
+          return { ...g, wraps: resto }
+        })
         break
       }
       case 'handover': {
@@ -192,6 +202,20 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         next.sealer = ch.to
         break
       }
+      case 'keyring': {
+        // Generación NUEVA de la clave de contenido (al rotar: expulsar a alguien).
+        const g = ch.generation
+        if (!g || !Number.isInteger(g.gen)) throw new Error('keyring: generación inválida')
+        next.keyring = [...next.keyring.filter((x) => x.gen !== g.gen), g].sort((a, b) => a.gen - b.gen)
+        break
+      }
+      case 'wrap': {
+        // Envolver la clave YA existente para un miembro nuevo (al admitir: no hace falta rotar).
+        const g = next.keyring.find((x) => x.gen === ch.gen)
+        if (!g) throw new Error('wrap: esa generación no está en el llavero')
+        g.wraps = { ...g.wraps, [ch.pub]: ch.wrap }
+        break
+      }
       case 'revoke': {
         if (typeof ch.nonce !== 'string') throw new Error('revoke: falta el nonce')
         next.revoked.push({ nonce: ch.nonce, until: ch.until || (now + 30 * 24 * 60 * 60 * 1000) })

package/vault/content.js

@@ -0,0 +1,132 @@
+/**
+ * content.js — la LLAVE DE CONTENIDO del perfil, para que todos tus dispositivos lean lo
+ * mismo sin que ninguna llave de identidad se mueva.
+ *
+ * La distinción que ordena esto (y que conviene decir en voz alta):
+ *
+ *   · Las llaves de FIRMA son intransferibles. Nacen y mueren en su dispositivo.
+ *   · La llave de CONTENIDO se comparte por diseño — si no, dos dispositivos tuyos no
+ *     podrían leer el mismo archivo, que es justo lo que se quiere.
+ *
+ * Cómo: el perfil tiene una clave simétrica (la CEK) que se ENVUELVE hacia la llave de
+ * cifrado de cada miembro (ECDH P-256 efímero + AES-GCM, la misma cripto que ya usa el
+ * ecosistema para los sobres sellados). Cada miembro abre su envoltura con su propia
+ * privada; nadie más puede. Admitir un miembro = envolverle la CEK. Expulsarlo = ROTAR la
+ * CEK y envolver la nueva al resto.
+ *
+ * Lo que esto protege y lo que no: rotar corta el acceso al contenido FUTURO. Lo que el
+ * expulsado ya leyó, ya lo leyó — eso no se puede deshacer y no se promete.
+ *
+ * Módulo PURO (WebCrypto, sin kv/red/disco).
+ */
+
+const subtle = globalThis.crypto.subtle
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+
+const b64 = (buf) => {
+  const bytes = new Uint8Array(buf)
+  let s = ''
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
+  return btoa(s)
+}
+const fromB64 = (str) => {
+  const bin = atob(str)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+async function sharedKey (privateKey, peerPubJwkStr) {
+  const pub = await subtle.importKey('jwk', JSON.parse(peerPubJwkStr), ECDH, false, [])
+  const bits = await subtle.deriveBits({ name: 'ECDH', public: pub }, privateKey, 256)
+  return subtle.importKey('raw', bits, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt'])
+}
+
+/** Genera una clave de contenido nueva (AES-256-GCM). Devuelve los bytes en base64. */
+export async function makeContentKey () {
+  const k = await subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
+  return b64(await subtle.exportKey('raw', k))
+}
+
+/**
+ * Envuelve la CEK hacia la llave de cifrado de un miembro. La envoltura es pública: solo
+ * la abre quien tenga la privada de `memberEncPub`, así que puede viajar en el acta.
+ * @returns {Promise<{epk:string, iv:string, ct:string}>}
+ */
+export async function wrapForMember ({ cek, memberEncPub }) {
+  if (typeof cek !== 'string' || !cek) throw new Error('wrapForMember: falta la clave de contenido')
+  if (typeof memberEncPub !== 'string' || !memberEncPub) throw new Error('wrapForMember: el miembro no tiene llave de cifrado')
+  const eph = await subtle.generateKey(ECDH, false, ['deriveBits'])
+  const key = await sharedKey(eph.privateKey, memberEncPub)
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, key, new TextEncoder().encode(cek))
+  const epk = await subtle.exportKey('jwk', eph.publicKey)
+  return {
+    epk: JSON.stringify({ kty: epk.kty, crv: epk.crv, x: epk.x, y: epk.y }),
+    iv: b64(iv),
+    ct: b64(ct)
+  }
+}
+
+/** Abre la envoltura con la llave de cifrado privada de ESTE miembro. */
+export async function openWrap ({ wrap, myEncPrivateKey }) {
+  if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('envoltura inválida')
+  const key = await sharedKey(myEncPrivateKey, wrap.epk)
+  const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(wrap.iv) }, key, fromB64(wrap.ct))
+  return new TextDecoder().decode(pt)
+}
+
+/**
+ * Genera la CEK de una generación y la envuelve a TODOS los miembros que tengan llave de
+ * cifrado. Un miembro sin `encPub` simplemente no recibe envoltura (y por tanto no lee el
+ * contenido): se devuelve la lista para que la consola lo diga en vez de fallar en silencio.
+ */
+export async function makeGeneration ({ members, gen = 1, cek = null, now = Date.now() }) {
+  const key = cek || await makeContentKey()
+  const wraps = {}
+  const sinLlave = []
+  for (const m of members || []) {
+    if (!m?.encPub) { sinLlave.push(m?.pub); continue }
+    wraps[m.pub] = await wrapForMember({ cek: key, memberEncPub: m.encPub })
+  }
+  return { generation: { gen, createdAt: now, wraps }, cek: key, sinLlave }
+}
+
+/** La CEK vigente para mí, sacada del llavero del acta. `null` si no tengo envoltura. */
+export async function myContentKey ({ keyring, myPub, myEncPrivateKey }) {
+  const gens = [...(keyring || [])].sort((a, b) => (b.gen || 0) - (a.gen || 0))
+  for (const g of gens) {
+    const w = g.wraps?.[myPub]
+    if (!w) continue
+    try { return { gen: g.gen, cek: await openWrap({ wrap: w, myEncPrivateKey }) } } catch (_) {}
+  }
+  return null
+}
+
+/** Cifra con la CEK. Devuelve un sobre `{ gen, iv, ct }` (el `gen` dice con cuál se cifró). */
+export async function encryptWithCek ({ cek, gen, plaintext }) {
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['encrypt'])
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, k, new TextEncoder().encode(plaintext))
+  return { gen, iv: b64(iv), ct: b64(ct) }
+}
+
+/**
+ * Descifra un sobre. Hay que darle el llavero porque el contenido viejo está cifrado con
+ * generaciones anteriores: por eso las CEK antiguas se conservan (32 bytes cada una) en vez
+ * de re-cifrarlo todo de golpe al rotar.
+ */
+export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPrivateKey }) {
+  const g = (keyring || []).find((x) => x.gen === envelope?.gen)
+  const w = g?.wraps?.[myPub]
+  if (!w) throw new Error('este dispositivo no tiene la llave de esa generación de contenido')
+  const cek = await openWrap({ wrap: w, myEncPrivateKey })
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['decrypt'])
+  const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(envelope.iv) }, k, fromB64(envelope.ct))
+  return new TextDecoder().decode(pt)
+}
+
+export default {
+  makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
+  encryptWithCek, decryptWithKeyring
+}

package/vault/core.js

@@ -20,6 +20,7 @@
 
 import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
 import * as Acta from './acta.js'
+import * as Content from './content.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
@@ -374,11 +375,48 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function ensureActa (label = '') {
     if (loadActa()) return loadActa()
-    const acta = await seal(Acta.genesisActa({
+    const base = Acta.genesisActa({
       pub: publickeyJwkStr, encPub: encPublickeyJwkStr, label: label || me?.nickname || ''
-    }))
-    saveActa(acta)
-    return acta
+    })
+    // La primera generación de la clave de contenido va DENTRO del acta de génesis, no en
+    // un cambio aparte: un perfil recién nacido está en `seq 1`, no en `seq 2`.
+    try {
+      const { generation } = await Content.makeGeneration({ members: base.members, gen: 1 })
+      base.keyring = [generation]
+    } catch (e) { console.warn('[identity] no se pudo crear la clave de contenido:', e.message) }
+    saveActa(await seal(base))
+    return loadActa()
+  }
+
+  // ----- CLAVE DE CONTENIDO del perfil (para que todos tus dispositivos lean lo mismo) -----
+  // Las llaves de FIRMA no se mueven nunca; la de CONTENIDO se comparte por diseño,
+  // envuelta a la llave de cifrado de cada miembro (ver content.js).
+
+  /** Mi copia de la clave de contenido vigente, o null si aún no me la han envuelto. */
+  const myCek = () => Content.myContentKey({
+    keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
+  })
+
+  /** Envuelve la clave vigente para un miembro recién admitido (no hace falta rotar). */
+  async function wrapForNewMember (pub) {
+    const acta = loadActa()
+    const gen = (acta?.keyring || []).at(-1)
+    const m = acta?.members.find((x) => x.pub === pub)
+    if (!gen || !m?.encPub) return false
+    const mine = await myCek()
+    if (!mine) return false
+    const wrap = await Content.wrapForMember({ cek: mine.cek, memberEncPub: m.encPub })
+    await sealChanges([{ op: 'wrap', gen: mine.gen, pub, wrap }])
+    return true
+  }
+
+  /** Rota la clave: generación nueva envuelta SOLO a los miembros actuales. */
+  async function rotateCek () {
+    const acta = loadActa()
+    const gen = ((acta.keyring || []).at(-1)?.gen || 0) + 1
+    const { generation, sinLlave } = await Content.makeGeneration({ members: acta.members, gen })
+    await sealChanges([{ op: 'keyring', generation }])
+    return { gen, sinLlave }
   }
 
   /**
@@ -1033,7 +1071,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async admitMember ({ pub, encPub = null, label = '', caps = ['store', 'read'], cert = null, continuity = null } = {}) {
       const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, caps, cert, continuity } }])
-      return { ok: true, seq: acta.seq }
+      // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
+      // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
+      let wrapped = false
+      try { wrapped = await wrapForNewMember(pub) } catch (_) {}
+      return { ok: true, seq: acta.seq, wrapped }
     },
 
     async setCaps ({ pub, caps } = {}) {
@@ -1043,7 +1085,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async removeMember ({ pub } = {}) {
       const acta = await sealChanges([{ op: 'remove', pub }])
-      return { ok: true, seq: acta.seq }
+      // Expulsar rota la clave: el que sale no podrá abrir el contenido NUEVO. Lo que ya
+      // leyó no vuelve — eso no se puede deshacer y no se promete.
+      let rotated = null
+      try { rotated = await rotateCek() } catch (_) {}
+      return { ok: true, seq: acta.seq, rotated }
     },
 
     /**
@@ -1084,6 +1130,38 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, seq: acta.seq }
     },
 
+    /**
+     * La clave de contenido de este perfil, ya abierta con la llave de cifrado de este
+     * dispositivo. `null` si todavía no te la han envuelto (o si te expulsaron).
+     */
+    async contentKey () { return myCek() },
+
+    /**
+     * Cifra algo con la clave de contenido del perfil. Devuelve el sobre `{gen,iv,ct}`.
+     * La llave privada de cifrado NUNCA sale de aquí: se cifra y descifra dentro.
+     */
+    async sealContent ({ plaintext } = {}) {
+      const mine = await myCek()
+      if (!mine) throw new Error('este dispositivo todavía no tiene la clave de contenido del perfil')
+      return Content.encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: String(plaintext) })
+    },
+
+    /** Abre un sobre de contenido con el llavero del perfil (todas las generaciones). */
+    async openContent ({ envelope } = {}) {
+      return Content.decryptWithKeyring({
+        envelope, keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
+      })
+    },
+
+    /**
+     * Rota la clave de contenido: generación nueva envuelta solo a los miembros de ahora.
+     * Corta el acceso al contenido FUTURO de quien ya no está; lo que ya leyó, ya lo leyó.
+     */
+    async rotateContentKey () {
+      const r = await rotateCek()
+      return { ok: true, ...r }
+    },
+
     /** Adopta un acta que llega de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
     async adoptActa ({ acta } = {}) { return adoptActa(acta) },
 
@@ -1105,7 +1183,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const continuity = (mio && mio.members.length === 1)
         ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
         : null
-      const res = await remoteEnroll({ qr, device, continuity, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
+      const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
       kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
       kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
       // Conectarse a una bóveda es ENTRAR A SU PERFIL: el acta viene con el cert.
@@ -1142,12 +1220,31 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     // Store DELEGADO: lee/escribe el store de hilos+aperturas EN tu vault (con el cert).
     // Reusa el MISMO emparejamiento (no hay un pairing aparte para el store).
+    /**
+     * 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.
+     */
     async vaultStore ({ method, args }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args, onRevoked: wipeVaultLink }) }
-      catch (e) { return handleVaultError(e) }
+      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 ?? {}) }) }
+      }
+      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
+          }))
+        }
+        return res
+      } catch (e) { return handleVaultError(e) }
     },
 
     // Lista (solo lectura) de dispositivos enrolados en tu vault.
@@ -1165,9 +1262,17 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     // El cert de delegación de este dispositivo (para presentarlo al proxy en `identify`
     // → "una identidad": el proxy bindea tu pubkey también bajo tu maestra M). Sin secretos.
+    /**
+     * Lo que este dispositivo presenta al identificarse ante el proxy: su cert de
+     * delegación y su ACTA de perfil. Con el cert, el proxy enruta lo dirigido a la
+     * maestra; con el acta, lo dirigido a la PERSONA (cualquiera de sus dispositivos).
+     * Sin secretos: las dos cosas son públicas y auto-verificables.
+     */
     async getVaultCert () {
       const v = loadVaultCert()
-      return v?.cert ? { cert: v.cert, master: v.master } : null
+      const acta = loadActa()
+      if (!v?.cert) return acta ? { cert: null, master: null, acta } : null
+      return { cert: v.cert, master: v.master, acta }
     },
 
     async listContacts () {

package/vault/remote.js

@@ -41,11 +41,12 @@ export async function isAuthenticRevoke ({ body, signature, master, devicePubkey
  * direccionable, es lo que hace que el proxy le entregue lo que tenía ENCOLADO (24 h) —
  * entre otras cosas, un `vault.revoked` emitido mientras estaba apagado.
  */
-async function identifyAsDevice (client, device) {
+async function identifyAsDevice (client, device, { cert = null, acta = null } = {}) {
   if (!client.token) return
   const data = { op: 'identify', publickey: device.publickey, token: client.token, ts: Date.now() }
   const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
-  await client.identify({ data, signature })
+  // cert → el proxy enruta lo dirigido a la maestra; acta → lo dirigido a la PERSONA.
+  await client.identify({ data, signature, cert, acta })
 }
 
 /**
@@ -56,7 +57,7 @@ async function identifyAsDevice (client, device) {
  * @param {number} [opts.approveTimeoutMs]  Espera de la aprobación humana (def 3 min).
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string}>}
  */
-export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, approveTimeoutMs = 180000 } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000 } = {}) {
   if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: qr.proxy, enableWebRTC: false, autoReconnect: false })
@@ -77,7 +78,9 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     const commit = await commitCode({ code, dpub: dev.publickey, sn: qr.sn })
     // `continuity`: si esta identidad ya existía, va firmada por ella misma para que lo
     // que hizo antes se pueda seguir atribuyendo a la misma persona (ver acta.js).
-    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), ...(continuity ? { continuity } : {}) }
+    // `encPub`: la llave de CIFRADO de este dispositivo. Sin ella la bóveda no puede
+    // envolverle la clave de contenido del perfil, y entraría sin poder leer nada.
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {}) }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -125,13 +128,13 @@ export async function requestSign ({ master, proxy, device, cert, payload, onRev
  * dispositivo estaba apagado la bóveda emitió un `vault.revoked` firmado, llega aquí y se
  * ejecuta el autoborrado (`onRevoked`) tras verificar la firma contra la maestra pineada.
  */
-async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
+async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
   if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
   try {
-    try { await identifyAsDevice(client, device) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
+    try { await identifyAsDevice(client, device, { cert, acta }) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
     const signed = { ...data, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data: signed })
     const pending = new Promise((resolve, reject) => {
@@ -155,8 +158,10 @@ async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data,
 }
 
 /** Lee/escribe el store de hilos+aperturas EN el vault (con el cert del dispositivo). */
-export async function requestStore ({ master, proxy, device, cert, method, args, onRevoked } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.store', okType: 'vault.store.result', data: { op: 'store', method, args: args || {} } })
+export async function requestStore ({ master, proxy, device, cert, method, args, enc, onRevoked } = {}) {
+  // `enc`: argumentos cifrados con la clave de contenido del perfil (el proxy no los ve).
+  const data = enc ? { op: 'store', method, enc } : { op: 'store', method, args: args || {} }
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.store', okType: 'vault.store.result', data })
   return res.result
 }
 

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.6.0 (lib/src/{index,enroll}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.7.0 (lib/src/{index,enroll}.js, sin dependencias).
 El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
 resuelve en el navegador sin bundler. index.js importa ./enroll.js (relativo, se
 vendoriza tambien) y @dotrino/identity/capabilities (=../../capabilities.js) y

package/vault/vendor/vault/enroll.js

@@ -158,6 +158,9 @@ export function createEnrollDesk ({
     pend.dpub = d.dpub
     pend.deviceId = deviceId
     pend.commit = d.commit
+    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave de contenido del
+    // perfil al admitirlo. Sin ella entra, pero no podrá leer lo que haya guardado.
+    if (typeof d.encPub === 'string') pend.encPub = d.encPub
     // Certificado de continuidad (opcional): lo firma la identidad que se une, con su
     // propia llave. Se comprueba aquí y se guarda con el miembro al aprobar.
     if (d.continuity) {
@@ -213,7 +216,7 @@ export function createEnrollDesk ({
     try {
       if (typeof identity.admitMember === 'function') {
         const caps = scopeToCaps(pend.scope)
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, label: pend.label || '', caps, cert, continuity: pend.continuity || null })
+        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', caps, cert, continuity: pend.continuity || null })
       }
       acta = (await identity.profileActa?.())?.acta || null
     } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }