@dotrino/vaultd 0.106.0 → 0.106.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.106.0",
+  "version": "0.106.2",
   "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/vault.js

@@ -1330,7 +1330,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       sock.on('error', cerrar)
     })
     server.on('error', (e) => log('[vault] the local desk could not open (' + e.message + '): services will use the proxy'))
-    try { fs.mkdirSync(socketDir(), { recursive: true, mode: 0o700 }) } catch (_) {}
+    // EL DIRECTORIO ES EL CONTROL, no el modo del socket.
+    //
+    // `mkdir` con `mode` NO corrige un directorio que ya existe, y sin `XDG_RUNTIME_DIR`
+    // —un servicio de sistema, un contenedor— esto cae en `/tmp`, donde cualquiera puede
+    // haberlo creado antes con permiso de escritura para todos. Quien sea dueño del
+    // directorio puede borrar el socket y poner el suyo: los servicios de esta máquina
+    // acabarían hablando con él. No leería nada (la respuesta va firmada por una llave que
+    // nombra el acta y el cliente la comprueba), pero los deja sin arrancar.
+    //
+    // Y el `chmod 0600` de abajo llega DESPUÉS de `listen`, así que por sí solo deja una
+    // rendija. Lo que la cierra de verdad es que el directorio sea nuestro y solo nuestro.
+    const dir = socketDir()
+    try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }) } catch (_) {}
+    try {
+      const st = fs.statSync(dir)
+      const ajeno = typeof process.getuid === 'function' && st.uid !== process.getuid()
+      const abierto = (st.mode & 0o077) !== 0
+      if (ajeno || abierto) {
+        return log(`[vault] the local desk stays closed: ${dir} is ${ajeno ? 'owned by another user' : 'writable by others'} ` +
+          '— services on this machine will use the proxy instead')
+      }
+    } catch (e) {
+      return log('[vault] the local desk stays closed: could not check ' + dir + ' (' + e.message + ')')
+    }
     try { fs.rmSync(socketPath, { force: true }) } catch (_) {}
     server.listen(socketPath, () => {
       try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
@@ -1900,6 +1923,29 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'renounce', reason: 'signature' })
       return reply(from, { type: MSG.ERROR, error: 'renounce: the signature is not the member own' })
     }
+    // UNA RENUNCIA QUE NO QUITA NADA NO SE HONRA, y esto es lo que corta el replay barato.
+    //
+    // El registro va firmado y lleva `ts`, pero nadie lo miraba: cualquiera que lo viera
+    // pasar por el proxio podía volver a mandarlo cuando quisiera. Como `absorbRenounce`
+    // SELLA UN ACTA NUEVA cada vez, repetirlo hacía subir el `seq` y empujar a todos los
+    // aparatos sin que hubiera cambiado nada — y dejaba en la bitácora una renuncia con el
+    // nombre del aparato, que es lo peor: la bitácora es la prueba, y ahí decía algo que
+    // ese aparato no hizo.
+    //
+    // Mirando lo que el acta dice HOY, un registro repetido no quita nada y se para aquí.
+    // Lo que esto NO cierra, y queda anotado: si el dueño vuelve a conceder ese permiso, el
+    // mismo registro viejo lo quita otra vez. Cerrarlo del todo pide que el acta recuerde
+    // la fecha de la última renuncia por miembro y rechace las que no sean posteriores.
+    const actual = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!actual) {
+      audit('rejected', { what: 'renounce', reason: 'sin-acta' })
+      return reply(from, { type: MSG.ERROR, error: 'renounce: this vault has no record to apply it to' })
+    }
+    const tiene = new Set(Acta.effectiveCaps(actual, record.member) || [])
+    if (!(record.caps || []).some((c) => tiene.has(c))) {
+      audit('rejected', { what: 'renounce', reason: 'nada-que-quitar' })
+      return reply(from, { type: MSG.ERROR, error: 'renounce: that member no longer holds any of those capabilities' })
+    }
     try {
       const r = await identity.absorbRenounce(record)
       const device = await deviceIdOf(record.member).catch(() => null)