@dotrino/vault 0.84.0 → 0.86.0

package/src/enroll.js

@@ -31,6 +31,7 @@
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
 import { verifyContinuity, canSeal, DEVICE_CAPS, VAULT_CN } from '@dotrino/identity/acta'
+import { cleanMachine } from '@dotrino/identity/machine'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -113,7 +114,7 @@ export async function deviceIdOf (pub) {
  * @param {(pub:string, obj:object)=>void} opts.sendByPubkey   dirigir por pubkey (cola offline 24 h).
  * @param {(op:string, info?:object)=>void} [opts.audit]
  * @param {(...a:any[])=>void} [opts.log]
- * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
+ * @param {(c:{deviceId:string, scope:any, label:string, machine?:any, mode?:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
  * @param {()=>void} [opts.onPendingChange]
  * @param {(sub:string)=>void} [opts.onDeviceRemoved]  se quitó un aparato (fuera del acta y sin papeles):
  *   para que quien guarde algo indexado por esa llave lo suelte. Se avisa desde AQUÍ y no desde
@@ -210,7 +211,7 @@ export function createEnrollDesk ({
   function listPending () {
     return [...pending.values()]
       .filter((p) => p.state === 'PENDING_CONFIRM')
-      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope }))
+      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope, machine: p.machine || null }))
   }
 
   function findPending (deviceId) {
@@ -314,12 +315,15 @@ export function createEnrollDesk ({
     // cuál era cuál. Si en `pair` le diste un nombre, ese es el nombre; el del aparato
     // sigue valiendo como propuesta cuando no dijiste nada.
     if (d.label && !pend.label) pend.label = String(d.label).slice(0, 60)
+    // DÓNDE CORRE (`@dotrino/identity/machine`): entra al acta con el aparato, para que la
+    // lista lo distinga de los demás aunque todos se llamen igual.
+    pend.machine = cleanMachine(d.machine)
     // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
     // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
     if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', machine: pend.machine || null, mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -396,7 +400,7 @@ export function createEnrollDesk ({
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     try {
-      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null, machine: pend.machine || null })
     } catch (e) {
       // El certificado ya está firmado y no se entrega: se revoca, para que no quede uno
       // válido suelto. Si ni eso sale, se dice también.

package/src/proc.js

@@ -29,18 +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 } }
@@ -53,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
@@ -131,62 +105,18 @@ export function selfContext () {
   }
 }
 
-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.
+ * DÓNDE CORRE ESTE PROCESO (`@dotrino/identity/machine`): para que la bóveda lo reconozca en
+ * su lista de aparatos. Va en lo que el aparato firma al emparejarse y en cada pedido de
+ * secretos, así que se refresca solo cuando cambia de máquina o de sistema.
  */
-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')
+export function selfMachine () {
+  const tipo = os.type()
+  const sistema = tipo === 'Darwin' ? 'macOS' : tipo === 'Windows_NT' ? 'Windows' : tipo
+  return cleanMachine({ kind: 'node', os: `${sistema} ${os.release()}`, name: os.hostname() })
 }
 
-/** ¿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
-}
+const safeCwd = () => { try { return process.cwd() } catch (_) { return '' } }
+const userName = () => { try { return os.userInfo().username } catch (_) { return '' } }
 
 export default { selfContext, readProcContext, sanitizeContext, commandFingerprint, sameCommand, commandLine, hasProc }

package/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/src/service.js

@@ -32,7 +32,7 @@ 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'
+import { selfContext, selfMachine } from './proc.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
@@ -378,7 +378,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     // aprende solo cuando un humano lo tipea → aprobar exige TENER esta máquina.
     const code = makePairingCode()
     const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
-    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, encPub: enc?.encPublickey || null, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
+    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, encPub: enc?.encPublickey || null, token: qr.token || qr.sn, sn: qr.sn, commit, label, machine: selfMachine(), ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -908,7 +908,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     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, ...(ctx ? { ctx } : {}), ...(publicOnly ? { publicOnly: true } : {}) }
+    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, machine: selfMachine(), ...(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