@dotrino/vaultd 0.65.0 → 0.73.0

package/src/profiles.js

@@ -162,12 +162,40 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
   // hora a la que se cierra solo si nadie lo usa (ver AUTO_LOCK_MS).
   const unlocked = new Map() // id -> vence (ms epoch)
 
+  /**
+   * LA LLAVE DERIVADA DE LA FRASE, mientras el perfil está abierto.
+   *
+   * Hasta ahora «abierto» era SOLO una bandera: la llave se derivaba en el `unlock`, se
+   * usaba para rehacer el llavero y se borraba en el `finally` de la misma línea. La
+   * consecuencia se veía media hora después y no se parecía a su causa — enrolar un
+   * servicio con la bóveda recién abierta contestaba «wrong password», porque envolverle
+   * la llave de su cajón exige abrir la copia de recuperación y para eso hace falta la
+   * frase, que ya no estaba. El aparato entraba y descubría al PRIMER ARRANQUE que no
+   * podía leer su cajón (dueño, 2026-08-31: «el rato de enrolar la bóveda está abierta,
+   * así que debía crear los sobres sin preguntar»).
+   *
+   * Lo que se guarda NO es la contraseña: es la llave que sale de ella por scrypt, y solo
+   * mientras el candado esté abierto. Se borra —con `wipe`, no con un `delete`— al
+   * cerrarse, al cerrarse solo por inactividad, al borrar el perfil y al reiniciar el
+   * daemon. Ese es el precio, y es el mismo que ya se paga por poder sellar actas
+   * estando abierta: lo que acota la exposición es el auto-candado, no el olvido.
+   */
+  const llaves = new Map() // id -> Uint8Array (la llave derivada, solo si está abierto)
+
+  /** Borra el material de verdad antes de soltar la referencia. */
+  const olvidar = (id) => {
+    const k = llaves.get(id)
+    if (k) { try { k.fill(0) } catch (_) {} }
+    llaves.delete(id)
+  }
+
   /** ¿Sigue abierto? Vence al MIRARLO, así que no hace falta ningún temporizador. */
   const isOpen = (id) => {
     const until = unlocked.get(id)
     if (until == null) return false
     if (autoLockMs > 0 && Date.now() >= until) {
       unlocked.delete(id)
+      olvidar(id)
       // El aviso va después de borrarlo: quien lo escuche verá el perfil ya cerrado.
       try { onAutoLock?.(id) } catch (_) {}
       return false
@@ -395,6 +423,7 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
       }
       if (data.current === id) data.current = quiere
       if (unlocked.has(id)) { unlocked.set(quiere, unlocked.get(id)); unlocked.delete(id) }
+      if (llaves.has(id)) { llaves.set(quiere, llaves.get(id)); llaves.delete(id) }
       save()
       return quiere
     },
@@ -425,6 +454,7 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
       if (data.current === id) data.current = data.profiles[0].id
       save()
       unlocked.delete(id)
+      olvidar(id)
       try { fs.rmSync(dirOf(id), { recursive: true, force: true }) } catch (_) {}
       return { id, name: p.name || '' }
     },
@@ -511,10 +541,21 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
       delete p.tries
       save()
       open(id)
+      // La llave se queda mientras el candado esté abierto: es lo que permite envolverle
+      // su cajón a un servicio que se enrola AHORA, sin volver a pedir la frase.
+      llaves.set(id, await api.adminKey(id, password))
       return { ok: true, locked: false }
     },
 
-    lock (id) { assertExists(id); unlocked.delete(id); return { ok: true, locked: api.isLocked(id) } },
+    lock (id) { assertExists(id); unlocked.delete(id); olvidar(id); return { ok: true, locked: api.isLocked(id) } },
+
+    /**
+     * La llave del perfil ABIERTO, o `null`. Es lo que hace que «la bóveda está abierta»
+     * signifique algo más que una bandera: con ella se envuelve la llave de un cajón sin
+     * volver a pedir la frase. Cerrado —o nunca abierto— devuelve `null` y quien llame
+     * tendrá que pedirla, que es exactamente el comportamiento de antes.
+     */
+    openKey (id) { return isOpen(id) ? (llaves.get(id) || null) : null },
 
     /** Pone o cambia la contraseña. Cambiarla exige haber desbloqueado antes. */
     async setPassword (id, password) {

package/src/sealers.js

@@ -0,0 +1,159 @@
+/**
+ * sealers.js — depositar la cadena de selladores en el registro público.
+ *
+ * POR QUÉ ESTO EXISTE. Un acta que alguien guardó el año pasado no puede responder la única
+ * pregunta que importa al leer una firma vieja: *la llave que firmó esto, ¿sigue pudiendo
+ * sellar?* Si a una bóveda le quitaron el permiso, quien tenga el acta vieja no se entera
+ * nunca — y seguiría creyéndole. El registro es el sitio donde mirar.
+ *
+ * QUÉ SE MANDA: los ESLABONES (`sealerLinkOf`), nunca las actas. Y un eslabón no es un acta
+ * recortada: es un documento propio de ocho campos, firmado aparte y metido DENTRO del acta
+ * antes de firmarla (identity >= 0.72). Costó una vuelta descubrirlo — la primera cadena que
+ * llegó al registro se fue con los `label` y los `cn` de cada aparato, porque «un eslabón»
+ * era un acta entera. Un acta lleva el inventario de tu casa: no se publica, ni recortada.
+ *
+ * POR QUÉ SIN SELLAR, y no es un descuido (§4.1 pide sellar los mensajes dirigidos): lo que
+ * viaja aquí va a acabar en un repo PÚBLICO, que es su propósito. Es el mismo caso que los
+ * canales `publish`/`list` del proxio, exentos por la misma razón: no hay nada que ocultar.
+ * Y no filtra de más — quién lo manda ya lo sabe el proxio por el `identify`. Sellarlo,
+ * además, obligaría a conocer la llave de cifrado del testigo, y depositar tiene que poder
+ * hacerlo cualquiera sin pedirle nada a nadie.
+ *
+ * Va por `sendByPubkey` y no por `send`: al testigo se le conoce por su pubkey, y así lo
+ * depositado entra en la cola de 24 h del proxio si estuviera caído.
+ *
+ * CUÁNDO: al arrancar y después de cada acta. Publicar de más no cuesta nada (el registro
+ * contesta «ya estaba») y así no hay que llevar la cuenta de qué se depositó — un estado
+ * que se desincroniza en cuanto se restaura un disco.
+ */
+import * as Acta from '@dotrino/identity/acta'
+import { verifyDelegation } from '@dotrino/identity/capabilities'
+
+export const OP = 'sealers.publish'
+
+/**
+ * LA IDENTIDAD DEL TESTIGO DE DOTRINO — no su aparato (dueño, 2026-08-31: «¿no me puedes
+ * quemar un device en el código?»).
+ *
+ * Tenía razón y era el mismo fallo que ya costó caro con el `nodeId` del proxio: la pubkey
+ * de un APARATO muere en cuanto lo revocas o lo re-enrolas, y todo lo que la tuviera
+ * apuntada se queda hablando con una dirección muerta. Lo que no cambia nunca es la
+ * IDENTIDAD: el `profileId` es el nombre de la cuenta y es para siempre.
+ *
+ * Así que aquí va la identidad, y el aparato se DESCUBRE: el testigo se anuncia en el canal
+ * con su cert, y se acepta al que traiga uno emitido por esta identidad. Re-enrolarlo da un
+ * cert nuevo de la misma identidad y todo sigue solo; revocarlo lo saca del acta y su
+ * anuncio deja de valer.
+ *
+ * Y nadie configura nada: esto es una dirección pública, como `wss://proxy.dotrino.com`.
+ */
+export const DOTRINO_REGISTRY_ID = "{\"key_ops\":[\"verify\"],\"ext\":true,\"kty\":\"EC\",\"x\":\"McyhKieRw_Jcl3TY9EvLovL-ALzGoWqMOrfnFjT7XpA\",\"y\":\"V7tfpDWN37tPnhXnIFUlMaTepcTzzxPWTj_72PkpKPw\",\"crv\":\"P-256\"}"
+
+/** El canal donde el testigo se anuncia (ver `@dotrino/sealers`). */
+export const CANAL = 'dotrino.sealers'
+
+/** Se le pregunta a cada anunciado quién es; contesta con su cert (ver `@dotrino/sealers`). */
+export const WHOIS = 'sealers.whois'
+
+export function startSealersPublisher ({ identity, client, log = console.log, registryId = DOTRINO_REGISTRY_ID, canal = CANAL } = {}) {
+  if (!registryId) return () => {}
+
+  /** Una respuesta a `sealers.whois`, o null si no contesta a tiempo. */
+  function preguntarQuienEs (token, timeoutMs = 8000) {
+    return new Promise((resolve) => {
+      const fin = (v) => { try { off() } catch (_) {} ; clearTimeout(t); resolve(v) }
+      const off = client.on('message', (_f, p) => { if (p?.op === WHOIS + '.result') fin(p) })
+      const t = setTimeout(() => fin(null), timeoutMs)
+      t.unref?.()
+      try { client.send(token, { op: WHOIS }) } catch (_) { fin(null) }
+    })
+  }
+
+  /**
+   * ¿A QUIÉN LE MANDO ESTO? Al que esté anunciado en el canal y demuestre ser de la
+   * IDENTIDAD que llevamos en el código.
+   *
+   * El canal dice DÓNDE mirar y nada más: `list` del proxio devuelve tokens sueltos — el
+   * `extraData` del `publish` no vuelve, comprobado contra el servidor. Así que a cada uno
+   * se le pregunta quién es (`sealers.whois`) y contesta con su cert. Que el cert venga del
+   * propio testigo y no del anuncio es además mejor: llega fresco.
+   *
+   * Sin comprobar el cert, cualquiera se anuncia ahí y se queda con los depósitos. No
+   * filtraría nada —el eslabón es público— pero se los tragaría EN SILENCIO, que es peor
+   * que un error.
+   */
+  async function testigo () {
+    let tokens
+    try { tokens = await client.list(canal) } catch (_) { return null }
+    for (const token of tokens || []) {
+      const r = await preguntarQuienEs(token)
+      const cert = r?.cert
+      if (!cert?.sub || cert.iss !== registryId) continue
+      // AQUÍ SOMOS EXTRAÑOS: no tenemos el acta del registro, así que no podemos preguntarle
+      // quién sella. Lo que sí tenemos es su `profileId` quemado en el código —inmutable, a
+      // diferencia de la dirección de un aparato— y eso es lo que se ancla: aceptamos un
+      // papel firmado POR ESA LLAVE, para el acta que él diga.
+      //
+      // Es exactamente la misma fuerza que antes (`cert.iss === registryId` + firma válida),
+      // dicho con la forma nueva. Y tiene un límite que conviene decir: si el registro
+      // llegara a tener una SEGUNDA selladora, sus papeles no entrarían por aquí hasta que
+      // presente su cadena de eslabones — que es, con gracia, justo lo que este registro
+      // publica.
+      const v = await verifyDelegation({
+        cert, expectedSub: cert.sub, actaSeq: cert.seq, sealers: [registryId]
+      }).catch(() => ({ ok: false }))
+      if (v?.ok) return cert.sub
+    }
+    return null
+  }
+
+  let ultima = null
+
+  let avisadoDeOtroTestigo = false
+
+  async function publicar (motivo) {
+    let actas
+    try { actas = await identity.sealerChain?.() } catch (_) { return }
+    if (!Array.isArray(actas)) return
+
+    // SI LA CUENTA DECLARÓ SU PROPIO TESTIGO, no se deposita en el de Dotrino. No es que
+    // hacerlo filtre algo —el eslabón es público— sino que el `chainUrl` del génesis es la
+    // forma que tiene una cuenta de decir dónde vive su cadena, y decidir por ella sería
+    // exactamente lo que ese campo existe para impedir. Se dice una vez y se calla.
+    const genesis = actas[0]
+    if (genesis?.chainUrl && registryId === DOTRINO_REGISTRY_ID) {
+      if (!avisadoDeOtroTestigo) {
+        avisadoDeOtroTestigo = true
+        log(`[sealers] this account names its own registry (${genesis.chainUrl}): not depositing into Dotrino's`)
+      }
+      return
+    }
+    // De cada acta sale su eslabón, y las que no cambiaron el sellador no dan ninguno.
+    const chain = actas.map((a) => Acta.sealerLinkOf(a)).filter(Boolean)
+    // Una cuenta de una sola bóveda no tiene nada que refrescar: su conjunto de selladores
+    // no puede cambiar. El registro la rechazaría, así que ni se molesta en mandarla.
+    // Una cuenta anterior a identity 0.72 tampoco tiene eslabones, y es el mismo caso: no
+    // aparece en el registro hasta que selle un acta nueva.
+    if (chain.length < 2) return
+
+    const cabeza = chain[chain.length - 1]?.seq
+    if (cabeza === ultima) return
+    try {
+      const a = await testigo()
+      if (!a) { log('[sealers] no witness announced in ' + canal + ': the chain stays for the next time'); return }
+      await client.sendByPubkey(a, { op: OP, chain })
+      ultima = cabeza
+      log(`[sealers] chain up to #${cabeza} deposited (${motivo})`)
+    } catch (e) {
+      // Que no se pueda depositar no rompe nada de lo que la bóveda hace: el registro es
+      // una comodidad para terceros, no una dependencia. Se reintenta en la próxima acta.
+      log('[sealers] could not deposit the chain:', e.message)
+    }
+  }
+
+  publicar('startup').catch(() => {})
+  const off = identity.onVault?.((e) => { if (e?.phase === 'acta') publicar(`record #${e.seq}`).catch(() => {}) })
+  return () => { try { off?.() } catch (_) {} }
+}
+
+export default { startSealersPublisher, OP, DOTRINO_REGISTRY_ID, CANAL }

package/src/transport.js

@@ -1,9 +1,19 @@
 /**
  * Transporte headless del vault: el cliente OFICIAL `@dotrino/proxy-client`
  * corriendo en Node (mismo patrón que `dotrino-bots/src/core/transport.js`).
- * Hace el `identify` firmado por la maestra del vault — liga el token efímero de
- * la conexión a la pubkey estable, habilitando el direccionamiento por pubkey
- * (`sendByPubkey`) y la cola offline de 24 h del proxy.
+ * Hace el `identify` — liga el token efímero de la conexión a una pubkey estable,
+ * habilitando el direccionamiento por pubkey (`sendByPubkey`) y la cola offline
+ * de 24 h del proxy.
+ *
+ * QUIÉN FIRMA ESE `identify`, que es lo que cambió: **la llave de comunicación**
+ * (`commKey.js`), no la maestra. La maestra sella el acta y reenvuelve sobres, y
+ * nada más; si además tuviera que firmar aquí no podría vivir bajo llave, porque
+ * esto se firma en cada conexión Y en cada reconexión — una bóveda cerrada no
+ * existiría en la red.
+ *
+ * Lo que ata el token al PERFIL entonces ya no es un certificado sino el ACTA: el
+ * proxio comprueba que quien habla sea miembro (`verifyActaMembership`) y ata el
+ * token también al `profileId`. Por eso se manda el acta siempre.
  *
  * IMPORTANTE: `me.publickey` puede ser null en el primer arranque (solo se puebla
  * al fijar un nickname), así que la pubkey maestra se obtiene de forma robusta
@@ -26,7 +36,7 @@ export async function masterPubkeyOf (identity) {
  * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
  * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
  */
-export async function createTransport ({ identity, dir, url = DEFAULT_PROXY }) {
+export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, commKey = null, log = () => {} }) {
   installNodeGlobals(dir)
   // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
   // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
@@ -47,13 +57,27 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY }) {
   await client.connect()
 
   const identify = async () => {
+    if (!client.token) return
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const comm = commKey?.pub?.() || null
+    // ¿Nos nombra el acta? Con `cn` o sin él, lo que el proxio mira es la pertenencia.
+    const esMiembro = comm && (record?.members || []).some((m) => m?.pub === comm)
+
+    if (comm && esMiembro) {
+      const data = { op: 'identify', publickey: comm, token: client.token, ts: Date.now() }
+      const signature = await commKey.sign(data)
+      if (signature) return client.identify({ data, signature, acta: record })
+    }
+
+    // REPLIEGUE, y solo para migrar: una bóveda que todavía no ha metido su llave de
+    // comunicación en el acta se identifica con la maestra, como siempre. Exige el perfil
+    // ABIERTO —la maestra bajo llave no firma— y por eso se dice en voz alta: mientras se
+    // esté aquí, cerrar el perfil deja la bóveda sin voz.
     const publickey = await masterPubkeyOf(identity)
-    if (!publickey || !client.token) return
+    if (!publickey) return
     const data = { op: 'identify', publickey, token: client.token, ts: Date.now() }
     const { signature } = await identity.signData(data)
-    // Con el acta, el proxy bindea también el `profileId`: escribirle a la PERSONA llega
-    // a cualquiera de sus dispositivos, no solo a esta bóveda.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    log('[vault] identifying with the master key: this vault is not in its own record yet (open the profile once to fix it)')
     await client.identify({ data, signature, acta: record })
   }
   await identify()