@dotrino/vault 0.62.1 → 0.64.0

package/README.md

@@ -127,6 +127,29 @@ Para procesos que no son Node, el CLI los inyecta en el entorno de un hijo:
 dotrino-env run --ns miapp -- ./mi-binario
 ```
 
+### El pedido dice QUÉ COMANDO pide, y desde dónde
+
+Cuando el cajón exige aprobación, el pedido que te llega al teléfono lleva **el comando
+entero y la carpeta** desde la que corre — `node server.js --port 8080` en `/srv/mi-app`—,
+no solo qué aparato pide qué cajón. En `dotrino-env run -- node server.js` el comando de
+destino va dentro de la propia línea de `dotrino-env`, así que sale medido y no hace falta
+creerle nada aparte.
+
+Dos límites que se dicen y no se esconden:
+
+- **Solo viaja por el mostrador local.** El pedido de secretos va firmado pero en claro
+  (CONVENCIONES §4.1), así que mandar el `argv` y el `cwd` por el proxio le enseñaría a quien
+  lo opere las rutas de tu disco. Desde otra máquina el pedido no lleva comando — y sin
+  comando no hay concesión: ese pide aprobación cada vez.
+- **No es una credencial.** La bóveda lo comprueba contra el proceso de verdad cuando está en
+  su misma máquina, pero cualquier proceso de tu mismo usuario puede leer el
+  `service-identity.json` y pedir con esa llave. Sirve para decidir mirando lo que pasa y
+  para dejar rastro, no para parar a quien ya tiene la llave.
+
+**Aprobar vale una hora y se renueva con cada uso**, así que un servicio que sigue pidiendo
+lo mismo no vuelve a timbrarte. Cambiar un argumento o la carpeta es otro comando: pregunta
+otra vez.
+
 ### Un agente tiene UNA identidad, y se la da el vault
 
 Un **aparato** puede llevar varios perfiles, y hasta meter su propia cuenta al vault

package/bin/dotrino-env.js

@@ -23,10 +23,26 @@ import { loadEnv, serviceDir, serviceRoot, listEnrolled, resolveNs, resolveVault
 // llegó a funcionar, y por eso el único servicio enrolado del ecosistema (el
 // proxy) lo hizo con su propio `enroll-vault.js` en vez de con esta CLI.
 import { parseInvite as sharedParseInvite } from '../src/invite.js'
+import { selfContext, commandLine } from '../src/proc.js'
 
 const argv = process.argv.slice(2)
 const flag = (name) => { const i = argv.indexOf('--' + name); return i >= 0 ? argv[i + 1] : undefined }
 
+/**
+ * QUÉ VA A VER EN EL TELÉFONO, dicho aquí también.
+ *
+ * El pedido que llega al aparato que aprueba enseña el comando y la carpeta; si por aquí solo
+ * se imprime «waiting for approval», no hay forma de emparejar lo que uno acaba de lanzar con
+ * lo que suena en el bolsillo — y con dos ventanas abiertas eso es exactamente lo que hay que
+ * distinguir antes de decir que sí.
+ */
+function esperandoAprobacion () {
+  const ctx = selfContext()
+  console.error('[dotrino-env] the vault asks for approval — approve it on a device with «aprueba» (up to 5 min)')
+  console.error('[dotrino-env]   %s', commandLine(ctx, 160))
+  console.error('[dotrino-env]   from %s', ctx.cwd || '?')
+}
+
 function help () {
   console.log(`dotrino-env — credenciales del vault en vez del .env
 
@@ -223,7 +239,7 @@ async function cmdCheck () {
   // bóveda contestó, que lo que falta es un permiso, ni cuánto va a esperar. `run` sí lo
   // decía; `check`, que es el comando de DIAGNÓSTICO, era el único que no. Le pasó al dueño
   // el 2026-09-05 con un cajón cuyo servicio no tenía a nadie que pudiera aprobarle.
-  const onPending = () => console.error('[dotrino-env] la bóveda pide aprobación: apruébalo en un aparato con «aprueba» (hasta 5 min)')
+  const onPending = () => esperandoAprobacion()
   const secrets = await fetchSecrets({ dir: serviceDir(etiquetaBoveda(), ns), ns, publicOnly, onPending })
   const keys = Object.keys(secrets)
   console.log('ns "%s": %d %s%s', ns, keys.length,
@@ -240,7 +256,7 @@ async function cmdRun () {
   const sep = argv.indexOf('--')
   const cmd = sep >= 0 ? argv.slice(sep + 1) : []
   if (!cmd.length) { console.error('uso: dotrino-env run [--vault <bóveda>] [--ns <ns>] [--public] -- <cmd> [args…]'); process.exit(2) }
-  const onPending = () => console.error('[dotrino-env] waiting for approval on your phone…')
+  const onPending = () => esperandoAprobacion()
   // POR QUÉ SE REINTENTA, SIEMPRE. Sin esto la espera es muda: la bóveda contestaba, la
   // respuesta se caía por un motivo concreto —un aparato sin sobre en su cajón, por
   // ejemplo— y por fuera solo se veía «waiting for approval» una y otra vez, aunque el
@@ -280,7 +296,7 @@ async function cmdSshAgent () {
   const dir = flag('dir') || serviceDir(etiquetaBoveda(), ns)
   const socketPath = flag('socket') || defaultSocketPath(dir)
   console.error('[dotrino-env] asking the vault for the keys of «%s»…', ns)
-  const secrets = await waitForSecrets({ dir, ns, onPending: () => console.error('[dotrino-env] waiting for approval on your phone…') })
+  const secrets = await waitForSecrets({ dir, ns, onPending: () => esperandoAprobacion() })
   const keys = []
   for (const [name, value] of Object.entries(secrets)) {
     if (!/^SSH_KEY_[A-Z0-9_]*$/.test(name)) continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.62.1",
+  "version": "0.64.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",
@@ -50,7 +50,7 @@
     "pairing"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.73.1",
+    "@dotrino/identity": ">=0.92.0",
     "@dotrino/proxy-client": ">=0.18.0"
   },
   "license": "MIT",

package/src/proc.js

@@ -0,0 +1,192 @@
+/**
+ * proc.js — QUIÉN ESTÁ PIDIENDO LOS SECRETOS: qué comando, desde qué carpeta.
+ *
+ * Hasta ahora un pedido de aprobación decía «el aparato 904C-1002 pide el cajón proxy» y
+ * nada más. Con eso no se puede decidir: el dueño no sabe si es el arranque que acaba de
+ * lanzar o cualquier otra cosa de la misma máquina. Lo que hace falta es el **comando** y
+ * el **path** (dueño, 2026-09-11).
+ *
+ * DOS FUENTES, Y NO VALEN LO MISMO:
+ *
+ *   · `selfContext()` — lo que un proceso dice de sí mismo. Es lo que viaja en el pedido.
+ *   · `readProcContext(pid)` — lo que el KERNEL dice de ese pid, leyendo `/proc`. Solo la
+ *     puede usar quien está en la misma máquina, y es la que manda.
+ *
+ * Cuando el pedido entra por el mostrador local, la bóveda lee la segunda y la compara con
+ * la primera: si no cuadran, no es un matiz, es una mentira, y se deniega. Cuando entra por
+ * el proxio (un servicio en otra máquina) no hay nada que leer, y entonces lo declarado se
+ * marca como declarado — que es distinto de comprobado, y se enseña distinto.
+ *
+ * EL LÍMITE, DICHO EN VOZ ALTA: esto no es una credencial. Cualquier proceso del MISMO
+ * usuario puede leer `service-identity.json` y pedir los secretos con esa llave, y también
+ * puede llamarse como quiera (`exec -a`) y arrancar desde donde quiera. La frontera de
+ * verdad es el usuario, no el proceso. Esto existe para que quien aprueba decida con lo que
+ * está pasando delante, y para que quede rastro — no para parar a quien ya tiene la llave.
+ *
+ * En `dotrino-env run -- node server.js` el comando de destino ya va DENTRO de la línea de
+ * comandos del propio `dotrino-env`, así que se mide igual que todo lo demás: no hay que
+ * creerle nada aparte.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import crypto from 'node:crypto'
+
+/** 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')
+}
+
+/** ¿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 } }
+
+/** `/proc/<pid>/cmdline` viene separado por NUL y termina en NUL. */
+function readCmdline (pid) {
+  const raw = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8')
+  const parts = raw.split('\0')
+  if (parts.length && parts[parts.length - 1] === '') parts.pop()
+  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
+ * saber que el pid no se recicló entre que pidió y que se miró: el nombre del proceso va
+ * entre paréntesis y puede llevar espacios, así que se corta por el ÚLTIMO `)`.
+ */
+function readStart (pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8')
+    const campos = stat.slice(stat.lastIndexOf(')') + 2).split(' ')
+    const t = Number(campos[19])
+    return Number.isFinite(t) ? t : null
+  } catch (_) { return null }
+}
+
+/**
+ * Lo que el KERNEL dice del proceso `pid`. `null` si no hay `/proc`, si el proceso ya no
+ * está o si no se puede mirar (otro usuario). No se inventa nada: no poder medir se
+ * contesta como no poder medir.
+ */
+export function readProcContext (pid) {
+  if (!hasProc() || !Number.isInteger(pid) || pid <= 0) return null
+  try {
+    const st = fs.statSync(`/proc/${pid}`)
+    const { argv, truncated } = trimArgv(readCmdline(pid))
+    return {
+      pid,
+      uid: st.uid,
+      exe: clip(fs.readlinkSync(`/proc/${pid}/exe`), MAX_PATH_BYTES),
+      cwd: clip(fs.readlinkSync(`/proc/${pid}/cwd`), MAX_PATH_BYTES),
+      argv,
+      truncated,
+      start: readStart(pid)
+    }
+  } catch (_) { return null }
+}
+
+/**
+ * Lo que ESTE proceso dice de sí mismo. En Linux sale de `/proc/self`, o sea de la misma
+ * fuente que va a leer la bóveda: así lo declarado y lo medido coinciden byte a byte y una
+ * diferencia significa lo que tiene que significar. Fuera de Linux se arma con lo que da
+ * Node, y entonces no hay nada que comprobar al otro lado.
+ */
+export function selfContext () {
+  const medido = readProcContext(process.pid)
+  if (medido) return { ...medido, user: userName(), host: os.hostname() }
+  const { argv, truncated } = trimArgv([process.execPath, ...process.argv.slice(1)])
+  return {
+    pid: process.pid,
+    uid: typeof process.getuid === 'function' ? process.getuid() : null,
+    exe: clip(process.execPath, MAX_PATH_BYTES),
+    cwd: clip(safeCwd(), MAX_PATH_BYTES),
+    argv,
+    truncated,
+    start: null,
+    user: userName(),
+    host: os.hostname()
+  }
+}
+
+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/src/service.js

@@ -22,16 +22,17 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
-  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
+  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice,
   verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
-import { verifyActa, sealKeyAt, sealersOf, memberCan } from '@dotrino/identity/acta'
+import { verifyActa, sealKeyAt, memberCan, checkVaultReply } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
 import { PKG_VERSION } from './version.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
 import { atRestFor } from './atrest.js'
 import { connectLocal, hasLocalVault } from './localdesk.js'
+import { selfContext } from './proc.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
@@ -399,18 +400,15 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     // por reloj, dice el `seq` del acta con el que se emitió, y quien lo emitió tiene que
     // ser SELLADORA de ese acta. Sin acta no se puede comprobar nada de eso, y entrar a
     // ciegas en un perfil es justo lo que no se hace.
-    const acta = res.acta
-    if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    // Y el acta tiene que ser la DEL PERFIL DEL QR. Antes esto se comprobaba mirando que el
-    // cert lo firmara `qr.iss`; con varias selladoras el emisor puede ser otra llave del
-    // mismo perfil, así que lo que se fija es el perfil, no la llave.
-    if (acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one in the QR')
-    const v = await verifyDelegation({
-      cert: res.cert, expectedSub: device.publickey,
-      actaSeq: acta.seq, sealers: sealersOf(acta),
-      ...(expectedScope ? { expectedScope } : {})
+    //
+    // Se juzga contra la llave de LA BÓVEDA del QR, con la regla del pilar. Antes se exigía
+    // `acta.profileId === qr.iss`, que solo es verdad en una cuenta que nació en esa bóveda:
+    // un servicio no podía emparejarse con una segunda bóveda ni con una que adoptó la cuenta.
+    const chk = await checkVaultReply({
+      acta: res.acta, cert: res.cert, vault: qr.iss, sub: device.publickey,
+      scope: expectedScope || null, justSealed: true
     })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
 
     return { device, enc: enc ? { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk } : null, cert: res.cert, iss: qr.iss, proxy: qr.proxy || 'wss://proxy.dotrino.com' }
   } finally { client.close() }
@@ -598,7 +596,13 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
         const pending = waitForMsg(client, (p) => p.type === MSG.RENEWED || p.type === MSG.ERROR, 15000)
         client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
         const res = await pending
-        if (res.type === MSG.RENEWED && res.cert?.sub === device.publickey) {
+        // SE VERIFICA ANTES DE GUARDARLO. Aquí solo se miraba que fuera para esta llave: un
+        // papel cualquiera, sin firma que valga, sustituía al bueno y el servicio se quedaba
+        // fuera hasta el siguiente arranque. Misma regla que al enrolarse, sin `justSealed`:
+        // la última acta pudo sellarla otra selladora de la cuenta.
+        const ok = res.type === MSG.RENEWED &&
+          (await checkVaultReply({ acta: res.acta, cert: res.cert, vault: masterPubkey, sub: device.publickey })).ok
+        if (ok) {
           cert = res.cert
           recordar({ cert })
           // QUIEN NO PASA `dir` GUARDA ÉL. Un servicio que lleva su identidad en su propio
@@ -611,9 +615,24 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     }
 
     const eph = await makeEphemeralKey()
+    /**
+     * QUÉ COMANDO Y DESDE QUÉ CARPETA — pero SOLO por el mostrador local.
+     *
+     * Quien aprueba necesita saber qué está pidiendo las claves: «el aparato 904C-1002 pide
+     * el cajón proxy» no alcanza para decidir nada (dueño, 2026-09-11). Así que el pedido
+     * lleva el comando y el path, y la bóveda los comprueba contra `/proc`.
+     *
+     * POR EL PROXIO NO VA, y no es un olvido: el pedido de secretos viaja firmado pero EN
+     * CLARO (CONVENCIONES §4.1 — el transporte no cifra), así que meter ahí el `argv` y el
+     * `cwd` le enseñaría al proxio las rutas de tu disco y los argumentos de tus comandos,
+     * que es justo lo que este ecosistema promete que no pasa. Sin contexto no hay huella,
+     * y sin huella no hay ventana: un servicio que pide desde otra máquina sigue pidiendo
+     * aprobación cada vez. Se abrirá cuando el pedido vaya sellado (la deuda del §4.1).
+     */
+    const ctx = client.local ? selfContext() : null
     // `publicOnly` VIAJA FIRMADO (va dentro de `data`), así que nadie lo puede quitar ni
     // poner por el camino. Quien decide qué se manda es la bóveda; esto solo es la petición.
-    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, ...(publicOnly ? { publicOnly: true } : {}) }
+    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, ...(ctx ? { ctx } : {}), ...(publicOnly ? { publicOnly: true } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     // A QUIÉN SE LE PREGUNTA: primero a la bóveda, y si no contesta, a los REPLICADORES
     // que el acta nombraba la última vez que la vimos (`docs/replicas.md` §8: «el servicio