@dotrino/vault 0.24.0 → 0.26.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.24.0",
-  "description": "Usa ESTE dispositivo (navegador) como b\u00f3veda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegaci\u00f3n a tus m\u00e1quinas. 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'`).",
+  "version": "0.26.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",
   "module": "src/index.js",
@@ -32,7 +32,8 @@
     "src",
     "bin",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "!src/types.d.ts"
   ],
   "keywords": [
     "dotrino",
@@ -42,7 +43,7 @@
     "pairing"
   ],
   "peerDependencies": {
-    "@dotrino/identity": ">=0.30.0",
+    "@dotrino/identity": ">=0.53.0",
     "@dotrino/proxy-client": ">=0.9.0"
   },
   "license": "MIT",
@@ -50,12 +51,5 @@
     "type": "git",
     "url": "git+https://github.com/imdotrino/dotrino-vault.git",
     "directory": "lib"
-  },
-  "devDependencies": {
-    "typescript": "^5.7.3",
-    "@types/node": "^22.0.0"
-  },
-  "scripts": {
-    "type-check": "tsc --noEmit"
   }
 }

package/src/service.js

@@ -22,9 +22,10 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
-  makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig,
-  makePairingCode, commitCode, pubkeyId
+  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
+  verifyDeviceSig, makePairingCode, commitCode, pubkeyId
 } from '@dotrino/identity/capabilities'
+import { openWrap, decryptWithCek } from '@dotrino/identity/content'
 import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
@@ -277,6 +278,11 @@ export async function enrollService ({ qr, ns, dir, label, onCode, onReplace, ap
   }
   try {
     const device = await makeDeviceKey({ label })
+    // La llave de CIFRADO, hermana de la de firma. Sin ella el vault no puede
+    // sellarle sus variables a ESTE aparato, y arrancaría sin configuración sin
+    // que nadie sepa por qué. Su pública viaja en el enrolamiento y acaba en el
+    // acta como `encPub`; la privada no sale de este disco.
+    const enc = await makeDeviceEncKey()
     const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
     // Código ALEATORIO generado AQUÍ: el vault no lo conoce; solo puede echarlo
     // de vuelta si el dueño lo tipeó (= tiene esta pantalla a la vista).
@@ -288,7 +294,7 @@ export async function enrollService ({ qr, ns, dir, label, onCode, onReplace, ap
     // si falta, asume `join` — pero un agente no debe apoyarse en un default
     // para algo que decide de quién es la cuenta. Yendo dentro de `data`, viaja
     // firmado: nadie en el medio puede convertirlo en una adopción.
-    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, 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, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -314,8 +320,65 @@ export async function enrollService ({ qr, ns, dir, label, onCode, onReplace, ap
 
     // Reemplazo, no acumulación: el archivo se sobrescribe entero y la identidad
     // anterior deja de existir en este agente.
-    writeServiceIdentity(dir, { v: 1, ns, iss: qr.iss, proxy: qr.proxy, device, cert: res.cert, enrolledAt: Date.now() })
-    return { device, cert: res.cert, iss: qr.iss, replaced }
+    // v2: suma `enc`. El `device` (la llave de FIRMA) no se toca — de él sale el
+    // `nodeId` del proxio, y cambiarlo le costaría su cajón de variables.
+    writeServiceIdentity(dir, { v: 2, ns, iss: qr.iss, proxy: qr.proxy, device, enc: { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk }, cert: res.cert, enrolledAt: Date.now() })
+    return { device, enc, cert: res.cert, iss: qr.iss, replaced }
+  } finally { client.close() }
+}
+
+/**
+ * Se asegura de que este servicio TENGA llave de cifrado, generándola si le falta.
+ *
+ * Existe para los agentes que se enrolaron ANTES de que la llave existiera: su
+ * `service-identity.json` es v1 y solo lleva la de firma. Sin esto, la única forma de
+ * conseguirla sería re-enrolarse — y re-enrolar le cambia la pubkey, con lo que pierde
+ * su cajón de variables (va indexado por ella) y arrancaría sin configuración, en
+ * silencio. Ese es justo el accidente que esta función existe para evitar.
+ *
+ * La llave de FIRMA no se toca: de ella sale el `nodeId` del proxio.
+ *
+ * @returns {Promise<{ encPub: string, created: boolean }>}
+ */
+export async function ensureEncKey ({ dir } = {}) {
+  const saved = readServiceIdentity(dir)
+  if (!saved) throw new Error('service not enrolled: run enrollService() first')
+  if (saved.enc?.publickey && saved.enc?.privateJwk) return { encPub: saved.enc.publickey, created: false }
+  const enc = await makeDeviceEncKey()
+  writeServiceIdentity(dir, { ...saved, v: 2, enc: { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk } })
+  return { encPub: enc.encPublickey, created: true }
+}
+
+/**
+ * Registra en la bóveda la llave de cifrado de ESTE servicio, para que pueda sellarle
+ * sus variables. Genera la llave si falta.
+ *
+ * Va por `MSG.SECRETS` con `op:'enckey'` a propósito: no hace falta una constante nueva
+ * del protocolo, y así el trío de archivos vendorizado en el iframe de identidad no se
+ * mueve. Registrar una llave no da acceso a nada por sí solo —quien firma esta petición
+ * ya tiene la llave de firma del servicio, o sea ya lee ese namespace—, así que no exige
+ * la contraseña del perfil.
+ */
+export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device, cert, timeoutMs = 30000 } = {}) {
+  const saved = readServiceIdentity(dir)
+  const { encPub, created } = await ensureEncKey({ dir })
+  ns = ns || saved?.ns
+  proxyUrl = proxyUrl || saved?.proxy
+  masterPubkey = masterPubkey || saved?.iss
+  device = device || saved?.device
+  cert = cert || saved?.cert
+  if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
+
+  const client = await freshClient(proxyUrl)
+  try {
+    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)
+    client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
+    const res = await pending
+    if (res.type === MSG.ERROR) throw new Error(res.error)
+    return { encPub, created, ok: true }
   } finally { client.close() }
 }
 
@@ -373,11 +436,51 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     if (!ok) throw new Error('invalid master signature on the secrets reply')
 
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
+
+    // DOS CAPAS DE SOBRE, y hacen cosas distintas:
+    //   · la de fuera (`ek` efímera, recién abierta) tapa el TRAMO — el proxio no ve
+    //     ni los nombres de tus variables;
+    //   · 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)
+
+    // 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`).
     if (!payload || typeof payload.secrets !== 'object') throw new Error('malformed secrets envelope')
     return payload.secrets
   } finally { client.close() }
 }
 
+/**
+ * Abre un bundle sellado: saca la CEK de la envoltura dirigida a este aparato y
+ * descifra con ella las variables privadas. Las públicas vienen en claro.
+ *
+ * Un fallo al abrir es un ERROR DURO, nunca un salto a lo del scope ni un valor
+ * 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) {
+  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 })
+  }
+
+  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']
+    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 })
+  }
+  return out
+}
+
 /**
  * Escucha los avisos de cambio de configuración de la bóveda.
  *

package/src/types.d.ts

@@ -1,5 +0,0 @@
-interface Element { [key: string]: any; }
-interface EventTarget { [key: string]: any; }
-interface HTMLElement { [key: string]: any; }
-interface Event { [key: string]: any; }
-interface Window { [key: string]: any; }