@dotrino/vaultd 0.154.1 → 0.155.0

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

@@ -30,6 +30,7 @@
 import fs from 'node:fs'
 import os from 'node:os'
 import crypto from 'node:crypto'
+import { cleanMachine } from '@dotrino/identity/machine'
 
 /** 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
@@ -131,6 +132,17 @@ export function selfContext () {
   }
 }
 
+/**
+ * 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 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() })
+}
+
 const safeCwd = () => { try { return process.cwd() } catch (_) { return '' } }
 const userName = () => { try { return os.userInfo().username } catch (_) { return '' } }
 

package/lib/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.154.1",
+  "version": "0.155.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,7 +22,7 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "^0.111.0",
+    "@dotrino/identity": "^0.115.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
     "@dotrino/proxy-client": "^0.32.2",

package/src/ctl.js

@@ -40,6 +40,7 @@ import { VERSION } from './version.js'
 import * as hw from './hwkeys.js'
 import { isNewer } from './update.js'
 import { COMM_CN } from './commKey.js'
+import { machineLine } from '@dotrino/identity/machine'
 
 const dir = dataDir()
 const stateFile = path.join(dir, 'state.json')
@@ -673,6 +674,8 @@ async function cmdMembers () {
     if (m.renounced?.length) {
       console.log('      %s↓ renunció a %s (pendiente de sellar: abre la bóveda)%s', R, m.renounced.join(', '), Z)
     }
+    // DÓNDE CORRE (`@dotrino/identity/machine`): con qué se reconoce cuál es cuál.
+    if (machineLine(m.machine)) console.log('      %s%s%s', D, machineLine(m.machine), Z)
     if (m.running) {
       const v = `${m.running.product} ${m.running.version}`
       if (m.running.compatible) console.log('      %scorre %s%s', D, v, Z)

package/src/daemon.js

@@ -87,8 +87,8 @@ export async function runDaemon () {
   const pendingEnrollFile = path.join(dir, 'pending-enroll.json')
   // Cuando un dispositivo pide enrolarse, exponemos su deviceId (y a QUÉ perfil
   // quiere entrar) para que el dueño lo compare con el del dispositivo y apruebe.
-  const onEnrollChallenge = ({ deviceId, scope, profile, profileName }) => {
-    ipcWrite(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName })
+  const onEnrollChallenge = ({ deviceId, scope, profile, profileName, machine }) => {
+    ipcWrite(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName, machine: machine || null })
   }
 
   const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })

package/src/machines.js

@@ -0,0 +1,69 @@
+/**
+ * DÓNDE CORRE CADA APARATO, según lo último que dijo (`@dotrino/identity/machine`).
+ *
+ * El acta guarda lo que el aparato dijo AL EMPAREJARSE, y eso no cambia sin una firma de la
+ * maestra. Aquí va lo que dice en cada pedido firmado: así un aparato que entró antes de que
+ * existiera el campo aparece con su máquina en cuanto se actualiza y habla, y uno que cambió
+ * de sistema sale al día. La lista enseña esto primero y, si no hay, lo del acta.
+ *
+ * NO DECIDE NADA: se enseña. Lo dice el propio aparato, dentro de lo que firma; nadie más lo
+ * puede escribir por él, pero tampoco prueba nada.
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se lanza.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { cleanMachine, sameMachine } from '@dotrino/identity/machine'
+
+export const MACHINES_FILE = 'machines.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ dir: string, atRest: { encrypt: (s: string) => string, decrypt: (s: string) => string }, now?: () => number }} opts
+ */
+export function openMachines ({ dir, atRest, now = Date.now }) {
+  const file = path.join(dir, MACHINES_FILE)
+  /** pub → { kind, os, name, at } */
+  const items = load()
+
+  function load () {
+    let raw
+    try { raw = fs.readFileSync(file, 'utf8') } catch (e) {
+      if (e.code === 'ENOENT') return new Map()
+      throw fail('machines-unreadable', `cannot read ${MACHINES_FILE}: ${e.message}`)
+    }
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('machines-unreadable', `${MACHINES_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('machines-unreadable', `${MACHINES_FILE} has an unknown shape`)
+    return new Map(Object.entries(d.items))
+  }
+
+  function save () {
+    const tmp = file + '.tmp'
+    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })), { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  }
+
+  return {
+    /**
+     * Lo que acaba de decir un aparato. Solo se escribe si cambió: casi todos los pedidos
+     * repiten lo de siempre, y reescribir el archivo en cada uno sería disco para nada.
+     * Lo que no tiene forma de máquina no borra lo que ya había.
+     */
+    note (pub, raw) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'note: a device key is required')
+      const m = cleanMachine(raw)
+      if (!m) return false
+      if (sameMachine(items.get(pub), m)) return false
+      items.set(pub, { ...m, at: now() })
+      save()
+      return true
+    },
+    /** Lo último que dijo, o `null` si nunca dijo nada. */
+    of (pub) {
+      const m = items.get(pub)
+      return m ? { ...m } : null
+    }
+  }
+}

package/src/tui/app.js

@@ -41,6 +41,7 @@ import * as hw from '../hwkeys.js'
 import { VERSION } from '../version.js'
 import * as up from '../update.js'
 import { DEVICE_CAPS } from '@dotrino/identity/acta'
+import { machineLine } from '@dotrino/identity/machine'
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
@@ -158,6 +159,9 @@ function mergeMembersAndCerts (members, issued) {
       // QUÉ CORRE ESE APARATO (CONVENCIONES §14). Lo apunta la bóveda cuando le habla, así
       // que aquí solo hay que dejarlo pasar — que es justo lo que le faltaba a `addedAt`.
       running: m.running || null,
+      // DÓNDE CORRE (`@dotrino/identity/machine`): lo último que dijo firmado o, si no, lo
+      // que dijo al emparejarse. Es lo que distingue tres navegadores que se llaman igual.
+      machine: m.machine || cert?.machine || null,
       // SI LE LLEGAN LOS AVISOS, solo en quien aprueba (`undefined` = no aprueba, no se pinta).
       notifiedAt: (m.caps || []).includes('approve') && 'notifiedAt' in m ? m.notifiedAt : undefined
     }
@@ -473,6 +477,9 @@ function deviceRows (st, t) {
   }
   for (const d of devices) {
     const label = d.label || t.muted(i.noLabel)
+    // Dónde corre (`node · Linux 7.0 · mi-pc`), pegado al nombre: es con lo que se reconoce.
+    const maquina = machineLine(d.machine)
+    const donde = maquina ? t.muted(`  ${maquina}`) : ''
     const vars = devVarsOf(st, d.sub).length
     const debt = debtOf(st, d.sub)
     const desde = d.addedAt ? t.muted(`  ${i.deviceSince}:${fmtExp(d.addedAt)}`) : ''
@@ -511,7 +518,7 @@ function deviceRows (st, t) {
         ? t.muted(i.thisVault)
         : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp)))
     const marca = conCambios.has(d.sub) ? t.bold('*') : ' '
-    rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${desde}  ${status}${extra}`, sel: true, meta: d })
+    rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${donde}${desde}  ${status}${extra}`, sel: true, meta: d })
   }
   const revoked = st.devices?.revoked || []
   if (revoked.length) {
@@ -2504,7 +2511,11 @@ function pairingBody (st, t, cols, height) {
   lines.push('')
   lines.push(t.danger(i.pairWarning))
   lines.push('')
-  if (st.pending) lines.push(t.warn(i.pairConnected(st.pending.deviceId)))
+  if (st.pending) {
+    lines.push(t.warn(i.pairConnected(st.pending.deviceId)))
+    // Dónde dice que corre, para comprobar que es el aparato que tienes delante.
+    if (machineLine(st.pending.machine)) lines.push(t.muted('  ' + machineLine(st.pending.machine)))
+  }
   else lines.push(t.muted(i.pairWaiting))
   return lines
 }

package/src/vault.js

@@ -31,6 +31,8 @@ import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER }
 import { openSubacta } from './subacta.js'
 import { openBlocked } from './blocked.js'
 import { openNotifiable } from './notifiable.js'
+import { openMachines } from './machines.js'
+import { machineLine } from '@dotrino/identity/machine'
 import { openNotices } from './notices.js'
 import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.js'
@@ -266,6 +268,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const blocked = openBlocked({ dir, atRest: passwordsAtRest })
   // Qué aprobadores dijeron que pueden recibir avisos (`src/notifiable.js`). No decide nada: se enseña.
   const notifiable = openNotifiable({ dir, atRest: passwordsAtRest })
+  // Dónde corre cada aparato, según lo último que dijo firmado (`src/machines.js`). Se enseña.
+  const machines = openMachines({ dir, atRest: passwordsAtRest })
   // Lo que hay que contarle a quien aprueba y no es un pedido (`src/notices.js`): hoy, «me actualicé».
   const notices = openNotices({ dir, atRest: passwordsAtRest })
   const readPasswordsFile = () => {
@@ -549,6 +553,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   /** El dictamen de un aparato, para enseñarlo o para pegárselo a un error. */
   const versionDe = (pub) => versiones.get(pub) || null
+  /** Dónde corre un aparato: lo último que dijo firmado (`machines`) o, si no, lo del acta. */
+  const machineOf = (pub, record) => machines.of(pub) || (record?.members || []).find((m) => m.pub === pub)?.machine || null
 
   // ----- LA SUBACTA: lo decidido que todavía no selló el acta (`src/subacta.js`) -----
   //
@@ -612,6 +618,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const verifyChain = async (args) => {
     const chk = await verifyChainRaw(args)
     if (chk.ok && args?.data?.v) apuntarVersion(chk.device, args.data.v)
+    // DÓNDE CORRE, por el mismo motivo: se apunta de lo firmado. Un fallo al guardarlo no
+    // puede tumbar el pedido —es un dato para la lista—, pero se dice.
+    if (chk.ok && args?.data?.machine) {
+      try { machines.note(chk.device, args.data.machine) } catch (e) { log(`[vault] could not record where a device runs: ${e.message}`) }
+    }
     // UN BLOQUEADO NO PASA POR NINGÚN MOSTRADOR. Sigue en el acta —bloquear no la toca,
     // porque la bóveda vive cerrada y eso lo decide un aprobador desde el teléfono—, así que
     // el papel verifica; la puerta se cierra aquí, que es por donde entra todo, y con su
@@ -809,12 +820,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       markRotationDue(sub).catch((e) => log('[vault] could not rotate after the removal:', e.message))
     },
     defaultScope: [SCOPE.READ],
-    onChallenge ({ deviceId, scope }) {
+    onChallenge ({ deviceId, scope, machine }) {
       log(`\n[vault] Un dispositivo quiere conectarse:`)
       log(`        deviceId: ${deviceId}`)
+      if (machine) log(`        machine: ${machineLine(machine)}`)
       log(`        Ingresa el código que MUESTRA el dispositivo:`)
       log(`          dotrino-vault approve <código>    (o rechaza: dotrino-vault reject ${deviceId})\n`)
-      try { onEnrollChallenge?.({ deviceId, scope }) } catch (_) {}
+      try { onEnrollChallenge?.({ deviceId, scope, machine: machine || null }) } catch (_) {}
     }
   })
 
@@ -1330,6 +1342,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const devices = await Promise.all(issued.map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce,
       running: x.sub ? versionDe(x.sub) : null,
+      machine: x.sub ? machineOf(x.sub, record) : null,
       notifiedAt: x.sub ? notifiable.since(x.sub) : null
     })))
     // LA SUBACTA VIAJA CON EL ACTA. Es la mitad de «se comparte entre todos los
@@ -4371,6 +4384,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         members: (r?.members || []).map((m) => ({
           ...m,
           running: versionDe(m.pub),
+          // Dónde corre: lo último que dijo firmado y, si nunca habló, lo del acta.
+          machine: machines.of(m.pub) || m.machine || null,
           // Cuándo dijo que le llegan los avisos (null = no lo ha dicho, o caducó). Solo
           // tiene sentido en quien aprueba, y es un dato para enseñar: no decide nada.
           notifiedAt: notifiable.since(m.pub),