@dotrino/vaultd 0.12.0 → 0.13.0

package/src/paths.js

@@ -1,8 +1,14 @@
 /**
  * Resolución del directorio de datos y escritura de archivos con permisos
- * restrictivos (0600). En v1 la clave maestra va en claro dentro de este dir
- * (la guarda `@dotrino/identity` en `identity.json`); 0600 evita que sea
- * world-readable. v2 añadirá cifrado en reposo con contraseña maestra.
+ * restrictivos (0600) **y cifrados en reposo**.
+ *
+ * `readJson`/`writeJson` aceptan un códec de reposo (`atRestFor(dir)`, ver
+ * `atrest.js`): con él, el contenido del archivo NO queda en claro en el disco.
+ * Lo usan TODOS los archivos de datos del vault —identidad, árbol de contenido
+ * (`vault.json`), hilos y perfil (`threads.json`) y secretos de servicios
+ * (`secrets.json`)—, no solo la identidad: el contenido del usuario merece el
+ * mismo trato que la maestra. `decrypt` deja pasar el texto en claro, así que
+ * una instalación anterior se lee igual y queda cifrada en la primera escritura.
  */
 import os from 'node:os'
 import path from 'node:path'
@@ -33,15 +39,25 @@ export function ensureDir (dir) {
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
 }
 
-export function readJson (file, fallback) {
-  try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch (_) { return fallback }
+/** @param {{decrypt:(t:string)=>string}} [atRest] códec de reposo (`atRestFor(dir)`). */
+export function readJson (file, fallback, atRest) {
+  try {
+    let text = fs.readFileSync(file, 'utf8')
+    if (atRest) text = atRest.decrypt(text)
+    return JSON.parse(text)
+  } catch (_) { return fallback }
 }
 
-/** Escritura atómica (tmp + rename) con modo 0600. */
-export function writeJson (file, obj) {
+/**
+ * Escritura atómica (tmp + rename) con modo 0600. Con `atRest`, el archivo se
+ * escribe CIFRADO (nunca toca el disco en claro: se cifra antes del tmp).
+ * @param {{encrypt:(t:string)=>string}} [atRest]
+ */
+export function writeJson (file, obj, atRest) {
   ensureDir(path.dirname(file))
+  const text = JSON.stringify(obj, null, 2)
   const tmp = file + '.tmp'
-  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2), { mode: 0o600 })
+  fs.writeFileSync(tmp, atRest ? atRest.encrypt(text) : text, { mode: 0o600 })
   fs.renameSync(tmp, file)
   try { fs.chmodSync(file, 0o600) } catch (_) {}
 }

package/src/profiles.js

@@ -28,8 +28,14 @@ const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // mismo coste que el candado del navegador
 const MAX_NAME = 40
 
-/** Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz. */
-const LEGACY_FILES = ['identity.json', 'peers.json', 'vault.json', 'threads.json', 'secrets.json', 'activity.log']
+/**
+ * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
+ *
+ * `atrest.salt` va en la lista y NO es un detalle: los datos van cifrados con una clave
+ * derivada del salt que vive JUNTO a ellos, así que mover los archivos sin el salt los
+ * dejaría ilegibles (la clave se derivaría de un salt nuevo). Se mudan juntos.
+ */
+const LEGACY_FILES = ['identity.json', 'peers.json', 'vault.json', 'threads.json', 'secrets.json', 'activity.log', 'atrest.salt']
 
 const b64 = (buf) => Buffer.from(new Uint8Array(buf)).toString('base64')
 
@@ -70,7 +76,7 @@ export function openProfiles (root = dataDir()) {
 
   function assertExists (id) {
     const p = find(id)
-    if (!p) throw new Error('el perfil no existe: ' + id)
+    if (!p) throw new Error('profile does not exist: ' + id)
     return p
   }
 
@@ -92,7 +98,7 @@ export function openProfiles (root = dataDir()) {
       const hits = data.profiles.filter((p) => (p.name || '').toLowerCase() === needle)
       if (hits.length === 1) return hits[0].id
       if (hits.length > 1) throw new Error(`hay ${hits.length} perfiles llamados "${ref}"; usa su id (dotrino-vault profile ls)`)
-      throw new Error('el perfil no existe: ' + ref)
+      throw new Error('profile does not exist: ' + ref)
     },
 
     /**
@@ -162,7 +168,7 @@ export function openProfiles (root = dataDir()) {
     /** Borra el perfil y TODOS sus datos (incluida su maestra). Irreversible. */
     remove (id) {
       const p = assertExists(id)
-      if (data.profiles.length <= 1) throw new Error('no se puede borrar el único perfil')
+      if (data.profiles.length <= 1) throw new Error('cannot delete the only profile')
       api.assertUnlocked(id)
       data.profiles = data.profiles.filter((x) => x.id !== id)
       if (data.current === id) data.current = data.profiles[0].id
@@ -177,7 +183,7 @@ export function openProfiles (root = dataDir()) {
     isProtected: (id) => !!find(id)?.pwd,
     isLocked: (id) => { const p = find(id); return !!p?.pwd && !unlocked.has(id) },
     assertUnlocked (id) {
-      if (api.isLocked(id)) throw new Error('perfil bloqueado: desbloquéalo con tu contraseña (dotrino-vault unlock)')
+      if (api.isLocked(id)) throw new Error('profile locked: unlock it with your password (dotrino-vault unlock)')
     },
 
     async unlock (id, password) {
@@ -193,7 +199,7 @@ export function openProfiles (root = dataDir()) {
       if (proof !== p.pwd.verifier) {
         p.tries = { n: tries.n + 1, at: Date.now() }
         save()
-        throw new Error('contraseña incorrecta')
+        throw new Error('wrong password')
       }
       delete p.tries
       save()
@@ -207,7 +213,7 @@ export function openProfiles (root = dataDir()) {
     async setPassword (id, password) {
       const p = assertExists(id)
       api.assertUnlocked(id)
-      if (!password || String(password).length < 4) throw new Error('la contraseña debe tener al menos 4 caracteres')
+      if (!password || String(password).length < 4) throw new Error('password must be at least 4 characters')
       const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
       p.pwd = { v: 1, salt, iter: PWD_ITER, verifier: await derivePwd(password, salt, PWD_ITER) }
       delete p.tries

package/src/secretsStore.js

@@ -1,12 +1,14 @@
 /**
  * Store de SECRETOS de servicios (`secrets.json`, 0600, mismo dir 0700 que la
- * maestra — mismo dominio de confianza, v1 en claro en reposo igual que
- * `identity.json`; el cifrado en reposo con contraseña llega con v2 para todo
- * el dir). Organizado por NAMESPACE de servicio (`proxy`, `geo`, `bots`…):
- * un cert `vault:secrets:<ns>` solo puede leer SU ns.
+ * maestra — mismo dominio de confianza, y **cifrado en reposo** con la misma
+ * clave ligada a la máquina que la identidad, ver `atrest.js`: son tokens y
+ * llaves de producción, no pueden quedar en claro en el disco). Organizado por
+ * NAMESPACE de servicio (`proxy`, `geo`, `bots`…): un cert
+ * `vault:secrets:<ns>` solo puede leer SU ns.
  */
 import path from 'node:path'
 import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
 import { isValidSecretsNs } from './protocol.js'
 
 const SCHEMA_VERSION = 1
@@ -15,15 +17,16 @@ const KEY_RE = /^[A-Z0-9_]{1,64}$/
 
 export function openSecretsStore (dir) {
   const file = path.join(dir, 'secrets.json')
-  let data = readJson(file, null)
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
   if (!data || data.schemaVersion !== SCHEMA_VERSION) {
     data = { schemaVersion: SCHEMA_VERSION, ns: {} }
-    writeJson(file, data)
   }
-  const save = () => writeJson(file, data)
+  writeJson(file, data, atRest) // reescribe al abrir: cifra lo que venía en claro
+  const save = () => writeJson(file, data, atRest)
 
   const assertNs = (ns) => {
-    if (!isValidSecretsNs(ns)) throw new Error('namespace inválido (usa [a-z0-9-]{1,32}, p.ej. "proxy")')
+    if (!isValidSecretsNs(ns)) throw new Error('invalid namespace (use [a-z0-9-]{1,32}, e.g. "proxy")')
   }
 
   return {
@@ -34,9 +37,9 @@ export function openSecretsStore (dir) {
     },
     set (ns, key, value) {
       assertNs(ns)
-      if (!KEY_RE.test(String(key || ''))) throw new Error('clave inválida (usa MAYUSCULAS_CON_GUION_BAJO, p.ej. TURN_KEY_ID)')
-      if (typeof value !== 'string' || !value) throw new Error('el valor debe ser un string no vacío')
-      if (value.length > MAX_VALUE_LEN) throw new Error(`valor demasiado largo (máx ${MAX_VALUE_LEN})`)
+      if (!KEY_RE.test(String(key || ''))) throw new Error('invalid key (use UPPERCASE_WITH_UNDERSCORES, e.g. TURN_KEY_ID)')
+      if (typeof value !== 'string' || !value) throw new Error('value must be a non-empty string')
+      if (value.length > MAX_VALUE_LEN) throw new Error(`value too long (max ${MAX_VALUE_LEN})`)
       if (!data.ns[ns]) data.ns[ns] = {}
       data.ns[ns][key] = value
       save()

package/src/store.js

@@ -1,12 +1,14 @@
 /**
- * Store del árbol de contenidos del vault (`vault.json`). Versionado con
- * `schemaVersion` para que v2 pueda introducir cifrado en reposo sin migración
- * dolorosa. NO guarda identidad/dispositivos/certs: de eso se encarga
+ * Store del árbol de contenidos del vault (`vault.json`). **Cifrado en reposo**
+ * con la misma clave ligada a la máquina que la identidad (`atrest.js`): el
+ * contenido del usuario no es menos sensible que la maestra. NO guarda
+ * identidad/dispositivos/certs: de eso se encarga
  * `@dotrino/identity` dentro del mismo dir (keypair, contactos, delegaciones,
  * revocaciones). Aquí vive solo lo del usuario: el árbol y los settings.
  */
 import path from 'node:path'
 import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
 
 const SCHEMA_VERSION = 1
 
@@ -28,12 +30,15 @@ function findNode (node, id) {
 
 export function openStore (dir) {
   const file = path.join(dir, 'vault.json')
-  let data = readJson(file, null)
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
   if (!data || data.schemaVersion !== SCHEMA_VERSION) {
     data = { schemaVersion: SCHEMA_VERSION, tree: newTree(), settings: {} }
-    writeJson(file, data)
   }
-  const save = () => writeJson(file, data)
+  // Se reescribe SIEMPRE al abrir: así un archivo de una instalación anterior
+  // (en claro) queda cifrado sin pedirle nada al usuario.
+  writeJson(file, data, atRest)
+  const save = () => writeJson(file, data, atRest)
 
   return {
     get raw () { return data },
@@ -41,7 +46,7 @@ export function openStore (dir) {
     getNode (id) { return findNode(data.tree, id || 'root') },
     addNode (parentId, node) {
       const parent = findNode(data.tree, parentId || 'root')
-      if (!parent) throw new Error('nodo padre no encontrado: ' + parentId)
+      if (!parent) throw new Error('parent node not found: ' + parentId)
       if (!Array.isArray(parent.children)) parent.children = []
       parent.children.push(node)
       save()

package/src/threadStore.js

@@ -9,19 +9,32 @@
  *
  * File-backed (`threads.json`), síncrono y simple (sin cuota/IndexedDB). Es el
  * backend autoritativo; el navegador usa su IndexedDB como caché y sincroniza.
+ * **Cifrado en reposo** con la clave ligada a la máquina (`atrest.js`): aquí
+ * vive el contenido de las apps y el perfil del usuario, que es exactamente lo
+ * que el ecosistema promete que no queda en claro en ningún disco.
  */
 import path from 'node:path'
 import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
 
 const MAX_PER_THREAD = 1000
 
+// 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.
+const MAX_SECURE_ITEMS = 2000
+const MAX_SECURE_BLOB = 64 * 1024   // por campo sellado (meta y valor)
+
 export function openThreadStore (dir) {
   const file = path.join(dir, 'threads.json')
-  let data = readJson(file, null)
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
   if (!data || typeof data !== 'object') data = { v: 1, threads: {}, opens: {} }
   if (!data.threads) data.threads = {}
   if (!data.opens) data.opens = {}
-  const save = () => writeJson(file, data)
+  if (!data.secure) data.secure = {}
+  const save = () => writeJson(file, data, atRest)
+  save() // reescribe al abrir: cifra lo que venía en claro
   const trim = (arr) => { if (arr.length > MAX_PER_THREAD) arr.splice(0, arr.length - MAX_PER_THREAD) }
 
   const methods = {
@@ -89,16 +102,75 @@ export function openThreadStore (dir) {
       save(); return { ok: true, updatedAt: data.profile.updatedAt }
     },
     profileGet () { return { me: data.profile || null } },
+
+    // ----- DATOS SENSIBLES del usuario (F4, docs/consola-remota.md §6) -----
+    //
+    // Contraseñas, notas, documentos: van al contenido del perfil, cifrados con la
+    // CEK de la cuenta y accesibles con `vault:store` — el mismo camino que hilos y
+    // perfil. NO tocan `secrets.json`: ese es el cajón de los SERVICIOS (proxy, geo),
+    // acotado por CN y con clave ligada a la máquina. Mismo nombre coloquial, distinto
+    // dueño.
+    //
+    // La bóveda guarda DOS SOBRES OPACOS por ficha y no abre ninguno:
+    //   `meta` — lo que hace falta para pintar la lista (nombre, tipo, carpeta)
+    //   `enc`  — el valor en sí, que solo viaja cuando abres la ficha
+    // Los sella el dispositivo con la clave de contenido (`identity.sealContent`). Que
+    // sean dos y no uno es lo que permite listar sin bajar todas las contraseñas, y que
+    // el nombre («Banco») tampoco quede legible aquí.
+    //
+    // Alcance: esto es el ALMACÉN. Una app de contraseñas con generador y
+    // autocompletado es otra cosa y no vive aquí.
+    'secure.list' () {
+      return Object.values(data.secure)
+        .map(({ enc, ...rest }) => rest)   // el valor NO viaja al listar
+        .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0))
+    },
+    'secure.get' ({ id }) {
+      if (!id || typeof id !== 'string') throw new Error('id required')
+      return data.secure[id] || null
+    },
+    'secure.put' ({ id, meta, enc }) {
+      if (typeof enc !== 'string' || !enc) throw new Error('enc required (sealed value)')
+      if (meta != null && typeof meta !== 'string') throw new Error('meta must be a sealed string')
+      // Se comprueba el TAMAÑO, nunca el contenido: son sobres cerrados.
+      if (enc.length > MAX_SECURE_BLOB || (meta || '').length > MAX_SECURE_BLOB) throw new Error('secure: item too large')
+      const prev = id ? data.secure[id] : null
+      if (!prev && Object.keys(data.secure).length >= MAX_SECURE_ITEMS) throw new Error('secure: too many items')
+      const rec = {
+        id: prev?.id || id || crypto.randomUUID(),
+        ts: prev?.ts || Date.now(),
+        updatedAt: Date.now(),
+        meta: meta ?? prev?.meta ?? null,
+        enc
+      }
+      data.secure[rec.id] = rec
+      save()
+      return { id: rec.id, updatedAt: rec.updatedAt }
+    },
+    'secure.del' ({ id }) {
+      if (!id || typeof id !== 'string') throw new Error('id required')
+      const had = !!data.secure[id]
+      delete data.secure[id]
+      if (had) save()
+      return { removed: had ? 1 : 0 }
+    },
+
     getStats () {
       const threads = {}
       for (const [k, arr] of Object.entries(data.threads)) threads[k] = { count: arr.length }
-      return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length }
+      return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length, secureCount: Object.keys(data.secure).length }
     }
   }
   return { methods, raw: () => data }
 }
 
-/** Métodos del store que son de SOLO LECTURA (para decidir el scope necesario). */
+/**
+ * Métodos del store que son de SOLO LECTURA (para decidir el scope necesario).
+ *
+ * `secure.list`/`secure.get` NO están aquí a propósito, aunque sean lecturas: los datos
+ * sensibles piden `vault:store` (doc §6), que es MÁS estricto que `vault:read`. Un
+ * dispositivo al que solo le diste «leer» no lee tus contraseñas.
+ */
 export const STORE_READ_METHODS = new Set([
   'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet'
 ])