@dotrino/vaultd 0.21.0 → 0.23.0

package/lib/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/lib/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/lib/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/lib/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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.21.0",
+  "version": "0.23.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.41.0",
+    "@dotrino/identity": "^0.43.0",
     "@dotrino/proxy-client": "^0.10.0",
     "ws": "^8.18.0"
   },

package/src/daemon.js

@@ -222,10 +222,14 @@ export async function runDaemon () {
           console.log('[vault] permissions updated: %s', capsReq.caps.join(', ') || '(ninguno)')
         } catch (e) { console.error('[vault] could not change permissions:', e.message) }
       }
+      // Quitar un dispositivo: se pide por `sub` (la llave del aparato). `nonce` sigue
+      // aceptado para una consola vieja, pero retira UN certificado, no el aparato.
       const req = readJsonSafe(revokeReqFile)
-      if (req?.nonce) {
-        try { await targetOf(req)?.revokeDevice(req.nonce); console.log('[vault] revoked nonce=%s', req.nonce) }
-        catch (e) { console.error('[vault] revocation failed:', e.message) }
+      if (req?.sub || req?.nonce) {
+        try {
+          await targetOf(req)?.revokeDevice(req.sub ? { sub: req.sub } : { nonce: req.nonce })
+          console.log(req.sub ? '[vault] device removed' : '[vault] revoked nonce=%s', req.nonce || '')
+        } catch (e) { console.error('[vault] revocation failed:', e.message) }
         rm(revokeReqFile)
       }
       // Secretos de servicios: `secret set/rm` del CLI. El archivo con el valor

package/src/tui/app.js

@@ -70,6 +70,24 @@ const shortScope = (scope) => {
   return arr.map((s) => String(s).replace(/^vault:/, '')).join(',') || '—'
 }
 
+/**
+ * Un aparato = una llave (`sub`), aunque tenga varios certificados vigentes. Se queda con
+ * el de vencimiento más lejano (el último emitido) y suma los alcances de todos, para que
+ * la fila no prometa menos de lo que el aparato puede hacer de verdad.
+ */
+function groupByDevice (issued) {
+  const by = new Map()
+  for (const d of issued) {
+    const key = d.sub || d.deviceId || d.nonce
+    const prev = by.get(key)
+    if (!prev) { by.set(key, { ...d, certCount: 1, scope: [...(Array.isArray(d.scope) ? d.scope : [d.scope])] }); continue }
+    prev.certCount++
+    for (const s of (Array.isArray(d.scope) ? d.scope : [d.scope])) if (!prev.scope.includes(s)) prev.scope.push(s)
+    if ((d.exp || 0) > (prev.exp || 0)) { prev.exp = d.exp; prev.nonce = d.nonce; prev.label = d.label || prev.label }
+  }
+  return [...by.values()]
+}
+
 function activeProfile (st) {
   const list = st.profiles?.profiles || []
   return list.find((p) => p.current) || list[0] || null
@@ -172,13 +190,17 @@ function deviceRows (st, t) {
     rows.push({ text: t.warn(i.pendingDevice(pend.deviceId)) + t.muted(i.pendingHint), sel: false })
     rows.push({ text: '', sel: false })
   }
-  const issued = st.devices?.issued || []
+  // UNA FILA POR APARATO, no por certificado. Antes se pintaba `issued` tal cual y un
+  // aparato con dos certs (el viejo + el de la renovación) salía dos veces: parecían dos
+  // máquinas. Se agrupa por llave y se muestra el cert vigente más largo.
+  const issued = groupByDevice(st.devices?.issued || [])
   if (!issued.length) {
     rows.push({ text: t.muted(i.noDevices), sel: false })
   }
   for (const d of issued) {
     const label = d.label || t.muted(i.noLabel)
-    const line = ` ${t.bold(d.deviceId)}  ${label}  ${t.muted('scope:' + shortScope(d.scope))}  ${t.muted('exp:' + fmtExp(d.exp))}  ${t.muted('nonce:' + (d.nonce ?? '—'))}`
+    const extra = d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : ''
+    const line = ` ${t.bold(d.deviceId)}  ${label}  ${t.muted('scope:' + shortScope(d.scope))}  ${t.muted('exp:' + fmtExp(d.exp))}${extra}`
     rows.push({ text: line, sel: true, meta: d })
   }
   const revoked = st.devices?.revoked || []
@@ -523,12 +545,13 @@ async function onKeyDevices (term, st, key) {
     if (!st.pending) { flash(st, i.noPendingToReject, 'warn'); return true }
     const r = await guard(term, st, i.rejecting, () => vc.rejectPending(st.pending.deviceId, activeId(st)))
     if (r.ok) { flash(st, i.deviceRejected); st.pending = null }
-  } else if ((ch === 'v' || key.name === 'delete') && cur?.nonce != null) { // revocar el enrolado seleccionado
+  } else if ((ch === 'v' || key.name === 'delete') && (cur?.sub || cur?.nonce != null)) { // quitar el aparato seleccionado
     setConfirm(st, {
       text: i.revokeConfirm(cur.deviceId),
       onYes: async () => {
         st.confirm = null
-        const r = await guard(term, st, i.revoking, () => vc.revokeDevice(cur.nonce, activeId(st)))
+        // Por `sub`: se le retiran TODOS los certificados, no solo el de esta fila.
+        const r = await guard(term, st, i.revoking, () => vc.revokeDevice({ sub: cur.sub, nonce: cur.nonce }, activeId(st)))
         if (r.ok) { flash(st, i.deviceRevoked(cur.deviceId)); st.devices = r.v; st.sel.devices = 0 }
       },
       onNo: () => { st.confirm = null }

package/src/vault.js

@@ -331,6 +331,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.RENEW) return await handleRenew(from, payload)
       if (payload.type === MSG.SECRETS) return await handleSecrets(from, payload)
       if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
+      if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
@@ -456,6 +457,34 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
   })
 
+  /**
+   * RENUNCIA: un miembro se quita capacidades a sí mismo y la bóveda la SELLA en el acta.
+   *
+   * NO se pide certificado, y es a propósito: el registro va firmado por el propio miembro
+   * y solo puede QUITAR, así que honrarlo no puede hacer daño — y exigir un cert válido
+   * dejaría fuera justo el caso que la justifica (un aparato que ya no es de fiar, o cuyo
+   * cert caducó). Sin esto la renuncia se quedaba en el dispositivo: la bóveda seguía
+   * teniendo escrito que podía firmar y le seguía aceptando peticiones.
+   */
+  async function handleRenounce (from, p) {
+    const record = p?.data?.record || p?.record
+    if (!record || typeof record !== 'object') return reply(from, { type: MSG.ERROR, error: 'renounce: record required' })
+    if (!(await Acta.verifyRenounce(record).catch(() => false))) {
+      audit('rejected', { what: 'renounce', reason: 'signature' })
+      return reply(from, { type: MSG.ERROR, error: 'renounce: the signature is not the member own' })
+    }
+    try {
+      const r = await identity.absorbRenounce(record)
+      const device = await deviceIdOf(record.member).catch(() => null)
+      audit('renounce', { device, caps: record.caps })
+      log(`[vault] ${device} renounced: ${(record.caps || []).join(', ')}`)
+      await notifyMembers('renounce', { deviceId: device, caps: record.caps })
+      reply(from, { type: MSG.RENOUNCE_RESULT, ok: true, seq: r?.seq ?? null })
+    } catch (e) {
+      reply(from, { type: MSG.ERROR, error: 'renounce: ' + e.message })
+    }
+  }
+
   async function handleAdmin (from, p) {
     // La frescura se comprueba aquí (es del transporte, igual que en el resto de
     // handlers); el resto de la regla vive en el módulo puro.
@@ -505,9 +534,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       await notifyMembers('label', { deviceId: device, label: r?.label ?? label })
       return r
     },
-    revokeDevice: async (nonce) => {
-      const r = await desk.revoke(nonce)
-      await notifyMembers('revoked', { certNonce: nonce, by: 'pc' })
+    // QUITAR EL DISPOSITIVO. Se identifica por su llave (`sub`), no por un `nonce`: un
+    // aparato puede tener varios certificados y retirar uno no lo echaba de la bóveda.
+    // Se sigue aceptando `{ nonce }` para no romper una consola vieja en vuelo.
+    revokeDevice: async (target) => {
+      const sub = typeof target === 'object' && target ? target.sub : null
+      if (!sub) {
+        const nonce = typeof target === 'string' ? target : target?.nonce
+        const r = await desk.revoke(nonce)
+        await notifyMembers('revoked', { certNonce: nonce, by: 'pc' })
+        return r
+      }
+      const r = await desk.revokeDevice(sub)
+      audit('revoke-device', { device: await deviceIdOf(sub).catch(() => null), certs: r?.nonces?.length ?? null })
+      await notifyMembers('revoked', { deviceId: await deviceIdOf(sub).catch(() => null), by: 'pc' })
       return r
     },
     close () {

package/src/vaultControl.js

@@ -245,10 +245,15 @@ export async function setDeviceCaps (pub, caps, profile) {
   return listDevices(profile)
 }
 
-/** Revoca un dispositivo por su `nonce` (le ordena autoborrarse) y revuelca. */
-export async function revokeDevice (nonce, profile) {
+/**
+ * Quita un dispositivo por su llave `sub` (le ordena autoborrarse) y revuelca.
+ * Se acepta un `nonce` suelto por compatibilidad, pero eso retira UN certificado:
+ * un aparato puede tener varios y seguiría entrando con el otro.
+ */
+export async function revokeDevice (target, profile) {
   requireAlive()
-  writeReq(F.revokeReq, { nonce }, profile)
+  const req = typeof target === 'string' ? { nonce: target } : { sub: target?.sub, nonce: target?.nonce }
+  writeReq(F.revokeReq, req, profile)
   signalOrCleanup('SIGUSR2', [F.revokeReq])
   await sleep(300)
   return listDevices(profile)