@dotrino/vaultd 0.84.0 → 0.85.0

package/lib/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,
@@ -205,14 +220,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 +237,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 +296,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/lib/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.84.0",
+  "version": "0.85.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {

package/src/secretsStore.js

@@ -209,9 +209,12 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
   /** Los NOMBRES con su visibilidad: es lo que ve cualquier lista. Nunca valores. */
   const names = (bag, k) => Object.entries(varsOf(bag, k)).map(([key, e]) => ({ key, public: !!e.pub }))
   /** Solo las PÚBLICAS, con valor: lo único que puede salir de esta máquina en claro. */
-  const publics = (bag, k) => Object.fromEntries(
-    Object.entries(varsOf(bag, k)).filter(([, e]) => e.pub).map(([key, e]) => [key, e.v])
-  )
+  /**
+   * LOS NOMBRES de las públicas. Ya no hay valores que devolver: desde 2026-09-02 una
+   * pública se guarda en sobre igual que una privada, y `pub` solo dice si se despacha sin
+   * aprobación. Para VER un valor hay que poder abrirlo, como con cualquier otro.
+   */
+  const publics = (bag, k) => Object.keys(varsOf(bag, k)).filter((key) => varsOf(bag, k)[key].pub)
   /**
    * Las entradas TAL CUAL van al bundle: la pública con su valor, la privada con su
    * sobre y su firma. No se descifra nada aquí — de eso vive todo esto.
@@ -260,7 +263,10 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
   const gcKeyring = (bag, k, owner) => {
     if (!bag[k]) return
     const vivos = new Set()
-    for (const e of Object.values(bag[k].vars || {})) if (!e.pub && e.gen != null) vivos.add(e.gen)
+    // TAMBIÉN LAS PÚBLICAS. Se saltaban porque antes no tenían generación —se guardaban en
+    // claro—, así que su llave se recogía por «no la usa nadie» y la variable quedaba
+    // ilegible. Desde 2026-09-02 van en sobre como todas y cuentan como todas.
+    for (const e of Object.values(bag[k].vars || {})) if (e.gen != null) vivos.add(e.gen)
     for (const h of data.history) if (h.owner === owner && h.gen != null) vivos.add(h.gen)
     bag[k].keyring = (bag[k].keyring || []).filter((g) => vivos.has(g.gen))
   }
@@ -332,9 +338,10 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
     /**
      * @param {string} ns
      * @param {string|null} devicePub
-     * @param {{publicOnly?: boolean}} [opts] `publicOnly`: SOLO las públicas, y sin
-     *   envolturas. Una pública está guardada en claro, así que no hay llave que repartir
-     *   ni sobre que abrir — y por eso pedirlas no pasa por la aprobación (ver `handleSecrets`).
+     * @param {{publicOnly?: boolean}} [opts] `publicOnly`: SOLO las públicas — pero CON sus
+     *   envolturas, porque desde 2026-09-02 van en sobre igual que las privadas. Lo que las
+     *   distingue es solo que se despachan sin aprobación (ver `handleSecrets`); aquí se
+     *   devolvía el paquete sin llavero, y entonces no había con qué abrirlas.
      */
     bundleFor (ns, devicePub = null, { publicOnly = false } = {}) {
       assertNs(ns)
@@ -346,8 +353,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
         ? Object.fromEntries(Object.entries(todo).filter(([, e]) => e.pub))
         : todo
       if (isLegacy()) return { legacy: true, entries }
-      // Sin privadas no hay nada que envolver: el paquete va sin llavero.
-      if (publicOnly) return { entries, ns: null, dev: null, wraps: { ns: [], dev: [] } }
+
       const misWraps = (bag, k) => (bag[k]?.keyring || [])
         .filter((g) => g.wraps?.[devicePub])
         .map((g) => ({ gen: g.gen, wrap: g.wraps[devicePub] }))
@@ -372,7 +378,9 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       const bag = kind === 'ns' ? data.ns : data.dev
       const e = varsOf(bag, k)[key]
       if (!e) return null
-      if (e.pub) return e.v
+      // UNA PÚBLICA SE ABRE IGUAL QUE UNA PRIVADA (dueño, 2026-09-02). Aquí había un atajo
+      // —`if (e.pub) return e.v`— porque una pública se guardaba en claro. Ya no: la marca
+      // solo dice si se despacha sin aprobación, y para VER un valor hay que poder abrirlo.
       if (isLegacy()) return e.v
       const priv = await openRecovery(adminKey)
       const cek = await this._cekOf(bag, k, e.gen, priv)
@@ -401,7 +409,8 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       const bag = kind === 'ns' ? data.ns : data.dev
       const out = []
       for (const [key, e] of Object.entries(varsOf(bag, k))) {
-        if (e.pub) continue
+        // También las públicas: desde 2026-09-02 van en sobre, así que a quien no tenga su
+        // envoltura le falta igual que con una privada.
         const g = (bag[k]?.keyring || []).find((x) => x.gen === e.gen)
         if (!g?.wraps?.[memberPub]) out.push(key)
       }
@@ -423,7 +432,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       if (isLegacy()) return []
       const [kind, k] = splitOwner(owner)
       const bag = kind === 'ns' ? data.ns : data.dev
-      const inUse = new Set(Object.values(varsOf(bag, k)).filter((e) => !e.pub).map((e) => e.gen))
+      const inUse = new Set(Object.values(varsOf(bag, k)).map((e) => e.gen))
       const out = []
       for (const g of bag[k]?.keyring || []) {
         if (!inUse.has(g.gen) || g.wraps?.[memberPub]) continue
@@ -514,10 +523,15 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       if (isLegacy()) { vars[key] = { v: value, pub }; save(); return }
       if (needsMigration()) throw new NeedsMigration()
 
-      // Una PÚBLICA se guarda en claro a propósito: eso es lo que significa marcarla.
-      if (pub) { vars[key] = { v: value, pub: true }; save(); return }
-
-      needSealer('write a private variable')
+      // PÚBLICA Y PRIVADA SE GUARDAN IGUAL (dueño, 2026-09-02: «las variables públicas
+      // igual, codificadas en sobres… la única diferencia es si se despachan o no, son
+      // políticas, dales el mismo tratamiento de seguridad»).
+      //
+      // Antes una pública se guardaba EN CLARO, y eso mezclaba dos cosas que no tienen que
+      // ver: quién puede recibirla (política) y cómo se guarda (seguridad). El precio era
+      // un valor legible en el disco y un camino aparte en cada sitio que las tocaba.
+      // Ahora `pub` es solo la marca de despacho: se lleva sin aprobación (`--public`).
+      needSealer('write a variable')
       await ensureRecovery(null)
 
       // CEK NUEVA, siempre: no se puede reutilizar la de antes sin poder abrirla.
@@ -530,13 +544,102 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       const seal = signer ? await signer({ owner, key, gen, iv: e.iv, ct: e.ct }) : null
 
       pushHistory(owner, key, before, by)
-      vars[key] = { pub: false, owner, gen, e, seal, at: Date.now(), by: by || null }
+      vars[key] = { pub, owner, gen, e, seal, at: Date.now(), by: by || null }
       bag[k].keyring = [...(bag[k].keyring || []), { gen, createdAt: Date.now(), wraps }]
       gcKeyring(bag, k, owner)
       save()
       return { gen, sinLlave }
     },
 
+    /**
+     * GUARDAR UN SOBRE YA HECHO, SIN ABRIRLO (dueño, 2026-09-01).
+     *
+     * «La bóveda cerrada no puede ver el valor; debe confiar en la firma del admin y en el
+     * contenido de esos sobres, y es la razón por la que al abrir la bóveda rehace los
+     * sobres: por si alguno tiene alguna incoherencia.»
+     *
+     * Antes, escribir hacía un rodeo absurdo: la consola sellaba el valor AL PERFIL, la
+     * bóveda lo ABRÍA para sacarlo en claro y `_putRaw` lo volvía a cerrar. Ese descifrado
+     * era el único motivo por el que la llave de cifrado del perfil tenía que estar
+     * accesible con la bóveda cerrada — o sea, la razón por la que una copia del disco
+     * abría todos los sobres dirigidos al perfil.
+     *
+     * Aquí no se abre nada: llega el valor ya cifrado con una CEK nueva y esa CEK ya
+     * envuelta para cada destinatario. Lo único que se comprueba es lo que se puede
+     * comprobar sin la llave — la FORMA, y sobre todo que venga la envoltura de
+     * recuperación: sin ella el cajón nace ilegible para siempre, y eso no se arregla
+     * después ni abriendo la bóveda.
+     *
+     * @param {string} owner `ns:<scope>` o `dev:<pub>`
+     * @param {{e:{iv:string,ct:string,gen?:number}, wraps:Object}} sobre
+     */
+    async putSealed (owner, key, sobre, { by = null, public: isPublic = false } = {}) {
+      return enFila(() => this._putSealedRaw(owner, key, sobre, by, !!isPublic))
+    },
+    /** @private */
+    async _putSealedRaw (owner, key, sobre, by, isPublic) {
+      if (isLegacy()) throw new Error('putSealed: this store is still v3 (run `migrate` first)')
+      if (needsMigration()) throw new NeedsMigration()
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      const e = sobre?.e; const wraps = sobre?.wraps
+      if (!e || typeof e.iv !== 'string' || typeof e.ct !== 'string') {
+        throw new Error('putSealed: the envelope must carry `iv` and `ct`')
+      }
+      if (!wraps || typeof wraps !== 'object' || !wraps[RECOVERY]) {
+        // SIN LA ENVOLTURA DE RECUPERACIÓN EL CAJÓN NACE MUERTO. Es la que abre la frase, y
+        // la única que puede rehacer las demás: si falta, ni el dueño con su contraseña
+        // podría reenvolverlo para nadie. Se rechaza antes de tocar el disco.
+        throw new Error('putSealed: the wraps must include the recovery one (#recovery), or the drawer could never be re-wrapped')
+      }
+      const vars = ensureBag(bag, k)
+      const before = vars[key]
+      // Una PRIVADA no se vuelve pública: cambiar eso es cambiar quién la recibe sin
+      // aprobación, y no puede colarse en una escritura normal.
+      if (before && !before.pub && isPublic) throw new PrivateStaysPrivate(key)
+
+      // LA GENERACIÓN LA PONE EL ALMACÉN, no quien escribe: es la que ordena el llavero, y
+      // dejar que la eligiera el que llega permitiría pisar una anterior.
+      const gen = (topGen(bag, k)?.gen || 0) + 1
+      // La FIRMA sigue siendo de la bóveda —dice que este sobre salió de aquí y con qué
+      // acta (§8.8)— y se hace con la llave de SELLADO, que funciona con el perfil cerrado.
+      const seal = signer ? await signer({ owner, key, gen, iv: e.iv, ct: e.ct }) : null
+
+      pushHistory(owner, key, before, by)
+      vars[key] = { pub: isPublic, owner, gen, e: { ...e, gen }, seal, at: Date.now(), by: by || null }
+      bag[k].keyring = [...(bag[k].keyring || []), { gen, createdAt: Date.now(), wraps }]
+      gcKeyring(bag, k, owner)
+      save()
+      return { gen }
+    },
+
+    /**
+     * ¿EXISTE YA ESTA VARIABLE? Sin abrirla ni decir qué vale.
+     *
+     * Hace falta para la regla de «un servicio solo rellena lo que falta, no pisa lo que
+     * hay» (dueño, 2026-09-01): quien decide eso necesita saber si había algo, y nada más.
+     */
+    has (owner, key) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      return key in varsOf(bag, k)
+    },
+
+    /**
+     * PARA QUIÉN hay que envolver, con su llave pública de cifrado, más la de recuperación.
+     * Es lo que necesita quien va a fabricar el sobre — y se lo dice la BÓVEDA, para que no
+     * haya dos sitios respondiendo a «quién puede abrir este cajón» (la lista la sabe el
+     * acta, y de ahí sale `recipients`).
+     */
+    async recipientsFor (owner) {
+      await ensureRecovery(null)
+      const members = (await recipients?.(owner)) || []
+      return {
+        recoveryPub: data.recovery.pub,
+        members: members.filter((m) => m.encPub).map((m) => ({ pub: m.pub, encPub: m.encPub }))
+      }
+    },
+
     async delete (ns, key) {
       assertNs(ns)
       return this._drop(data.ns, ns, `ns:${ns}`, key)
@@ -588,13 +691,21 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       if (!e) return false
       const want = !!isPublic
       if (!!e.pub === want) return true
+      // DE PRIVADA A PÚBLICA NO EXISTE, y no es una limitación técnica: hacer despachable
+      // sin aprobación algo que se guardó como secreto no puede ser una casilla. Se crea
+      // otra variable a propósito.
       if (!e.pub) throw new PrivateStaysPrivate(key)
       if (isLegacy()) { e.pub = false; save(); return true }
       if (needsMigration()) throw new NeedsMigration()
 
-      // De pública a privada: es una escritura normal, con su generación y su firma.
-      held++
-      try { await this._putRaw(bag, k, owner, key, e.v, false, null) } finally { held-- }
+      // DE PÚBLICA A PRIVADA ES CAMBIAR LA MARCA, Y NADA MÁS (dueño, 2026-09-02).
+      //
+      // Antes había que reescribir la variable entera —generación nueva, sobre nuevo—
+      // porque una pública se guardaba EN CLARO y taparla significaba cifrarla por primera
+      // vez. Ya no: las dos se guardan igual desde el principio, así que aquí solo cambia
+      // a quién se le despacha sin aprobación. Reescribir ahora sería trabajo (y una
+      // generación) para no cambiar nada de lo guardado.
+      e.pub = false
       save()
       return true
     },
@@ -624,12 +735,12 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       return Object.keys(topGen(bag, k)?.wraps || {})
     },
 
-    /** Las PÚBLICAS de un scope, con valor. Lo que la consola remota puede ver. */
+    /** Los NOMBRES de las públicas de un scope. Ya no hay valor que devolver: van en sobre. */
     publicOf (ns) {
       assertNs(ns)
       return publics(data.ns, ns)
     },
-    /** Las PÚBLICAS de un aparato, con valor. */
+    /** Los NOMBRES de las públicas de un aparato. */
     publicOfDevice (pub) {
       assertPub(pub)
       return publics(data.dev, pub)
@@ -894,7 +1005,10 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
           for (const [key, e] of Object.entries(entradas)) {
             const value = await claro(owner, e)
             antes[`${owner}\u0000${key}`] = value
-            if (e.pub) { vars[key] = { v: value, pub: true }; continue }
+            // LA PÚBLICA TAMBIÉN SE SELLA (dueño, 2026-09-02). Aquí se dejaba en claro,
+            // así que un archivo migrado se quedaba con valores legibles en el disco —
+            // exactamente lo que la conversión venía a quitar. La marca se conserva: dice
+            // a quién se le despacha sin aprobación, no cómo se guarda.
             if (!cek) {
               cek = await sealer.newKey()
               const { wraps, sinLlave: faltan } = await sealer.wrapFor(cek, (await membersOf(owner)) || [])
@@ -904,7 +1018,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
             }
             const sobre = await sealer.encrypt(cek, value, gen)
             const seal = signer ? await signer({ owner, key, gen, iv: sobre.iv, ct: sobre.ct }) : null
-            vars[key] = { pub: false, owner, gen, e: sobre, seal, at: Date.now(), by: null }
+            vars[key] = { pub: !!e.pub, owner, gen, e: sobre, seal, at: Date.now(), by: null }
           }
           dst[k] = { vars, keyring }
         }
@@ -916,12 +1030,10 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
         for (const [k, bag] of Object.entries(dst)) {
           const owner = `${kind}:${k}`
           for (const [key, e] of Object.entries(bag.vars)) {
-            let abierto
-            if (e.pub) abierto = e.v
-            else {
-              const g = bag.keyring.find((x) => x.gen === e.gen)
-              abierto = await sealer.openValue(await sealer.openWrapWith(priv, g.wraps[RECOVERY]), e.e)
-            }
+            // Se abre TODO, también las públicas: ahora van selladas igual, así que la
+            // comprobación de que la migración no cambió ningún valor vale para las dos.
+            const g = bag.keyring.find((x) => x.gen === e.gen)
+            const abierto = await sealer.openValue(await sealer.openWrapWith(priv, g.wraps[RECOVERY]), e.e)
             if (abierto !== antes[`${owner}\u0000${key}`]) {
               throw new Error(`secrets: the migration check failed on ${owner}/${key}; nothing was touched`)
             }

package/src/vault.js

@@ -16,14 +16,14 @@ import { Identity } from '@dotrino/identity/node'
 import { verifyChain, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
 import * as Acta from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
-import { createAdminDesk } from '../lib/src/admin.js'
+import { createAdminDesk, authorBody } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
 import { createTransport, masterPubkeyOf } from './transport.js'
 import { startSealersPublisher } from './sealers.js'
 import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
-import { openSecretsStore, assertVar } from './secretsStore.js'
+import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP } from './secretsStore.js'
 // `PENDING_TTL_MS` se usa abajo, al esperar la firma del aprobador: sin importarlo, esa
 // espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
 // llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
@@ -1381,15 +1381,59 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         }))
       }
     },
-    async set ({ ns, pub, key, enc, public: isPublic, by: who = null }) {
-      const payload = JSON.parse(await identity.openContent(enc))
-      const value = payload?.value
-      if (typeof value !== 'string' || !value) throw new Error('var.set: the sealed envelope must carry a non-empty value')
-      // NO PIDE LA CONTRASEÑA (§8.1): sellar solo necesita las públicas de quien va a
-      // leer. Lo que se guarda es quién lo escribió, para que el histórico lo diga.
-      if (ns) await setSecret(ns, key, value, isPublic, { by: who })
-      else await setDeviceSecret(pub, key, value, isPublic, { by: who })
-      return { ok: true, key }
+    /**
+     * PARA QUIÉN ENVOLVER. Lo contesta la bóveda porque la lista sale del ACTA
+     * (`recipientsOf`), y tener dos sitios respondiendo a «quién puede abrir este cajón» es
+     * exactamente cómo se acaba dejando fuera a alguien sin que nadie se entere.
+     */
+    async recipients ({ ns, pub }) {
+      return secrets.recipientsFor(ns ? `ns:${ns}` : `dev:${pub}`)
+    },
+    /**
+     * GUARDAR UNA VARIABLE **SIN VERLA** (dueño, 2026-09-01).
+     *
+     * «La bóveda cerrada no puede ver el valor; debe confiar en la firma del admin y en el
+     * contenido de esos sobres, y es la razón por la que al abrir la bóveda rehace los
+     * sobres: por si alguno tiene alguna incoherencia.»
+     *
+     * Antes esto abría el sobre para sacar el valor en claro y volvía a cerrarlo. Ese
+     * rodeo era el ÚNICO motivo por el que la llave de cifrado del perfil tenía que estar
+     * accesible con la bóveda cerrada — o sea, la razón por la que una copia del disco
+     * abría todo lo dirigido al perfil.
+     *
+     * Ahora llega hecho: el valor cifrado con una CEK nueva y esa CEK envuelta para cada
+     * destinatario. Aquí se comprueba lo que se puede comprobar SIN la llave: que las
+     * envolturas cubren exactamente a quien dice el acta. Lo que no se puede comprobar
+     * —que dentro haya lo que dice— lo corrige el repaso al abrir la bóveda.
+     *
+     * Una PÚBLICA sigue viajando en claro y por el camino de siempre: marcarla pública es
+     * precisamente decir que no hay nada que ocultar.
+     */
+    async set ({ ns, pub, key, sealed, caller = null, public: isPublic, by: who = null }) {
+      const owner = ns ? `ns:${ns}` : `dev:${pub}`
+      if (sealed) {
+        // PÚBLICA Y PRIVADA VAN IGUAL (dueño, 2026-09-02: «la única diferencia es si se
+        // despachan o no, son políticas; dales el mismo tratamiento de seguridad»). La
+        // marca solo decide si se entrega sin aprobación.
+        await verificarAutor(owner, key, sealed, caller)
+        await verificarDestinatarios(owner, sealed.wraps)
+        await secrets.putSealed(owner, key, sealed, { by: who, public: isPublic })
+        audit('secret.set', { ns: ns || null, key, sealed: true }); scheduleNotice(ns)
+        await settleDebts(owner)
+        return { ok: true, key }
+      }
+      // NO HAY OTRO CAMINO (dueño, 2026-09-02: «no dejes caminos viejos ni fallbacks; no hay
+      // que hacer retrocompatibilidad y es una regla del estado actual del proyecto, por eso
+      // quedan luego backdoors»).
+      //
+      // Aquí estaba el `enc`: la consola sellaba el valor AL PERFIL y la bóveda lo ABRÍA
+      // para volver a cerrarlo. Ese descifrado era el único motivo por el que la llave de
+      // cifrado del perfil tenía que estar accesible con la bóveda cerrada — o sea, la
+      // razón por la que una copia del disco abría todo lo dirigido al perfil. Dejarlo
+      // «por si acaso» habría dejado el agujero entero abierto con otro nombre.
+      throw Object.assign(
+        new Error('var.set: the value must come already sealed (`sealed`); the old `enc` path is gone — build it with buildSealedVar()'),
+        { code: 'needs-sealed' })
     },
     /**
      * VARIAS DE UNA VEZ, y por eso existe: cada guardado suelto hace que la bóveda avise
@@ -1401,22 +1445,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * Los NOMBRES también viajan dentro del sobre —no solo los valores—: el proxy
      * transporta y no tiene por qué aprender cómo se llama la configuración de un servicio.
      */
-    async setMany ({ ns, pub, enc, public: isPublic, by: who = null }) {
-      const payload = JSON.parse(await identity.openContent(enc))
-      const items = payload?.items
-      if (!Array.isArray(items) || !items.length) throw new Error('var.setMany: the sealed envelope must carry the variables')
-      // Borrar no se delega (`docs/consola-remota.md` §2): un aparato robado no puede
-      // dejar sin configuración a un servicio. Así que aquí solo entran valores nuevos.
-      /** @type {Array<{op:'set', key:string, value:string, public?:boolean}>} */
-      const list = items.map((it) => ({
-        op: /** @type {'set'} */ ('set'),
-        key: it?.key,
-        value: it?.value,
-        ...(typeof it?.public === 'boolean' ? { public: it.public } : (isPublic === undefined ? {} : { public: isPublic }))
-      }))
-      // NO PIDE LA CONTRASEÑA (§8.1). Y sí, `applySecrets` va con `await` — sin él la
-      // escritura quedaba al aire y la respuesta salía antes de guardar nada.
-      const keys = ns ? await applySecrets(ns, list, { by: who }) : await applyDeviceSecrets(pub, list, { by: who })
+    async setMany ({ ns, pub, items, caller = null, by: who = null }) {
+      // CADA VARIABLE VIENE EN SU PROPIO SOBRE, ya hecho. La bóveda no abre ninguno: solo
+      // comprueba quién los firma y a quién envuelven, igual que en `set`. Aquí estaba el
+      // `enc` que las traía todas juntas selladas AL PERFIL, y abrirlo era lo que obligaba
+      // a tener la llave de cifrado accesible con la bóveda cerrada.
+      if (!Array.isArray(items) || !items.length) throw new Error('var.setMany: no variables came')
+      const owner = ns ? `ns:${ns}` : `dev:${pub}`
+      const keys = []
+      for (const it of items) {
+        if (!it?.key || !it?.sealed) throw new Error('var.setMany: each variable needs its key and its sealed envelope')
+        await verificarAutor(owner, it.key, it.sealed, caller)
+        await verificarDestinatarios(owner, it.sealed.wraps)
+      }
+      // Se comprueban TODAS antes de escribir NINGUNA: media carga aplicada es una
+      // configuración que nadie quiso, y el servicio se reinicia con ella.
+      for (const it of items) {
+        await secrets.putSealed(owner, it.key, it.sealed, { by: who, public: !!it.public })
+        keys.push(it.key)
+      }
+      audit('secret.setMany', { ns: ns || null, keys }); scheduleNotice(ns)
+      await settleDebts(owner)
       return { ok: true, keys }
     }
   }
@@ -1937,6 +1986,88 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * `if` para ese caso no sería prudencia: sería un repliegue que le pone cara de trámite
    * normal a una contradicción. Si aun así falta la llave, se dice como lo que es.
    */
+  /**
+   * ¿QUIÉN HIZO ESTE SOBRE? Tiene que decirlo, y tiene que ser un MIEMBRO DEL ACTA.
+   *
+   * Regla del dueño (2026-09-01): «los sobres deben traer información de quién los hizo,
+   * deberían tener la firma para que no se cuelen sobres firmados por cualquiera; solo
+   * puede haber sobres firmados por miembros del acta».
+   *
+   * La petición ya viene firmada y comprobada (`verifyChain` + el acta), así que un extraño
+   * no llega hasta aquí. Esto es otra cosa y hace falta igual: la bóveda guarda unos bytes
+   * que NO PUEDE LEER, y sin esta firma lo único que ataba esos bytes a un autor era el
+   * momento de la llamada. Con ella, el registro guardado se explica solo — se puede
+   * comprobar después, en frío, sin fiarse de ningún log.
+   *
+   * El autor tiene que ser QUIEN LLAMA. Aceptar un sobre firmado por otro sería admitir un
+   * relevo: alguien con `admin` colando un sobre que fabricó un tercero, sin que ninguna de
+   * las dos comprobaciones lo note.
+   */
+  async function verificarAutor (owner, key, sealed, caller) {
+    const a = sealed?.author
+    if (!a || typeof a.pub !== 'string' || typeof a.sig !== 'string' || typeof a.ts !== 'number') {
+      throw new Error('var.set: the envelope must say WHO made it (`author: { pub, sig, ts }`)')
+    }
+    if (caller && a.pub !== caller) {
+      throw new Error('var.set: the envelope was signed by someone other than the caller — a relayed envelope is not accepted')
+    }
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    const m = (record?.members || []).find((x) => x.pub === a.pub)
+    if (!record || !m) {
+      throw new Error('var.set: the envelope is signed by a key the record does not name')
+    }
+    // UN SERVICIO SOLO PARA SU CAJÓN (dueño, 2026-09-01: «un cn no puede poner un sobre
+    // faltante fuera de su cn»). Es la misma regla que ya aplica el reparto delegado
+    // (`handleRewrapOk`), y tiene que valer también aquí: si no, un servicio con `admin`
+    // podría escribir en el cajón de otro. Quien administra sin `cn` sí puede: ese es su
+    // trabajo, y para eso se le concede a mano.
+    const ns = owner.startsWith('ns:') ? owner.slice(3) : null
+    if (m.cn && ns && m.cn !== ns) {
+      throw new Error(`var.set: "${m.cn}" cannot write into "${owner}" — a service only authors envelopes for its own drawer`)
+    }
+    // Y UN SERVICIO NO PISA LO QUE YA HAY (dueño, 2026-09-01: «un cn no puede sobrescribir
+    // un sobre existente; solamente el admin y el vault editan sobres, los otros pueden
+    // crear los que faltan nomás»).
+    //
+    // Es la misma regla que `putWrap` («solo añade, nunca pisa») y por el mismo motivo: un
+    // servicio que pudiera reemplazar un sobre podría dejar sin leer a otro miembro con uno
+    // basura — denegación de servicio disfrazada de escritura. Rellenar lo que falta no
+    // quita nada a nadie; reemplazar sí, y eso es de quien administra.
+    if (m.cn && secrets.has?.(owner, key)) {
+      throw new Error(`var.set: "${m.cn}" cannot overwrite "${key}" — a service only fills in what is missing; replacing is for who administers`)
+    }
+    const cuerpo = authorBody(owner, key, sealed.e, a.ts)
+    if (!(await verifyDeviceSig({ publickey: a.pub, data: cuerpo, signature: a.sig }))) {
+      throw new Error('var.set: the author signature does not verify over this envelope')
+    }
+  }
+
+  /**
+   * ¿ESTE SOBRE ENVUELVE A QUIEN TOCA? Lo único que se puede comprobar sin la llave.
+   *
+   * No se puede saber si dentro de cada envoltura está la CEK correcta —para eso habría que
+   * abrirla, que es justo lo que ya no se hace—, pero sí QUIÉN puede abrirlas. Y eso ya
+   * ataja lo que importa: que no falte nadie (un servicio que arrancaría sin configuración)
+   * y que no sobre nadie (alguien a quien el acta no nombra leyendo el cajón).
+   *
+   * Lo de dentro lo corrige el repaso al abrir la bóveda, que es para lo que está.
+   */
+  async function verificarDestinatarios (owner, wraps) {
+    if (!wraps || typeof wraps !== 'object') throw new Error('var.set: the envelope carries no wraps')
+    const { recoveryPub, members } = await secrets.recipientsFor(owner)
+    if (!recoveryPub) throw new Error('var.set: this vault has no recovery key yet')
+    const deben = new Set(members.map((m) => m.pub))
+    const traidos = new Set(Object.keys(wraps).filter((k) => k !== RECOVERY_WRAP))
+    const faltan = [...deben].filter((p) => !traidos.has(p))
+    const sobran = [...traidos].filter((p) => !deben.has(p))
+    if (faltan.length) {
+      throw new Error(`var.set: the envelope leaves ${faltan.length} member(s) of "${owner}" out — they could not read it (ask the vault for the recipients with \`var.recipients\`)`)
+    }
+    if (sobran.length) {
+      throw new Error(`var.set: the envelope wraps for ${sobran.length} key(s) the record does not name for "${owner}"`)
+    }
+  }
+
   async function refreshWraps (motivo) {
     // HAY CANDADO SOLO SI HAY LAS DOS COSAS: contraseña Y alguien que sepa abrirla.
     //
@@ -2171,12 +2302,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * era lo único que la marca no significaba. La consola remota ya las enseña.
    */
   function listSecrets () {
-    const out = {}
-    for (const [ns, keys] of Object.entries(secrets.list())) {
-      const values = secrets.publicOf(ns)
-      out[ns] = keys.map((k) => (k.public ? { ...k, value: values[k.key] } : k))
-    }
-    return out
+    // YA NO SE ENSEÑA EL VALOR DE UNA PÚBLICA (dueño, 2026-09-02). Desde que todas van en
+    // sobre, «pública» dejó de significar «en claro»: dice a quién se le despacha sin
+    // aprobación, nada más. Para ver un valor hay que poder abrirlo, igual que cualquiera —
+    // y en un cajón con dueño, quien administra deliberadamente no puede.
+    return secrets.list()
   }
   /** Cambiar SOLO quién puede ver el valor (no toca el valor ni avisa: el servicio lee lo mismo). */
   async function setSecretVisibility (ns, key, isPublic, adminKey) {
@@ -2253,13 +2383,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const out = []
     for (const [pub, keys] of Object.entries(secrets.listDevices())) {
       const m = members.find((x) => x.pub === pub) || null
-      const values = secrets.publicOfDevice(pub)
       out.push({
         pub,
         id: m?.id || await deviceIdOf(pub).catch(() => null),
         label: m?.label || '',
         cn: m?.cn || null,
-        keys: keys.map((k) => (k.public ? { ...k, value: values[k.key] } : k)),
+        // Sin valores: desde 2026-09-02 una pública también va en sobre (ver `listSecrets`).
+        keys,
         orphan: !!members.length && !m
       })
     }