@dotrino/vault 0.92.0 → 0.93.1

package/src/service.js

@@ -174,8 +174,8 @@ async function freshClient (proxyUrl, connectTimeoutMs = 20000, master = null) {
   // reventaría al negociar; en un navegador es nativo y es el camino directo que hay que
   // preferir. Se mira si está, en vez de apagarlo a mano para siempre: el día que este
   // código corra en un navegador —o que Node lo traiga— se enciende solo.
-  const hayWebRTC = typeof globalThis.RTCPeerConnection === 'function'
-  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: hayWebRTC, autoReconnect: false })
+  const hasWebRTC = typeof globalThis.RTCPeerConnection === 'function'
+  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: hasWebRTC, autoReconnect: false })
   // connect() del cliente solo se resuelve con 'connected' y solo rechaza en el
   // evento 'error' de transporte: si el socket cierra LIMPIO antes de 'connected'
   // (p.ej. el proxy banea la IP y envía close 1008), la promesa quedaría colgada
@@ -207,16 +207,40 @@ async function identifyAsService (client, device) {
 /** Cuánto espera un agente a que alguien apruebe (el pedido vive 5 min en la bóveda). */
 export const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000 + 10 * 1000
 
-function waitForMsg (client, predicate, timeoutMs = 30000) {
+/**
+ * Espera la respuesta de la bóveda. Con `guard` (las peticiones de SECRETOS), un `vault.error`
+ * solo cuenta si viene firmado con la llave de sellado que nombra el acta y atado a ESTA
+ * petición (`re`, la huella de su firma): lo que va a la cuenta lo reciben todas sus bóvedas,
+ * y la que no puede servir contestaba con un error que se tomaba por la respuesta (accounts se
+ * quedaba sin secretos, 2026-10-18). Un error que no se verifica no corta nada; si al acabar el
+ * plazo nadie contestó otra cosa, se dice cuál fue, y que no se pudo comprobar.
+ */
+function waitForMsg (client, predicate, timeoutMs = 30000, guard = null) {
   return new Promise((resolve, reject) => {
-    const off = client.on('message', (_from, payload) => {
-      if (payload && typeof payload === 'object' && predicate(payload)) { cleanup(); resolve(payload) }
+    let unverified = null
+    const off = client.on('message', async (_from, payload) => {
+      if (!payload || typeof payload !== 'object' || !predicate(payload)) return
+      if (guard && payload.type === MSG.ERROR && !await isMyVaultError(payload, guard)) { unverified = payload; return }
+      cleanup(); resolve(payload)
     })
-    const t = setTimeout(() => { cleanup(); reject(new Error('timeout waiting for the vault reply')) }, timeoutMs)
+    const t = setTimeout(() => {
+      cleanup()
+      if (unverified) reject(Object.assign(new Error(`no verifiable reply from the vault; an unverified one said: ${unverified.error}`), { code: 'unverified-error' }))
+      else reject(new Error('timeout waiting for the vault reply'))
+    }, timeoutMs)
     const cleanup = () => { off(); clearTimeout(t) }
   })
 }
 
+/** La huella con la que la bóveda ata un error a la petición que lo causó (`re`). */
+export const requestRef = (signature) => createHash('sha256').update(String(signature || '')).digest('hex')
+
+/** ¿Este error lo firmó una llave de sellado del acta, y es para esta petición? */
+export async function isMyVaultError (p, { re, masterPubkey, knownSeq = null }) {
+  if (!p?.signed || p.signed.re !== re || p.signed.op !== 'secrets.error' || p.signed.error !== p.error) return false
+  try { await verifyResponder({ body: p.signed, seal: p.seal, acta: p.acta, masterPubkey, knownSeq }); return true } catch (_) { return false }
+}
+
 const identityFileOf = (dir) => path.join(dir, IDENTITY_FILE)
 
 /**
@@ -521,7 +545,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
     await identifyAsService(client, device)
     const data = { op: 'enckey', ns, encPub, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-    const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
+    const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs, { re: requestRef(signature), masterPubkey, knownSeq: saved?.actaSeq ?? null })
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
     const res = await pending
     if (res.type === MSG.ERROR) throw vaultError(res)
@@ -573,7 +597,7 @@ export async function storeVars ({ dir, ns, proxyUrl, masterPubkey, device, cert
     const ask = async (data) => {
       const signed = { ...data, ns, publickey: device.publickey, ts: Date.now() }
       const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data: signed })
-      const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
+      const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs, { re: requestRef(signature), masterPubkey, knownSeq: saved?.actaSeq ?? null })
       client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data: signed, signature, cert })
       const res = await pending
       if (res.type === MSG.ERROR) throw vaultError(res)
@@ -627,7 +651,7 @@ export async function fetchDigest ({ dir, ns, proxyUrl, masterPubkey, device, ce
     await identifyAsService(client, device)
     const data = { op: 'digest', ns, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.digest'), timeoutMs)
+    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.digest'), timeoutMs, { re: requestRef(signature), masterPubkey, knownSeq: saved?.actaSeq ?? null })
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
     const res = await pending
     if (res.type === MSG.ERROR) throw vaultError(res)
@@ -792,7 +816,7 @@ async function reportToVault (op, { product, version, from = null, dir, proxyUrl
     await identifyAsService(client, device)
     const data = { op, product, version, ...(typeof from === 'string' && from ? { from } : {}), publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === op && p.body.product === product && p.body.version === version), timeoutMs)
+    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === op && p.body.product === product && p.body.version === version), timeoutMs, { re: requestRef(signature), masterPubkey, knownSeq: saved?.actaSeq ?? null })
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
     const res = await pending.catch((e) => {
       if (/timeout/.test(e.message)) throw Object.assign(new Error(`${op}: the vault did not answer`), { code: 'vault-no-reply' })
@@ -844,7 +868,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
    * Eso pasó — renovar guardaba el papel nuevo y acto seguido apuntar el acta lo pisaba con
    * el viejo, que ya estaba revocado. Al siguiente arranque: «unauthorized: revoked».
    */
-  const recordar = (patch) => {
+  const remember = (patch) => {
     if (!saved) return
     saved = { ...saved, ...patch }
     if (dir) { try { writeServiceIdentity(dir, saved) } catch (_) {} }
@@ -858,14 +882,14 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
    * ahí en adelante. Un pin que retrocede no es un pin — se llama `maxSeq` en el diseño
    * justo por esto (`acta-de-perfil.md` §2.3).
    */
-  const anotarActa = (acta) => {
+  const recordActa = (acta) => {
     if (typeof acta?.seq !== 'number') return
     if (typeof saved?.actaSeq === 'number' && acta.seq <= saved.actaSeq) return
     // Y QUIÉNES REPARTEN. Sale del acta, que llega firmada en cada respuesta, así que no
     // hay una lista que mantener a mano ni un `.env` que se olvide: darle `replica` a un
     // aparato basta para que sus servicios sepan preguntarle cuando la bóveda no esté.
     const replicas = (acta.members || []).filter((m) => memberCan(acta, m.pub, 'replica')).map((m) => m.pub)
-    recordar({ actaSeq: acta.seq, replicas })
+    remember({ actaSeq: acta.seq, replicas })
   }
 
     // DOS MOTIVOS PARA PEDIR PAPEL NUEVO:
@@ -874,15 +898,15 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     //     servicio. Sin esta rama la migración no terminaba nunca — el disparador comparaba
     //     `seq` contra `seq`, y un papel viejo no tiene ninguno, así que no saltaba jamás.
     //   · o el acta que hemos visto va por delante del papel: el dueño cambió permisos.
-    const legado = !!cert && typeof cert.seq !== 'number'
-    const atrasado = typeof saved?.actaSeq === 'number' && typeof cert?.seq === 'number' && saved.actaSeq > cert.seq
-    const renovar = legado || atrasado
+    const legacy = !!cert && typeof cert.seq !== 'number'
+    const behind = typeof saved?.actaSeq === 'number' && typeof cert?.seq === 'number' && saved.actaSeq > cert.seq
+    const renew = legacy || behind
 
     // RENOVAR YA NO ES UNA TAREA DE CALENDARIO. El papel no vence: lo único que obliga a
     // pedir otro es que la bóveda diga que el nuestro se quedó atrás respecto del acta, y
     // eso lo contesta ella cuando lo pide (`acta-vieja`). Aquí se intenta una vez y no se
     // insiste: si falla, se sigue con el papel que hay — que probablemente valga.
-    if (renovar) {
+    if (renew) {
       try {
         const data = { op: 'renew', publickey: device.publickey, ts: Date.now() }
         const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
@@ -897,7 +921,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
           (await checkVaultReply({ acta: res.acta, cert: res.cert, vault: masterPubkey, sub: device.publickey })).ok
         if (ok) {
           cert = res.cert
-          recordar({ cert })
+          remember({ cert })
           // QUIEN NO PASA `dir` GUARDA ÉL. Un servicio que lleva su identidad en su propio
           // archivo (`link.json`) y nos pasa el enlace a mano no tiene `saved`, así que
           // `recordar` no escribe nada: sin esto renovaba en cada arranque y volvía a
@@ -937,18 +961,18 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // exactamente el caso que un replicador existe para cubrir.
     //
     // La bóveda va PRIMERO siempre: un replicador solo puede estar igual de al día o menos.
-    const destinos = [masterPubkey, ...(saved?.replicas || []).filter((k) => k !== masterPubkey)]
+    const targets = [masterPubkey, ...(saved?.replicas || []).filter((k) => k !== masterPubkey)]
     // El plazo se reparte: no tiene sentido esperar el timeout entero a una bóveda apagada
     // y quedarse sin tiempo para preguntarle a quien sí está.
-    const porDestino = Math.max(4000, Math.round(timeoutMs / destinos.length))
+    const byTarget = Math.max(4000, Math.round(timeoutMs / targets.length))
     let res = null
-    let ultimo = null
-    for (const destino of destinos) {
-      const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, porDestino)
-      client.sendByPubkey(destino, { type: MSG.SECRETS, data, signature, cert })
-      try { res = await pending; break } catch (e) { ultimo = e }
+    let last = null
+    for (const target of targets) {
+      const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, byTarget, { re: requestRef(signature), masterPubkey, knownSeq: saved?.actaSeq ?? null })
+      client.sendByPubkey(target, { type: MSG.SECRETS, data, signature, cert })
+      try { res = await pending; break } catch (e) { last = e }
     }
-    if (!res) throw ultimo || new Error('nobody answered: neither the vault nor any replica')
+    if (!res) throw last || new Error('nobody answered: neither the vault nor any replica')
     if (res.type === MSG.ERROR) throw vaultError(res)
 
     // CAJÓN CON APROBACIÓN: la bóveda contesta «pendiente» (firmado) y la respuesta de
@@ -956,10 +980,10 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // sigue identificada. Se espera lo que dura el pedido; denegado o vencido es error.
     if (res.body?.op === 'secrets.pending' && res.body.ns === ns) {
       await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
-      anotarActa(res.acta)
+      recordActa(res.acta)
       try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
-      res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
+      res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs), { re: requestRef(signature), masterPubkey, knownSeq: saved?.actaSeq ?? null })
         .catch((e) => {
           if (/timeout/.test(e.message)) throw Object.assign(new Error('approval: nobody approved the request in time'), { code: 'unanswered' })
           throw e
@@ -981,7 +1005,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // dentro se usa hasta después de verificar.
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
     await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
-    anotarActa(payload?.acta)
+    recordActa(payload?.acta)
     // La huella de lo que se acaba de recibir: con ella se compara después (`fetchDigest`)
     // sin volver a pedir claves. Ya comprobada: va dentro del cuerpo firmado.
     if (typeof body.digest === 'string') lastDigests.set(digestKey(ns, device.publickey), body.digest)
@@ -1117,10 +1141,10 @@ export async function makeSealCheck (acta, masterPubkey, log = console.log) {
     log('[vault] ⚠ the record does not come from the master this agent knows: envelope provenance NOT checked')
     return () => {}
   }
-  let avisado = false
+  let warned = false
   return async (owner, key, gen, e, seal) => {
     if (!seal?.sig) {
-      if (!avisado) { avisado = true; log('[vault] ⚠ some envelopes carry no signature (sealed before this vault could sign)') }
+      if (!warned) { warned = true; log('[vault] ⚠ some envelopes carry no signature (sealed before this vault could sign)') }
       return
     }
     const pub = sealKeyAt(acta, seal.seq)
@@ -1142,23 +1166,23 @@ async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null
   // TODAS las envolturas de este aparato; se abren perezosamente, solo las que hagan
   // falta. `sealed.ns`/`sealed.dev` (una sola, la vigente) siguen entrando: es el bundle
   // de v4 y sirve para lo que ese vault selló.
-  const porGen = { ns: new Map(), dev: new Map() }
-  const añade = (cual, info) => { if (info?.wrap) porGen[cual].set(info.gen ?? 0, info.wrap) }
+  const byGen = { ns: new Map(), dev: new Map() }
+  const añade = (which, info) => { if (info?.wrap) byGen[which].set(info.gen ?? 0, info.wrap) }
   añade('ns', sealed.ns); añade('dev', sealed.dev)
-  for (const cual of ['ns', 'dev']) for (const info of sealed.wraps?.[cual] || []) añade(cual, info)
+  for (const which of ['ns', 'dev']) for (const info of sealed.wraps?.[which] || []) añade(which, info)
 
-  const abiertas = { ns: new Map(), dev: new Map() }
-  const cekDe = async (cual, gen) => {
-    if (abiertas[cual].has(gen)) return abiertas[cual].get(gen)
+  const opened = { ns: new Map(), dev: new Map() }
+  const cekFrom = async (which, gen) => {
+    if (opened[which].has(gen)) return opened[which].get(gen)
     // Un bundle de v4 no traía `gen` en la envoltura: si solo hay una, es esa.
-    const wrap = porGen[cual].get(gen) ?? (porGen[cual].size === 1 ? [...porGen[cual].values()][0] : null)
+    const wrap = byGen[which].get(gen) ?? (byGen[which].size === 1 ? [...byGen[which].values()][0] : null)
     if (!wrap) return null
     const cek = await openWrap({ wrap, myEncPrivateKey: mine })
-    abiertas[cual].set(gen, cek)
+    opened[which].set(gen, cek)
     return cek
   }
 
-  const comprobarFirma = await makeSealCheck(acta, masterPubkey)
+  const checkSignature = await makeSealCheck(acta, masterPubkey)
 
   const out = {}
   for (const [key, e] of Object.entries(sealed.entries || {})) {
@@ -1177,10 +1201,10 @@ async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null
         { code: 'plaintext-var' })
     }
     // `owner` dice de qué cajón salió, y `gen` con qué llave de ese cajón se abre.
-    const cual = String(e.owner || '').startsWith('dev:') ? 'dev' : 'ns'
+    const which = String(e.owner || '').startsWith('dev:') ? 'dev' : 'ns'
     const gen = e.gen ?? e.e?.gen ?? 0
-    await comprobarFirma(e.owner, key, gen, e.e, e.seal)
-    const cek = await cekDe(cual, gen)
+    await checkSignature(e.owner, key, gen, e.e, e.seal)
+    const cek = await cekFrom(which, gen)
     if (!cek) {
       // NO ES UN TROPIEZO: ES UN ESTADO QUE HAY QUE ARREGLAR EN LA BÓVEDA.
       //

package/src/sshKeys.js

@@ -108,9 +108,9 @@ export function signSsh (k, data, flags = 0) {
   if (k.type === 'ssh-rsa') {
     // Sin flags es el `ssh-rsa` (SHA-1) histórico, que los servidores modernos rechazan;
     // OpenSSH pide rsa-sha2-256/512 con las banderas del agente (RFC 8332).
-    const algo = (flags & SSH_AGENT_RSA_SHA2_512) ? 'rsa-sha2-512' : (flags & SSH_AGENT_RSA_SHA2_256) ? 'rsa-sha2-256' : 'ssh-rsa'
-    const hash = algo === 'rsa-sha2-512' ? 'sha512' : algo === 'rsa-sha2-256' ? 'sha256' : 'sha1'
-    return Buffer.concat([sshString(Buffer.from(algo)), sshString(nodeSign(hash, Buffer.from(data), k.privateKey))])
+    const something = (flags & SSH_AGENT_RSA_SHA2_512) ? 'rsa-sha2-512' : (flags & SSH_AGENT_RSA_SHA2_256) ? 'rsa-sha2-256' : 'ssh-rsa'
+    const hash = something === 'rsa-sha2-512' ? 'sha512' : something === 'rsa-sha2-256' ? 'sha256' : 'sha1'
+    return Buffer.concat([sshString(Buffer.from(something)), sshString(nodeSign(hash, Buffer.from(data), k.privateKey))])
   }
   throw new Error('ssh: cannot sign with ' + k.type)
 }

package/src/version.js

@@ -14,10 +14,10 @@ import fs from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-function leer () {
+function read () {
   try {
-    const aqui = dirname(fileURLToPath(import.meta.url))
-    for (const p of [join(aqui, '..', 'package.json'), join(aqui, '..', '..', 'package.json')]) {
+    const here = dirname(fileURLToPath(import.meta.url))
+    for (const p of [join(here, '..', 'package.json'), join(here, '..', '..', 'package.json')]) {
       try {
         const v = JSON.parse(fs.readFileSync(p, 'utf8'))
         if (v?.name === '@dotrino/vault' && typeof v.version === 'string') return v.version
@@ -27,4 +27,4 @@ function leer () {
   return '0.0.0'
 }
 
-export const PKG_VERSION = leer()
+export const PKG_VERSION = read()