@dotrino/vaultd 0.93.1 → 0.94.1

package/package.json

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

@@ -24,6 +24,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { execFileSync } from 'node:child_process'
 import tty from 'node:tty'
+import crypto from 'node:crypto'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir } from './paths.js'
 // EL CANAL LOCAL VA CIFRADO (ver `ipc.js`): por aquí salen la contraseña y los valores.
@@ -926,16 +927,68 @@ function cmdAtrest (rest) {
 }
 
 // Bitácora de actividad de seguridad (quién firmó/renovó/enroló y qué se rechazó).
-function cmdActivity (n = 30) {
-  const f = path.join(profileDir(), 'activity.log')
-  let lines = []
-  try { lines = fs.readFileSync(f, 'utf8').trim().split('\n').filter(Boolean) } catch {
+/**
+ * Toda la bitácora EN ORDEN, archivos rotados incluidos. Se leen del más viejo al más
+ * nuevo (`.5` … `.1`, y al final el vivo) porque la cadena los cruza: verificarla mirando
+ * solo el archivo actual diría «rota» en su primera línea, que es exactamente lo contrario
+ * de lo que pasa.
+ */
+function readActivity (dir) {
+  const atRest = atRestFor(dir)
+  const out = []
+  const files = []
+  for (let i = 9; i >= 1; i--) { const f = path.join(dir, `activity.log.${i}`); if (fs.existsSync(f)) files.push(f) }
+  files.push(path.join(dir, 'activity.log'))
+  for (const f of files) {
+    let raw = ''
+    try { raw = fs.readFileSync(f, 'utf8') } catch { continue }
+    for (const l of raw.trim().split('\n').filter(Boolean)) {
+      // `decrypt` deja pasar el texto en claro, así que una bitácora anterior a 0.89 se
+      // sigue leyendo entera.
+      try { out.push(atRest.decrypt(l)) } catch { out.push(l) }
+    }
+  }
+  return out
+}
+
+/**
+ * ¿ESTÁ LA CADENA ENTERA? Cada entrada lleva el hash de la anterior, así que tocar o quitar
+ * una rompe todo lo que va detrás. Esto lo recorre y dice dónde se rompió.
+ *
+ * Lo que NO comprueba, y se dice: que no le hayan cortado el FINAL. Un prefijo válido sigue
+ * siendo válido; cerrarlo pide anclar el último hash fuera de esta máquina.
+ */
+function verifyActivity (lines) {
+  const sha256 = (t) => crypto.createHash('sha256').update(t, 'utf8').digest('hex')
+  let prev = null; let seq = null; let checked = 0; let unchained = 0
+  for (const text of lines) {
+    let e; try { e = JSON.parse(text) } catch { continue }
+    // Sin `logSeq` es de antes de que la cadena existiera: no se puede verificar, y se
+    // dice cuántas hay en vez de callarlo.
+    if (typeof e.logSeq !== 'number') { unchained++; continue }
+    if (seq !== null) {
+      if (e.logSeq !== seq + 1) return { ok: false, at: e.logSeq, why: `salta del #${seq} al #${e.logSeq}` }
+      if (e.logPrev !== prev) return { ok: false, at: e.logSeq, why: `el #${e.logSeq} no encadena con el #${seq}` }
+    }
+    seq = e.logSeq; prev = sha256(text); checked++
+  }
+  return { ok: true, checked, unchained, last: seq }
+}
+
+function cmdActivity (n = 30, { verify = false, exportar = false } = {}) {
+  const dir = profileDir()
+  const lines = readActivity(dir)
+  if (!lines.length) {
     console.log('Sin actividad registrada todavía (o el servicio es anterior a 0.1.10).'); return
   }
-  // Cada entrada va cifrada por separado (ver `audit` en `vault.js`). `decrypt` deja pasar
-  // el texto en claro, así que una bitácora anterior a 0.89 se sigue leyendo entera.
-  const atRest = atRestFor(profileDir())
-  lines = lines.map((l) => { try { return atRest.decrypt(l) } catch { return l } })
+  if (exportar) { for (const l of lines) console.log(l); return }
+  if (verify) {
+    const r = verifyActivity(lines)
+    if (!r.ok) { console.error(`${R}CADENA ROTA${Z} en la entrada #${r.at}: ${r.why}`); process.exit(1) }
+    console.log(`Cadena íntegra: ${r.checked} entrada(s) encadenada(s)${r.last ? ` hasta la #${r.last}` : ''}.`)
+    if (r.unchained) console.log(`  ${r.unchained} entrada(s) anteriores a 0.94, sin encadenar: no se pueden verificar.`)
+    return
+  }
   const ICON = { sign: '🖊 firma', renew: '♻ renovación', enroll: '➕ enrolado', revoke: '⛔ revocado', rejected: '🚫 RECHAZADO', secrets: '🔑 secretos leídos', 'secret.set': '🔑 secreto guardado', 'secret.rm': '🔑 secreto borrado' }
   for (const line of lines.slice(-n)) {
     try {
@@ -1610,6 +1663,8 @@ function help () {
                       (--machine para volver a la clave de esta máquina). Editar
                       atrest.json a mano NO vale: dejaría el perfil ilegible
   activity [n]        bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
+  activity --verify   comprueba que la cadena está entera (nadie tocó el pasado)
+  activity --export   la vuelca entera en JSONL, para auditar o guardar fuera
   logs                últimos logs del servicio
   version             muestra la versión instalada
 
@@ -1664,7 +1719,9 @@ export async function runCtl (argv) {
     case 'secret': return cmdSecret(rest)
     case 'approval': return cmdApproval(rest)
     case 'atrest': return cmdAtrest(rest)
-    case 'activity': return cmdActivity(Number(rest[0]) || 30)
+    case 'activity': return cmdActivity(Number(rest.find((a) => /^\d+$/.test(a))) || 30, {
+      verify: rest.includes('--verify'), exportar: rest.includes('--export')
+    })
     case 'logs': return cmdLogs()
     case 'version':
     case '--version':

package/src/vault.js

@@ -11,6 +11,7 @@
  * Toda la cripto es de `@dotrino/identity`. Este módulo solo orquesta.
  */
 import fs from 'node:fs'
+import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
@@ -367,18 +368,81 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // 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)
   } catch (_) { /* no hay bitácora todavía */ }
+  /**
+   * LA BITÁCORA ES UNA CADENA, no una lista de líneas sueltas.
+   *
+   * Cifrarla (0.89) le dio confidencialidad y ninguna integridad: quien tenga la llave de
+   * la máquina puede reescribir una línea y nadie lo nota. Como evidencia no valía nada, y
+   * eso es justo lo que un auditor mira (`CUMPLIMIENTO.md` §2).
+   *
+   * Cada entrada lleva su `seq` y el **hash de la anterior**, así que tocar o quitar una
+   * rompe la cadena de ahí en adelante y se ve. Se encadena el TEXTO exacto de la línea,
+   * no un objeto re-serializado: así verificar no depende de que las claves salgan en el
+   * mismo orden.
+   *
+   * **Lo que esto NO resuelve, dicho para no venderlo de más:** quien tenga la máquina
+   * puede cortar el final de la cadena y quedarse con un prefijo válido. Eso no se cierra
+   * en local — pide anclar el último hash fuera (un TSA, otro aparato). Lo que sí cierra
+   * es reescribir el pasado sin dejar rastro, que es el caso que importaba.
+   */
+  const AUDIT_MAX_BYTES = 1024 * 1024
+  /** Cuántos archivos viejos se guardan. Es la RETENCIÓN, y va declarada. */
+  const AUDIT_KEEP = 5
+  const sha256 = (text) => nodeCrypto.createHash('sha256').update(text, 'utf8').digest('hex')
+
+  let auditSeq = 0
+  let auditPrev = null
+
+  /** Reconstruye el estado de la cadena leyendo la última entrada que haya. */
+  try {
+    const lines = fs.readFileSync(activityFile, 'utf8').split('\n').filter(Boolean)
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const text = activityAtRest.decrypt(lines[i])
+        const e = JSON.parse(text)
+        if (typeof e.logSeq === 'number') { auditSeq = e.logSeq; auditPrev = sha256(text); break }
+      } catch (_) { /* una línea vieja o ilegible: se sigue hacia atrás */ }
+    }
+  } catch (_) { /* no hay bitácora todavía */ }
+
+  /**
+   * ROTA ARCHIVANDO, NO TIRANDO. Antes se quedaba con la mitad del archivo y la otra mitad
+   * desaparecía sin que nada lo dijera: una bitácora que pierde historia en silencio es
+   * peor que no tenerla, porque parece completa. Ahora los viejos se corren a `.1`…`.N` y,
+   * cuando uno se cae del borde, **queda anotado que se cayó**.
+   */
+  const rotateAudit = () => {
+    let dropped = null
+    const older = `${activityFile}.${AUDIT_KEEP}`
+    try { if (fs.existsSync(older)) { fs.rmSync(older); dropped = `activity.log.${AUDIT_KEEP}` } } catch (_) {}
+    for (let i = AUDIT_KEEP - 1; i >= 1; i--) {
+      try { if (fs.existsSync(`${activityFile}.${i}`)) fs.renameSync(`${activityFile}.${i}`, `${activityFile}.${i + 1}`) } catch (_) {}
+    }
+    try { fs.renameSync(activityFile, `${activityFile}.1`) } catch (_) {}
+    return dropped
+  }
+
   const audit = (op, info = {}) => {
     try {
-      const line = activityAtRest.encrypt(JSON.stringify({ ts: Date.now(), op, ...info }))
-      fs.appendFileSync(activityFile, line + '\n', { mode: 0o600 })
+      // LOS CAMPOS DE LA CADENA VAN AL FINAL Y CON NOMBRE PROPIO, y las dos cosas por el
+      // mismo motivo: que quien llama no pueda pisarlos.
+      //
+      // Estaban delante y se llamaban `seq`/`prev`, así que `...info` los sobrescribía. Y
+      // no era hipotético: `renew` ya mandaba un `seq` —el del ACTA, que no tiene nada que
+      // ver— y dejaba dos entradas seguidas numeradas igual. Lo cazó el propio verificador
+      // contra la bitácora de producción a los diez minutos de desplegarlo, que es
+      // exactamente para lo que sirve.
+      const entry = { ...info, ts: Date.now(), op, logSeq: ++auditSeq, logPrev: auditPrev }
+      const text = JSON.stringify(entry)
+      fs.appendFileSync(activityFile, activityAtRest.encrypt(text) + '\n', { mode: 0o600 })
+      auditPrev = sha256(text)
       // El `mode` de `appendFileSync` solo aplica al CREAR: las bitácoras de antes de
       // 0.89 ya existen con 0664 y hay que estrecharlas a mano.
       try { if ((fs.statSync(activityFile).mode & 0o077) !== 0) fs.chmodSync(activityFile, 0o600) } catch (_) {}
-      // rotación simple: si pasa de ~1 MB, conservar la última mitad
-      const st = fs.statSync(activityFile)
-      if (st.size > 1024 * 1024) {
-        const lines = fs.readFileSync(activityFile, 'utf8').split('\n')
-        fs.writeFileSync(activityFile, lines.slice(Math.floor(lines.length / 2)).join('\n'), { mode: 0o600 })
+      if (fs.statSync(activityFile).size > AUDIT_MAX_BYTES) {
+        const dropped = rotateAudit()
+        // La primera entrada del archivo nuevo dice de dónde viene, y si se perdió algo.
+        audit('log.rotated', { keep: AUDIT_KEEP, ...(dropped ? { dropped } : {}) })
       }
     } catch (_) {}
   }