@dotrino/identity 0.41.0 → 0.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -251,6 +251,14 @@ export class Identity {
     return this._call('revokeDelegation', { nonce })
   }
 
+  /**
+   * QUITA EL DISPOSITIVO: retira **todos** los certificados vigentes de esa llave.
+   * Revocar por `nonce` retira un papel; un aparato puede tener otros y seguir entrando.
+   */
+  async revokeDevice (sub) {
+    return this._call('revokeDevice', { sub })
+  }
+
   /** Lista las delegaciones emitidas + la lista de revocación (para el gestor de dispositivos). */
   async listDelegations () {
     return this._call('listDelegations')

package/src/node.js

@@ -160,6 +160,8 @@ export class Identity {
   // Delegación de capacidad (sub-clave de dispositivo con scope/exp/revocación)
   signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
   revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }
+  /** Quitar el DISPOSITIVO: retira todos sus certificados vigentes, no solo uno. */
+  revokeDevice (sub) { return this._h('revokeDevice', { sub }) }
   listDelegations () { return this._h('listDelegations') }
   // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
   profileActa () { return this._h('profileActa') }

package/vault/acta.js

@@ -245,6 +245,15 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         // No se puede ascender un servicio a dispositivo cambiándole las capacidades: para
         // eso hay que sacarlo y volver a admitirlo, que es un gesto visible.
         m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
+        // CONCEDER LIMPIA LA RENUNCIA. `effectiveCaps` resta lo renunciado, así que sin
+        // esto una renuncia sellada era IRREVERSIBLE: el master le devolvía el permiso en
+        // `caps` y la resta seguía dejándolo fuera, para siempre. La interfaz promete
+        // «puedes devolvérselo desde el Master», así que tiene que ser verdad.
+        // Se tira el registro entero y no se le recortan capacidades: va FIRMADO por el
+        // miembro, y editarlo lo dejaría sin firma válida.
+        const renunciadas = new Set()
+        for (const r of next.renounced) if (r.member === m.pub) for (const c of (r.caps || [])) renunciadas.add(c)
+        if (m.caps.some((c) => renunciadas.has(c))) next.renounced = next.renounced.filter((r) => r.member !== m.pub)
         break
       }
       case 'label': {

package/vault/core.js

@@ -22,7 +22,7 @@ import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { pubkeyId as pubkeyIdOf } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestRenounce as remoteRenounce } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -314,6 +314,27 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   }
   const saveRevocations = (o) => kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
 
+  /**
+   * Retira todos los certificados vigentes de la llave `sub`, menos `keepNonce` (el recién
+   * emitido, cuando esto se llama desde `signDelegation`). Devuelve los nonces retirados.
+   * Solo toca las listas locales: avisar al aparato es cosa del mostrador de enrolamiento,
+   * que es quien puede firmar la orden de autoborrado.
+   */
+  function revokePriorCertsFor (sub, keepNonce) {
+    const store = loadDelegations()
+    const rev = loadRevocations()
+    const now = Date.now()
+    const hit = []
+    for (const [nonce, d] of Object.entries(store)) {
+      if (nonce === keepNonce || d?.sub !== sub || d?.revokedAt) continue
+      rev[nonce] = now
+      d.revokedAt = now
+      hit.push(nonce)
+    }
+    if (hit.length) { saveRevocations(rev); saveDelegations(store) }
+    return hit
+  }
+
   // ----- emparejamiento con el vault del usuario (este dispositivo enrolado) -----
   // Canal de eventos 'vault' (p.ej. el código a tipear durante el emparejamiento).
   const vaultListeners = new Set()
@@ -1043,7 +1064,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // de dispositivo `sub`, acotado por `scope` y `exp`, revocable por `nonce`.
     // Es la ÚNICA forma en que la autoridad sale de la clave maestra, y va limitada.
 
-    async signDelegation ({ sub, scope, ttlMs, exp, nonce, label }) {
+    async signDelegation ({ sub, scope, ttlMs, exp, nonce, label, supersede }) {
       if (!sub || typeof sub !== 'string') throw new Error('sub (device pubkey) required')
       if (!scope || (typeof scope !== 'string' && !Array.isArray(scope))) throw new Error('scope required')
       const iat = Date.now()
@@ -1054,9 +1075,27 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const store = loadDelegations()
       store[cert.nonce] = { nonce: cert.nonce, sub, scope, iat, exp: cappedExp, label: typeof label === 'string' ? label.slice(0, 60) : '' }
       saveDelegations(store)
+      // UNA LLAVE, UN CERTIFICADO VIGENTE. Renovar emitía uno nuevo y dejaba vivo el
+      // anterior: el mismo aparato salía dos veces en la lista (parecían dos máquinas) y,
+      // peor, «quitar el dispositivo» revocaba UN cert y el aparato seguía entrando con el
+      // otro — a veces justo con el que llevaba `vault:admin`. Al firmar, los certs previos
+      // de esa misma `sub` se retiran. Silencioso a propósito: NO se emite el aviso de
+      // autoborrado (eso solo lo dispara una revocación de verdad, desde el mostrador).
+      if (supersede !== false) revokePriorCertsFor(sub, cert.nonce)
       return { cert }
     },
 
+    /**
+     * Retira TODOS los certificados vigentes de un dispositivo (por su llave `sub`).
+     * Es lo que significa «quitar el dispositivo»: revocar por `nonce` retira un papel,
+     * no al aparato, que puede tener otros.
+     */
+    async revokeDevice ({ sub }) {
+      if (!sub || typeof sub !== 'string') throw new Error('sub (device pubkey) required')
+      const nonces = revokePriorCertsFor(sub, null)
+      return { ok: true, nonces, revokedAt: Date.now() }
+    },
+
     async revokeDelegation ({ nonce }) {
       if (!nonce || typeof nonce !== 'string') throw new Error('nonce required')
       const rev = loadRevocations()
@@ -1067,10 +1106,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, revokedAt: rev[nonce] }
     },
 
+    // `issued` = lo que HOY sirve para entrar. Antes devolvía el almacén entero, revocados
+    // incluidos (revocar solo estampa `revokedAt`), así que la consola seguía pintando como
+    // activo un cert ya retirado: pulsabas «quitar» y la fila no se movía. Los caducados ya
+    // los poda `loadDelegations`. El histórico retirado va aparte, en `revokedCerts`.
     async listDelegations () {
       const store = loadDelegations(); const rev = loadRevocations()
+      const all = Object.values(store).sort((a, b) => (b.iat || 0) - (a.iat || 0))
       return {
-        issued: Object.values(store).sort((a, b) => (b.iat || 0) - (a.iat || 0)),
+        issued: all.filter((d) => !d.revokedAt && !rev[d.nonce]),
+        revokedCerts: all.filter((d) => d.revokedAt || rev[d.nonce]),
         revoked: Object.keys(rev).map(nonce => ({ nonce, revokedAt: rev[nonce] }))
       }
     },
@@ -1270,6 +1315,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       pend.push(record)
       saveRenounces(pend)
       emitVault({ phase: 'renounced', caps: record.caps })
+      // Y se le MANDA a la bóveda para que la selle en el acta. Sin esto la renuncia solo
+      // valía aquí dentro: la bóveda seguía teniendo escrito que este aparato puede firmar
+      // y le seguía aceptando peticiones. Best-effort: si la bóveda está apagada, la
+      // renuncia ya está en pie localmente (para eso no necesita a nadie) y se reintenta
+      // la próxima vez que se renuncie.
+      const v = loadVaultCert(); const dev = loadVaultDevice()
+      if (v?.cert && dev) {
+        remoteRenounce({ master: v.master, proxy: v.proxy, device: dev, cert: v.cert, record })
+          .catch(() => {})
+      }
       // Si además soy el master, la absorbo ya en el acta.
       if (amMaster()) { try { await sealChanges([{ op: 'renounce', record }]) } catch (_) {} }
       return { ok: true, record, caps: Acta.effectiveCaps(loadActa(), publickeyJwkStr, loadRenounces()) }

package/vault/remote.js

@@ -32,6 +32,9 @@ const MSG = {
   ADMIN: 'vault.admin',
   ADMIN_RESULT: 'vault.admin.result',
   ADMIN_EVENT: 'vault.admin.event',
+  // Renuncia: el miembro se quita capacidades a sí mismo y la bóveda la sella en el acta.
+  RENOUNCE: 'vault.renounce',
+  RENOUNCE_RESULT: 'vault.renounce.result',
   ERROR: 'vault.error'
 }
 export { MSG as VAULT_MSG }
@@ -275,6 +278,26 @@ export async function requestRenew ({ master, proxy, device, cert, onRevoked } =
   return { cert: res.cert }
 }
 
+/**
+ * Manda a la bóveda la RENUNCIA de este dispositivo para que la selle en el acta.
+ *
+ * Sin esto, renunciar solo valía en el propio aparato: la bóveda seguía teniendo escrito
+ * que podía firmar, le seguía aceptando peticiones, y cualquiera que mirara el acta lo
+ * seguía viendo como firmante. Una renuncia que no llega al acta no es oponible a nadie —
+ * y en el caso que la justifica (te robaron el aparato) su registro local no vale nada,
+ * porque lo borra quien lo tenga en la mano.
+ *
+ * El `record` va FIRMADO por el propio miembro y solo puede QUITAR, así que la bóveda no
+ * necesita comprobar ningún certificado para honrarlo: le basta la firma.
+ */
+export async function requestRenounce ({ master, proxy, device, cert, record, onRevoked } = {}) {
+  const res = await vaultRpc({
+    master, proxy, device, cert, onRevoked,
+    sendType: MSG.RENOUNCE, okType: MSG.RENOUNCE_RESULT, data: { op: 'renounce', record }
+  })
+  return { ok: !!res.ok, seq: res.seq ?? null }
+}
+
 /**
  * CONSOLA REMOTA (`dotrino-vault/docs/consola-remota.md`): administrar el perfil desde
  * este dispositivo, sin ir al PC. Requiere un cert con scope `vault:admin`, que **no se

package/vault/vault.js

@@ -118,6 +118,7 @@ import { pubkeyId } from './capabilities.js'
     signDelegation: (sub, scope, opts) => handlers.signDelegation({ sub, scope, ...(opts || {}) }),
     listDelegations: () => handlers.listDelegations({}),
     revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
+    revokeDevice: (sub) => handlers.revokeDevice({ sub }),
     admitMember: (m) => handlers.admitMember(m),
     profileActa: () => handlers.profileActa({}),
     // Camino A (`mode: 'adopt'`): la bóveda se queda con la cuenta que trae el aparato,