@dotrino/vaultd 0.81.0 → 0.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.81.0",
+  "version": "0.82.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": {

package/src/secretsStore.js

@@ -796,6 +796,19 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      * `null` en cualquiera de las dos significa «la del perfil sin contraseña».
      */
     async rekeyRecovery (...a) { return enFila(() => this._rekeyRecovery(...a)) },
+    /**
+     * ¿ESTA llave abre la copia de recuperación? Lanza si no.
+     *
+     * Sirve para saber con cuál está cerrada sin tocar nada — que es lo que hace falta para
+     * decidir si hay que migrarla. Preguntarlo intentando reenvolver un cajón mezcla dos
+     * cosas y deja el fallo diciendo «wrong password» sobre el cajón, que no es donde está.
+     */
+    async recoveryOpensWith (key) {
+      needSealer('check the recovery key')
+      if (!data.recovery?.priv) throw new NeedsPassword('this store has no recovery key yet')
+      await sealer.openMaster(data.recovery.priv, keyOr(key))
+      return true
+    },
     /** @private */
     async _rekeyRecovery (oldKey, newKey) {
       if (isLegacy()) return { rekeyed: false, reason: 'v3' }

package/src/vault.js

@@ -1826,6 +1826,21 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    *
    * @returns {Promise<{ done: number, asked: number }>}
    */
+  /**
+   * PEDIRLE A UN HERMANO QUE ENVUELVA — Y QUE SE LO ENTREGUE A LA BÓVEDA (§8.11).
+   *
+   * Regla del dueño (2026-09-01): «un servicio reparte la llave AL VAULT para que este la
+   * reparta después, pero no se la entrega directo; si lo hace sin pasar por el vault está
+   * mal». Es lo que hace este camino, y conviene verlo en el orden de las líneas:
+   *
+   *   1. la BÓVEDA le pide el sobre al hermano (`sendByPubkey` → `REWRAP`);
+   *   2. el hermano le contesta A ELLA, nunca al recién llegado;
+   *   3. la BÓVEDA lo guarda (`putWrap`) y a partir de ahí lo sirve ella.
+   *
+   * El destinatario no habla con nadie, y la bóveda nunca ve la llave en claro: el sobre
+   * llega ya cerrado a la pública del destinatario. Por eso esto funciona con el perfil
+   * cerrado, que es justo cuando hace falta.
+   */
   async function delegateRewrap (owner, targetPub, { timeoutMs = 15000 } = {}) {
     const ns = owner.startsWith('ns:') ? owner.slice(3) : null
     if (!ns) return { done: 0, asked: 0 }
@@ -1935,7 +1950,50 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return r
   }
 
+  /**
+   * MIGRACIÓN, CON FECHA: la copia de recuperación pudo quedar sellada con la llave de la
+   * MÁQUINA aunque el perfil tenga contraseña.
+   *
+   * Pasa por un camino perfectamente normal: escribir una variable NO pide la frase (§8.1),
+   * así que si el cajón se estrenó con el perfil cerrado, `ensureRecovery` la selló con lo
+   * único que había — la llave de la máquina. A partir de ahí, abrir el perfil y reenvolver
+   * pasa la llave de la CONTRASEÑA, que no abre ese sobre: «wrong password», el llavero no
+   * se rehace, y los servicios se quedan sin poder leer sus cajones para siempre. Es
+   * exactamente lo que le pasó a un perfil real el 2026-09-01.
+   *
+   * Aquí se abre con la de la máquina y se vuelve a cerrar con la de la contraseña, que es
+   * el `rekey` que aquel `password-set` no llegó a hacer. NO es un repliegue: no decide un
+   * permiso, no deja pasar a nadie, y **se acaba** — al primer desbloqueo el sobre queda
+   * bajo la frase y esta rama no vuelve a entrar. Y va en el sentido estricto: el material
+   * de la llave de máquina vive en este mismo disco, así que pasar a la contraseña PROTEGE
+   * más de lo que había, no menos.
+   *
+   * Se puede quitar cuando no queden perfiles de antes de 0.81.0 (2027-03-01).
+   */
+  const MIGRACION_RECUPERACION_HASTA = Date.parse('2027-03-01T00:00:00Z')
+  async function migrarRecuperacionALaFrase (adminKey) {
+    if (!adminKey || Date.now() > MIGRACION_RECUPERACION_HASTA) return false
+    try {
+      // Si la frase ya la abre, no hay nada que migrar.
+      await secrets.recoveryOpensWith(adminKey)
+      return false
+    } catch (_) {}
+    try {
+      const r = await secrets.rekeyRecovery(null, adminKey)   // `null` = la llave de la máquina
+      if (!r?.rekeyed) return false
+      log('[vault] the recovery copy was sealed with this machine\'s key: re-sealed under the profile password')
+      audit('secret.recovery-rekeyed', {})
+      return true
+    } catch (e) {
+      log(`[vault] the recovery copy does not open with the password nor with this machine's key (${e.message}): the drawers cannot be re-wrapped`)
+      return false
+    }
+  }
+
   async function resealAll (adminKey = null) {
+    // ANTES de reenvolver nada: si la copia de recuperación se quedó bajo la llave de la
+    // máquina, se pasa a la frase. Sin esto, todo lo de abajo falla con «wrong password».
+    if (adminKey) await migrarRecuperacionALaFrase(adminKey)
     const out = { drawers: 0, wrapped: 0, dropped: 0, sinLlave: [], failed: [] }
     for (const owner of secrets.owners?.() || []) {
       const before = new Set(secrets.recipientsIn(owner))