@dotrino/vaultd 0.53.0 → 0.58.0

package/lib/src/service.js

@@ -23,8 +23,7 @@ import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
   makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
-  verifyDeviceSig, makePairingCode, commitCode, pubkeyId
-} from '@dotrino/identity/capabilities'
+  verifyDeviceSig, makePairingCode, commitCode, pubkeyId, PEER_SKEW_MS } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
 import { verifyActa, sealKeyAt } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
@@ -298,7 +297,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     const res = await enrolled
 
     if (res.code !== code) throw new Error('the vault echoed a code other than the one shown (possible malicious relay)')
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...(expectedScope ? { expectedScope } : {}) })
+    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS, ...(expectedScope ? { expectedScope } : {}) })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
     if (res.cert.iss !== qr.iss) throw new Error('cert signed by a master other than the one in the QR')
 
@@ -440,7 +439,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
         client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
         const res = await pending
         if (res.type === MSG.RENEWED && res.cert?.sub === device.publickey) {
-          const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, expectedScope: secretsScope(ns) })
+          const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS, expectedScope: secretsScope(ns) })
           if (v.ok) { cert = res.cert; if (dir && saved) writeServiceIdentity(dir, { ...saved, cert }) }
         }
       } catch (_) { /* la renovación no bloquea el fetch */ }
@@ -458,8 +457,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // verdad llega cuando el aparato que aprueba firme — por esta misma conexión, que
     // sigue identificada. Se espera lo que dura el pedido; denegado o vencido es error.
     if (res.body?.op === 'secrets.pending' && res.body.ns === ns) {
-      const okPending = await verifyDeviceSig({ publickey: masterPubkey, data: res.body, signature: res.signature })
-      if (!okPending) throw new Error('invalid master signature on the pending reply')
+      await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey })
       try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
       res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
@@ -467,14 +465,20 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       if (res.type === MSG.ERROR) throw new Error(res.error)
     }
 
-    // Autenticidad: el cuerpo viene firmado por la MAESTRA pineada.
+    // AUTENTICIDAD: la firma NO es de la maestra. El acta dice qué llave vale para esto
+    // (`sealPub`, buscada por `seq`), que es la misma regla que ya gobierna los sobres.
+    // La maestra solo sella el acta y reenvuelve; servir no es cosa suya, y por eso puede
+    // quedarse cerrada.
     const body = res.body
     if (!body || body.op !== 'secrets.result' || body.ns !== ns) throw new Error('malformed secrets reply')
     if (typeof body.ts !== 'number' || Math.abs(Date.now() - body.ts) > FRESH_WINDOW_MS) throw new Error('stale secrets reply')
-    const ok = await verifyDeviceSig({ publickey: masterPubkey, data: body, signature: res.signature })
-    if (!ok) throw new Error('invalid master signature on the secrets reply')
 
+    // Se abre ANTES de comprobar la firma, y no es un descuido: el sobre de fuera va
+    // sellado a la efímera que acabamos de estrenar, así que abrirlo no prueba nada ni
+    // confía en nadie — solo saca el acta con la que SÍ se comprueba. Nada de lo que hay
+    // dentro se usa hasta después de verificar.
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
+    await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey })
 
     // DOS CAPAS DE SOBRE, y hacen cosas distintas:
     //   · la de fuera (`ek` efímera, recién abierta) tapa el TRAMO — el proxio no ve
@@ -499,6 +503,40 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
  * omitido: silenciarlo convertiría una rotación mal sellada en «el servicio sigue
  * con el valor viejo y nadie se entera», que es el peor modo de fallo de todo esto.
  */
+/**
+ * ¿QUIÉN CONTESTÓ, Y PUEDE? La misma regla que gobierna los sobres, aplicada al
+ * transporte: **el acta dice qué llave firma qué**.
+ *
+ * La maestra no entra aquí. Sus dos trabajos son sellar el acta y reenvolver los sobres
+ * de todos los aparatos; servir una petición no es ninguno de los dos, así que exigir su
+ * firma la obligaba a estar despierta todo el tiempo — y de paso hacía imposible que
+ * sirviera nadie más.
+ *
+ * Lo que se comprueba, en orden:
+ *   1. el acta que llega va firmada por la maestra que este agente lleva pineada desde
+ *      que se enroló (o por la que aquella nombró al traspasar);
+ *   2. la firma del cuerpo cuadra con la llave de sellado que ESA acta nombra para el
+ *      `seq` con el que se firmó.
+ *
+ * Sin el paso 1 el paso 2 no vale nada: un acta cualquiera nombraría la llave que
+ * quisiera.
+ */
+export async function verifyResponder ({ body, seal, acta, masterPubkey }) {
+  if (!seal?.sig || typeof seal.seq !== 'number') {
+    throw new Error('the reply carries no sealing signature: this vault is too old to serve (update it)')
+  }
+  if (!acta) throw new Error('the reply carries no record: cannot tell which key was allowed to sign it')
+  if (acta.sealedBy !== masterPubkey) {
+    throw new Error('the record was not sealed by the master this agent knows: refusing the reply')
+  }
+  if (!(await verifyActa({ acta })).ok) throw new Error('the record does not verify')
+  const pub = sealKeyAt(acta, seal.seq)
+  if (!pub) throw new Error(`the record names no sealing key for #${seal.seq}`)
+  if (!(await verifyDeviceSig({ publickey: pub, data: body, signature: seal.sig }))) {
+    throw new Error('the reply signature does not check out against the key the record names')
+  }
+}
+
 /**
  * ¿SALIÓ ESTE SOBRE DE MI BÓVEDA? (§8.8 de `dotrino-vault/docs/secretos-sellados.md`)
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.53.0",
+  "version": "0.58.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": {
@@ -20,8 +20,8 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.61.0",
-    "@dotrino/passmanager": "^0.1.0",
+    "@dotrino/identity": "^0.64.0",
+    "@dotrino/passmanager": "^0.9.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"
   },
@@ -44,7 +44,7 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "^0.3.2",
+    "@dotrino/remote-agent": "^0.5.3",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
   }

package/src/client.js

@@ -11,7 +11,7 @@
  * 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, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId, PEER_SKEW_MS } from '@dotrino/identity/capabilities'
 import { installNodeGlobals } from './node-globals.js'
 import { MSG } from './protocol.js'
 
@@ -84,7 +84,7 @@ export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeout
     const res = await enrolled
 
     // VALIDACIÓN ESTRICTA antes de persistir (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: device.publickey, skewMs: PEER_SKEW_MS })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
     if (res.cert.iss !== qr.iss) throw new Error('cert signed by a master other than the one you saw (possible malicious proxy)')
     if (res.cert.sub !== device.publickey) throw new Error('cert issued for a different device')
@@ -151,7 +151,7 @@ export async function requestRenew ({ masterPubkey, proxyUrl, device, cert, dir
     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.
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey })
+    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
     if (res.cert.iss !== masterPubkey) throw new Error('cert signed by a master other than the pinned one')
     return { cert: res.cert }