@dotrino/vaultd 0.92.0 → 0.93.1

package/package.json

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

package/src/ctl.js

@@ -780,7 +780,7 @@ function profileDir () {
  * antes de tener clave, `key.json` es una pública que dice de quién es la carpeta, y las
  * preferencias no son de nadie. Todo lo demás en claro es un hallazgo.
  */
-function enClaroEn (d) {
+function plaintextFilesIn (d) {
   const OK = new Set(['atrest.salt', 'atrest.machine', 'atrest.kek', 'atrest.json', 'vault.lock', 'prefs.json', 'key.json'])
   let names = []
   try { names = fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name) } catch (_) { return [] }
@@ -820,11 +820,11 @@ function cmdAtrest (rest) {
     // versión vieja dejó en claro, con el verificador de la contraseña dentro— meses
     // después de que su migración terminara. Se mira el perfil Y la raíz, porque el canal
     // local con la CLI vive arriba.
-    for (const [donde, d] of [['este perfil', dir], ['la raíz de la bóveda', vaultRoot]]) {
-      const sueltos = enClaroEn(d)
-      if (sueltos.length) {
+    for (const [label, d] of [['este perfil', dir], ['la raíz de la bóveda', vaultRoot]]) {
+      const loose = plaintextFilesIn(d)
+      if (loose.length) {
         console.log('')
-        console.log(`${R}En claro en ${donde}:${Z} ` + sueltos.join(', '))
+        console.log(`${R}En claro en ${label}:${Z} ` + loose.join(', '))
         console.log('  Si es un respaldo de una migración terminada, bórralo: no lo cifra nadie.')
       }
     }

package/src/daemon.js

@@ -20,7 +20,7 @@ import { takeLock } from '../lib/src/lock.js'
 import { startVaultManager } from './manager.js'
 import { dataDir } from './paths.js'
 // EL CANAL LOCAL VA CIFRADO: por aquí pasan la contraseña, los valores y las invitaciones.
-import { ipcRead, ipcWrite } from './ipc.js'
+import { ipcRead, ipcWrite, migrateIpcDir } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
 import { watchBinary } from './selfupdate.js'
 import { VERSION } from './version.js'
@@ -70,6 +70,9 @@ export async function runDaemon () {
   const dir = dataDir()
   const proxyUrl = process.env.PROXY_URL || 'wss://proxy.dotrino.com'
   assertSingleInstance(dir)
+  // Lo que dejó escrito una versión anterior al canal cifrado. Se agota sola.
+  const sealedLeftovers = migrateIpcDir(dir)
+  if (sealedLeftovers) console.log('[vault] control channel: %d leftover file(s) sealed at rest', sealedLeftovers)
 
   const pendingEnrollFile = path.join(dir, 'pending-enroll.json')
   // Cuando un dispositivo pide enrolarse, exponemos su deviceId (y a QUÉ perfil

package/src/ipc.js

@@ -26,6 +26,7 @@
  * Ojo con el dir: todos estos archivos cuelgan del directorio raíz, así que la clave sale
  * de ahí (`path.dirname`). Un archivo de perfil tiene otro salt y NO se lee con esta.
  */
+import fs from 'node:fs'
 import path from 'node:path'
 import { atRestFor } from './atrest.js'
 import { readJson, writeJson } from './paths.js'
@@ -38,4 +39,33 @@ export const ipcRead = (file, fallback = null) => readJson(file, fallback, codec
 /** Escribe un archivo del canal, cifrado y 0600 (atómico: tmp + rename). */
 export const ipcWrite = (file, obj) => writeJson(file, obj, codecOf(file))
 
-export default { ipcRead, ipcWrite }
+/**
+ * CONVIERTE LO QUE DEJÓ ESCRITO UNA VERSIÓN ANTERIOR.
+ *
+ * Cifrar al escribir no limpia el disco: un archivo del canal solo se reescribe cuando
+ * alguien vuelve a pedir esa operación, y hay respuestas que se quedan meses. `approve.json`
+ * —con el id del último aparato aprobado— seguía en claro días después de la actualización,
+ * esperando a que hubiera otra aprobación.
+ *
+ * Se pasa una vez al arrancar el daemon y se agota sola. Un archivo que no se pueda leer se
+ * deja como está: no es de nadie borrar lo que no entiende.
+ */
+export function migrateIpcDir (dir) {
+  let names = []
+  try { names = fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name) } catch (_) { return 0 }
+  let n = 0
+  for (const name of names) {
+    if (!name.endsWith('.json') || name.startsWith('atrest.')) continue
+    const file = path.join(dir, name)
+    try {
+      const raw = fs.readFileSync(file, 'utf8')
+      if (!raw.trim() || raw.startsWith('DOTRINO-ATREST-v1.')) continue
+      const obj = JSON.parse(raw)
+      ipcWrite(file, obj)
+      n++
+    } catch (_) { /* no se entiende: se deja */ }
+  }
+  return n
+}
+
+export default { ipcRead, ipcWrite, migrateIpcDir }

package/src/node-globals.js

@@ -23,11 +23,23 @@ import { atRestFor } from './atrest.js'
 export function fileLocalStorage (filePath) {
   const atRest = atRestFor(path.dirname(filePath))
   let data = {}
-  try { if (fs.existsSync(filePath)) data = JSON.parse(atRest.decrypt(fs.readFileSync(filePath, 'utf8'))) || {} } catch (_) {}
+  let wasPlaintext = false
+  try {
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, 'utf8')
+      wasPlaintext = !!raw.trim() && !raw.startsWith('DOTRINO-ATREST-v1.')
+      data = JSON.parse(atRest.decrypt(raw)) || {}
+    }
+  } catch (_) {}
   const flush = () => {
     fs.mkdirSync(path.dirname(filePath), { recursive: true })
     fs.writeFileSync(filePath, atRest.encrypt(JSON.stringify(data)), { mode: 0o600 })
   }
+  // CIFRAR AL ESCRIBIR NO CONVIERTE LO YA ESCRITO, y aquí eso importaba de verdad: el par
+  // de transporte se acuña UNA vez y no se vuelve a tocar, así que el archivo que dejó una
+  // versión anterior —con su privada en claro— se quedaba así para siempre. Se convierte de
+  // una vez al abrirlo. Se agota solo: la siguiente vez ya está cifrado.
+  if (wasPlaintext) { try { flush() } catch (_) {} }
   return {
     getItem: (k) => (k in data ? data[k] : null),
     setItem: (k, v) => { data[k] = String(v); flush() },

package/src/vault.js

@@ -260,25 +260,41 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * `identify` se repliega a la maestra y lo dice. Por eso una bóveda que se actualiza
    * tiene que abrirse UNA vez, y a partir de ahí ya puede vivir cerrada.
    */
-  try {
-    const info = await identity.profileActa?.()
-    const acta = info?.acta
-    // CON EL PERFIL ABIERTO, y `isLocked()` es la pregunta correcta — no `masterLocked`.
-    //
-    // Se coló así: en la PRIMERA arrancada tras actualizar, la maestra todavía está guardada
-    // en claro (se sella al abrir el perfil), o sea que `masterLocked` es `false` aunque el
-    // perfil esté cerrado. Con ese guardián, la bóveda de producción admitió su llave de
-    // comunicación y SELLÓ UN ACTA NUEVA (#76 → #77) estando cerrada — justo lo que la regla
-    // prohíbe, y encima rotando de paso la llave de sellado sin que nadie lo pidiera.
-    if (acta && !isLocked() && !identity.masterLocked) {
+  /**
+   * METER LA LLAVE DE COMUNICACIÓN EN EL ACTA, si el perfil está abierto.
+   *
+   * `isLocked()` es la pregunta correcta — no `masterLocked`. Se coló así: en la PRIMERA
+   * arrancada tras actualizar, la maestra todavía está guardada en claro (se sella al abrir
+   * el perfil), o sea que `masterLocked` es `false` aunque el perfil esté cerrado. Con ese
+   * guardián, la bóveda de producción admitió su llave de comunicación y SELLÓ UN ACTA
+   * NUEVA (#76 → #77) estando cerrada — justo lo que la regla prohíbe, y encima rotando de
+   * paso la llave de sellado sin que nadie lo pidiera.
+   *
+   * SE LLAMA TAMBIÉN AL ABRIR, y esa es la mitad que faltaba. Antes solo corría al arrancar
+   * el servicio, y **un perfil con contraseña arranca cerrado siempre**: nunca pasaba por
+   * aquí, así que jamás llegaba a tener su llave. O sea que los perfiles que MÁS la
+   * necesitan —los protegidos, los que no pueden firmar con la maestra estando cerrados—
+   * eran precisamente los únicos que se quedaban sin ella, y seguían identificándose con la
+   * maestra o quedándose mudos. Se vio el 2026-09-02: de dos perfiles, el que tenía
+   * contraseña era el que no tenía `commkey.json`.
+   */
+  async function ensureCommKeyInActa () {
+    try {
+      const info = await identity.profileActa?.()
+      const acta = info?.acta
+      if (!acta || isLocked() || identity.masterLocked) return false
       const pub = await commKey.ensure()
-      const yaEsta = (acta.members || []).some((m) => m?.pub === pub)
-      if (!yaEsta && info?.isMaster) {
-        await identity.admitMember({ pub, label: 'esta bóveda', cn: COMM_CN, caps: [...COMM_CAPS] })
-        log('[vault] this vault is now a member of its own record: it talks with its own key, not the master one')
-      }
+      if ((acta.members || []).some((m) => m?.pub === pub)) return false
+      if (!info?.isMaster) return false
+      await identity.admitMember({ pub, label: 'esta bóveda', cn: COMM_CN, caps: [...COMM_CAPS] })
+      log('[vault] this vault is now a member of its own record: it talks with its own key, not the master one')
+      return true
+    } catch (e) {
+      log('[vault] could not put the communication key in the record:', e.message)
+      return false
     }
-  } catch (e) { log('[vault] could not put the communication key in the record:', e.message) }
+  }
+  await ensureCommKeyInActa()
 
   const { client } = await createTransport({ identity, dir, url: proxyUrl, commKey, log })
 
@@ -338,15 +354,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // cierto también para lo que ya estaba escrito, no solo para lo que se escriba desde
   // ahora. Se agota sola — cuando no queda ninguna línea en claro, no vuelve a tocar nada.
   try {
-    const crudo = fs.readFileSync(activityFile, 'utf8')
-    const lineas = crudo.split('\n')
-    if (lineas.some((l) => l && !l.startsWith('DOTRINO-ATREST-v1.'))) {
-      const convertidas = lineas.map((l) => (l && !l.startsWith('DOTRINO-ATREST-v1.') ? activityAtRest.encrypt(l) : l))
+    const raw = fs.readFileSync(activityFile, 'utf8')
+    const lines = raw.split('\n')
+    if (lines.some((l) => l && !l.startsWith('DOTRINO-ATREST-v1.'))) {
+      const sealedLines = lines.map((l) => (l && !l.startsWith('DOTRINO-ATREST-v1.') ? activityAtRest.encrypt(l) : l))
       // Escribir aparte y renombrar: a medio convertir, la bitácora sería ilegible entera.
-      fs.writeFileSync(activityFile + '.tmp', convertidas.join('\n'), { mode: 0o600 })
+      fs.writeFileSync(activityFile + '.tmp', sealedLines.join('\n'), { mode: 0o600 })
       fs.renameSync(activityFile + '.tmp', activityFile)
       // Sin `%d`: el `log` de la bóveda no formatea, así que el placeholder salía literal.
-      log(`[vault] activity log: ${convertidas.filter(Boolean).length} line(s) sealed at rest`)
+      log(`[vault] activity log: ${sealedLines.filter(Boolean).length} line(s) sealed at rest`)
     }
     // Y el modo, que hasta 0.89 se creaba 0664: legible por cualquier usuario.
     if ((fs.statSync(activityFile).mode & 0o077) !== 0) fs.chmodSync(activityFile, 0o600)
@@ -648,7 +664,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * exactamente lo que el acta nombra, así que decir quién pregunta no necesita más.
    *
    * La respuesta es sí o no, y nada más: al que sigue dentro no se le manda el acta —no la
-   * pidió, y contarle el perfil entero a quien no trae papel es dar de más—. Al que ya no
+   * pidió, y contarle el perfil entero a quien no trae papel es attach de más—. Al que ya no
    * está se le manda el aviso FIRMADO de expulsión, que es lo único que le borra la cuenta.
    * Que un desconocido pregunte no cuesta nada: lo que se le puede contestar es un aviso a
    * nombre de SU propia llave, que no le sirve contra nadie más (`verifyRevoke` exige que
@@ -757,7 +773,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
     // EL SCOPE SALE DEL ACTA, no del cert viejo. El acta es la política (lo que el dueño
     // decidió con `caps`); el cert es su reflejo, y solo dura 30 días para poder cambiar.
-    // Copiar `p.cert.scope` congelaba la política en el momento del emparejamiento: dar
+    // Copiar `p.cert.scope` congelaba la política en el momento del emparejamiento: attach
     // `administra` no llegaba nunca al cert (la consola remota no podía funcionar) y
     // QUITARLO tampoco surtía efecto hasta que el cert caducara, hasta un mes después.
     // Si el miembro ya no está en el acta, no se renueva nada: lo echaron.
@@ -1405,7 +1421,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // aprender cómo se llaman tus variables ni qué servicios corres.
       return {
         enc: await identity.sealContent(JSON.stringify({
-          ns: conSobres(listSecrets(), 'ns', caller), dev: conSobres(await listDeviceSecrets(), 'dev', caller),
+          ns: withEnvelopes(listSecrets(), 'ns', caller), dev: withEnvelopes(await listDeviceSecrets(), 'dev', caller),
           // Aparatos que están en el acta pero no pueden abrir lo suyo: hay que
           // enseñarlo donde se administra, no solo en el log del servicio.
           incomplete: await incompleteMembers(),
@@ -1459,8 +1475,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // PÚBLICA Y PRIVADA VAN IGUAL (dueño, 2026-09-02: «la única diferencia es si se
         // despachan o no, son políticas; dales el mismo tratamiento de seguridad»). La
         // marca solo decide si se entrega sin aprobación.
-        await verificarAutor(owner, key, sealed, caller)
-        await verificarDestinatarios(owner, sealed.wraps, !!isPublic)
+        await checkAuthor(owner, key, sealed, caller)
+        await checkRecipients(owner, sealed.wraps, !!isPublic)
         await secrets.putSealed(owner, key, sealed, { by: who, public: isPublic })
         audit('secret.set', { ns: ns || null, key, sealed: true }); scheduleNotice(ns)
         await settleDebts(owner)
@@ -1499,8 +1515,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       const keys = []
       for (const it of items) {
         if (!it?.key || !it?.sealed) throw new Error('var.setMany: each variable needs its key and its sealed envelope')
-        await verificarAutor(owner, it.key, it.sealed, caller)
-        await verificarDestinatarios(owner, it.sealed.wraps, !!it.public)
+        await checkAuthor(owner, it.key, it.sealed, caller)
+        await checkRecipients(owner, it.sealed.wraps, !!it.public)
       }
       // Se comprueban TODAS antes de escribir NINGUNA: media carga aplicada es una
       // configuración que nadie quiso, y el servicio se reinicia con ella.
@@ -2077,7 +2093,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * relevo: alguien con `admin` colando un sobre que fabricó un tercero, sin que ninguna de
    * las dos comprobaciones lo note.
    */
-  async function verificarAutor (owner, key, sealed, caller) {
+  async function checkAuthor (owner, key, sealed, caller) {
     const a = sealed?.author
     if (!a || typeof a.pub !== 'string' || typeof a.sig !== 'string' || typeof a.ts !== 'number') {
       throw new Error('var.set: the envelope must say WHO made it (`author: { pub, sig, ts }`)')
@@ -2126,7 +2142,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    *
    * Lo de dentro lo corrige el repaso al abrir la bóveda, que es para lo que está.
    */
-  async function verificarDestinatarios (owner, wraps, isPublic = false) {
+  async function checkRecipients (owner, wraps, isPublic = false) {
     if (!wraps || typeof wraps !== 'object') throw new Error('var.set: the envelope carries no wraps')
     const { recoveryPub, members } = await secrets.recipientsFor(owner, { public: isPublic })
     if (!recoveryPub) throw new Error('var.set: this vault has no recovery key yet')
@@ -2390,20 +2406,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * pública, y no se puede leer. Eso es cierto y se arregla abriendo la bóveda; inventarse
    * un valor o esconder la fila sería peor.
    */
-  const conSobres = (lista, tipo, caller) => {
-    if (!caller) return lista
-    const dar = (owner, k) => {
+  const withEnvelopes = (entries, kind, caller) => {
+    if (!caller) return entries
+    const attach = (owner, k) => {
       if (!k.public) return k
       const e = secrets.entryOf?.(owner, k.key)
       const wrap = e?.gen != null ? secrets.wrapOf?.(owner, e.gen, caller) : null
       return e?.e && wrap ? { ...k, e: e.e, wrap } : k
     }
-    if (tipo === 'ns') {
+    if (kind === 'ns') {
       const out = {}
-      for (const [ns, keys] of Object.entries(lista)) out[ns] = keys.map((k) => dar(`ns:${ns}`, k))
+      for (const [ns, keys] of Object.entries(entries)) out[ns] = keys.map((k) => attach(`ns:${ns}`, k))
       return out
     }
-    return lista.map((row) => ({ ...row, keys: row.keys.map((k) => dar(`dev:${row.pub}`, k)) }))
+    return entries.map((row) => ({ ...row, keys: row.keys.map((k) => attach(`dev:${row.pub}`, k)) }))
   }
 
   function listSecrets () {
@@ -2523,6 +2539,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     async takeMasterKey () {
       const r = await identity.reloadMasterKey?.()
       if (r?.locked === false) { try { await identity.sealMasterKey?.() } catch (_) {} }
+      // ABRIR ES EL ÚNICO MOMENTO en que un perfil con contraseña está abierto, así que es
+      // aquí donde puede estrenar su llave de comunicación (ver `ensureCommKeyInActa`).
+      // Si falla, no se arrastra: abrir el perfil no puede depender de esto.
+      if (r?.locked === false) { try { await ensureCommKeyInActa() } catch (_) {} }
       return { locked: r?.locked !== false }
     },
     startPairing: desk.startPairing,