@dotrino/vaultd 0.26.2 → 0.46.2

package/src/profiles.js

@@ -11,8 +11,8 @@
  *   <root>/transport.json     keypair del proxy-client (a nivel PROCESO, no por perfil)
  *   <root>/p/<id>/…           los datos de cada perfil (incluida su maestra)
  *
- * CONTRASEÑA (opcional, por perfil): es un VERIFICADOR PBKDF2 —mismo modelo que el
- * candado del navegador (`@dotrino/identity` vault/core.js)— NO cifra nada en reposo.
+ * CONTRASEÑA (opcional, por perfil): es un VERIFICADOR scrypt (v2; v1 era PBKDF2 y se
+ * asciende al desbloquear) que NO cifra nada en reposo.
  * Y solo bloquea EDITAR el perfil: el daemon sigue firmando y sirviendo a los
  * dispositivos ya enrolados aunque el perfil esté bloqueado, para que un reinicio
  * del PC no deje las apps muertas hasta que alguien teclee la contraseña.
@@ -21,12 +21,36 @@
  * cifrado en reposo, ver `paths.js`).
  */
 import fs from 'node:fs'
+import crypto2 from 'node:crypto'
 import path from 'node:path'
 import { dataDir, ensureDir, readJson, writeJson } from './paths.js'
+import { atRestFor, migrateFile, machineKey } from './atrest.js'
 
 const REGISTRY = 'profiles.json'
-const PWD_ITER = 300000 // mismo coste que el candado del navegador
+const PWD_ITER = 300000 // PBKDF2 del verificador v1 (heredado); v2 usa scrypt
 const MAX_NAME = 40
+/**
+ * Lo MÍNIMO que se acepta al poner una contraseña.
+ *
+ * Eran 4 caracteres, y eso se quedó corto el día que los secretos pasaron a sellarse:
+ * desde entonces la contraseña no bloquea una consola, **es la llave** que abre la
+ * copia maestra, y todo el cifrado vale lo que valga ella. Cuatro dígitos son 10.000
+ * combinaciones — se prueban enteras en un rato aunque la derivación sea cara.
+ *
+ * No se piden mayúsculas ni símbolos a propósito: hacen la frase difícil de recordar
+ * y fácil de adivinar. Lo que da fuerza es la LONGITUD y que no la elija un humano;
+ * por eso lo que se pide en pantalla son varias palabras al azar.
+ */
+const PWD_MIN = 12
+
+/**
+ * Cuánto tarda el freno en OLVIDAR los fallos. Sin esto la cuenta solo subía —solo la
+ * borraba un acierto—, así que teclear mal la contraseña cinco veces un martes te dejaba
+ * el vault con esperas de minutos el miércoles, y cada intento nuevo (aunque fuera el
+ * bueno) la alargaba sin llegar a comprobarse: la bóveda quedaba cerrada para su dueño.
+ * El freno tiene que estorbar a una RÁFAGA, no a quien vuelve al día siguiente.
+ */
+const TRIES_FORGET_MS = 15 * 60 * 1000
 
 /**
  * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
@@ -39,7 +63,24 @@ const LEGACY_FILES = ['identity.json', 'peers.json', 'vault.json', 'threads.json
 
 const b64 = (buf) => Buffer.from(new Uint8Array(buf)).toString('base64')
 
-/** PBKDF2-SHA256 → verificador base64 (byte-idéntico al del navegador). */
+/**
+ * El verificador del candado.
+ *
+ * v2 es **scrypt, con el mismo coste que `adminKey`**, y no por gusto: este valor vive
+ * EN CLARO en `profiles.json`, así que quien tenga el disco lo ataca fuera de línea. Si
+ * es más barato que la llave de verdad, se convierte en el camino corto para llegar a
+ * ella — que es exactamente lo que pasaba con PBKDF2 al lado de un scrypt.
+ *
+ * v1 (PBKDF2) se sigue aceptando porque hay perfiles con él en el disco, y se ASCIENDE
+ * a v2 en el primer desbloqueo correcto: es el único momento en que se tiene la
+ * contraseña en la mano.
+ */
+function deriveScryptPwd (password, saltB64) {
+  const salt = Buffer.from(saltB64, 'base64')
+  return b64(crypto2.scryptSync(String(password || ''), salt, 32, { N: 16384, r: 8, p: 1 }))
+}
+
+/** PBKDF2-SHA256 → verificador base64 (v1, heredado). */
 async function derivePwd (password, saltB64, iter) {
   const salt = Buffer.from(saltB64, 'base64')
   const km = await crypto.subtle.importKey('raw', new TextEncoder().encode(String(password)), 'PBKDF2', false, ['deriveBits'])
@@ -52,9 +93,18 @@ const cleanName = (name) => String(name || '').slice(0, MAX_NAME)
 
 export function openProfiles (root = dataDir()) {
   const file = path.join(root, REGISTRY)
-  let data = readJson(file, null)
+  // CIFRADO EN REPOSO, como todo lo demás. Era el único archivo del vault sin códec, y
+  // lleva dentro el verificador del candado. No protege de quien tenga el disco entero
+  // —el material de la llave vive en ese mismo disco, y eso está dicho en voz alta en
+  // `docs/secretos-sellados.md`— pero sí de que el registro viaje en claro en un
+  // respaldo o en una carpeta compartida por descuido, que es lo que el códec cubre
+  // para el resto. La migración verifica antes de reemplazar y es de una sola vez.
+  ensureDir(root)
+  try { migrateFile(file, machineKey(root)) } catch (_) {}
+  const atRest = atRestFor(root)
+  let data = readJson(file, null, atRest)
   if (!data || !Array.isArray(data.profiles)) data = { v: 1, current: null, profiles: [] }
-  const save = () => writeJson(file, data)
+  const save = () => writeJson(file, data, atRest)
 
   // Perfiles DESBLOQUEADOS en esta ejecución del daemon (en memoria: un reinicio
   // vuelve a bloquear, igual que cerrar la pestaña en el navegador).
@@ -97,7 +147,7 @@ export function openProfiles (root = dataDir()) {
       const needle = String(ref).trim().toLowerCase()
       const hits = data.profiles.filter((p) => (p.name || '').toLowerCase() === needle)
       if (hits.length === 1) return hits[0].id
-      if (hits.length > 1) throw new Error(`hay ${hits.length} perfiles llamados "${ref}"; usa su id (dotrino-vault profile ls)`)
+      if (hits.length > 1) throw new Error(`there are ${hits.length} profiles named "${ref}"; use its id (dotrino-vault profile ls)`)
       throw new Error('profile does not exist: ' + ref)
     },
 
@@ -186,20 +236,63 @@ export function openProfiles (root = dataDir()) {
       if (api.isLocked(id)) throw new Error('profile locked: unlock it with your password (dotrino-vault unlock)')
     },
 
+    /**
+     * La llave con la que se abre la copia MAESTRA de los secretos, derivada de la
+     * contraseña del perfil. Va por operación: quien la pide la usa y la suelta.
+     *
+     * Es scrypt (mismo coste que `machineKey`) y NO reusa el verificador del candado:
+     * ese es PBKDF2 y vive en claro en este mismo archivo, así que sería el camino
+     * barato para atacarla. Aquí la prueba de que es correcta es el tag AES-GCM del
+     * propio sobre — si no cuadra, la contraseña no era.
+     */
+    async adminKey (id, password) {
+      const p = find(id)
+      if (!p) throw new Error('profile not found')
+      if (!p.kdf) {
+        p.kdf = { v: 1, salt: b64(crypto.getRandomValues(new Uint8Array(32))) }
+        save()
+      }
+      const salt = Buffer.from(p.kdf.salt, 'base64')
+      return new Uint8Array(crypto2.scryptSync(String(password || ''), salt, 32, { N: 16384, r: 8, p: 1 }))
+    },
+
     async unlock (id, password) {
       const p = assertExists(id)
       if (!p.pwd) { unlocked.add(id); return { ok: true, locked: false } }
       // Freno de fuerza bruta (una contraseña corta se adivina probando): tras 5
       // fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro.
-      const tries = p.tries || { n: 0, at: 0 }
+      // Los fallos VIEJOS se olvidan (ver TRIES_FORGET_MS): si desde el último ha pasado
+      // el rato, se empieza de cero. Así el freno sigue frenando una ráfaga —los intentos
+      // seguidos se cuentan igual— pero no convierte un despiste de ayer en un vault que
+      // ya no se abre.
+      let tries = p.tries || { n: 0, at: 0 }
+      if (tries.at && Date.now() - tries.at > TRIES_FORGET_MS) {
+        tries = { n: 0, at: 0 }
+        if (p.tries) { delete p.tries; save() }
+      }
       const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
       const left = tries.at + waitMs - Date.now()
-      if (left > 0) throw new Error(`demasiados intentos: espera ${Math.ceil(left / 1000)} s`)
-      const proof = await derivePwd(password, p.pwd.salt, p.pwd.iter)
+      // Con CÓDIGO: la TUI es bilingüe y lo traduce, y la CLI puede decirlo con sus
+      // palabras. Sin código, el rechazo llegaba como un texto suelto del daemon y era
+      // indistinguible de «se volvió a pedir la contraseña porque sí».
+      if (left > 0) {
+        throw Object.assign(new Error(`too many tries: wait ${Math.ceil(left / 1000)} s`),
+          { code: 'TOO_MANY_TRIES', waitSec: Math.ceil(left / 1000) })
+      }
+      const proof = p.pwd.v === 2
+        ? deriveScryptPwd(password, p.pwd.salt)
+        : await derivePwd(password, p.pwd.salt, p.pwd.iter)
       if (proof !== p.pwd.verifier) {
         p.tries = { n: tries.n + 1, at: Date.now() }
         save()
-        throw new Error('wrong password')
+        throw Object.assign(new Error('wrong password'), { code: 'WRONG_PASSWORD', tries: p.tries.n })
+      }
+      // ASCENSO v1 → v2. Aquí, y solo aquí, se tiene la contraseña correcta en la mano:
+      // es el momento de dejar de guardar el verificador barato. No cambia la
+      // contraseña ni toca los secretos — el `adminKey` sale de `p.kdf`, que es otro.
+      if (p.pwd.v !== 2) {
+        const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
+        p.pwd = { v: 2, salt, verifier: deriveScryptPwd(password, salt) }
       }
       delete p.tries
       save()
@@ -213,9 +306,12 @@ export function openProfiles (root = dataDir()) {
     async setPassword (id, password) {
       const p = assertExists(id)
       api.assertUnlocked(id)
-      if (!password || String(password).length < 4) throw new Error('password must be at least 4 characters')
+      if (!password || String(password).length < PWD_MIN) {
+        throw Object.assign(new Error(`password must be at least ${PWD_MIN} characters: use several random words`),
+          { code: 'PASSWORD_TOO_SHORT', min: PWD_MIN })
+      }
       const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
-      p.pwd = { v: 1, salt, iter: PWD_ITER, verifier: await derivePwd(password, salt, PWD_ITER) }
+      p.pwd = { v: 2, salt, verifier: deriveScryptPwd(password, salt) }
       delete p.tries
       save()
       unlocked.add(id)

package/src/sealKey.js

@@ -0,0 +1,80 @@
+/**
+ * La LLAVE DE SELLADO de esta bóveda: con ella FIRMA los sobres de los secretos, para
+ * que se sepa que salieron de aquí. Diseño: `docs/secretos-sellados.md` §8.8 y §8.9.
+ *
+ * Tres cosas que la hacen distinta de todo lo demás que hay en este directorio:
+ *
+ *   · **Firmar no es leer.** Esta llave no abre ningún valor. Por eso puede vivir
+ *     cifrada en reposo con la llave de la máquina y usarse **sin la frase** — que es
+ *     justo lo que hace posible administrar sin contraseña.
+ *   · **Su autoridad la da el ACTA**, que la nombra (`sealPub`) y que sella únicamente
+ *     la maestra. Ella no se autoriza a sí misma.
+ *   · **Rota con el acta.** Cada acta nueva puede estrenar una, así que aquí se guarda
+ *     un puñado: la vigente para firmar, y las anteriores porque un sobre se firmó con
+ *     la que mandaba entonces y hay que poder seguir firmando… no, seguir
+ *     **identificando** cuál era. Verificar se hace con la pública que dice el acta.
+ *
+ * No guarda ninguna correspondencia con `seq`: quién mandaba y cuándo lo dice el acta
+ * (`sealKeys` con su tramo). Aquí solo están las privadas, indexadas por su pública.
+ */
+import path from 'node:path'
+import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
+import { signWithDevice } from '@dotrino/identity/capabilities'
+
+/**
+ * Cuántas llaves anteriores se conservan. Firmar solo usa la vigente; las viejas se
+ * guardan por si hay que re-firmar algo sellado con ellas (recoger el histórico), y
+ * porque tirarlas no ahorra nada: son cuatro líneas de JSON.
+ */
+const MAX_KEYS = 8
+
+/** Abre (o estrena) el llavero de sellado del perfil. */
+export function openSealKeys (dir) {
+  const file = path.join(dir, 'sealkeys.json')
+  const atRest = atRestFor(dir)
+  const data = readJson(file, null, atRest) || { v: 1, keys: [] }
+  if (!Array.isArray(data.keys)) data.keys = []
+
+  const save = () => writeJson(file, data, atRest)
+  const find = (pub) => data.keys.find((k) => k.pub === pub) || null
+
+  return {
+    /** La pública de la llave vigente (la última estrenada), o `null` si no hay ninguna. */
+    current: () => data.keys[data.keys.length - 1]?.pub || null,
+
+    /** ¿Tenemos la privada de esta pública? Es lo que decide si podemos firmar por ella. */
+    has: (pub) => !!find(pub),
+
+    /**
+     * Estrena una llave y devuelve su PÚBLICA, para que el acta la nombre. La privada
+     * se queda aquí; no sale de esta máquina ni viaja a ninguna parte.
+     *
+     * Es lo que se le pasa a `identity.setSealKeyProvider`, así que se llama una vez
+     * por acta sellada.
+     */
+    async mint () {
+      const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+      const pub = JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey))
+      const priv = await crypto.subtle.exportKey('jwk', pair.privateKey)
+      data.keys.push({ pub, priv, createdAt: Date.now() })
+      if (data.keys.length > MAX_KEYS) data.keys = data.keys.slice(-MAX_KEYS)
+      save()
+      return pub
+    },
+
+    /**
+     * Firma un cuerpo con la llave que el acta nombra. Devuelve `null` si esa llave no es
+     * nuestra —el disco se restauró, o el acta la puso otro master—: entonces el sobre
+     * sale SIN firma, que es peor que firmado pero mucho mejor que no poder guardar.
+     */
+    async sign (sealPub, body) {
+      const k = sealPub ? find(sealPub) : null
+      if (!k) return null
+      const { signature } = await signWithDevice({ privateJwk: k.priv, publickey: k.pub, data: body })
+      return signature
+    }
+  }
+}
+
+export default { openSealKeys }

package/src/sealer.js

@@ -0,0 +1,170 @@
+/**
+ * El SELLADOR: lo único de los secretos que toca criptografía.
+ *
+ * `secretsStore.js` guarda la forma y las reglas y no sabe cifrar; le inyecta este
+ * puerto y le pide sobres. Así el store se prueba con un sellador falso y este archivo
+ * se lee entero de una sentada.
+ *
+ * QUÉ HACE. Cada cajón (un namespace, o el cajón propio de un aparato) tiene una CEK
+ * AES-256-GCM. Las variables privadas se cifran con ella. La CEK viaja de dos formas,
+ * y esa dualidad es todo el diseño:
+ *
+ *   · **hacia los miembros** — envuelta a la llave de cifrado (`encPub`) de cada
+ *     aparato que deba leer ese cajón, con ECDH efímero: quien abre solo necesita su
+ *     propia privada. Es lo que va en el llavero del archivo y lo que viaja al agente.
+ *   · **hacia quien administra** — en la COPIA MAESTRA, cifrada con la llave derivada
+ *     de la contraseña del perfil. Es lo que permite sellar una variable nueva o
+ *     re-envolver la CEK a un aparato que entra.
+ *
+ * Y hay una tercera forma que NO existe a propósito: **la CEK nunca se envuelve a la
+ * llave de esta bóveda**. Si se hiciera, el daemon podría abrir todo por su cuenta y
+ * esto no valdría nada — que es exactamente la situación de la que venimos.
+ *
+ * La contraseña no está en el disco, así que una copia del disco no abre las privadas.
+ * Lo que sí abre es todo lo demás; los límites honestos están en
+ * `docs/secretos-sellados.md` §3 y conviene leerlos antes de confiar de más.
+ */
+import crypto from 'node:crypto'
+import {
+  makeContentKey, makeGeneration, encryptWithCek, decryptWithCek, wrapForMember, openWrap
+} from '@dotrino/identity/content'
+
+const b64 = (b) => Buffer.from(b).toString('base64')
+const un64 = (s) => Buffer.from(s, 'base64')
+
+/** La copia maestra va cifrada con AES-256-GCM bajo la llave derivada de la contraseña. */
+const MASTER_V = 1
+
+/** Se pidió abrir la copia maestra sin llave, o con la equivocada. */
+export class WrongPassword extends Error {
+  constructor (msg = 'wrong password') {
+    super(msg)
+    this.code = 'WRONG_PASSWORD'
+  }
+}
+
+function assertKey (adminKey) {
+  if (!(adminKey instanceof Uint8Array) || adminKey.length !== 32) {
+    throw new WrongPassword('the derived key is missing or malformed (32 bytes expected)')
+  }
+}
+
+/**
+ * Crea el sellador. No guarda estado ni recuerda la contraseña: cada operación recibe
+ * la llave derivada y la suelta. Que no se cachee es la mitad del valor de todo esto —
+ * una llave que se queda en memoria para siempre deja el disco protegido y la máquina
+ * igual de expuesta que antes.
+ */
+export function makeSealer () {
+  return {
+    /**
+     * Abre la copia maestra: `{ "ns:<ns>": cek, "dev:<pub>": cek }`. Un `blob` vacío
+     * devuelve un mapa vacío — es el primer arranque, no un error.
+     */
+    async openMaster (blob, adminKey) {
+      assertKey(adminKey)
+      if (!blob) return {}
+      if (blob.v !== MASTER_V) throw new Error(`master copy: unknown format v${blob.v}`)
+      try {
+        const d = crypto.createDecipheriv('aes-256-gcm', adminKey, un64(blob.iv))
+        d.setAuthTag(un64(blob.tag))
+        return JSON.parse(Buffer.concat([d.update(un64(blob.ct)), d.final()]).toString('utf8'))
+      } catch (_) {
+        // El tag de AES-GCM ES el verificador: si no cuadra, la contraseña no era.
+        // Por eso no hace falta guardar aparte un verificador de la contraseña, que
+        // sería un camino más barato para atacarla desde una copia del disco.
+        throw new WrongPassword()
+      }
+    },
+
+    async sealMaster (obj, adminKey) {
+      assertKey(adminKey)
+      const iv = crypto.randomBytes(12)
+      const c = crypto.createCipheriv('aes-256-gcm', adminKey, iv)
+      const ct = Buffer.concat([c.update(JSON.stringify(obj), 'utf8'), c.final()])
+      return { v: MASTER_V, iv: b64(iv), ct: b64(ct), tag: b64(c.getAuthTag()) }
+    },
+
+    /** La CEK de un cajón, creándola si es la primera variable que entra ahí. */
+    async cekFor (master, owner) {
+      if (!master[owner]) master[owner] = await makeContentKey()
+      return master[owner]
+    },
+
+    /** Una CEK NUEVA para el cajón, tirando la anterior. Rotar es esto. */
+    async newCek (master, owner) {
+      master[owner] = await makeContentKey()
+      return master[owner]
+    },
+
+    /** Cifra un valor con la CEK del cajón. */
+    async encrypt (cek, plaintext, gen = 0) {
+      const { iv, ct } = await encryptWithCek({ cek, gen, plaintext })
+      return { iv, ct }
+    },
+
+    /** Descifra con la CEK que corresponda al cajón. Solo lo usa quien administra. */
+    async decrypt (master, envelope, owner) {
+      const cek = master[owner]
+      if (!cek) throw new Error(`master copy: no key for drawer ${owner}`)
+      return decryptWithCek({ cek, envelope })
+    },
+
+    /**
+     * Una CEK NUEVA, sin llavero de por medio. Es lo que usa cada escritura desde v5: la
+     * bóveda no puede reutilizar la de antes porque **no puede abrir ninguna envoltura
+     * para recuperarla** — sellar es una capacidad pública, abrir no. Una generación por
+     * escritura es la consecuencia, no un capricho (§8.7).
+     */
+    async newKey () {
+      return makeContentKey()
+    },
+
+    /**
+     * El par de RECUPERACIÓN: su pública se guarda en claro —para poder envolverle sin
+     * saber nada— y su privada va sellada bajo la frase. Es la copia que se abre el día
+     * que no queda ningún aparato, y la que abre la TUI cuando el dueño pide ver un valor.
+     */
+    async makeRecoveryPair () {
+      const pair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey', 'deriveBits'])
+      return {
+        pub: JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey)),
+        priv: await crypto.subtle.exportKey('jwk', pair.privateKey)
+      }
+    },
+
+    /** Envuelve una CEK a UNA pública suelta (la de recuperación, que no es un miembro). */
+    async wrapForKey (cek, encPub) {
+      return wrapForMember({ cek, memberEncPub: encPub })
+    },
+
+    /**
+     * Abre una envoltura con una privada ECDH **en JWK**. Lo hace quien PUEDE leer.
+     *
+     * La privada llega como JWK porque así se guarda (sellada bajo la frase, en un JSON),
+     * y `openWrap` quiere una `CryptoKey`: importarla es el puente, y va aquí porque este
+     * es el único archivo que toca criptografía.
+     */
+    async openWrapWith (privJwk, wrap) {
+      const key = await crypto.subtle.importKey('jwk', privJwk, { name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+      return openWrap({ wrap, myEncPrivateKey: key })
+    },
+
+    /** Descifra un sobre con la CEK ya abierta. */
+    async openValue (cek, envelope) {
+      return decryptWithCek({ cek, envelope })
+    },
+
+    /**
+     * Envuelve la CEK a cada miembro. Los que no tengan llave de cifrado salen en
+     * `sinLlave` en vez de reventar: quien administra tiene que poder VERLO, porque el
+     * síntoma sería un servicio arrancando sin configuración y sin decir por qué.
+     */
+    async wrapFor (cek, members) {
+      const { generation, sinLlave } = await makeGeneration({ members, cek })
+      return { wraps: generation.wraps, sinLlave }
+    }
+  }
+}
+
+export default { makeSealer, WrongPassword }