@dotrino/identity 0.11.0 → 0.12.0

package/package.json

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

package/src/index.js

@@ -245,6 +245,15 @@ export class Identity {
     return this._call('listVaultDevices', {}, 20000)
   }
 
+  /**
+   * El cert de delegación de este dispositivo (o null si no está emparejado). El
+   * transporte lo presenta al proxy en `identify` → "una identidad": el proxy enruta
+   * los mensajes dirigidos a tu maestra M también a este dispositivo. No tiene secretos.
+   */
+  async getVaultCert () {
+    return this._call('getVaultCert')
+  }
+
   /** Suscribe a eventos de emparejamiento ('vault'): { phase:'challenge'|'paired'|'unpaired', ... }. */
   onVault (handler) {
     return this.on('vault', handler)

package/src/node.js

@@ -142,6 +142,7 @@ export class Identity {
   vaultSign (payload) { return this._h('vaultSign', { payload }) }
   vaultStore (method, args) { return this._h('vaultStore', { method, args }) }
   listVaultDevices () { return this._h('listVaultDevices') }
+  getVaultCert () { return this._h('getVaultCert') }
   onVault (handler) { return this.on('vault', handler) }
   mergeEndorsements (subject, endorsements, askerPubkey) {
     return this._h('mergeEndorsements', { subject, endorsements, askerPubkey })

package/vault/core.js

@@ -515,7 +515,11 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
     // Genera D aquí dentro (su privada NUNCA sale de la identidad), hace el enroll
     // endurecido por el proxy y guarda el cert. NO cambia signData todavía (Fase 2).
     async vaultPair ({ qr }) {
-      const res = await remoteEnroll({ qr, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, sas: c.sas }) })
+      // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
+      // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
+      let device
+      try { const k = JSON.parse(kv.getItem(KEY_STORAGE)); device = { publickey: JSON.stringify(k.publicJwk), privateJwk: k.privateJwk } } catch (_) { device = undefined }
+      const res = await remoteEnroll({ qr, device, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, sas: c.sas }) })
       kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify(res.device))
       kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
       emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master })
@@ -559,6 +563,13 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
       return remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert })
     },
 
+    // 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.
+    async getVaultCert () {
+      const v = loadVaultCert()
+      return v?.cert ? { cert: v.cert, master: v.master } : null
+    },
+
     async listContacts () {
       return Object.values(loadPeers()).filter(p => p && p.isContact).sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0))
     },

package/vault/remote.js

@@ -29,17 +29,20 @@ const MSG = {
  * @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, onChallenge, label = '', approveTimeoutMs = 180000 } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', 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 })
   await client.connect()
   try {
-    const device = await makeDeviceKey({ label })
-    const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
-    const sas = await deriveSAS(qr.iss, device.publickey, qr.sn)
-    const data = { op: 'enroll', dpub: device.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
+    // Por defecto genera una sub-clave nueva; pero el iframe pasa SU PROPIA llave de
+    // identidad (P) como `device` → el cert delega tu identidad y hay UNA sola (signData/
+    // identify/cert son la misma P).
+    const dev = device || await makeDeviceKey({ label })
+    const deviceId = (await pubkeyId(dev.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+    const sas = await deriveSAS(qr.iss, dev.publickey, qr.sn)
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
       const off = client.on('message', (_from, p) => {
@@ -55,11 +58,11 @@ export async function enrollDevice ({ qr, onChallenge, label = '', approveTimeou
     const res = await enrolled
 
     // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey })
+    const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey })
     if (!v.ok) throw new Error('cert inválido: ' + v.reason)
     if (res.cert.iss !== qr.iss) throw new Error('cert firmado por una maestra distinta a la que viste')
-    if (res.cert.sub !== device.publickey) throw new Error('cert emitido para otro dispositivo')
-    return { device, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId }
+    if (res.cert.sub !== dev.publickey) throw new Error('cert emitido para otro dispositivo')
+    return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId }
   } finally { try { client.close() } catch (_) {} }
 }
 

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

@@ -1,4 +1,2 @@
-Copia vendorizada de @dotrino/proxy-client@0.6.3 (src/, sin dependencias).
-El iframe id.dotrino.com se sirve estático (sin bundler), así que el transporte
-va self-hosted aquí (no por CDN) para no depender de terceros en runtime.
-Actualizar: re-copiar node_modules/@dotrino/proxy-client/src/*.js y bumpear esta nota.
+Copia vendorizada de @dotrino/proxy-client@0.6.4 (src/, sin dependencias).
+Ver dotrino-identity: el iframe se sirve estatico, transporte self-hosted (no CDN).

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

@@ -233,9 +233,11 @@ export class WebSocketProxyClient {
    * (típicamente por el identity vault). Devuelve la respuesta del proxy con
    * `queued_delivered` (mensajes offline despachados al instante).
    */
-  identify ({ data, signature }) {
+  identify ({ data, signature, cert }) {
     if (!data || !signature) throw new Error('identify requires {data, signature}')
-    return this._request({ type: 'identify', data, signature }, 'identified')
+    const msg = { type: 'identify', data, signature }
+    if (cert) msg.cert = cert // "una identidad": el proxy bindea este token también bajo tu maestra M
+    return this._request(msg, 'identified')
   }
 
   /**