@dotrino/vault 0.25.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.25.0",
+  "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",

package/src/service.js

@@ -327,6 +327,61 @@ export async function enrollService ({ qr, ns, dir, label, onCode, onReplace, ap
   } 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() }
+}
+
 /**
  * Pide los secretos del ns al vault (una petición puntual; lanza si falla).
  * Usa la identidad persistida por `enrollService` salvo que se pase explícita.