@dotrino/identity 0.91.0 → 0.92.0

package/package.json

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

package/vault/acta.js

@@ -35,7 +35,7 @@
  * Módulo PURO: sin kv, sin red, sin disco. Cripto de `./capabilities.js`.
  */
 import { canonicalStringify } from './core.js'
-import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
+import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
 
 export const ACTA_V = 5
 
@@ -649,6 +649,52 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
   return mal ? { ok: false, reason: mal } : { ok: true }
 }
 
+/**
+ * ¿ES DE FIAR LO QUE CONTESTA LA BÓVEDA CON LA QUE TE EMPAREJASTE? El papel y el acta que
+ * llegan al enrolarse o al renovar, juzgados contra la llave de ESA bóveda (`vault`: la
+ * `iss` del QR, o la que quedó guardada al enrolarse).
+ *
+ * Antes cada cliente comparaba `acta.profileId` con esa llave. Eso solo es verdad en una
+ * cuenta de una bóveda que además nació en ella: el `profileId` es la llave del GÉNESIS, y
+ * en una cuenta que la bóveda ADOPTÓ, o en la SEGUNDA bóveda de un multivault, la llave de
+ * la bóveda es otra. Ahí ningún aparato podía entrar ni renovar. Y encima no protegía: el
+ * acta no se verificaba, así que bastaba con escribir ese `profileId` en una inventada.
+ *
+ * Lo que se comprueba ahora, y por qué alcanza:
+ *   1. el acta está bien firmada por quien dice haberla sellado;
+ *   2. esa bóveda PUEDE SELLAR esta acta — es de la cuenta, con el permiso, y una llave
+ *      está en una sola cuenta, así que esto también fija la cuenta;
+ *   3. el papel lo firmó ESA bóveda y no otra selladora: la respuesta es suya, porque nadie
+ *      por el camino puede firmar con su llave;
+ *   4. y el papel vale según esa acta (para esta llave, este permiso, un `seq` que no viene
+ *      del futuro).
+ *
+ * `justSealed` es para el ENROLAMIENTO: aprobar es admitir al aparato, así que el acta que
+ * vuelve la acaba de sellar esa misma bóveda. Exigirlo ata el acta a su llave y no solo el
+ * papel — el llavero que el aparato va a usar viaja ahí dentro. Al RENOVAR no se pide: la
+ * última acta pudo sellarla otra selladora de la cuenta.
+ *
+ * @returns {Promise<{ok:true}|{ok:false, reason:string}>}
+ */
+export async function checkVaultReply ({ acta, cert, vault, sub, scope = null, justSealed = false } = {}) {
+  if (!acta) return { ok: false, reason: 'sin-acta' }
+  if (!isPub(vault)) return { ok: false, reason: 'sin-boveda' }
+  // Para QUÉ llave es el papel no es opcional: sin ella `verifyDelegation` no lo mira, y un
+  // papel emitido para otra llave pasaría por bueno.
+  if (!isPub(sub)) return { ok: false, reason: 'sin-llave-del-aparato' }
+  const v = await verifyActa({ acta })
+  if (!v.ok) return { ok: false, reason: 'acta:' + v.reason }
+  if (!canSeal(acta, vault)) return { ok: false, reason: 'boveda-no-sella' }
+  if (justSealed && !samePubkey(acta.sealedBy, vault)) return { ok: false, reason: 'acta-de-otra-selladora' }
+  if (!cert || !samePubkey(cert.iss, vault)) return { ok: false, reason: 'papel-de-otra-llave' }
+  const d = await verifyDelegation({
+    cert, expectedSub: sub, actaSeq: acta.seq, sealers: sealersOf(acta),
+    ...(scope ? { expectedScope: scope } : {})
+  })
+  if (!d.ok) return { ok: false, reason: 'papel:' + d.reason }
+  return { ok: true }
+}
+
 /**
  * Aplica cambios y devuelve el acta SIGUIENTE, **sin firmar** (hay que `sealActa`).
  * `by` es quien va a sellar: si no es el sellador vigente, se rechaza (regla 1).
@@ -1218,7 +1264,7 @@ export async function canAdopt ({ candidate, current }) {
 
 export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain, verifySignedBy,
-  sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
+  sealActa, verifyActa, checkVaultReply, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
   effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt,

package/vault/remote.js

@@ -13,8 +13,8 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
-import { sealersOf } from './acta.js'
+import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
+import { checkVaultReply } from './acta.js'
 
 const MSG = {
   HELLO: 'vault.hello',
@@ -218,14 +218,12 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // (Aquí vivía el margen de reloj: el cert lo sellaba la bóveda con SU reloj y lo validaba
     // este aparato con el suyo, y 850 ms de diferencia bastaban para no poder enrolarse. Sin
     // vencimiento no hay ventana que ajustar y el problema no puede volver.)
-    if (!res.acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    if (res.acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw')
-    const v = await verifyDelegation({
-      cert: res.cert, expectedSub: dev.publickey,
-      actaSeq: res.acta.seq, sealers: sealersOf(res.acta)
-    })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.sub !== dev.publickey) throw new Error('cert issued for a different device')
+    //
+    // Se juzga contra la llave de LA BÓVEDA con la que hablas, no contra el `profileId`:
+    // eso solo coincidía en una cuenta que nació en esa bóveda, y dejaba fuera a quien se
+    // emparejaba con una segunda bóveda o con una que adoptó la cuenta (`checkVaultReply`).
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: qr.iss, sub: dev.publickey, justSealed: true })
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
     return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
   } finally { try { client.close() } catch (_) {} }
 }
@@ -381,12 +379,17 @@ export async function requestDevices ({ master, proxy, device, cert, sinceSeq, o
  */
 export async function requestRenew ({ master, proxy, device, cert, onRevoked } = {}) {
   const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
-  if (!res.cert || res.cert.sub !== device.publickey) throw new Error('invalid renewed cert')
   // EL ACTA VIAJA CON EL PAPEL y hay que dejarla pasar: quien lo recibe la necesita para
   // comprobar que lo firmó una SELLADORA de este perfil. Aquí se comparaba `cert.iss` con
   // la maestra y se tiraba el acta, así que arriba no había con qué juzgar y la renovación
   // fallaba con «the vault did not send its record» — con el papel correcto en la mano.
-  return { cert: res.cert, acta: res.acta || null }
+  //
+  // Y se juzga AQUÍ, en el pilar: antes lo hacía cada cliente por su cuenta —uno comparando
+  // el `profileId`, que con dos bóvedas no vale, y el navegador guardando el papel sin mirar
+  // nada—. `master` es la bóveda a la que se le pidió.
+  const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: master, sub: device.publickey })
+  if (!chk.ok) throw new Error('invalid renewed cert: ' + chk.reason)
+  return { cert: res.cert, acta: res.acta }
 }
 
 /**