@dotrino/vault 0.18.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.18.0",
+  "version": "0.20.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",

package/src/admin.js

@@ -127,7 +127,15 @@ export function createAdminDesk ({
         return { ok: true, result: { ok: true } }
       }
 
+      // Quitar un dispositivo: por `sub` se le retiran TODOS sus certificados. Con
+      // `certNonce` a secas solo cae ese papel, y el aparato puede tener otro vigente.
       if (data.op === 'revoke') {
+        if (data.sub) {
+          const r = await desk.revokeDevice(String(data.sub))
+          audit('admin.revoke-device', { by, certs: r?.nonces?.length ?? null })
+          await notify('revoked', { by })
+          return { ok: true, result: r || { ok: true } }
+        }
         const r = await desk.revoke(String(data.certNonce || ''))
         audit('admin.revoke', { by, certNonce: data.certNonce })
         await notify('revoked', { certNonce: data.certNonce, by })

package/src/enroll.js

@@ -441,9 +441,32 @@ export function createEnrollDesk ({
     return res
   }
 
+  /**
+   * QUITA EL DISPOSITIVO entero: retira TODOS sus certificados vigentes y le manda una
+   * sola orden de autoborrado. `revoke(nonce)` retira un papel, y un aparato puede tener
+   * varios (una renovación dejaba vivo el anterior): quitarle uno no lo echaba, y podía
+   * quedarse dentro justo con el que llevaba `vault:admin`.
+   */
+  async function revokeDevice (sub) {
+    if (!sub) throw new Error('sub (device pubkey) required')
+    const { issued } = await identity.listDelegations()
+    const mine = (issued || []).filter((d) => d.sub === sub)
+    audit('revoke-device', { certs: mine.length })
+    // Si el núcleo no trae `revokeDevice` (bóveda vieja), se cae a retirarlos uno a uno.
+    const res = identity.revokeDevice
+      ? await identity.revokeDevice(sub)
+      : { ok: true, nonces: await (async () => {
+          const done = []
+          for (const d of mine) { await identity.revokeDelegation(d.nonce); done.push(d.nonce) }
+          return done
+        })() }
+    await emitRevoke(sub, mine[0]?.nonce || null)
+    return res
+  }
+
   return {
     startPairing, stopPairing, handleEnroll, handleActaSealed, handleHello, approve, reject,
-    listPending, findPending, emitRevoke, revoke,
+    listPending, findPending, emitRevoke, revoke, revokeDevice,
     get pendingCount () { return pending.size }
   }
 }

package/src/env.js

@@ -172,7 +172,7 @@ export function applyEnv (secrets, override = overrideByDefault()) {
  * @param {Object} [opts]
  * @param {string} [opts.ns]
  * @param {string} [opts.dir]
- * @param {(info:{ns:string, ts:number, motivo:'cambio'|'revocado'})=>void} [opts.onUpdate]
+ * @param {(info:{ns:string, ts:number, reason:'changed'|'revoked'})=>void} [opts.onUpdate]
  *   Reemplaza la salida por defecto. Úsalo cuando terminar el proceso no sea una
  *   opción — el caso del proxio, cuyo reinicio corta el transporte de todos.
  * @param {number} [opts.exitCode=0]  Salida LIMPIA: systemd con `Restart=on-failure`
@@ -183,24 +183,24 @@ export function applyEnv (secrets, override = overrideByDefault()) {
 export async function watchEnv ({ ns, dir, onUpdate, exitCode = 0, quiet = false, ...resto } = {}) {
   ns = resolveNs(ns)
   dir = dir || serviceDir(ns)
-  const decir = (m) => { if (!quiet) console.error(m) }
+  const say = (m) => { if (!quiet) console.error(m) }
 
-  const salir = (motivo) => {
-    decir(`[dotrino-env] ${motivo === 'revocado'
+  const exitNow = (reason) => {
+    say(`[dotrino-env] ${reason === 'revoked'
       ? 'la bóveda REVOCÓ este agente: terminando (no volverá a arrancar)'
       : 'configuración nueva en la bóveda: terminando para que el supervisor lo levante limpio'}`)
-    process.exit(motivo === 'revocado' ? 1 : exitCode)
+    process.exit(reason === 'revoked' ? 1 : exitCode)
   }
 
   return watchSecretsChanges({
     dir,
     ns,
-    log: decir,
-    onChange: ({ ts }) => (onUpdate ? onUpdate({ ns, ts, motivo: 'cambio' }) : salir('cambio')),
+    log: say,
+    onChange: ({ ts }) => (onUpdate ? onUpdate({ ns, ts, reason: 'changed' }) : exitNow('changed')),
     // Un cert revocado sale con código de FALLO a propósito: si el supervisor lo
     // levanta, va a morir otra vez al no poder leer sus secretos, y el contador de
     // reinicios fallidos es lo que hace que se note en vez de girar en silencio.
-    onRevoked: () => (onUpdate ? onUpdate({ ns, ts: Date.now(), motivo: 'revocado' }) : salir('revocado')),
+    onRevoked: () => (onUpdate ? onUpdate({ ns, ts: Date.now(), reason: 'revoked' }) : exitNow('revoked')),
     ...resto
   })
 }

package/src/index.js

@@ -155,14 +155,16 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
     const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
-    const { issued, revoked } = await identity.listDelegations()
+    const { issued, revoked, revokedCerts } = await identity.listDelegations()
     const devices = await Promise.all((issued || []).map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,
       label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
     })))
     send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
-    const mine = (issued || []).find((x) => x.sub === chk.device && x.revokedAt)
+    // Se busca en `revokedCerts`: desde que `issued` solo trae lo vigente, los retirados
+    // ya no están ahí y este aviso dejaba de dispararse (se caía en silencio).
+    const mine = (revokedCerts || issued || []).find((x) => x.sub === chk.device && x.revokedAt)
     if (mine) desk.emitRevoke(chk.device, mine.nonce)
   }
 

package/src/protocol.js

@@ -42,6 +42,8 @@ export const MSG = Object.freeze({
   DEVICES: 'vault.devices',                   // dispositivo → vault: { data:{publickey,ts}, signature, cert }
   DEVICES_RESULT: 'vault.devices.result',     // vault → dispositivo: { devices, revoked }
   RENEW: 'vault.renew',                       // dispositivo → vault: { data:{op,publickey,ts}, signature, cert }
+  RENOUNCE: 'vault.renounce',                 // dispositivo → vault: { record }  (RENUNCIA firmada por el propio miembro)
+  RENOUNCE_RESULT: 'vault.renounce.result',   // vault → dispositivo: { ok, seq }
   RENEWED: 'vault.renewed',                   // vault → dispositivo: { cert }  (cert fresco, misma sub-clave/scope)
   SECRETS: 'vault.secrets',                   // servicio → vault: { data:{op,ns,ek,publickey,ts}, signature, cert }
   SECRETS_RESULT: 'vault.secrets.result',     // vault → servicio: { body:{op,ns,enc,ts}, signature } (enc SELLADO a ek; body firmado por la maestra)