@dotrino/vaultd 0.138.0 → 0.139.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.138.0",
+  "version": "0.139.1",
   "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": {
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.105.0",
+    "@dotrino/identity": "^0.107.1",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
     "@dotrino/proxy-client": "0.27.1",

package/src/threadStore.js

@@ -15,6 +15,7 @@
  */
 import path from 'node:path'
 import * as core from '@dotrino/store/core'
+import { resealStale } from '@dotrino/identity/content'
 import { readJson, writeJson } from './paths.js'
 import { atRestFor } from './atrest.js'
 
@@ -26,6 +27,11 @@ const MAX_PER_THREAD = core.MAX_PER_THREAD_LIMIT
 // DATOS SENSIBLES (F4): topes para que un dispositivo con `vault:store` no pueda
 // llenar el disco de la bóveda. Son generosos para el uso real (unas contraseñas,
 // notas, un documento corto) y ridículos para un abuso.
+// LO QUE SE VUELVE A CERRAR AL ROTAR NO SE BORRA: la versión anterior de cada sobre se
+// guarda como respaldo AL MENOS UN AÑO (política del dueño, 2026-09-30). No se sirve por
+// ningún método; solo está por si volver a cerrar sale mal.
+export const RESEALED_KEEP_MS = 366 * 24 * 60 * 60 * 1000
+
 const MAX_SECURE_ITEMS = 2000
 const MAX_SECURE_BLOB = 64 * 1024   // por campo sellado (meta y valor)
 
@@ -203,7 +209,51 @@ export function openThreadStore (dir) {
       return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length, secureCount: Object.keys(data.secure).length }
     }
   }
-  return { methods, raw: () => data }
+  /**
+   * VUELVE A CERRAR CON LA LLAVE VIGENTE todo sobre de la cuenta (`t: 'dotrino-cek'`) de
+   * una generación anterior que haya en lo guardado. Lo llama la BÓVEDA al abrirse y
+   * después de quitar un aparato —que es cuando la llave rota—; NO está en `methods`, así
+   * que ningún aparato puede dispararlo.
+   *
+   * Lo que sirve la bóveda va así siempre con la generación vigente: un aparato que entra
+   * después, que solo recibe esa, abre todo; y la vieja deja de abrir nada porque ya no se
+   * sirve nada cerrado con ella (dueño, 2026-09-30). Cada entrada que cambia estrena `ts`,
+   * para que los aparatos la bajen en su siguiente sincronización.
+   *
+   * También MIGRA los sobres de la cuenta anteriores a la marca (`{ gen, iv, ct }` a secas,
+   * identity < 0.107): si abren con la llave de la cuenta se vuelven a cerrar marcados; si no,
+   * no eran de la cuenta y se cuentan en `skipped` sin tocarlos.
+   *
+   * La versión anterior NO se tira: queda en `resealed` con la fecha, por si algo sale mal
+   * (lo pidió el dueño: «podría retenerlos… pero no los envía»), y se guarda AL MENOS un
+   * año (`RESEALED_KEEP_MS`). No se sirve por ningún método.
+   *
+   * @param {{ gen: number, reseal: (env: object) => Promise<object> }} o
+   * @returns {Promise<{ changed: number, entries: number, skipped: number }>}
+   */
+  async function resealStaleEnvelopes ({ gen, reseal }) {
+    let changed = 0; let entries = 0; let skipped = 0
+    const now = Date.now()
+    if (!data.resealed) data.resealed = []
+    // Solo sale lo que ya cumplió su año de respaldo.
+    const antes = data.resealed.length
+    data.resealed = data.resealed.filter((x) => now - (x.at || 0) < RESEALED_KEEP_MS)
+    const podados = antes - data.resealed.length
+    for (const [key, arr] of Object.entries(data.threads)) {
+      for (let i = 0; i < arr.length; i++) {
+        const r = await resealStale(arr[i], { gen, reseal })
+        skipped += r.skipped || 0
+        if (!r.changed) continue
+        data.resealed.push({ threadKey: key, at: now, gen, before: arr[i] })
+        arr[i] = { ...r.value, ts: Math.max(now, (arr[i].ts || 0) + 1) }
+        changed += r.changed; entries++
+      }
+    }
+    if (entries || podados) save()
+    return { changed, entries, skipped }
+  }
+
+  return { methods, raw: () => data, resealStaleEnvelopes }
 }
 
 /**

package/src/vault.js

@@ -116,6 +116,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   const store = openStore(dir)
   const threads = openThreadStore(dir)
+  /**
+   * LO QUE SIRVE LA BÓVEDA VA CON LA LLAVE VIGENTE (dueño, 2026-09-30). Tras una rotación
+   * de la llave de la cuenta, los sobres (`t: 'dotrino-cek'`) de generaciones anteriores
+   * que haya en el almacén se vuelven a cerrar con la vigente. Se llama al abrir y después
+   * de quitar un aparato. Si la bóveda no tiene la llave de contenido, no hay nada que
+   * hacer y se dice; si un sobre no abre, se para y se dice — no se deja a medias.
+   */
+  async function resealStaleThreads (why) {
+    const mine = await identity.contentKey?.()
+    if (!mine) { log(`[vault] ${why}: no content key on this vault, envelopes not resealed`); return null }
+    const r = await threads.resealStaleEnvelopes({
+      gen: mine.gen,
+      reseal: async (env) => identity.sealContent(await identity.openContent(env))
+    })
+    if (r.changed) {
+      audit('resealed', { envelopes: r.changed, entries: r.entries, gen: mine.gen })
+      log(`[vault] ${why}: resealed ${r.changed} envelope(s) in ${r.entries} entr${r.entries === 1 ? 'y' : 'ies'} with content key generation ${mine.gen}`)
+    }
+    if (r.skipped) log(`[vault] ${why}: ${r.skipped} unmarked envelope(s) that the account key does not open were left as they are`)
+    return r
+  }
   const approvals = createApprovals()
   /**
    * LO QUE YA SE APROBÓ: comando + carpeta, por una hora desde el último uso.
@@ -3845,6 +3866,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
           }
         } catch (e) { log(`[vault] unlock: could not remove expired devices: ${e.message}`) }
       }
+      // Y DESPUÉS, LOS SOBRES A LA LLAVE VIGENTE: la poda de arriba pudo rotarla.
+      if (r?.locked === false) {
+        try { await resealStaleThreads('unlock') } catch (e) { log(`[vault] unlock: could not reseal old envelopes: ${e.message}`) }
+      }
       return { locked: r?.locked !== false }
     },
     // Forzar un empujón: lo usa `replica push` de la CLI y el smoke, para no depender
@@ -4077,6 +4102,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       const r = await desk.revokeDevice(sub)
       audit('revoke-device', { device: await deviceIdOf(sub).catch(() => null), certs: r?.nonces?.length ?? null })
       await refreshWraps('revoked')
+      // Quitar un aparato rota la llave de la cuenta: lo guardado pasa a la nueva.
+      try { await resealStaleThreads('revoke') } catch (e) { log(`[vault] revoke: could not reseal old envelopes: ${e.message}`) }
       await notifyMembers('revoked', { deviceId: await deviceIdOf(sub).catch(() => null), by: 'pc' })
       return r
     },