@dotrino/vaultd 0.117.0 → 0.118.0

package/lib/src/service.js

@@ -22,10 +22,10 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
-  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
+  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice,
   verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
-import { verifyActa, sealKeyAt, sealersOf, memberCan } from '@dotrino/identity/acta'
+import { verifyActa, sealKeyAt, memberCan, checkVaultReply } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
 import { PKG_VERSION } from './version.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
@@ -400,18 +400,15 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     // por reloj, dice el `seq` del acta con el que se emitió, y quien lo emitió tiene que
     // ser SELLADORA de ese acta. Sin acta no se puede comprobar nada de eso, y entrar a
     // ciegas en un perfil es justo lo que no se hace.
-    const acta = res.acta
-    if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    // Y el acta tiene que ser la DEL PERFIL DEL QR. Antes esto se comprobaba mirando que el
-    // cert lo firmara `qr.iss`; con varias selladoras el emisor puede ser otra llave del
-    // mismo perfil, así que lo que se fija es el perfil, no la llave.
-    if (acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one in the QR')
-    const v = await verifyDelegation({
-      cert: res.cert, expectedSub: device.publickey,
-      actaSeq: acta.seq, sealers: sealersOf(acta),
-      ...(expectedScope ? { expectedScope } : {})
+    //
+    // Se juzga contra la llave de LA BÓVEDA del QR, con la regla del pilar. Antes se exigía
+    // `acta.profileId === qr.iss`, que solo es verdad en una cuenta que nació en esa bóveda:
+    // un servicio no podía emparejarse con una segunda bóveda ni con una que adoptó la cuenta.
+    const chk = await checkVaultReply({
+      acta: res.acta, cert: res.cert, vault: qr.iss, sub: device.publickey,
+      scope: expectedScope || null, justSealed: true
     })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
 
     return { device, enc: enc ? { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk } : null, cert: res.cert, iss: qr.iss, proxy: qr.proxy || 'wss://proxy.dotrino.com' }
   } finally { client.close() }
@@ -599,7 +596,13 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
         const pending = waitForMsg(client, (p) => p.type === MSG.RENEWED || p.type === MSG.ERROR, 15000)
         client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
         const res = await pending
-        if (res.type === MSG.RENEWED && res.cert?.sub === device.publickey) {
+        // SE VERIFICA ANTES DE GUARDARLO. Aquí solo se miraba que fuera para esta llave: un
+        // papel cualquiera, sin firma que valga, sustituía al bueno y el servicio se quedaba
+        // fuera hasta el siguiente arranque. Misma regla que al enrolarse, sin `justSealed`:
+        // la última acta pudo sellarla otra selladora de la cuenta.
+        const ok = res.type === MSG.RENEWED &&
+          (await checkVaultReply({ acta: res.acta, cert: res.cert, vault: masterPubkey, sub: device.publickey })).ok
+        if (ok) {
           cert = res.cert
           recordar({ cert })
           // QUIEN NO PASA `dir` GUARDA ÉL. Un servicio que lleva su identidad en su propio

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.117.0",
+  "version": "0.118.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -22,10 +22,10 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.81.0",
+    "@dotrino/identity": "0.92.0",
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.18.2",
-    "@dotrino/roadmap": "0.2.0",
+    "@dotrino/roadmap": "0.3.3",
     "@dotrino/store": "0.11.0",
     "ws": "^8.18.0"
   },

package/src/client.js

@@ -11,19 +11,10 @@
  * estrictamente (firmado por la maestra que vio en el QR, y para SU clave) antes de
  * guardarlo. La maestra nunca sale del vault.
  */
-import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { myContentKey, encryptWithCek, decryptWithKeyring } from '@dotrino/identity/content'
-import { sealersOf } from '@dotrino/identity/acta'
-
-/**
- * Con qué se juzga un papel: el ACTA que la bóveda manda junto a él. Sustituye a comparar
- * `cert.iss` con la maestra — con varias selladoras el emisor puede ser otra llave del mismo
- * perfil, así que lo que se fija es el PERFIL, no la llave.
- */
-function contexto (acta) {
-  if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-  return { actaSeq: acta.seq, sealers: sealersOf(acta) }
-}
+// Con qué se juzga lo que devuelve la bóveda (papel + acta): la regla del pilar, una sola.
+import { checkVaultReply } from '@dotrino/identity/acta'
 import { installNodeGlobals } from './node-globals.js'
 import { MSG } from './protocol.js'
 
@@ -102,11 +93,11 @@ export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeout
     client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
     const res = await enrolled
 
-    // VALIDACIÓN ESTRICTA antes de persistir (cierra inyección de cert / sustitución de maestra).
-    if (res.acta?.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw (possible malicious proxy)')
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...contexto(res.acta) })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.sub !== device.publickey) throw new Error('cert issued for a different device')
+    // VALIDACIÓN ESTRICTA antes de persistir (cierra inyección de cert / sustitución de maestra),
+    // contra la llave de la bóveda del QR y con la regla del pilar: vale también para una
+    // segunda bóveda o una que adoptó la cuenta, donde esa llave no es el `profileId`.
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: qr.iss, sub: device.publickey, justSealed: true })
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
     // OJO: devolvemos qr.iss (la maestra que el usuario VIO), NO res.iss.
     return { device: { ...device, encPublickey: enc.encPublickey, encPrivateJwk: enc.encPrivateJwk }, cert: res.cert, iss: qr.iss, acta: res.acta }
   } finally { client.close() }
@@ -168,11 +159,10 @@ export async function requestRenew ({ masterPubkey, proxyUrl, device, cert, dir
     client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
     const res = await pending
     if (res.type === MSG.ERROR) throw new Error(res.error)
-    // Se valida antes de devolverlo, igual que en el enrolamiento: un cert que no está
-    // firmado por la maestra que ya conocemos, o que no es para esta llave, no se guarda.
-    if (res.acta?.profileId !== masterPubkey) throw new Error('the record is from a profile other than the pinned one')
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...contexto(res.acta) })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
+    // Se valida antes de devolverlo, igual que en el enrolamiento: un cert que no firmó la
+    // bóveda que ya conocemos, o que no es para esta llave, no se guarda.
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: masterPubkey, sub: device.publickey })
+    if (!chk.ok) throw new Error('invalid renewed cert: ' + chk.reason)
     return { cert: res.cert }
   } finally { client.close() }
 }