@dotrino/vaultd 0.38.0 → 0.49.0

package/src/daemon.js

@@ -17,6 +17,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { startVaultManager } from './manager.js'
+import { startSshAgent, defaultSocketPath } from './sshAgent.js'
 import { dataDir, writeJson, readJson } from './paths.js'
 import { VERSION } from './version.js'
 
@@ -63,6 +64,14 @@ export async function runDaemon () {
 
   const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })
 
+  // --- agente SSH (la llave vive en el teléfono; ver sshAgent.js). `DOTRINO_VAULT_SSH_AGENT=0`
+  // lo apaga; cualquier otro valor es la ruta del socket.
+  let sshAgent = null
+  if (process.env.DOTRINO_VAULT_SSH_AGENT !== '0' && process.platform !== 'win32') {
+    const socketPath = process.env.DOTRINO_VAULT_SSH_AGENT || defaultSocketPath(dir)
+    try { sshAgent = startSshAgent({ socketPath, vault: () => mgr.current(), log: console.log }) } catch (e) { console.error('[vault] ssh-agent could not start: %s', e.message) }
+  }
+
   // --- state.json ---
   const stateFile = path.join(dir, 'state.json')
   const daemonVersion = VERSION
@@ -73,7 +82,7 @@ export async function runDaemon () {
     const cur = mgr.summary().find((p) => p.current) || {}
     writeJson(stateFile, {
       v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
-      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
+      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(), sshAgent: sshAgent?.socketPath || null,
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -143,7 +152,20 @@ export async function runDaemon () {
       if (!vault) return
       const profileId = pairReq?.profile ? mgr.resolve(pairReq.profile) : mgr.currentId()
       const isService = typeof pairReq?.service === 'string' && pairReq.service
-      const scope = isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
+      // PERMISOS, no tipos (2026-08-22): el cert lleva lo que pidió `pair --scope`, y si
+      // no pidió nada, el juego de siempre. `--service <ns>` sigue siendo el atajo de
+      // `vault:secrets:<ns>`. Se valida aquí porque es la maestra la que firma: nada
+      // que no esté en esta lista entra en un cert, y `vault:admin` / `vault:approve` nunca
+      // por este camino (se conceden a mano con `caps`).
+      const ALLOWED = (x) => x === 'vault:sign' || x === 'vault:read' || x === 'vault:store' || /^vault:secrets:[a-z0-9-]{1,32}$/.test(x)
+      const asked = Array.isArray(pairReq?.scope) ? pairReq.scope.filter((x) => typeof x === 'string') : null
+      if (asked && asked.some((x) => !ALLOWED(x))) {
+        writeJson(pairFile, { v: 2, at: Date.now(), error: 'scope not allowed: ' + asked.filter((x) => !ALLOWED(x)).join(',') })
+        return console.error('[vault] pairing refused: scope not allowed (%s)', asked.join(','))
+      }
+      const scope = asked?.length
+        ? [...new Set(asked)]
+        : isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
       const label = pairReq?.label || (isService ? 'service:' + pairReq.service : 'cli')
       // `profile`/`profileName`: la CUENTA del vault a la que entra el dispositivo.
       // Con varias bóvedas en el mismo daemon, el QR sale de UNA y quien empareja
@@ -181,6 +203,21 @@ export async function runDaemon () {
   const revokeReqFile = path.join(dir, 'revoke-request.json')
   const secretReqFile = path.join(dir, 'secret-request.json')
   const secretsListFile = path.join(dir, 'secrets-list.json')
+  /**
+   * Por qué falló la última orden de variables. La consola pide el cambio y el volcado
+   * por señales distintas, así que el motivo no cabe en la respuesta: se guarda aquí y
+   * viaja en el volcado siguiente. Sin esto, una contraseña equivocada se leía como
+   * «El daemon no aplicó el cambio», que no dice qué hacer.
+   */
+  let lastSecretError = null
+  /**
+   * El VALOR que se acaba de destapar, esperando al volcado siguiente (mismo camino que
+   * `lastSecretError`: la orden y el volcado son señales distintas). Vive en memoria un
+   * instante y se va con el volcado — quien lo lee borra el archivo enseguida.
+   */
+  let lastSecretValue = null
+  /** Y las versiones anteriores que se acaban de pedir. Mismo camino, mismo volcado. */
+  let lastSecretHistory = null
   const profileReqFile = path.join(dir, 'profile-request.json')
   const dumpReqFile = path.join(dir, 'dump-request.json')
   const meReqFile = path.join(dir, 'me-request.json')
@@ -200,6 +237,19 @@ export async function runDaemon () {
    * 0700 del vault y se BORRA al consumirla — mismo camino que ya usan los
    * secretos, y así nunca pasa por `ps` ni por el historial de la shell.
    */
+  /**
+   * Vuelve a cerrar la copia maestra de los secretos con otra llave. Se llama al poner
+   * o quitar la contraseña del perfil: los sobres de las variables NO se tocan (siguen
+   * sellados a la llave de cada aparato), solo cambia con qué se abre el llavero de
+   * administración. Sin esto, cambiar la contraseña dejaría los secretos ilegibles.
+   */
+  async function rekey (id, vieja, nueva) {
+    const v = mgr.get(id)
+    if (!v?.rekeySecrets) return
+    const r = await v.rekeySecrets(vieja, nueva)
+    if (r?.rekeyed) console.log('[vault] secrets master re-sealed (%d drawer(s))', r.drawers)
+  }
+
   async function handleProfileRequest (req) {
     const ref = () => mgr.resolve(req.profile || mgr.currentId())
     switch (req.op) {
@@ -210,10 +260,54 @@ export async function runDaemon () {
       case 'rm': { const r = await mgr.remove(req.profile); return { done: `perfil borrado: ${r.name || r.id}` } }
       case 'rename': { const p = mgr.profiles.rename(ref(), req.name); return { done: `perfil renombrado: ${p.name}` } }
       case 'use': { const p = mgr.profiles.setCurrent(ref()); return { done: `perfil activo: ${p.name || p.id}` } }
-      case 'unlock': { await mgr.profiles.unlock(ref(), req.password); return { done: 'perfil desbloqueado' } }
+      // ABRIR LA BÓVEDA SALDA LO QUE SE DEBE. Un aparato que entró después de escrita
+      // una variable no puede abrirla —envolverle su llave exige abrir la CEK, y eso
+      // pide la frase—, así que se queda en deuda y se ve en la consola y en la TUI.
+      // Este es el único momento en que la frase está delante, así que es aquí donde se
+      // paga; el dueño no tiene que acordarse de un comando aparte.
+      case 'unlock': {
+        const id = ref()
+        await mgr.profiles.unlock(id, req.password)
+        let note = ''
+        try {
+          const ak = await mgr.profiles.adminKey(id, req.password)
+          // REHACER el llavero, no solo saldar: con la frase delante se puede dejar cada
+          // cajón envuelto para exactamente quien dice el acta — creando lo que falta,
+          // reemplazando lo que alguien metiera mal y quitando lo que sobre.
+          const r = await mgr.get(id)?.resealAll?.(ak)
+          if (r?.wrapped) console.log('[vault] keyring rebuilt on unlock: %d wrap(s) in %d drawer(s)%s',
+            r.wrapped, r.drawers, r.dropped ? `, ${r.dropped} stale one(s) dropped` : '')
+          if (r?.dropped) note = ` · llavero al día (${r.dropped} envoltura(s) de más retirada(s))`
+          else if (r?.wrapped) note = ' · llavero al día'
+        } catch (e) { console.error('[vault] could not rebuild the keyring on unlock:', e.message) }
+        return { done: 'perfil desbloqueado' + note }
+      }
       case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
-      case 'password-set': { await mgr.profiles.setPassword(ref(), req.password); return { done: 'contraseña guardada' } }
-      case 'password-rm': { mgr.profiles.removePassword(ref()); return { done: 'contraseña quitada' } }
+      // PONER contraseña: los secretos pasan de abrirse con la llave de la máquina a
+      // abrirse con la frase. Hay que volver a cerrar la copia maestra con la nueva, o
+      // quedarían ilegibles. Si el perfil YA tenía contraseña, hace falta la vieja para
+      // poder abrirla: por eso el camino normal para cambiarla es quitarla y ponerla.
+      case 'password-set': {
+        const id = ref()
+        const tenia = !!mgr.profiles.get(id)?.protected
+        if (tenia && !req.current) throw new Error('this profile already has a password: remove it first (`profile password --rm`) and then set the new one')
+        const vieja = tenia ? await mgr.profiles.adminKey(id, req.current) : null
+        await mgr.profiles.setPassword(id, req.password)
+        const nueva = await mgr.profiles.adminKey(id, req.password)
+        await rekey(id, vieja, nueva)
+        return { done: 'contraseña guardada' }
+      }
+      // QUITARLA: al revés. Se abre la copia maestra con la frase y se vuelve a cerrar
+      // con la llave de la máquina, que es la protección de siempre — el disco sigue
+      // cifrado, pero su material vive en ese mismo disco.
+      case 'password-rm': {
+        const id = ref()
+        if (!req.password) throw new Error('removing the password needs the current one: the secrets must be re-sealed before it goes')
+        const vieja = await mgr.profiles.adminKey(id, req.password)
+        await rekey(id, vieja, null)
+        mgr.profiles.removePassword(id)
+        return { done: 'contraseña quitada · los secretos ahora se abren con la llave de esta máquina' }
+      }
       default: throw new Error('unknown profile operation: ' + req.op)
     }
   }
@@ -278,25 +372,76 @@ export async function runDaemon () {
       // 0700 del vault y se borra al consumir.
       const sec = readJsonSafe(secretReqFile)
       if (sec?.op) {
-        rm(secretReqFile)
+        rm(secretReqFile) // puede llevar la contraseña: fuera del disco cuanto antes
+        lastSecretError = null
         try {
           const vault = targetOf(sec)
           // Carga en GRUPO (`secret set ns K=v K2=v2`, `secret import`): todas las
           // variables entran de una vez y sale UN solo aviso de cambio, para que el
           // servicio no se reinicie a media carga y arranque con la mitad puesta.
-          if (sec.op === 'batch') {
+          // La CONTRASEÑA, si vino, se convierte en la llave que abre la copia de
+          // RECUPERACIÓN, y no se guarda en ningún sitio: se usa y se suelta. Desde v5
+          // solo la piden las operaciones que LEEN —ver un valor, cambiar su visibilidad,
+          // convertir el archivo, rotar re-cifrando—: escribir no (§8.1). Sin ella se cae
+          // a la llave de la máquina, que es la protección de antes de esto (y el vault lo
+          // avisa al arrancar).
+          const ak = sec.password ? await mgr.profiles.adminKey(sec.profile ? mgr.resolve(sec.profile) : mgr.currentId(), sec.password) : undefined
+          if (sec.op === 'migrate') {
+            // Sin lista a mano: la pone el vault, y es la MISMA que usa cualquier
+            // escritura (servicios del cajón + aparatos que administran). Con una lista
+            // propia aquí, lo convertido quedaba sellado solo a los servicios y el dueño
+            // no podía ver desde su consola nada de lo que ya tenía.
+            const r = await vault.migrateSecrets(null, ak)
+            if (!r.migrated) console.log('[vault] nothing to migrate: %s', r.reason)
+            else {
+              console.log('[vault] secrets SEALED (v%d -> v5). Backup left at secrets.json.v%d.bak', r.from, r.from)
+              for (const [owner, sin] of Object.entries(r.sinLlave || {})) {
+                console.log('[vault] WARNING %s: %d member(s) without an encryption key will NOT read their variables', owner, sin.length)
+              }
+            }
+          } else if (sec.op === 'batch') {
             const changed = sec.pub
-              ? await vault.applyDeviceSecrets(sec.pub, sec.items)
-              : vault.applySecrets(sec.ns, sec.items)
+              ? await vault.applyDeviceSecrets(sec.pub, sec.items, { by: null })
+              : await vault.applySecrets(sec.ns, sec.items, { by: null })
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
-          } else if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
-          else if (sec.op === 'rm') { vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'policy') { const r = await vault.setSecretPolicy(sec.ns, { approval: !!sec.approval }); console.log('[vault] %s: approval %s', sec.ns, r.approval ? 'REQUIRED (15 min window)' : 'off') }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
+          // Saldar lo que quedó a deber: heredarle a un aparato nuevo lo ya guardado y
+          // rotar de verdad el cajón del que salió alguien. Las dos cosas abren, así que
+          // van con la frase — y por eso se hacen aquí y no al escribir.
+          else if (sec.op === 'settle') {
+            const r = await vault.settleSecretDebts(ak)
+            const n = Object.keys(r).length
+            console.log(n ? `[vault] ${n} pending drawer(s) settled` : '[vault] nothing pending')
+          }
+          // Ver el valor de una privada: lo único que la frase guarda (§8.3).
+          else if (sec.op === 'reveal') {
+            const value = await vault.revealSecret(sec.owner, sec.key, ak)
+            lastSecretValue = { owner: sec.owner, key: sec.key, value }
+          }
+          // Qué versiones anteriores hay (sin valores: son sobres).
+          else if (sec.op === 'history') {
+            lastSecretHistory = { owner: sec.owner || null, key: sec.key || null, items: vault.secretHistory(sec.owner || null, sec.key || null) }
+          }
+          // REVERTIR: abrir la versión vieja (frase) y volver a guardarla (nada).
+          else if (sec.op === 'revert') {
+            const ok = await vault.revertSecret(sec.owner, sec.key, sec.ts, { adminKey: ak })
+            if (!ok) throw new Error('that version is not in the history any more')
+            console.log('[vault] secret reverted: %s/%s', sec.owner, sec.key)
+          }
           // Visibilidad: si el valor puede salir hacia la consola remota. No toca el valor.
-          else if (sec.op === 'vis') { vault.setSecretVisibility(sec.ns, sec.key, sec.public); console.log('[vault] secret visibility: %s/%s → %s', sec.ns, sec.key, sec.public ? 'public' : 'private') }
-          else if (sec.op === 'dev-vis') { await vault.setDeviceSecretVisibility(sec.pub, sec.key, sec.public); console.log('[vault] device secret visibility: %s → %s', sec.key, sec.public ? 'public' : 'private') }
-        } catch (e) { console.error('[vault] secret failed:', e.message) }
+          else if (sec.op === 'vis') { await vault.setSecretVisibility(sec.ns, sec.key, sec.public, ak); console.log('[vault] secret visibility: %s/%s → %s', sec.ns, sec.key, sec.public ? 'public' : 'private') }
+          else if (sec.op === 'dev-vis') { await vault.setDeviceSecretVisibility(sec.pub, sec.key, sec.public, ak); console.log('[vault] device secret visibility: %s → %s', sec.key, sec.public ? 'public' : 'private') }
+        } catch (e) {
+          lastSecretError = {
+            error: e.message,
+            code: e.code || (/wrong password/i.test(e.message) ? 'WRONG_PASSWORD' : 'SECRET_FAILED')
+          }
+          console.error('[vault] secret failed:', e.message)
+        }
       }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)
@@ -376,8 +521,21 @@ export async function runDaemon () {
         writeJson(secretsListFile, {
           v: 2, at: Date.now(), req: reqId, profile: t.id,
           ns: t.vault.listSecrets(),
-          dev: await t.vault.listDeviceSecrets()
+          dev: await t.vault.listDeviceSecrets(),
+          // Lo que quedó a deber un sellado. Va en el volcado porque si no se ve, no se
+          // salda: son cajones cuyos miembros NO están leyendo sus variables.
+          pending: await t.vault.secretDebts(),
+          // Y quién NO puede abrir lo suyo. Es lo mismo visto desde el aparato, que es
+          // como lo mira quien administra: «este servicio está en el acta y aun así no
+          // arranca». Sin esto solo se veía en el log del propio servicio.
+          incomplete: await t.vault.incompleteMembers(),
+          ...(lastSecretError ? { secretError: lastSecretError } : {}),
+          ...(lastSecretValue ? { revealed: lastSecretValue } : {}),
+          ...(lastSecretHistory ? { history: lastSecretHistory } : {})
         })
+        lastSecretError = null
+        lastSecretValue = null
+        lastSecretHistory = null
         writeJson(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
         // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
         try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
@@ -458,6 +616,7 @@ export async function runDaemon () {
   const shutdown = (sig) => {
     console.log(`\n[vault] ${sig} → deteniendo…`)
     rm(pairFile); rm(pendingEnrollFile)
+    try { sshAgent?.close() } catch (_) {}
     try { mgr.close() } catch (_) {}
     process.exit(0)
   }

package/src/manager.js

@@ -56,6 +56,12 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       proxyUrl,
       log: (...a) => log(`[${tag}]`, ...a),
       isLocked: () => profiles.isLocked(id),
+      // Para poder DECIR que este perfil no tiene contraseña, y por tanto que sus
+      // variables privadas se abren con material que vive en este mismo disco.
+      hasPassword: () => !!profiles.get(id)?.protected,
+      // Para la consola remota: la contraseña llega dentro del sobre firmado y hay que
+      // convertirla en la llave que abre la copia maestra de los secretos.
+      deriveAdminKey: (password) => profiles.adminKey(id, password),
       // Camino A: nació para adoptar la cuenta de un aparato (ver profiles.add).
       forAdoption: !!p?.adopt,
       // Ya adoptó: la marca se consume (no vuelve a estar «a la espera»).

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,27 @@
  * 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
@@ -48,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'])
@@ -61,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).
@@ -195,6 +236,26 @@ 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 } }
@@ -218,12 +279,21 @@ export function openProfiles (root = dataDir()) {
         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 = await derivePwd(password, p.pwd.salt, p.pwd.iter)
+      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 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()
       unlocked.add(id)
@@ -236,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 }