@dotrino/vault 0.63.0 → 0.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.63.0",
+  "version": "0.65.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",
@@ -50,7 +50,7 @@
     "pairing"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.73.1",
+    "@dotrino/identity": ">=0.92.0",
     "@dotrino/proxy-client": ">=0.18.0"
   },
   "license": "MIT",

package/src/enroll.js

@@ -349,23 +349,50 @@ export function createEnrollDesk ({
       return { ok: true, deviceId: pend.deviceId, adopting: true }
     }
 
-    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
-
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
     // credencial y el acta es la política, y no tiene sentido emitir una sin la otra.
     // Las capacidades salen del scope que se pidió al emparejar (cert ∩ acta, §2.3).
-    let record = null
+    //
+    // NADA DE REPLIEGUES (2026-09-17). Esto antes estaba envuelto en un `catch` que solo
+    // anotaba el error, y además se saltaba en silencio si la identidad no sabía admitir o si
+    // el scope no daba ninguna capacidad: el aparato recibía su certificado SIN estar en el
+    // acta, y el fallo aparecía después y en otro sitio. Ahora, si no se puede admitir, no
+    // se entrega nada y se dice.
+    if (typeof identity.admitMember !== 'function') {
+      throw Object.assign(new Error('this vault cannot add devices to the account record: no certificate was issued'), { code: 'admit-unavailable' })
+    }
+    // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
+    // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
+    // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    const cn = scopeToCn(pend.scope)
+    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    if (!caps.length) {
+      throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
+    }
+
+    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
+
     try {
-      if (typeof identity.admitMember === 'function') {
-        // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
-        // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
-        // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
-        const cn = scopeToCn(pend.scope)
-        const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+    } catch (e) {
+      // El certificado ya está firmado y no se entrega: se revoca, para que no quede uno
+      // válido suelto. Si ni eso sale, se dice también.
+      let revoked = true
+      try { await identity.revokeDelegation(cert.nonce) } catch (re) {
+        revoked = false
+        log('[vault] could not revoke the undelivered certificate %s: %s', cert.nonce, re.message)
       }
-      record = (await identity.profileActa?.())?.acta || null
-    } catch (e) { log('[vault] could not admit into the record:', e.message) }
+      audit('rejected', { what: 'approve', device: pend.deviceId, reason: 'admit-failed' })
+      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not add this device to the account: pairing failed, try again' })
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      log('[vault] could not add %s to the record, no certificate was delivered: %s', pend.deviceId, e.message)
+      throw Object.assign(
+        new Error(`could not add the device to the account record (${e.message}): no certificate was delivered${revoked ? '' : ', and the signed one could not be revoked'}`),
+        { code: 'admit-failed', cause: e }
+      )
+    }
+    const record = (await identity.profileActa?.())?.acta || null
 
     audit('enroll', { device: pend.deviceId, label: pend.label || '', scope: pend.scope })
     // Echamos el código tipeado junto al cert: el DISPOSITIVO acepta solo si coincide

package/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