@dotrino/identity 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.11.0",
+  "version": "0.13.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)
@@ -417,4 +426,4 @@ export class Identity {
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), reutilizables
 // por apps/bridges sin cargar el iframe del vault.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

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 })
@@ -185,4 +186,4 @@ export default Identity
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), para que
 // un bridge/bot Node pueda crear su clave, firmar acciones y verificar cadenas D←P.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

package/vault/capabilities.js

@@ -77,6 +77,28 @@ export async function deriveSAS (master, dpub, sn) {
   return String(n % 1000000).padStart(6, '0')
 }
 
+/**
+ * Código de emparejamiento ALEATORIO de 6 dígitos. Lo genera el DISPOSITIVO y lo MUESTRA;
+ * el usuario lo tipea en el vault. El vault NO lo conoce: el dispositivo solo manda un
+ * COMPROMISO (`commitCode`), no el código → el vault lo aprende únicamente cuando vos se lo
+ * das, tipeándolo. Así, aprobar exige TENER el dispositivo (de ahí sale el código).
+ */
+export function makePairingCode () {
+  const b = crypto.getRandomValues(new Uint8Array(4))
+  const n = (((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]) >>> 0)
+  return String(n % 1000000).padStart(6, '0')
+}
+
+/**
+ * Compromiso del código: `SHA-256(code ‖ dpub ‖ sn)` en hex. Va en el ENROLL (no el código).
+ * Liga el código a ESTE dispositivo y sesión (no reusable para otro). El vault lo guarda y,
+ * cuando tipeás el código, recomputa y compara → verifica posesión sin conocer el código antes.
+ */
+export async function commitCode ({ code, dpub, sn }) {
+  const h = await crypto.subtle.digest('SHA-256', enc(canonicalStringify({ code: String(code), sub: dpub, sn })))
+  return [...new Uint8Array(h)].map((x) => x.toString(16).padStart(2, '0')).join('')
+}
+
 /** Cuerpo canónico del certificado (lo que se firma): el cert SIN la firma. */
 export function delegationBody (cert) {
   return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, exp: cert.exp, nonce: cert.nonce }

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, code: c.code }) })
       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

@@ -12,7 +12,7 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, deriveSAS, pubkeyId } from './capabilities.js'
+import { makeDeviceKey, signWithDevice, verifyDelegation, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
 
 const MSG = {
   ENROLL: 'vault.enroll',
@@ -24,27 +24,33 @@ const MSG = {
 /**
  * @param {Object} opts
  * @param {{v:number, iss:string, proxy:string, token:string, sn:string}} opts.qr  QR v2 del vault.
- * @param {(c:{deviceId:string, sas:string})=>void} [opts.onChallenge]  Para mostrar el SAS a comparar.
+ * @param {(c:{deviceId:string, code:string})=>void} [opts.onChallenge]  Para mostrar el código a tipear en el PC.
  * @param {string} [opts.label]
  * @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')
+    // El DISPOSITIVO genera el código y manda solo su COMPROMISO (no el código). El vault
+    // aprende el código únicamente cuando vos lo tipeás en el PC → aprobar exige tener el dispositivo.
+    const code = makePairingCode()
+    const commit = await commitCode({ code, dpub: dev.publickey, sn: qr.sn })
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, 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) => {
         if (!p || typeof p !== 'object') return
-        if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, sas }) } catch (_) {} }
+        if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, code }) } catch (_) {} }
         else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) }
         else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
       })
@@ -55,11 +61,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')
   }
 
   /**