@dotrino/vaultd 0.23.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.23.0",
+  "version": "0.24.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": {
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.43.0",
+    "@dotrino/identity": "^0.44.0",
     "@dotrino/proxy-client": "^0.10.0",
     "ws": "^8.18.0"
   },

package/src/ctl.js

@@ -410,13 +410,27 @@ async function cmdDevices () {
   let snap = null
   for (let i = 0; i < 50; i++) { await sleep(100); const d = readJson(devFile, null); if (d?.at) { snap = d; break } }
   if (!snap) { console.error('El daemon no respondió.'); process.exit(1) }
-  const active = snap.issued || snap.active || snap.delegations || []
   const revoked = snap.revoked || []
+  const fuera = new Set(revoked.map((r) => r?.nonce || r))
+  // UN APARATO, UNA LÍNEA. El daemon lleva la cuenta por CERTIFICADO —correcto para él,
+  // porque revocar es revocar un papel—, pero renovar emite uno nuevo cada 30 días: un
+  // aparato de un año salía doce veces, y los ya retirados seguían contando como
+  // enrolados. Se agrupa por llave y se dice cuántos certificados tiene.
+  const porLlave = new Map()
+  for (const d of (snap.issued || snap.active || snap.delegations || [])) {
+    if (d.revokedAt || fuera.has(d.nonce)) continue
+    const clave = d.sub || d.nonce
+    const y = porLlave.get(clave)
+    if (!y) porLlave.set(clave, { ...d, certs: 1 })
+    else { y.certs++; if ((d.exp || 0) > (y.exp || 0)) Object.assign(y, { ...d, certs: y.certs }) }
+  }
+  const active = [...porLlave.values()]
   console.log('Dispositivos enrolados: %d', active.length)
   for (const d of active) {
     const did = d.sub ? await deviceIdOf(d.sub) : '????-????'
-    console.log('  · %s  %s%s%s', did, d.label || '(sin etiqueta)',
-      d.exp ? '  exp=' + new Date(d.exp).toISOString() : '',
+    console.log('  · %s  %s%s%s%s', did, d.label || '(sin etiqueta)',
+      d.exp ? '  vence=' + new Date(d.exp).toISOString().slice(0, 10) : '',
+      d.certs > 1 ? '  (' + d.certs + ' certificados)' : '',
       d.nonce ? '  nonce=' + d.nonce : '')
   }
   if (revoked.length) {
@@ -426,12 +440,29 @@ async function cmdDevices () {
   console.log('\nPara revocar uno (y ordenarle autoborrarse):  dotrino-vault revoke <nonce>')
 }
 
-function cmdRevoke (nonce) {
-  if (!nonce) { console.error('uso: dotrino-vault revoke <nonce>'); process.exit(2) }
+/**
+ * `dotrino-vault revoke <ID|nonce>` — quita un dispositivo.
+ *
+ * Con el IDENTIFICADOR del aparato (`AB12-CD34`) se le retiran TODOS sus certificados,
+ * que es lo que la gente quiere decir con «quitar este dispositivo»: renovar emite uno
+ * nuevo cada 30 días, así que quitar solo el último dejaba vivos los anteriores hasta que
+ * caducaran — quitarlo sin quitarlo. Con un `nonce` suelto se retira ese y solo ese, que
+ * sigue siendo útil para casos finos.
+ */
+async function cmdRevoke (arg) {
+  if (!arg) { console.error('uso: dotrino-vault revoke <ID|nonce>   (el ID quita el aparato entero)'); process.exit(2) }
+  const esId = /^[0-9a-f]{4}-?[0-9a-f]{4}$/i.test(arg)
   const s = requireDaemon()
-  writeReq('revoke-request.json', { nonce })
+  if (esId) {
+    const m = await buscarMiembro(arg.toUpperCase().includes('-') ? arg.toUpperCase() : arg.toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
+    writeReq('revoke-request.json', { sub: m.pub })
+    avisar(s.pid, 'SIGUSR2')
+    console.log('Quitado %s (todos sus certificados). Se autoborrará al reconectar. Verifica: dotrino-vault devices', m.id)
+    return
+  }
+  writeReq('revoke-request.json', { nonce: arg })
   avisar(s.pid, 'SIGUSR2')
-  console.log('Revocación enviada para nonce=%s. El dispositivo se autoborrará al reconectar. Verifica: dotrino-vault devices', nonce)
+  console.log('Revocación enviada para nonce=%s. El dispositivo se autoborrará al reconectar. Verifica: dotrino-vault devices', arg)
 }
 
 /**
@@ -671,7 +702,7 @@ function help () {
   members             el acta del perfil: quién es tuyo y qué puede hacer
   label <ID> <nombre> renombra un dispositivo (el nombre con el que lo reconoces)
   caps <ID> ±permiso  cambia permisos (+firma -guarda +administra …)
-  revoke <nonce>      revoca un dispositivo (le ordena autoborrarse)
+  revoke <ID|nonce>   quita un dispositivo (con el ID, todos sus certificados)
   activity [n]        bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
   logs                últimos logs del servicio
   version             muestra la versión instalada

package/src/vault.js

@@ -217,10 +217,40 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   // Lista (solo lectura) de dispositivos enrolados, para un panel en el navegador.
   // Cualquier cert válido tuyo puede verla; REVOCAR sigue siendo solo desde el PC.
+  /**
+   * Un aparato REVOCADO que vuelve a aparecer: se le reemite el `vault.revoked` FIRMADO
+   * para que se entere y se auto-borre.
+   *
+   * Un «unauthorized: revoked» suelto no basta y no debe bastar: no va firmado, así que
+   * el dispositivo tiene prohibido borrar nada con él (si no, cualquiera destruiría datos
+   * ajenos con un mensaje). Lo único que puede borrar es un aviso firmado por la maestra
+   * — y hasta ahora el daemon no lo reemitía nunca. Si el aparato estaba apagado cuando lo
+   * quitaste, no se enteraba jamás: seguía enseñando el perfil como si nada.
+   */
+  async function avisarSiRevocado (pubkey) {
+    if (typeof pubkey !== 'string') return
+    try {
+      // OJO con dónde se buscan: desde identity 0.42 `issued` es «lo que HOY sirve para
+      // entrar», así que los retirados NO están ahí — viven en `revokedCerts`. Buscarlos
+      // en `issued` no daba error, daba una lista vacía y ningún aviso.
+      const dele = await identity.listDelegations()
+      const revocados = await revocationSet()
+      const candidatos = [...(dele.revokedCerts || []), ...(dele.issued || [])]
+      const suyas = candidatos.filter((x) => x.sub === pubkey && (x.revokedAt || revocados.has(x.nonce)))
+      if (suyas.length) {
+        await desk.emitRevoke(pubkey, suyas[0].nonce)
+        audit('revoke.notified', { device: await deviceIdOf(pubkey).catch(() => null) })
+      }
+    } catch (e) { log('[vault] could not re-emit the revocation:', e.message) }
+  }
+
   async function handleDevices (from, p) {
     if (!isFresh(p.data)) return staleReply(from)
     const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, trustedIssuer: master, revoked: await revocationSet() })
-    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+    if (!chk.ok) {
+      if (chk.reason === 'revoked') await avisarSiRevocado(p.data?.publickey)
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+    }
     const { issued, revoked } = await identity.listDelegations()
     // El acta viaja con la lista: así cada dispositivo se entera de los cambios de
     // política (quién manda, quién puede qué) sin un canal aparte.

package/src/vaultControl.js

@@ -196,10 +196,36 @@ export async function listDevices (profile) {
   const { devices } = await snapshot(profile)
   if (!devices) throw coded('the daemon did not reply', 'NO_REPLY')
   const issued = devices.issued || devices.active || devices.delegations || []
+  const revoked = devices.revoked || []
   const withIds = await Promise.all(issued.map(async (d) => ({
     ...d, deviceId: d.sub ? await deviceIdOf(d.sub) : '????-????'
   })))
-  return { issued: withIds, revoked: devices.revoked || [], profile: devices.profile || null }
+  return { issued: agruparPorAparato(withIds, revoked), revoked, profile: devices.profile || null }
+}
+
+/**
+ * UN APARATO, UNA FILA — y sin los certificados retirados.
+ *
+ * El daemon lleva la cuenta por CERTIFICADO, que es lo correcto para él: revocar es
+ * revocar un papel. Pero al dueño le sobra ese detalle — renovar emite uno nuevo cada 30
+ * días, así que un aparato de un año saldría doce veces, y los revocados seguían contando
+ * como «enrolados». Se agrupa por llave, se queda el más nuevo y se guardan TODOS sus
+ * nonces, que es lo que hace falta para retirarlo entero.
+ */
+export function agruparPorAparato (lista, revoked = []) {
+  const fuera = new Set(revoked.map((r) => r?.nonce || r))
+  const porLlave = new Map()
+  for (const d of lista) {
+    if (d.revokedAt || fuera.has(d.nonce)) continue
+    const clave = d.sub || d.nonce
+    const y = porLlave.get(clave)
+    if (!y) porLlave.set(clave, { ...d, nonces: [d.nonce] })
+    else {
+      y.nonces.push(d.nonce)
+      if ((d.exp || 0) > (y.exp || 0)) Object.assign(y, { ...d, nonces: y.nonces })
+    }
+  }
+  return [...porLlave.values()]
 }
 
 /**