@dotrino/vault 0.20.0 → 0.22.0

package/README.md

@@ -50,7 +50,7 @@ si la máquina se compromete, revocas el cert y no había nada que robar.
 ```bash
 # en el VAULT (tu PC): abres el emparejamiento del servicio y cargas sus secretos
 dotrino-vault pair --service miapp          # invitación con scope SOLO vault:secrets:miapp
-dotrino-vault secret set miapp API_KEY  sk-…
+dotrino-vault secret set miapp API_KEY  sk-…   # la comparten TODAS las máquinas del ns
 
 # en el PROYECTO/servidor: enrola esta máquina (pega la invitación)
 npx dotrino-env enroll --ns miapp
@@ -60,6 +60,17 @@ npx dotrino-env enroll --ns miapp
 dotrino-vault approve 7K3F-92Q1
 ```
 
+Si la misma app corre en **varias máquinas**, lo que cambia de una a otra (el puerto,
+la URL pública) va en el cajón **por aparato**, sin partir el `ns`:
+
+```bash
+dotrino-vault devices                                   # el ID del aparato: AB12-CD34
+dotrino-vault secret device set AB12-CD34 PORT 8443     # solo la lee ESA máquina
+```
+
+Llegan **mezcladas en el mismo bundle** —y por lo tanto en el mismo `process.env`—:
+las del scope, con las del aparato **encima** si se llaman igual.
+
 El código lo **genera el servicio** y **no viaja** por la red: el vault solo puede
 echarlo de vuelta si un humano lo tipeó. Así, un vault falso no puede enrolarte y
 aprobar a ciegas no enrola a nadie. Queda `~/.dotrino/service/<ns>/service-identity.json`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.20.0",
+  "version": "0.22.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/enroll.js

@@ -104,13 +104,16 @@ export async function deviceIdOf (pub) {
  * @param {(...a:any[])=>void} [opts.log]
  * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
  * @param {()=>void} [opts.onPendingChange]
+ * @param {(sub:string)=>void} [opts.onDeviceRemoved]  se quitó un aparato (fuera del acta y sin papeles):
+ *   para que quien guarde algo indexado por esa llave lo suelte. Se avisa desde AQUÍ y no desde
+ *   quien llama porque a `revokeDevice` se entra por dos puertas (el PC y la consola remota).
  * @param {string[]} [opts.defaultScope]
  * @param {number} [opts.defaultTtlMs]
  */
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {}, onDeviceRemoved = () => {},
   defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
   // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
   // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
@@ -461,6 +464,7 @@ export function createEnrollDesk ({
           return done
         })() }
     await emitRevoke(sub, mine[0]?.nonce || null)
+    fire(onDeviceRemoved, sub)
     return res
   }
 

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 }