@dotrino/vault 0.49.1 → 0.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.49.1",
+  "version": "0.51.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",
@@ -30,6 +30,9 @@
     },
     "./protocol": {
       "import": "./src/protocol.js"
+    },
+    "./admin": {
+      "import": "./src/admin.js"
     }
   },
   "files": [

package/src/admin.js

@@ -110,6 +110,21 @@ export const AUDIT_MAX = 500
  * @param {()=>boolean} [o.isLocked]  candado del perfil. Cerrado, solo se atiende
  *   `ADMIN_OPS_WHILE_LOCKED`; lo demás responde con el código `vault-locked`.
  */
+/**
+ * EL CUERPO QUE FIRMA EL AUTOR DE UN SOBRE. Uno solo, para los dos lados.
+ *
+ * Quien escribe firma esto y la bóveda verifica esto MISMO. Si cada lado se armara su
+ * versión, la firma dejaría de cuadrar el día que alguien añada un campo —y el síntoma
+ * sería «la firma no verifica», que manda a mirar la cripto en vez del formato.
+ *
+ * Lleva el CAJÓN y la CLAVE, no solo el sobre: sin ellos, una firma válida para
+ * `ns:aws/TOKEN` valdría igual para `ns:proxy/TOKEN`, que es exactamente el sobre colado
+ * fuera de su sitio que esto viene a impedir.
+ */
+export function authorBody (owner, key, e, ts) {
+  return { op: 'var.author', owner, key, iv: e?.iv || null, ct: e?.ct || null, ts }
+}
+
 export function createAdminDesk ({
   desk, verify, readActivity = () => [], deviceIdOf, vars = null,
   notify = async () => {}, audit = () => {}, isLocked = () => false,
@@ -189,7 +204,9 @@ export function createAdminDesk ({
         const toScope = typeof data.ns === 'string' && !!data.ns
         const toDevice = typeof data.pub === 'string' && !!data.pub
         if (data.op === 'vars') {
-          const result = await vars.list({ by })
+          // QUIÉN PREGUNTA, no solo su nombre: con su llave se le manda la envoltura de
+          // cada pública para que pueda abrirla en su casa.
+          const result = await vars.list({ by, caller: chk.device })
           audit('admin.vars', { by })
           return { ok: true, result }
         }
@@ -205,14 +222,14 @@ export function createAdminDesk ({
           // Una bóveda anterior a esto sabe guardar de una en una y nada más. Decirlo es
           // mejor que reventar con un TypeError que no explica qué falta actualizar.
           if (typeof vars.setMany !== 'function') return { ok: false, error: 'admin: this vault cannot save several variables at once (update it)' }
-          if (!data.enc || typeof data.enc !== 'object') {
-            return { ok: false, error: 'admin: var.setMany needs the variables sealed with the profile content key' }
+          if (!Array.isArray(data.items) || !data.items.length) {
+            return { ok: false, error: 'admin: var.setMany needs `items`, each with its key and its sealed envelope' }
           }
           const result = await vars.setMany({
             ns: toScope ? data.ns : null,
             pub: toDevice ? data.pub : null,
-            enc: data.enc,
-            public: typeof data.public === 'boolean' ? data.public : undefined,
+            items: data.items,
+            caller: chk.device,
             by
           })
           const keys = result?.keys || []
@@ -222,17 +239,22 @@ export function createAdminDesk ({
         }
 
         if (typeof data.key !== 'string' || !data.key) return { ok: false, error: 'admin: var.set needs a key' }
-        if (!data.enc || typeof data.enc !== 'object') {
-          // El valor NUNCA viaja en claro: si llega sin sobre, es un error de quien llama,
-          // no algo que se pueda «arreglar» aceptándolo.
-          return { ok: false, error: 'admin: var.set needs the value sealed with the profile content key' }
+        if (!data.sealed || typeof data.sealed !== 'object') {
+          // El valor NUNCA viaja en claro, y desde 2026-09-02 tampoco sellado al perfil: el
+          // sobre llega HECHO y la bóveda no lo abre. Si llega de otra forma es un error de
+          // quien llama, no algo que se pueda «arreglar» aceptándolo.
+          return { ok: false, error: 'admin: var.set needs the value already sealed (`sealed`); build it with buildSealedVar()' }
         }
         const result = await vars.set({
           ns: toScope ? data.ns : null,
           pub: toDevice ? data.pub : null,
           key: data.key,
-          enc: data.enc,
+          sealed: data.sealed,
           public: typeof data.public === 'boolean' ? data.public : undefined,
+          // LA LLAVE DE QUIEN LLAMA, no solo su nombre corto. `by` es el `deviceId`, que
+          // vale para el registro pero no para comprobar una firma: el sobre trae la de su
+          // AUTOR y hay que verificarla contra la llave de quien lo manda.
+          caller: chk.device,
           by
         })
         audit('admin.var.set', { by, ns: toScope ? data.ns : null, device: toDevice ? await deviceIdOf(data.pub).catch(() => null) : null, key: data.key })
@@ -276,3 +298,64 @@ export function createAdminDesk ({
 }
 
 export default { createAdminDesk, ADMIN_OPS, ADMIN_OPS_WHILE_LOCKED, ADMIN_NONCE_TTL_MS }
+
+/**
+ * FABRICAR EL SOBRE DE UNA VARIABLE — del lado de quien escribe.
+ *
+ * La bóveda ya no ve el valor (dueño, 2026-09-01): recibe el sobre hecho, comprueba lo que
+ * puede sin la llave —quién lo firma y a quién envuelve— y lo guarda. Esto es lo que hay que
+ * mandarle, y vive aquí para que no lo rearme cada consola por su cuenta.
+ *
+ * El orden importa y no es casual:
+ *   1. se pide a la BÓVEDA a quién hay que envolver (`var.recipients`). La lista sale del
+ *      acta y la sabe ella; tener dos sitios respondiendo a eso es cómo se deja fuera a
+ *      alguien sin que nadie se entere.
+ *   2. CEK nueva y el valor cifrado con ella;
+ *   3. esa CEK envuelta a la PÚBLICA de cada destinatario, más la de recuperación —sin la
+ *      cual el cajón nacería ilegible para siempre;
+ *   4. y la firma del AUTOR sobre el cajón, la clave y el sobre.
+ *
+ * QUIÉN FIRMA SE PASA COMO FUNCIÓN, no como llave. En el navegador la privada del aparato
+ * vive dentro del iframe de identidad y NO SALE de ahí —esa es media garantía del diseño—,
+ * así que la consola no puede firmar aquí: pide la firma y ya. En Node, donde la llave sí
+ * está a mano, se envuelve `signWithDevice` en dos líneas. Un solo camino para los dos.
+ *
+ * @param {{recipients:{recoveryPub:string, members:Array<{pub:string,encPub:string}>},
+ *          owner:string, key:string, value:string,
+ *          author:{publickey:string, sign:(body:any)=>Promise<{signature:string}>}}} opts
+ */
+export async function buildSealedVar ({ recipients, owner, key, value, author } = {}) {
+  const { makeContentKey, encryptWithCek, wrapForMember } = await import('@dotrino/identity/content')
+  if (!recipients?.recoveryPub) throw new Error('buildSealedVar: ask the vault for the recipients first (var.recipients)')
+  if (typeof value !== 'string' || !value) throw new Error('buildSealedVar: the value must be a non-empty string')
+  if (typeof author?.sign !== 'function' || typeof author?.publickey !== 'string') {
+    throw new Error('buildSealedVar: author needs { publickey, sign(body) }')
+  }
+
+  const cek = await makeContentKey()
+  const e = await encryptWithCek({ cek, gen: 0, plaintext: value })
+  // Envolver solo necesita PÚBLICAS: por eso esto se puede hacer en un navegador sin que
+  // ninguna llave privada ande suelta.
+  const wraps = { '#recovery': await wrapForMember({ cek, memberEncPub: recipients.recoveryPub }) }
+  for (const m of recipients.members || []) {
+    wraps[m.pub] = await wrapForMember({ cek, memberEncPub: m.encPub })
+  }
+  const ts = Date.now()
+  const { signature } = await author.sign(authorBody(owner, key, e, ts))
+  return { e, wraps, author: { pub: author.publickey, sig: signature, ts } }
+}
+
+/**
+ * El `author` de `buildSealedVar` a partir de una llave de aparato de Node (la que trae
+ * `makeDeviceKey` o un `service-identity.json`). En el navegador no se usa: allí la firma
+ * la da el iframe.
+ */
+export function authorFromDeviceKey (device) {
+  return {
+    publickey: device.publickey,
+    sign: async (body) => {
+      const { signWithDevice } = await import('@dotrino/identity/capabilities')
+      return signWithDevice({ ...device, data: body })
+    }
+  }
+}

package/src/service.js

@@ -662,7 +662,14 @@ async function openSealedBundle (sealed, ident, acta = null, masterPubkey = null
 
   const out = {}
   for (const [key, e] of Object.entries(sealed.entries || {})) {
-    if (e.pub) { out[key] = e.v; continue }
+    // UNA PÚBLICA SE ABRE IGUAL QUE UNA PRIVADA (dueño, 2026-09-02). Aquí había un atajo
+    // —`if (e.pub) out[key] = e.v`— porque una pública se guardaba en claro. Ya no: `pub`
+    // solo dice si se despacha sin aprobación, y el sobre es el mismo. Dejar el atajo
+    // sería aceptar un valor en claro dentro de un paquete que se supone todo sellado, o
+    // sea la puerta para colar uno.
+    if (typeof e.v === 'string' && !e.e) {
+      throw Object.assign(new Error(`${key} arrived in the clear: since 2026-09-02 every variable travels sealed`), { code: 'plaintext-var' })
+    }
     // `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