@dotrino/identity 0.45.0 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.45.0",
+  "version": "0.47.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

@@ -439,8 +439,18 @@ export class Identity {
   async selfVaultApprove (deviceId, code) { return this._call('selfVaultApprove', { deviceId, code }) }
   /** Rechaza una solicitud de emparejamiento pendiente. */
   async selfVaultReject (deviceId) { return this._call('selfVaultReject', { deviceId }) }
-  /** Revoca una máquina/agente enrolado por nonce de delegación. */
-  async selfVaultRevoke (nonce) { return this._call('selfVaultRevoke', { nonce }) }
+  /**
+   * QUITA una máquina/agente enrolado en esta bóveda. Se le pasa **el aparato**
+   * (`{ sub }`, su llave): sale del acta y se le retiran todos sus certificados.
+   *
+   * Un `nonce` suelto (string, o `{ nonce }`) retira UN certificado y deja al aparato
+   * dentro del acta: eso no es quitarlo, y quien queda así ya no recibe nunca el aviso
+   * de expulsión. Se acepta por compatibilidad, no como la forma normal.
+   */
+  async selfVaultRevoke (target) {
+    const p = typeof target === 'string' ? { nonce: target } : { sub: target?.sub, nonce: target?.nonce }
+    return this._call('selfVaultRevoke', p)
+  }
   /** Presencia online (ping/pong) de las máquinas enroladas. Devuelve { online: [pubkeys] }. */
   async selfVaultProbe (pubkeys) { return this._call('selfVaultProbe', { pubkeys }, 10000) }
   /** Suscribe a eventos del self-vault ('selfVault'): { running?, pending?, error? }. */

package/vault/remote.js

@@ -45,10 +45,17 @@ export { MSG as VAULT_MSG }
  * un `vault.error` con la palabra «revocado» no borra nada (cierra el wipe-DoS, ver
  * `dotrino-vault/docs/pairing-protocol.md §2.3`).
  */
-export async function isAuthenticRevoke ({ body, signature, master, devicePubkey }) {
+export async function isAuthenticRevoke ({ body, signature, master, devicePubkey, currentNonce = null }) {
   if (!body || body.op !== 'revoke' || typeof signature !== 'string') return false
   if (body.sub !== devicePubkey) return false
   if (typeof body.exp === 'number' && Date.now() > body.exp) return false
+  // Y tiene que hablar del certificado que este aparato usa AHORA. Un certificado se
+  // retira también cuando NO pasa nada malo: renovar retira el anterior, y cambiar
+  // permisos obliga a renovar. Sin esta comprobación, el aviso de «tu papel viejo ya no
+  // vale» borraba el enlace con la bóveda entero: dabas «administra» a un aparato y el
+  // aparato desaparecía solo, como si lo hubieran echado. El proxy encola 24 h, así que
+  // el aviso puede llegar mucho después de haber renovado.
+  if (currentNonce && typeof body.nonce === 'string' && body.nonce !== currentNonce) return false
   return verifyDeviceSig({ publickey: master, data: body, signature })
 }
 
@@ -216,6 +223,13 @@ export async function requestSign ({ master, proxy, device, cert, payload, onRev
   return { signature: res.signature, publickey: res.publickey }
 }
 
+/**
+ * Cuánto se espera el aviso FIRMADO de expulsión después de que la bóveda conteste
+ * «revoked». Corto a propósito: es el tiempo de un mensaje que ya viene en camino, no una
+ * espera de verdad.
+ */
+const REVOKE_GRACE_MS = 1500
+
 /**
  * Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`.
  *
@@ -233,19 +247,31 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
     const signed = { ...data, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data: signed })
     const pending = new Promise((resolve, reject) => {
+      let graceTimer = null
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
         if (p.type === MSG.REVOKED) {
-          isAuthenticRevoke({ body: p.body, signature: p.signature, master, devicePubkey: device.publickey })
+          isAuthenticRevoke({ body: p.body, signature: p.signature, master, devicePubkey: device.publickey, currentNonce: cert?.nonce || null })
             .then((ok) => { if (ok) { try { onRevoked?.() } catch (_) {} } })
             .catch(() => {})
           return
         }
         if (p.type === okType) { cleanup(); resolve(p) }
-        else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
+        else if (p.type === 'vault.error') {
+          // «Te echaron» llega en DOS mensajes: este error (que no va firmado, así que no
+          // puede borrar nada — wipe-DoS) y el `vault.revoked` FIRMADO, que es el único que
+          // sí. Cerrar el socket al recibir el primero era llegar a cerrar la puerta justo
+          // antes que el segundo, y entonces el aparato se quedaba con la cuenta puesta
+          // hasta vaya a saber cuándo. Se le da un respiro corto para recogerlo.
+          if (/\brevoked\b/.test(p.error || '') && !graceTimer) {
+            graceTimer = setTimeout(() => { cleanup(); reject(new Error(p.error)) }, REVOKE_GRACE_MS)
+            return
+          }
+          cleanup(); reject(new Error(p.error))
+        }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('the vault did not reply (is it running?)')) }, timeoutMs)
-      const cleanup = () => { off(); clearTimeout(t) }
+      const cleanup = () => { off(); clearTimeout(t); clearTimeout(graceTimer) }
     })
     client.sendByPubkey(master, { type: sendType, data: signed, signature, cert })
     return await pending

package/vault/vault.js

@@ -239,7 +239,20 @@ import { pubkeyId } from './capabilities.js'
       daemon.reject(deviceId)
       return { ok: true }
     },
-    selfVaultRevoke: async ({ nonce }) => {
+    /**
+     * QUITAR UN APARATO cuando la bóveda es ESTE navegador. Por `sub` (su llave): sale del
+     * acta y se le retiran todos los certificados, que son las dos caras del mismo acto.
+     *
+     * Con `nonce` a secas solo cae UN papel y el aparato sigue siendo miembro — un
+     * fantasma en la lista al que además ya nunca le llega el aviso de expulsión, porque
+     * mientras siga en el acta un papel retirado significa «renueva», no «estás fuera».
+     * Se conserva para quien de verdad quiera retirar un certificado suelto.
+     */
+    selfVaultRevoke: async ({ sub, nonce }) => {
+      if (sub) {
+        if (daemon?.revokeDevice) return daemon.revokeDevice(sub)
+        return handlers.revokeDevice({ sub })
+      }
       if (daemon) return daemon.revoke(nonce)
       return handlers.revokeDelegation({ nonce })
     },