@dotrino/vaultd 0.155.0 → 0.156.0

package/lib/src/proc.js

@@ -29,19 +29,10 @@
  */
 import fs from 'node:fs'
 import os from 'node:os'
-import crypto from 'node:crypto'
 import { cleanMachine } from '@dotrino/identity/machine'
+import { MAX_PATH_BYTES, clip, trimArgv, sanitizeContext, commandFingerprint, sameCommand, commandLine } from './procContext.js'
 
-/** Topes. Un `argv` puede ser enorme y esto viaja en cada pedido y se pinta en un teléfono. */
-export const MAX_ARGV_BYTES = 4096
-export const MAX_PATH_BYTES = 1024
-/** Cuántos argumentos como mucho: más que esto no lo lee nadie. */
-export const MAX_ARGV_ITEMS = 64
-
-const clip = (s, max) => {
-  if (typeof s !== 'string') return ''
-  return Buffer.byteLength(s) <= max ? s : Buffer.from(s).subarray(0, max).toString('utf8')
-}
+export { MAX_ARGV_BYTES, MAX_PATH_BYTES, MAX_ARGV_ITEMS, sanitizeContext, commandFingerprint, sameCommand, commandLine } from './procContext.js'
 
 /** ¿Hay `/proc`? Es lo que separa poder medir de tener que creer. */
 export const hasProc = () => { try { return fs.statSync('/proc/self').isDirectory() } catch (_) { return false } }
@@ -54,24 +45,6 @@ function readCmdline (pid) {
   return parts
 }
 
-/**
- * Recorta el `argv` a lo que se puede enseñar y transportar. Devuelve también si sobró
- * algo: un comando cortado que no dice que está cortado se lee como otro comando.
- */
-function trimArgv (argv) {
-  const list = (Array.isArray(argv) ? argv : []).map((a) => String(a))
-  let cut = list.length > MAX_ARGV_ITEMS
-  const kept = list.slice(0, MAX_ARGV_ITEMS)
-  let total = 0
-  const out = []
-  for (const a of kept) {
-    const b = Buffer.byteLength(a)
-    if (total + b > MAX_ARGV_BYTES) { cut = true; break }
-    total += b
-    out.push(a)
-  }
-  return { argv: out, truncated: cut }
-}
 
 /**
  * LA HORA DE ARRANQUE del proceso (campo 22 de `/proc/<pid>/stat`, en ticks). Sirve para
@@ -146,59 +119,4 @@ export function selfMachine () {
 const safeCwd = () => { try { return process.cwd() } catch (_) { return '' } }
 const userName = () => { try { return os.userInfo().username } catch (_) { return '' } }
 
-/**
- * LO QUE LLEGA POR LA RED NO SE CREE NI EN LA FORMA. Este dato lo manda otro proceso, se
- * guarda en memoria y se pinta en un teléfono: se recorta a lo que cabe y se tira lo que no
- * tiene el tipo que debería. Devuelve `null` si no queda nada que enseñar — que no es lo
- * mismo que un contexto vacío, y por eso no se devuelve un objeto a medias.
- */
-export function sanitizeContext (raw) {
-  if (!raw || typeof raw !== 'object') return null
-  const argvRaw = Array.isArray(raw.argv) ? raw.argv.filter((a) => typeof a === 'string') : []
-  const { argv, truncated } = trimArgv(argvRaw)
-  const exe = clip(typeof raw.exe === 'string' ? raw.exe : '', MAX_PATH_BYTES)
-  const cwd = clip(typeof raw.cwd === 'string' ? raw.cwd : '', MAX_PATH_BYTES)
-  if (!exe && !argv.length) return null
-  return {
-    pid: Number.isInteger(raw.pid) && raw.pid > 0 ? raw.pid : null,
-    uid: Number.isInteger(raw.uid) ? raw.uid : null,
-    exe,
-    cwd,
-    argv,
-    truncated: truncated || raw.truncated === true,
-    start: Number.isFinite(raw.start) ? raw.start : null,
-    user: clip(typeof raw.user === 'string' ? raw.user : '', 64),
-    host: clip(typeof raw.host === 'string' ? raw.host : '', 64)
-  }
-}
-
-/**
- * LA HUELLA DEL COMANDO: qué binario, desde qué carpeta y con qué argumentos. Es la llave
- * de la concesión por tiempo — aprobar `node server.js` en `/srv/app` no aprueba otra cosa
- * ni la misma cosa en otro sitio.
- *
- * El pid NO entra: cambia en cada arranque y la gracia es justamente que el mismo comando
- * se reconozca la próxima vez.
- */
-export function commandFingerprint (ctx) {
-  if (!ctx || typeof ctx !== 'object') return null
-  const argv = Array.isArray(ctx.argv) ? ctx.argv : []
-  if (!ctx.exe && !argv.length) return null
-  const material = [ctx.exe || '', ctx.cwd || '', ...argv].join('\0')
-  return crypto.createHash('sha256').update(material).digest('hex')
-}
-
-/** ¿Son el mismo comando? Mismo binario, misma carpeta, mismos argumentos. */
-export const sameCommand = (a, b) => {
-  const fa = commandFingerprint(a)
-  return !!fa && fa === commandFingerprint(b)
-}
-
-/** El comando en una línea, para un log o una pantalla estrecha. */
-export function commandLine (ctx, max = 160) {
-  const argv = Array.isArray(ctx?.argv) ? ctx.argv : []
-  const linea = argv.length ? argv.join(' ') : (ctx?.exe || '')
-  return linea.length > max ? linea.slice(0, max - 1) + '…' : linea
-}
-
 export default { selfContext, readProcContext, sanitizeContext, commandFingerprint, sameCommand, commandLine, hasProc }

package/lib/src/procContext.js

@@ -0,0 +1,97 @@
+/**
+ * LA PARTE PORTABLE DE `proc.js`: limpiar el contexto que declara quien pide, su huella y su
+ * línea. La usan el binario y la bóveda del navegador (que no tiene `/proc` y nunca mide,
+ * así que todo lo que le llega se queda como declarado). Leer `/proc` sigue en `proc.js`,
+ * que es solo de Node.
+ */
+import { sha256Hex } from './core/sha256.js'
+
+/** Topes. Un `argv` puede ser enorme y esto viaja en cada pedido y se pinta en un teléfono. */
+export const MAX_ARGV_BYTES = 4096
+export const MAX_PATH_BYTES = 1024
+/** Cuántos argumentos como mucho: más que esto no lo lee nadie. */
+export const MAX_ARGV_ITEMS = 64
+
+const enc = new TextEncoder()
+const byteLength = (s) => enc.encode(s).length
+export const clip = (s, max) => {
+  if (typeof s !== 'string') return ''
+  const b = enc.encode(s)
+  return b.length <= max ? s : new TextDecoder().decode(b.subarray(0, max))
+}
+
+/**
+ * Recorta el `argv` a lo que se puede enseñar y transportar. Devuelve también si sobró
+ * algo: un comando cortado que no dice que está cortado se lee como otro comando.
+ */
+export function trimArgv (argv) {
+  const list = (Array.isArray(argv) ? argv : []).map((a) => String(a))
+  let cut = list.length > MAX_ARGV_ITEMS
+  const kept = list.slice(0, MAX_ARGV_ITEMS)
+  let total = 0
+  const out = []
+  for (const a of kept) {
+    const b = byteLength(a)
+    if (total + b > MAX_ARGV_BYTES) { cut = true; break }
+    total += b
+    out.push(a)
+  }
+  return { argv: out, truncated: cut }
+}
+
+/**
+ * LO QUE LLEGA POR LA RED NO SE CREE NI EN LA FORMA. Este dato lo manda otro proceso, se
+ * guarda en memoria y se pinta en un teléfono: se recorta a lo que cabe y se tira lo que no
+ * tiene el tipo que debería. Devuelve `null` si no queda nada que enseñar — que no es lo
+ * mismo que un contexto vacío, y por eso no se devuelve un objeto a medias.
+ */
+export function sanitizeContext (raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const argvRaw = Array.isArray(raw.argv) ? raw.argv.filter((a) => typeof a === 'string') : []
+  const { argv, truncated } = trimArgv(argvRaw)
+  const exe = clip(typeof raw.exe === 'string' ? raw.exe : '', MAX_PATH_BYTES)
+  const cwd = clip(typeof raw.cwd === 'string' ? raw.cwd : '', MAX_PATH_BYTES)
+  if (!exe && !argv.length) return null
+  return {
+    pid: Number.isInteger(raw.pid) && raw.pid > 0 ? raw.pid : null,
+    uid: Number.isInteger(raw.uid) ? raw.uid : null,
+    exe,
+    cwd,
+    argv,
+    truncated: truncated || raw.truncated === true,
+    start: Number.isFinite(raw.start) ? raw.start : null,
+    user: clip(typeof raw.user === 'string' ? raw.user : '', 64),
+    host: clip(typeof raw.host === 'string' ? raw.host : '', 64)
+  }
+}
+
+/**
+ * LA HUELLA DEL COMANDO: qué binario, desde qué carpeta y con qué argumentos. Es la llave
+ * de la concesión por tiempo — aprobar `node server.js` en `/srv/app` no aprueba otra cosa
+ * ni la misma cosa en otro sitio.
+ *
+ * El pid NO entra: cambia en cada arranque y la gracia es justamente que el mismo comando
+ * se reconozca la próxima vez.
+ */
+export function commandFingerprint (ctx) {
+  if (!ctx || typeof ctx !== 'object') return null
+  const argv = Array.isArray(ctx.argv) ? ctx.argv : []
+  if (!ctx.exe && !argv.length) return null
+  const material = [ctx.exe || '', ctx.cwd || '', ...argv].join('\0')
+  return sha256Hex(material)
+}
+
+/** ¿Son el mismo comando? Mismo binario, misma carpeta, mismos argumentos. */
+export const sameCommand = (a, b) => {
+  const fa = commandFingerprint(a)
+  return !!fa && fa === commandFingerprint(b)
+}
+
+/** El comando en una línea, para un log o una pantalla estrecha. */
+export function commandLine (ctx, max = 160) {
+  const argv = Array.isArray(ctx?.argv) ? ctx.argv : []
+  const linea = argv.length ? argv.join(' ') : (ctx?.exe || '')
+  return linea.length > max ? linea.slice(0, max - 1) + '…' : linea
+}
+
+export default { sanitizeContext, commandFingerprint, sameCommand, commandLine, trimArgv }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.155.0",
+  "version": "0.156.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": {
@@ -22,11 +22,11 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "^0.115.0",
+    "@dotrino/identity": "^0.116.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
     "@dotrino/proxy-client": "^0.32.2",
-    "@dotrino/roadmap": "0.3.19",
+    "@dotrino/roadmap": "0.4.13",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.5.1",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -30,7 +30,7 @@ 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.
 import { ipcRead, ipcWrite } from './ipc.js'
-import { assertVar } from './secretsStore.js'
+import { assertVar } from '../lib/src/core/secretsStore.js'
 import { isValidSecretsNs } from './protocol.js'
 import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
@@ -39,7 +39,7 @@ import { atRestFor, readConfig as readKekConfig, probe as probeKek, rekeyDir, en
 import { VERSION } from './version.js'
 import * as hw from './hwkeys.js'
 import { isNewer } from './update.js'
-import { COMM_CN } from './commKey.js'
+import { COMM_CN } from '../lib/src/core/commKey.js'
 import { machineLine } from '@dotrino/identity/machine'
 
 const dir = dataDir()

package/src/daemon.js

@@ -29,7 +29,7 @@ import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelea
 import { VERSION } from './version.js'
 import { readSettings } from './settings.js'
 import { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo, readRootTold, writeRootTold, shouldTellRoot } from './updateApproval.js'
-import { UPDATE_TTL_MS } from './approvals.js'
+import { UPDATE_TTL_MS } from '../lib/src/core/approvals.js'
 import crypto from 'node:crypto'
 
 const readJsonSafe = (f) => ipcRead(f, null)

package/src/disk.js

@@ -0,0 +1,54 @@
+/**
+ * EL DISCO DEL BINARIO: archivos de verdad bajo el directorio del perfil, en modo 0600 y
+ * cifrados en reposo con la llave de esta máquina. Es la implementación de la interfaz de
+ * `lib/src/core/disk.js` que usa el demonio; el navegador pone la suya.
+ *
+ * Todo lo que es de Node y de un sistema de archivos con permisos (el `chmod`, escribir
+ * aparte y renombrar) vive aquí, y no en el núcleo, para que el núcleo sea el mismo código
+ * en las tres bóvedas.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { atRestFor, kekFor } from './atrest.js'
+import { ensureDir } from './paths.js'
+
+/** El modo de un archivo que existía con otro más abierto (las bitácoras de antes de 0.89). */
+function narrow (file) {
+  try { if ((fs.statSync(file).mode & 0o077) !== 0) fs.chmodSync(file, 0o600) } catch (_) {}
+}
+
+export function nodeDisk (dir, { atRest = null } = {}) {
+  ensureDir(dir)
+  const at = (name) => path.join(dir, name)
+  return {
+    dir,
+    read (name) {
+      try { return fs.readFileSync(at(name), 'utf8') } catch (e) {
+        if (e.code === 'ENOENT') return null
+        throw e
+      }
+    },
+    write (name, text) {
+      const file = at(name)
+      ensureDir(path.dirname(file))
+      const tmp = file + '.tmp'
+      fs.writeFileSync(tmp, text, { mode: 0o600 })
+      fs.renameSync(tmp, file)
+      narrow(file)
+    },
+    append (name, text) {
+      const file = at(name)
+      fs.appendFileSync(file, text, { mode: 0o600 })
+      // El `mode` de `appendFileSync` solo aplica al CREAR.
+      narrow(file)
+    },
+    exists: (name) => fs.existsSync(at(name)),
+    remove: (name) => { fs.rmSync(at(name), { force: true }) },
+    rename: (from, to) => { fs.renameSync(at(from), at(to)) },
+    size: (name) => { try { return fs.statSync(at(name)).size } catch (_) { return 0 } },
+    atRest: atRest || atRestFor(dir),
+    machineKey: () => new Uint8Array(kekFor(dir))
+  }
+}
+
+export default { nodeDisk }

package/src/platform.js

@@ -0,0 +1,139 @@
+/**
+ * LO QUE EL BINARIO PONE PARA CORRER LA BÓVEDA (`lib/src/core/vault.js`): el disco del
+ * perfil, la identidad leída de su directorio, `/proc`, el nombre de la máquina y el
+ * mostrador local por socket de archivo. El navegador pone lo suyo en
+ * `lib/src/core/browserPlatform.js`; el núcleo es el mismo.
+ */
+import fs from 'node:fs'
+import net from 'node:net'
+import os from 'node:os'
+import path from 'node:path'
+import { Identity } from '@dotrino/identity/node'
+import { MSG } from '../lib/src/protocol.js'
+import { readProcContext } from '../lib/src/proc.js'
+import { localSocketPath, socketDir } from '../lib/src/localdesk.js'
+import { kekFor, migrateFile, encryptText, decryptText, atRestFor } from './atrest.js'
+import { assertKeyOwnsDir } from './keyowner.js'
+import { installNodeGlobals } from './node-globals.js'
+import { nodeDisk } from './disk.js'
+import { VERSION } from './version.js'
+
+/**
+ * EL MOSTRADOR LOCAL: el mismo protocolo, sin salir de la máquina.
+ *
+ * Un servicio en ESTA máquina hablaba con la bóveda dando la vuelta por
+ * `proxy.dotrino.com`: sale a internet, vuelve, y si el proxio tiene un mal momento el
+ * arranque se retrasa cinco segundos por nada. Absurdo cuando los dos procesos comparten
+ * disco (dueño, 2026-09-03: «estando en la misma máquina debería ser inmediato»).
+ *
+ * Es EL MISMO PROTOCOLO y el mismo enrutador: llega `{type, data, signature, cert}` y se
+ * comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket no
+ * autoriza nada** — es la misma puerta por un camino más corto, no una puerta de atrás.
+ * Por eso no hay un solo `if` de «viene de local» en ningún handler, y no debe haberlo.
+ *
+ * Y no es un puerto: es un socket de archivo, en modo 0600 y bajo el directorio del
+ * usuario. No se alcanza desde otra máquina ni desde otro usuario, así que la promesa
+ * del `docker-compose` —«la bóveda no escucha nada»— sigue siendo cierta donde importa.
+ */
+function openLocalDesk ({ name, onMessage, channels: canales, maxBytes: MAX_REPLY_BYTES, log }) {
+  const socketPath = localSocketPath(name)
+  let n = 0
+  const server = net.createServer((sock) => {
+    const id = 'local:' + (++n)
+    let buf = ''
+    const enviar = (obj) => { try { sock.write(JSON.stringify(obj) + '\n') } catch (_) {} }
+    canales.set(id, enviar)
+    sock.on('data', (chunk) => {
+      buf += chunk
+      // UN TOPE, y por lo mismo que en las respuestas: sin él, quien se conecte puede
+      // hacer crecer este buffer hasta tumbar la bóveda mandando y sin saltos de línea.
+      if (buf.length > MAX_REPLY_BYTES) { buf = ''; enviar({ type: MSG.ERROR, error: 'request too big' }); return }
+      let i
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const linea = buf.slice(0, i); buf = buf.slice(i + 1)
+        if (!linea.trim()) continue
+        let p = null
+        try { p = JSON.parse(linea) } catch (_) { enviar({ type: MSG.ERROR, error: 'malformed request' }); continue }
+        onMessage(id, p).catch((e) => enviar({ type: MSG.ERROR, error: e.message }))
+      }
+    })
+    const cerrar = () => canales.delete(id)
+    sock.on('close', cerrar)
+    sock.on('error', cerrar)
+  })
+  server.on('error', (e) => log('[vault] the local desk could not open (' + e.message + '): services will use the proxy'))
+  // EL DIRECTORIO ES EL CONTROL, no el modo del socket.
+  //
+  // `mkdir` con `mode` NO corrige un directorio que ya existe, y sin `XDG_RUNTIME_DIR`
+  // —un servicio de sistema, un contenedor— esto cae en `/tmp`, donde cualquiera puede
+  // haberlo creado antes con permiso de escritura para todos. Quien sea dueño del
+  // directorio puede borrar el socket y poner el suyo: los servicios de esta máquina
+  // acabarían hablando con él. No leería nada (la respuesta va firmada por una llave que
+  // nombra el acta y el cliente la comprueba), pero los deja sin arrancar.
+  //
+  // Y el `chmod 0600` de abajo llega DESPUÉS de `listen`, así que por sí solo deja una
+  // rendija. Lo que la cierra de verdad es que el directorio sea nuestro y solo nuestro.
+  const dir = socketDir()
+  try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }) } catch (_) {}
+  try {
+    const st = fs.statSync(dir)
+    const ajeno = typeof process.getuid === 'function' && st.uid !== process.getuid()
+    const abierto = (st.mode & 0o077) !== 0
+    if (ajeno || abierto) {
+      return log(`[vault] the local desk stays closed: ${dir} is ${ajeno ? 'owned by another user' : 'writable by others'} ` +
+        '— services on this machine will use the proxy instead')
+    }
+  } catch (e) {
+    return log('[vault] the local desk stays closed: could not check ' + dir + ' (' + e.message + ')')
+  }
+  try { fs.rmSync(socketPath, { force: true }) } catch (_) {}
+  server.listen(socketPath, () => {
+    try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
+    log('[vault] local desk at ' + socketPath + ' (same machine, no round trip)')
+  })
+  server.unref?.()
+  return server
+}
+
+/**
+ * @param {string} dir  el directorio del perfil
+ */
+export function nodePlatform (dir) {
+  const disk = nodeDisk(dir)
+  // El transporte del ecosistema guarda su par en `localStorage`, y en Node no lo hay.
+  installNodeGlobals(dir)
+  return {
+    disk,
+    product: 'vaultd',
+    version: VERSION,
+    hostname: () => os.hostname(),
+    readProcContext,
+    openLocalDesk,
+    noticeGroupMs: Number(process.env.DOTRINO_VAULT_NOTICE_MS) || 3000,
+    async openIdentity ({ openKey = null, log = console.log } = {}) {
+      // CIFRADO EN REPOSO ligado a esta máquina: ningún archivo del dir queda en claro, así
+      // que copiarlos a otro equipo no sirve de nada. La identidad se migra AQUÍ (verificando
+      // antes de reemplazar); el resto lo hace su propio almacén al abrirse.
+      try {
+        const r = migrateFile(path.join(dir, 'identity.json'), kekFor(dir))
+        if (r === 'migrado') log('[vault] identity encrypted at rest (bound to this machine)')
+      } catch (e) { log('[vault] could not encrypt the identity at rest:', e.message) }
+      /**
+       * EL CANDADO DE LA MAESTRA. La mitad privada se guarda sellada con la llave que sale de
+       * la contraseña del perfil (`openKey`), no con la de la máquina: cerrada, la maestra no
+       * está en memoria y no hay con qué sacarla del disco. Un perfil sin contraseña no tiene
+       * `openKey`: se queda bajo la llave de máquina, y la consola lo dice en voz alta.
+       */
+      const keyLock = {
+        seal: async (texto) => { const k = openKey?.(); return k ? encryptText(texto, k) : null },
+        open: async (blob) => { const k = openKey?.(); if (!k) return null; try { return decryptText(blob, k) } catch (_) { return null } }
+      }
+      const identity = await Identity.connect({ dir, atRest: atRestFor(dir), keyLock })
+      // ESTE DIRECTORIO ES DE ESTA LLAVE: varias bóvedas en un disco, cada una con el suyo.
+      assertKeyOwnsDir(dir, identity.me?.publickey || null)
+      return identity
+    }
+  }
+}
+
+export default { nodePlatform }