@dotrino/vaultd 0.117.0 → 0.119.0

package/lib/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/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.119.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"
   },
@@ -48,7 +48,7 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "0.6.1",
+    "@dotrino/remote-agent": "0.10.0",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
   },

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() }
 }

package/src/ctl.js

@@ -1864,7 +1864,14 @@ export async function runCtl (argv) {
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])
     case 'secret': return cmdSecret(rest)
-    case 'approval': return cmdApproval(rest)
+    // `approval` se quitó el 2026-09-01 (ahora es el permiso `unattended`), pero la ruta se
+    // quedó apuntando a una función que ya no existía: reventaba con un ReferenceError. Se
+    // rechaza en voz alta, igual que `caps +approval`.
+    case 'approval':
+      console.error('`dotrino-vault approval` ya no existe. Pedir aprobación es el DEFECTO; lo que se concede es lo contrario:')
+      console.error('  dotrino-vault caps <ID> +desatendido   ← se lleva las claves privadas sin aprobación')
+      console.error('  dotrino-vault caps <ID> -desatendido   ← vuelve a pedir aprobación')
+      process.exit(2)
     case 'atrest': return cmdAtrest(rest)
     case 'activity': return cmdActivity(Number(rest.find((a) => /^\d+$/.test(a))) || 30, {
       verify: rest.includes('--verify'), exportar: rest.includes('--export')