@dotrino/identity 0.12.0 → 0.14.0

package/package.json

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

@@ -426,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

@@ -186,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

@@ -519,7 +519,7 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
       // 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 }) })
+      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 })

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, pubkeyId } from './capabilities.js'
 
 const MSG = {
   ENROLL: 'vault.enroll',
@@ -24,7 +24,7 @@ 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}>}
@@ -40,15 +40,21 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     // 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)
+    // 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()
+    // NO se manda el código ni un compromiso: el vault lo aprende SOLO cuando lo tipeás, y al
+    // ECHARLO de vuelta el dispositivo confía. Un vault falso no conoce el código → no empareja.
     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) => {
         if (!p || typeof p !== 'object') return
-        if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, sas }) } catch (_) {} }
-        else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) }
+        if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, code }) } catch (_) {} }
+        // El vault ECHA el código que tipeaste; aceptamos SOLO si coincide con el que generamos.
+        // (Un código distinto = un vault que no lo conoce → lo ignoramos y seguimos esperando.)
+        else if (p.type === MSG.ENROLLED) { if (p.code === code) { cleanup(); resolve(p) } }
         else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('timeout esperando la aprobación en el vault')) }, approveTimeoutMs)