@dotrino/vault 0.85.0 → 0.86.0

package/src/core/sealer.js

@@ -0,0 +1,172 @@
+/**
+ * El SELLADOR: lo único de los secretos que toca criptografía.
+ *
+ * `secretsStore.js` guarda la forma y las reglas y no sabe cifrar; le inyecta este
+ * puerto y le pide sobres. Así el store se prueba con un sellador falso y este archivo
+ * se lee entero de una sentada.
+ *
+ * QUÉ HACE. Cada cajón (un namespace, o el cajón propio de un aparato) tiene una CEK
+ * AES-256-GCM. Las variables privadas se cifran con ella. La CEK viaja de dos formas,
+ * y esa dualidad es todo el diseño:
+ *
+ *   · **hacia los miembros** — envuelta a la llave de cifrado (`encPub`) de cada
+ *     aparato que deba leer ese cajón, con ECDH efímero: quien abre solo necesita su
+ *     propia privada. Es lo que va en el llavero del archivo y lo que viaja al agente.
+ *   · **hacia quien administra** — en la COPIA MAESTRA, cifrada con la llave derivada
+ *     de la contraseña del perfil. Es lo que permite sellar una variable nueva o
+ *     re-envolver la CEK a un aparato que entra.
+ *
+ * Y hay una tercera forma que NO existe a propósito: **la CEK nunca se envuelve a la
+ * llave de esta bóveda**. Si se hiciera, el daemon podría abrir todo por su cuenta y
+ * esto no valdría nada — que es exactamente la situación de la que venimos.
+ *
+ * La contraseña no está en el disco, así que una copia del disco no abre las privadas.
+ * Lo que sí abre es todo lo demás; los límites honestos están en
+ * `docs/secretos-sellados.md` §3 y conviene leerlos antes de confiar de más.
+ */
+import {
+  makeContentKey, makeGeneration, encryptWithCek, decryptWithCek, wrapForMember, openWrap
+} from '@dotrino/identity/content'
+
+const b64 = (b) => { let s = ''; for (const x of new Uint8Array(b)) s += String.fromCharCode(x); return btoa(s) }
+const un64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0))
+/** AES-256-GCM con WebCrypto: el mismo en Node y en el navegador. */
+const aesKey = (raw, uses) => crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, false, uses)
+
+/** La copia maestra va cifrada con AES-256-GCM bajo la llave derivada de la contraseña. */
+const MASTER_V = 1
+
+/** Se pidió abrir la copia maestra sin llave, o con la equivocada. */
+export class WrongPassword extends Error {
+  constructor (msg = 'wrong password') {
+    super(msg)
+    this.code = 'WRONG_PASSWORD'
+  }
+}
+
+function assertKey (adminKey) {
+  if (!(adminKey instanceof Uint8Array) || adminKey.length !== 32) {
+    throw new WrongPassword('the derived key is missing or malformed (32 bytes expected)')
+  }
+}
+
+/**
+ * Crea el sellador. No guarda estado ni recuerda la contraseña: cada operación recibe
+ * la llave derivada y la suelta. Que no se cachee es la mitad del valor de todo esto —
+ * una llave que se queda en memoria para siempre deja el disco protegido y la máquina
+ * igual de expuesta que antes.
+ */
+export function makeSealer () {
+  return {
+    /**
+     * Abre la copia maestra: `{ "ns:<ns>": cek, "dev:<pub>": cek }`. Un `blob` vacío
+     * devuelve un mapa vacío — es el primer arranque, no un error.
+     */
+    async openMaster (blob, adminKey) {
+      assertKey(adminKey)
+      if (!blob) return {}
+      if (blob.v !== MASTER_V) throw new Error(`master copy: unknown format v${blob.v}`)
+      try {
+        // WebCrypto quiere la etiqueta pegada al final del cifrado; en disco van aparte.
+        const ct = un64(blob.ct); const tag = un64(blob.tag)
+        const both = new Uint8Array(ct.length + tag.length); both.set(ct); both.set(tag, ct.length)
+        const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: un64(blob.iv) }, await aesKey(adminKey, ['decrypt']), both)
+        return JSON.parse(new TextDecoder().decode(plain))
+      } catch (_) {
+        // El tag de AES-GCM ES el verificador: si no cuadra, la contraseña no era.
+        // Por eso no hace falta guardar aparte un verificador de la contraseña, que
+        // sería un camino más barato para atacarla desde una copia del disco.
+        throw new WrongPassword()
+      }
+    },
+
+    async sealMaster (obj, adminKey) {
+      assertKey(adminKey)
+      const iv = crypto.getRandomValues(new Uint8Array(12))
+      const both = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, await aesKey(adminKey, ['encrypt']), new TextEncoder().encode(JSON.stringify(obj))))
+      return { v: MASTER_V, iv: b64(iv), ct: b64(both.subarray(0, both.length - 16)), tag: b64(both.subarray(both.length - 16)) }
+    },
+
+    /** La CEK de un cajón, creándola si es la primera variable que entra ahí. */
+    async cekFor (master, owner) {
+      if (!master[owner]) master[owner] = await makeContentKey()
+      return master[owner]
+    },
+
+    /** Una CEK NUEVA para el cajón, tirando la anterior. Rotar es esto. */
+    async newCek (master, owner) {
+      master[owner] = await makeContentKey()
+      return master[owner]
+    },
+
+    /** Cifra un valor con la CEK del cajón. */
+    async encrypt (cek, plaintext, gen = 0) {
+      const { iv, ct } = await encryptWithCek({ cek, gen, plaintext })
+      return { iv, ct }
+    },
+
+    /** Descifra con la CEK que corresponda al cajón. Solo lo usa quien administra. */
+    async decrypt (master, envelope, owner) {
+      const cek = master[owner]
+      if (!cek) throw new Error(`master copy: no key for drawer ${owner}`)
+      return decryptWithCek({ cek, envelope })
+    },
+
+    /**
+     * Una CEK NUEVA, sin llavero de por medio. Es lo que usa cada escritura desde v5: la
+     * bóveda no puede reutilizar la de antes porque **no puede abrir ninguna envoltura
+     * para recuperarla** — sellar es una capacidad pública, abrir no. Una generación por
+     * escritura es la consecuencia, no un capricho (§8.7).
+     */
+    async newKey () {
+      return makeContentKey()
+    },
+
+    /**
+     * El par de RECUPERACIÓN: su pública se guarda en claro —para poder envolverle sin
+     * saber nada— y su privada va sellada bajo la frase. Es la copia que se abre el día
+     * que no queda ningún aparato, y la que abre la TUI cuando el dueño pide ver un valor.
+     */
+    async makeRecoveryPair () {
+      const pair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey', 'deriveBits'])
+      return {
+        pub: JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey)),
+        priv: await crypto.subtle.exportKey('jwk', pair.privateKey)
+      }
+    },
+
+    /** Envuelve una CEK a UNA pública suelta (la de recuperación, que no es un miembro). */
+    async wrapForKey (cek, encPub) {
+      return wrapForMember({ cek, memberEncPub: encPub })
+    },
+
+    /**
+     * Abre una envoltura con una privada ECDH **en JWK**. Lo hace quien PUEDE leer.
+     *
+     * La privada llega como JWK porque así se guarda (sellada bajo la frase, en un JSON),
+     * y `openWrap` quiere una `CryptoKey`: importarla es el puente, y va aquí porque este
+     * es el único archivo que toca criptografía.
+     */
+    async openWrapWith (privJwk, wrap) {
+      const key = await crypto.subtle.importKey('jwk', privJwk, { name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+      return openWrap({ wrap, myEncPrivateKey: key })
+    },
+
+    /** Descifra un sobre con la CEK ya abierta. */
+    async openValue (cek, envelope) {
+      return decryptWithCek({ cek, envelope })
+    },
+
+    /**
+     * Envuelve la CEK a cada miembro. Los que no tengan llave de cifrado salen en
+     * `sinLlave` en vez de reventar: quien administra tiene que poder VERLO, porque el
+     * síntoma sería un servicio arrancando sin configuración y sin decir por qué.
+     */
+    async wrapFor (cek, members) {
+      const { generation, sinLlave } = await makeGeneration({ members, cek })
+      return { wraps: generation.wraps, sinLlave }
+    }
+  }
+}
+
+export default { makeSealer, WrongPassword }

package/src/core/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 }