@dotrino/vault 0.19.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.19.0",
+  "version": "0.21.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,13 +127,22 @@ 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.
+      // QUITAR UN DISPOSITIVO se hace por `sub` (su llave): sale del acta Y se le retiran
+      // todos los certificados. Las dos cosas o ninguna.
+      //
+      // `certNonce` retira UN PAPEL y nada más — el aparato sigue siendo miembro. Sirve
+      // para eso y solo para eso, y se conserva por compatibilidad, pero no es «quitar»:
+      // usarlo para quitar dejaba un miembro sin certificados al que la bóveda ya nunca le
+      // mandaba el aviso de expulsión (mientras siga en el acta, un papel retirado
+      // significa «renueva»). Ese era el dispositivo fantasma.
       if (data.op === 'revoke') {
         if (data.sub) {
+          const deviceId = await deviceIdOf(String(data.sub)).catch(() => null)
           const r = await desk.revokeDevice(String(data.sub))
-          audit('admin.revoke-device', { by, certs: r?.nonces?.length ?? null })
-          await notify('revoked', { by })
+          audit('admin.revoke-device', { by, device: deviceId, certs: r?.nonces?.length ?? null })
+          // Con el `deviceId`: el aviso a los demás dispositivos tiene que decir a QUIÉN
+          // quitaron, o no se puede saber si el que sobra eres tú.
+          await notify('revoked', { deviceId, by })
           return { ok: true, result: r || { ok: true } }
         }
         const r = await desk.revoke(String(data.certNonce || ''))

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

@@ -206,8 +206,14 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     reject: (deviceId) => desk.reject(deviceId),
     listPending: desk.listPending,
     listMachines,
-    // Revoca y AVISA a la máquina con un REVOKED firmado para que se auto-borre (ahora si
-    // está online, o al reaparecer vía handleDevices).
+    // QUITA LA MÁQUINA entera (por su llave): fuera del acta y sin ningún certificado
+    // vigente, que son las dos caras del mismo acto. Y AVISA con un REVOKED firmado para
+    // que se auto-borre (ahora si está online, o al reaparecer vía handleDevices).
+    revokeDevice: (sub) => desk.revokeDevice(sub),
+    // Retira UN certificado. No es quitar la máquina: sigue siendo miembro del acta, y
+    // quien queda así ya no recibe el aviso de expulsión (mientras siga en el acta, un
+    // papel retirado significa «renueva»). Usar `revokeDevice` salvo que quieras
+    // exactamente esto.
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },

package/src/revocation.js

@@ -0,0 +1,67 @@
+/**
+ * revocation.js — CUÁNDO se le dice a un aparato que ya no es de casa.
+ *
+ * Módulo PURO (sin red, sin disco, sin `node:*`), como `enroll.js` y `admin.js`: la regla
+ * vive en un solo sitio, se lee entera y se prueba sin levantar nada.
+ *
+ * EL PROBLEMA QUE RESUELVE. Un dispositivo al que quitaron del perfil no se entera por su
+ * cuenta: lo único que le borra la cuenta es un aviso FIRMADO por la maestra
+ * (`vault.revoked`). Un «unauthorized» suelto no vale y no debe valer — no va firmado, así
+ * que cualquiera podría destruir datos ajenos con un mensaje (el wipe-DoS de
+ * `docs/pairing-protocol.md §2.3`). Por eso la bóveda tiene que **atender** la conexión de
+ * un aparato que fue suyo, aunque su papel ya no sirva, precisamente para poder mandarlo a
+ * paseo. Si no lo hace, el aparato se queda enseñando una cuenta que ya no existe.
+ *
+ * LA REGLA, en una línea: papel nuestro + ya no está en el acta ⇒ se le avisa.
+ */
+
+/**
+ * Motivos de rechazo de `verifyChain` que significan «este papel ya no sirve».
+ *
+ * Los tres se producen DESPUÉS de que `verifyChain` haya comprobado la firma del propio
+ * aparato y la del certificado, así que quien llega hasta aquí demostró tener la llave que
+ * el certificado nombra. El resto de motivos (`shape`, `bad-signature`,
+ * `bad-action-signature`, `cert-device-mismatch`, `untrusted-issuer`…) son ruido o gente
+ * ajena: ahí no hay a quién avisar de nada.
+ */
+export const STALE_PAPER = Object.freeze(['revoked', 'expired', 'scope'])
+const STALE = new Set(STALE_PAPER)
+
+/** ¿El motivo del rechazo es «tu papel ya no sirve»? */
+export const isStalePaper = (reason) => STALE.has(reason)
+
+/**
+ * ¿Hay que mandarle el aviso firmado de expulsión?
+ *
+ * @param {Object} o
+ * @param {string} o.reason      por qué falló `verifyChain`.
+ * @param {string} o.pubkey      la llave del aparato que acaba de escribir.
+ * @param {string} o.master      la maestra de ESTA bóveda.
+ * @param {string|null} [o.certIss]  quién firmó el certificado que presentó.
+ * @param {Array<{pub:string}>|null} [o.members]  miembros del acta; `null` = no hay acta.
+ * @param {boolean} [o.knownRevoked]  consta explícitamente como revocado en las
+ *   delegaciones. Es el único criterio que queda cuando no hay acta.
+ * @returns {boolean}
+ */
+export function shouldNotifyRevoked ({ reason, pubkey, master, certIss = null, members = null, knownRevoked = false } = {}) {
+  if (typeof pubkey !== 'string' || !pubkey) return false
+  if (!isStalePaper(reason)) return false
+  // Que el papel sea NUESTRO. No hace falta que siga siendo válido —justo por eso estamos
+  // aquí— pero sí que lo haya firmado esta maestra: es lo que separa a un aparato que fue
+  // de casa de uno que pasaba por ahí.
+  if (certIss && master && certIss !== master) return false
+  // El aparato no puede echarse a sí mismo, y la maestra tampoco se echa.
+  if (master && pubkey === master) return false
+
+  // EL ACTA MANDA, y es lo único que manda. Un certificado retirado o vencido NO significa
+  // «estás fuera»: renovar retira el anterior y cambiar permisos obliga a renovar, así que
+  // un aparato de casa con un papel viejo solo tiene que renovar. Decirle «estás fuera»
+  // ahí lo borraba solo: dabas «administra» y el dispositivo desaparecía.
+  if (Array.isArray(members)) return !members.some((m) => m?.pub === pubkey)
+
+  // Sin acta (bóveda anterior al acta) no se puede saber quién es del perfil: solo se
+  // avisa a quien conste explícitamente como revocado.
+  return !!knownRevoked
+}
+
+export default { STALE_PAPER, isStalePaper, shouldNotifyRevoked }