@dotrino/identity 0.26.0 → 0.28.0

package/package.json

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

@@ -301,6 +301,10 @@ export class Identity {
   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') }
 

package/src/node.js

@@ -20,15 +20,25 @@ import path from 'node:path'
 import os from 'node:os'
 import { createIdentityCore } from '../vault/core.js'
 
-/** kv síncrono respaldado por un archivo JSON (estilo localStorage). */
-function fileKv (filePath) {
+/**
+ * kv síncrono respaldado por un archivo JSON (estilo localStorage).
+ *
+ * `atRest` (opcional) cifra el archivo entero en disco: quien lo provee decide con qué
+ * (el vault lo liga a la máquina, ver `dotrino-vault/src/atrest.js`). Si el archivo estaba
+ * en claro se lee igual y queda cifrado en la primera escritura, sin pedir nada.
+ */
+function fileKv (filePath, atRest = null) {
   let data = {}
   try {
-    if (fs.existsSync(filePath)) data = JSON.parse(fs.readFileSync(filePath, 'utf8')) || {}
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, 'utf8')
+      data = JSON.parse(atRest ? atRest.decrypt(raw) : raw) || {}
+    }
   } catch (_) { data = {} }
   const flush = () => {
     fs.mkdirSync(path.dirname(filePath), { recursive: true })
-    fs.writeFileSync(filePath, JSON.stringify(data))
+    const text = JSON.stringify(data)
+    fs.writeFileSync(filePath, atRest ? atRest.encrypt(text) : text, { mode: 0o600 })
   }
   return {
     getItem: (k) => (k in data ? data[k] : null),
@@ -91,6 +101,7 @@ export class Identity {
    */
   constructor (options = {}) {
     this._dir = options.dir || DEFAULT_DIR
+    this._atRest = options.atRest || null
     this._core = null
     this._listeners = new Map()
   }
@@ -109,7 +120,7 @@ export class Identity {
   async ready () {
     if (this._core) return this
     this._core = await createIdentityCore({
-      kv: fileKv(path.join(this._dir, 'identity.json')),
+      kv: fileKv(path.join(this._dir, 'identity.json'), this._atRest),
       peers: filePeers(path.join(this._dir, 'peers.json')),
       makeSync: null
     })
@@ -164,6 +175,10 @@ export class Identity {
   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)

package/vault/core.js

@@ -1136,6 +1136,23 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     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ó.
@@ -1166,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.
@@ -1203,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.
@@ -1226,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) }