@dotrino/vaultd 0.105.3 → 0.106.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.105.3",
+  "version": "0.106.1",
   "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/replica.js

@@ -24,9 +24,10 @@ import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import { WebSocketProxyClient } from '@dotrino/proxy-client'
-import { signWithDevice, verifyDeviceSig, pubkeyId } from '@dotrino/identity/capabilities'
-import { verifyActa, memberCan, sealKeyAt } from '@dotrino/identity/acta'
-import { MSG } from '../lib/src/protocol.js'
+import { signWithDevice, verifyDeviceSig, verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
+import { verifyActa, memberCan, memberCanReadSecrets, sealKeyAt, sealersOf } from '@dotrino/identity/acta'
+import { MSG, secretsScope, isValidSecretsNs } from '../lib/src/protocol.js'
+import { FRESH_WINDOW_MS } from '../lib/src/enroll.js'
 import { seal } from '../lib/src/sealed.js'
 import { atRestFor } from './atrest.js'
 import { readJson, writeJson } from './paths.js'
@@ -169,17 +170,59 @@ export async function runReplica ({ dir = replicaDir(), proxyUrl, log = console.
    * quien pregunta y firmado con NUESTRA llave — que es lo que el cliente acepta cuando el
    * acta nos reconoce `replica` (`verifyResponder` de `@dotrino/vault`).
    *
-   * Lo que NO se decide aquí, y es a propósito: si quien pide tiene derecho a ese cajón.
-   * Lo dice el sobre, no nosotros — va cerrado a su llave, así que a quien no le toque le
-   * llega algo que no puede abrir. Un replicador que decidiera quién lee sería un
-   * replicador del que hay que fiarse, y la gracia es que no haga falta.
+   * SE COMPRUEBA QUIÉN PIDE, con lo mismo que comprueba la bóveda. Durante un día esto no
+   * miraba nada: bastaba con nombrar un cajón y una llave de aparato para llevarse el sobre
+   * y, dentro de él, EL ACTA — que es el inventario de máquinas del dueño, y que la bóveda
+   * no le enseña ni a un servicio de la casa. Un extraño con una llave recién hecha lo
+   * sacaba entero (`smoke/replica.mjs`, «a un DESCONOCIDO…»).
+   *
+   * El argumento de entonces era que el sobre va cerrado a su destinatario, así que a quien
+   * no le toque le llega algo que no puede abrir. Sigue siendo verdad y sigue siendo la
+   * segunda línea — pero no es una puerta: repartir cifrado a desconocidos regala el acta,
+   * deja el texto cifrado en manos de cualquiera para siempre, y no cuesta nada evitarlo.
+   * La petición YA viaja firmada y con papel desde `fetchSecrets`; aquí solo se miraban.
+   *
+   * Lo que sigue sin decidirse aquí, y eso sí es a propósito: NADA sobre el contenido. El
+   * replicador no abre, no filtra por clave y no sabe qué entrega. Comprobar quién llama no
+   * lo convierte en alguien de quien haya que fiarse: si mintiera diciendo que sí, el sobre
+   * sigue sin abrirse; si mintiera diciendo que no, es una caída, que es lo que un
+   * replicador puede costar.
+   *
+   * `revoked` no se le pasa a `verifyChain` porque aquí no hay registro de revocaciones —
+   * y no hace falta: quitar un aparato es sacarlo del acta (`docs/acta-de-perfil.md`), y de
+   * eso se ocupa `memberCanReadSecrets` con el acta de abajo.
    */
   async function onSecrets (from, p) {
     const ns = p?.data?.ns
     const ek = p?.data?.ek
-    const quien = p?.data?.publickey
-    if (typeof ns !== 'string' || !ek || !quien) return
+    if (!isValidSecretsNs(ns) || typeof ek !== 'string') return
     if (!store.acta) return client.send(from, { type: MSG.ERROR, error: 'replica: no record yet' })
+    const no = (error) => client.send(from, { type: MSG.ERROR, error })
+    const acta = store.acta
+
+    if (typeof p?.data?.ts !== 'number' || Math.abs(Date.now() - p.data.ts) > FRESH_WINDOW_MS) {
+      log('[replica] a secrets request arrived outside the freshness window: refused')
+      return no('replica: stale request')
+    }
+    const chk = await verifyChain({
+      data: p.data,
+      signature: p.signature,
+      cert: p.cert,
+      expectedScope: secretsScope(ns),
+      actaSeq: acta.seq,
+      sealers: sealersOf(acta)
+    })
+    if (!chk.ok) {
+      log(`[replica] a secrets request for "${ns}" does not check out (${chk.reason}): refused`)
+      return no('unauthorized: ' + chk.reason)
+    }
+    // EL ACTA MANDA, igual que en la bóveda: el papel dice qué se emitió, el acta dice qué
+    // vale hoy. Un aparato al que le quitaron el cajón trae un papel intacto.
+    if (!memberCanReadSecrets(acta, chk.device, ns)) {
+      log(`[replica] the record does not let ${(await pubkeyId(chk.device)).slice(0, 8)} read "${ns}": refused`)
+      return no(`unauthorized: cn — the record does not recognise this member as the "${ns}" service`)
+    }
+    const quien = chk.device
     const b = store.bundleFor(ns, quien)
     if (!b) {
       log(`[replica] asked for "${ns}" and has nothing stored for that device`)

package/src/vault.js

@@ -644,10 +644,24 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (d.method === 'profilePublic') {
       return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: secrets.profilePublic() })
     }
+    const revoked = await revocationSet()
+    // `vault:sign` — hablar por ti. No `vault:store`, que es guardar cosas.
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.SIGN, ...(await contextoActa()), revoked })
+    if (!chk.ok) return denyChain(from, chk, p, 'profile')
+    if (!await actaAllows(from, chk, SCOPE.SIGN, 'profile')) return
+
     // A QUIÉN HAY QUE ENVOLVERLE. Lo pide el aparato ANTES de sellar, porque sellar lo hace
     // él: envolver solo necesita públicas, así que puede hacerlo un navegador sin que
     // ninguna privada ande suelta. Sale de aquí y no de una lista suya para que conceder
     // `firma` a un aparato nuevo baste — sin que nadie tenga que acordarse de nada.
+    //
+    // VA DETRÁS DEL CONTROL, y estuvo delante. Que solo haga falta material PÚBLICO para
+    // envolver no significa que la lista sea pública: lo que devuelve es el INVENTARIO
+    // —cuántas máquinas tienes, sus llaves, y la de recuperación— y eso la bóveda no se lo
+    // enseña ni a un servicio de la casa (`modelo-de-amenazas.md` §2.5). Cualquiera que
+    // supiera la llave de la cuenta, que es pública, lo sacaba entero preguntando. Y no
+    // costaba nada evitarlo: la consola YA manda su firma y su papel en esta misma llamada
+    // (`requestStore` de `@dotrino/identity`), solo que aquí no se miraban.
     if (d.method === 'profileRecipients') {
       const members = await recipientsOf(PROFILE_OWNER)
       return reply(from, {
@@ -657,12 +671,6 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       })
     }
 
-    const revoked = await revocationSet()
-    // `vault:sign` — hablar por ti. No `vault:store`, que es guardar cosas.
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.SIGN, ...(await contextoActa()), revoked })
-    if (!chk.ok) return denyChain(from, chk, p, 'profile')
-    if (!await actaAllows(from, chk, SCOPE.SIGN, 'profile')) return
-
     try {
       if (d.method === 'profileBundle') {
         const b = secrets.profileBundleFor(chk.device)
@@ -1322,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 (_) {}
@@ -1344,6 +1375,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   async function handleAdminEvent (payload) {
     const acta = payload?.acta
     if (!acta || typeof acta !== 'object') return
+    // ESTE MENSAJE NO LO FIRMA NADIE, y no hace falta: el acta se autentica sola —va sellada
+    // y `canAdopt` comprueba que la selló quien la MÍA reconoce—. Pero eso solo funciona si
+    // hay una mía contra la que comparar: sin acta previa, `canAdopt` acepta cualquiera
+    // («sin-acta-previa»), y este es el único mostrador donde una llega de un desconocido.
+    // Anunciar no es cómo se entra en una cuenta —para eso está el enrolamiento—, así que
+    // sin acta propia no se adopta: se dice y se para.
+    const propia = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!propia) return log('[vault] a record was announced but this vault has none of its own to compare it with: ignored')
     try {
       const r = await identity.adoptActa?.(acta)
       if (r?.adopted) log(`[vault] adopted record #${acta.seq} announced by another vault (${r.reason})`)