@dotrino/vault 0.27.0 → 0.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.27.0",
+  "version": "0.29.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.54.0",
+    "@dotrino/identity": ">=0.56.0",
     "@dotrino/proxy-client": ">=0.9.0"
   },
   "license": "MIT",

package/src/admin.js

@@ -41,12 +41,11 @@ 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',
-  // 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'
+  // Ver un valor, su histórico o volver a una versión NO están, y es a propósito: un
+  // aparato que administra no tiene sobres de lo privado (solo el servicio dueño y la
+  // recuperación). Eso lo hace la bóveda en su máquina (`secret show/history/revert`).
+  // No lo cablees.
+  'vars', 'var.set', 'var.setMany'
 ])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
@@ -217,34 +216,6 @@ 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/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,7 @@ 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'
@@ -652,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