@dotrino/vault 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",
@@ -43,7 +43,7 @@
     "pairing"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.53.0",
+    "@dotrino/identity": ">=0.56.0",
     "@dotrino/proxy-client": ">=0.9.0"
   },
   "license": "MIT",
@@ -51,5 +51,12 @@
     "type": "git",
     "url": "git+https://github.com/imdotrino/dotrino-vault.git",
     "directory": "lib"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit"
   }
 }

package/src/admin.js

@@ -41,7 +41,12 @@ export const ADMIN_OPS = Object.freeze([
   // no debe poder dejar sin configuración a los servicios.
   // `var.setMany` es la MISMA operación con varias variables dentro de un solo sobre: no
   // añade permisos, quita reinicios (ver el enrutado abajo).
-  'vars', 'var.set', 'var.setMany'
+  'vars', 'var.set', 'var.setMany',
+  // VER un valor y sus versiones anteriores. Entran aquí —y no en la lista de lo que la
+  // bóveda hace por su cuenta— porque la bóveda NO abre nada: entrega el sobre y la
+  // envoltura dirigida a ESE aparato, que lo abre con su propia llave (§8.2). Sin esto,
+  // administrar a distancia obligaba a teclear la contraseña del perfil en un navegador.
+  'var.reveal', 'var.history'
 ])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
@@ -212,6 +217,34 @@ export function createAdminDesk ({
         return { ok: true, result: result || { ok: true } }
       }
 
+      // VER un valor (y sus versiones anteriores). La bóveda entrega material sellado a
+      // ESTE aparato; abrirlo es cosa suya. Se AUDITA, porque leer un secreto a distancia
+      // es exactamente lo que hay que poder revisar después.
+      if (data.op === 'var.reveal' || data.op === 'var.history') {
+        if (!vars) return { ok: false, error: 'admin: this vault does not serve environment variables' }
+        if (typeof vars.reveal !== 'function') return { ok: false, error: 'admin: this vault cannot show values (update it)' }
+        const toScope = typeof data.ns === 'string' && !!data.ns
+        const toDevice = typeof data.pub === 'string' && !!data.pub
+        if (toScope === toDevice) return { ok: false, error: 'admin: it needs exactly one target (ns or pub)' }
+        const target = { ns: toScope ? data.ns : null, pub: toDevice ? data.pub : null }
+
+        if (data.op === 'var.history') {
+          const result = await vars.history({ ...target, key: typeof data.key === 'string' ? data.key : null })
+          audit('admin.var.history', { by, ns: target.ns, key: data.key || null })
+          return { ok: true, result }
+        }
+        if (typeof data.key !== 'string' || !data.key) return { ok: false, error: 'admin: var.reveal needs a key' }
+        const result = await vars.reveal({
+          ...target,
+          key: data.key,
+          ts: Number.isFinite(data.ts) ? data.ts : null,
+          device: chk.device,
+          by
+        })
+        audit('admin.var.reveal', { by, ns: target.ns, key: data.key, ...(data.ts ? { ts: data.ts } : {}) })
+        return { ok: true, result }
+      }
+
       // QUITAR UN DISPOSITIVO se hace por `sub` (su llave): sale del acta Y se le retiran
       // todos los certificados. Las dos cosas o ninguna.
       //

package/src/enroll.js

@@ -261,9 +261,15 @@ export function createEnrollDesk ({
     pend.dpub = d.dpub
     pend.deviceId = deviceId
     pend.commit = d.commit
-    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave de contenido del
-    // perfil al admitirlo. Sin ella entra, pero no podrá leer lo que haya guardado.
+    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave del cajón al
+    // admitirlo. Un SERVICIO sin ella entraría al acta y no podría leer NUNCA ninguna
+    // variable —las privadas van selladas a esta llave—, así que se corta aquí en vez
+    // de admitirlo y dejar que falle más tarde y en otro sitio. Un dispositivo de
+    // persona sí puede entrar sin ella: no lee variables de servicio.
     if (typeof d.encPub === 'string') pend.encPub = d.encPub
+    if (!pend.encPub && scopeToCn(pend.scope)) {
+      return reply(from, { type: MSG_ERROR, error: 'a service must send its encryption key (update @dotrino/vault on the service)' })
+    }
     // Certificado de continuidad (opcional): lo firma la identidad que se une, con su
     // propia llave. Se comprueba aquí y se guarda con el miembro al aprobar.
     if (d.continuity) {

package/src/protocol.js

@@ -66,6 +66,16 @@ export const MSG = Object.freeze({
   // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
   // aviso de reinicio sin autenticar ES un ataque de denegación.
   SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  // REPARTIR LA LLAVE DE UN CAJÓN A UN MIEMBRO NUEVO. Lo hace el SERVICIO y no la
+  // bóveda, porque la bóveda no puede abrir la llave sin la frase y el servicio ya la
+  // tiene: re-envolverla no le añade ningún poder. Ver `docs/secretos-sellados.md` §8.11.
+  //
+  // El servicio NO se fía de lo que le manden: comprueba la firma de la maestra, comprueba
+  // el ACTA que viene dentro (también firmada) y saca de ahí la llave pública del
+  // destinatario. Así, ni siquiera una bóveda comprometida puede hacerle envolver la
+  // llave para alguien que la maestra no haya metido en su propio cajón.
+  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, signature }
+  REWRAP_OK: 'vault.rewrap.ok',               // servicio → vault: { data:{op,owner,gen,target,wrap,ts}, signature, cert }
   // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
   // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
   // Admitir y expulsar, nada más: cambiar permisos, traspasar el mando y los secretos

package/src/service.js

@@ -25,7 +25,8 @@ import {
   makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
   verifyDeviceSig, makePairingCode, commitCode, pubkeyId
 } from '@dotrino/identity/capabilities'
-import { openWrap, decryptWithCek } from '@dotrino/identity/content'
+import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
+import { verifyActa, sealKeyAt } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
@@ -443,7 +444,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     //   · la de dentro (`sealed`) tapa el REPOSO — la bóveda guarda lo que reparte
     //     sin poder abrirlo.
     // Se quedan las dos: quitar la de fuera dejaría los nombres al aire.
-    if (payload?.sealed) return openSealedBundle(payload.sealed, saved)
+    if (payload?.sealed) return openSealedBundle(payload.sealed, saved, payload.acta, masterPubkey)
 
     // Bóveda todavía en v3: manda los valores tal cual, como siempre. Desaparece
     // cuando el último vault haya migrado (ver `docs/secretos-sellados.md`).
@@ -460,21 +461,80 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
  * omitido: silenciarlo convertiría una rotación mal sellada en «el servicio sigue
  * con el valor viejo y nadie se entera», que es el peor modo de fallo de todo esto.
  */
-async function openSealedBundle (sealed, ident) {
+/**
+ * ¿SALIÓ ESTE SOBRE DE MI BÓVEDA? (§8.8 de `dotrino-vault/docs/secretos-sellados.md`)
+ *
+ * Envolver una llave solo necesita públicas, así que **cualquiera puede fabricar un sobre
+ * válido** para este servicio: abrirlo prueba que es para mí, no que lo escribió quien
+ * debía. Lo que lo prueba es la firma, hecha con la llave de sellado que el acta nombra
+ * para el `seq` con el que se firmó — y el acta la firma la maestra, que es la que este
+ * agente lleva pineada desde que se enroló.
+ *
+ * Una firma que NO cuadra es un error duro: es exactamente el caso que esto viene a
+ * cazar. Un sobre SIN firma se acepta y se avisa: los hay de antes de que esto existiera
+ * y negarse a arrancar por eso apagaría servicios que llevan meses bien.
+ */
+export async function makeSealCheck (acta, masterPubkey, log = console.log) {
+  if (!acta) return () => {}
+  // El acta tiene que venir firmada por la maestra que este agente ya conoce. Si la
+  // selló otro (un traspaso que este agente no ha visto), no se puede establecer
+  // procedencia: se dice y se sigue, en vez de fingir que se comprobó.
+  const ok = acta.sealedBy === masterPubkey && (await verifyActa({ acta })).ok
+  if (!ok) {
+    log('[vault] ⚠ the record does not come from the master this agent knows: envelope provenance NOT checked')
+    return () => {}
+  }
+  let avisado = 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)') }
+      return
+    }
+    const pub = sealKeyAt(acta, seal.seq)
+    if (!pub) throw new Error(`${key}: the record has no sealing key for #${seal.seq} (the envelope claims a record that does not exist)`)
+    const good = await verifyDeviceSig({ publickey: pub, data: { owner, key, gen, iv: e.iv, ct: e.ct }, signature: seal.sig })
+    if (!good) throw new Error(`${key}: the envelope signature does not check out — it did not come from this vault`)
+  }
+}
+
+async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null) {
   if (!ident?.enc?.privateJwk) {
     throw new Error('this service has no encryption key: update @dotrino/vault and re-enroll it')
   }
   const mine = await importDeviceEncKey(ident.enc.privateJwk)
-  const ceks = {}
-  for (const [cual, info] of Object.entries({ ns: sealed.ns, dev: sealed.dev })) {
-    if (info?.wrap) ceks[cual] = await openWrap({ wrap: info.wrap, myEncPrivateKey: mine })
+
+  // UNA LLAVE POR GENERACIÓN, no una por cajón. Desde v5 cada escritura estrena
+  // generación —la bóveda no puede reutilizar una llave que no puede abrir—, así que dos
+  // variables del mismo cajón pueden venir de generaciones distintas. El bundle trae
+  // 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) }
+  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)
+
+  const abiertas = { ns: new Map(), dev: new Map() }
+  const cekDe = async (cual, gen) => {
+    if (abiertas[cual].has(gen)) return abiertas[cual].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)
+    if (!wrap) return null
+    const cek = await openWrap({ wrap, myEncPrivateKey: mine })
+    abiertas[cual].set(gen, cek)
+    return cek
   }
 
+  const comprobarFirma = await makeSealCheck(acta, masterPubkey)
+
   const out = {}
   for (const [key, e] of Object.entries(sealed.entries || {})) {
     if (e.pub) { out[key] = e.v; continue }
-    // `owner` dice de qué cajón salió, y por tanto con qué CEK se abre.
-    const cek = ceks[String(e.owner || '').startsWith('dev:') ? 'dev' : 'ns']
+    // `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 gen = e.gen ?? e.e?.gen ?? 0
+    await comprobarFirma(e.owner, key, gen, e.e, e.seal)
+    const cek = await cekDe(cual, gen)
     if (!cek) throw new Error(`no key to open ${key}: this device has no wrapping for its drawer`)
     out[key] = await decryptWithCek({ cek, envelope: e.e })
   }
@@ -592,8 +652,59 @@ export async function watchSecretsChanges ({
     try { onRevoked?.({ nonce: body.nonce }) } catch (e) { log('[vault] ' + e.message) }
   }
 
+  /**
+   * REPARTIR LA LLAVE DE MI CAJÓN a un miembro nuevo (§8.11 del diseño).
+   *
+   * Un aparato que entra después de escrita una variable no tiene envoltura de ella, y
+   * la bóveda no se la puede hacer: envolver exige abrir la llave, y abrirla pide la
+   * frase. Este agente SÍ la tiene abierta, así que la reparte él. No gana ningún poder
+   * haciéndolo —ya podía leer eso— y por eso es el único que puede hacerlo sin que
+   * nadie ceda nada.
+   *
+   * NO SE FÍA DE LO QUE LE MANDAN, y esto es lo que hace que sea seguro incluso si la
+   * bóveda estuviera comprometida:
+   *
+   *  · la petición va firmada por la MAESTRA;
+   *  · el acta viaja dentro y se comprueba aparte (también la firma la maestra);
+   *  · **la llave pública del destinatario se saca del ACTA, nunca del mensaje** — si
+   *    se cogiera del mensaje, quien lo mandara podría hacer que este agente envolviera
+   *    la llave para una pública suya;
+   *  · y el destinatario tiene que ser de ESTE cajón (`cn === ns`): un servicio no puede
+   *    ampliar el acceso a nada que no sea lo suyo.
+   */
+  const handleRewrap = async (payload) => {
+    const body = payload?.body
+    if (!body || body.op !== 'rewrap') return
+    const mineOwners = [`ns:${ns}`, `dev:${saved.device.publickey}`]
+    if (!mineOwners.includes(body.owner)) return log('[vault] rewrap for a drawer that is not mine: ignored')
+    if (!(await verifyDeviceSig({ publickey: master, data: body, signature: payload.signature }))) {
+      return log('[vault] rewrap request BADLY SIGNED: ignored')
+    }
+    const acta = body.acta
+    if (!acta || acta.sealedBy !== master || !(await verifyActa({ acta })).ok) {
+      return log('[vault] rewrap request without a valid record: ignored')
+    }
+    const target = (acta.members || []).find((m) => m.pub === body.target)
+    if (!target?.encPub) return log('[vault] rewrap: the target is not in the record (or has no encryption key)')
+    if (target.cn !== ns) return log(`[vault] rewrap: ${String(body.target).slice(0, 12)}… is not part of «${ns}»: refused`)
+
+    try {
+      const ident = readServiceIdentity(dir)
+      if (!ident?.enc?.privateJwk) return log('[vault] rewrap: this agent has no encryption key')
+      const cek = await openWrap({ wrap: body.wrap, myEncPrivateKey: await importDeviceEncKey(ident.enc.privateJwk) })
+      const wrap = await wrapForMember({ cek, memberEncPub: target.encPub })
+      const data = { op: 'rewrap.ok', owner: body.owner, gen: body.gen, target: body.target, wrap, ts: Date.now() }
+      const { signature } = await signWithDevice({ privateJwk: saved.device.privateJwk, data })
+      client.sendByPubkey(master, { type: MSG.REWRAP_OK, data, signature, cert: saved.cert })
+      log(`[vault] key handed to ${String(body.target).slice(0, 12)}… for ${body.owner} (gen ${body.gen})`)
+    } catch (e) {
+      log('[vault] rewrap failed: ' + e.message)
+    }
+  }
+
   const handleMessage = async (payload) => {
     if (payload?.type === MSG.REVOKED) return handleRevocation(payload)
+    if (payload?.type === MSG.REWRAP) return handleRewrap(payload)
     if (payload?.type !== MSG.SECRETS_CHANGED) return
     const body = payload.body
     if (!body || body.op !== 'secrets.changed' || body.ns !== ns) return