@dotrino/vaultd 0.109.0 → 0.111.1

package/lib/src/admin.js

@@ -61,7 +61,11 @@ export const ADMIN_OPS = Object.freeze([
   // documentada en `buildSealedVar` y la consola la llamaba, pero no existía — así que
   // crear una variable desde la consola contestaba «admin: invalid operation». No expone
   // nada nuevo: son llaves PÚBLICAS, las mismas que ya viajan en el acta.
-  'vars', 'var.set', 'var.setMany', 'var.recipients'
+  'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // ABRIR LA BÓVEDA A DISTANCIA (`docs/abrir-a-distancia.md`). Dos pasos: `unlock.begin`
+  // pide una llave efímera y los parámetros del molino; `unlock` trae la derivada dentro
+  // de un sobre que solo esta bóveda puede abrir. No hay una tercera.
+  'unlock.begin', 'unlock'
 ])
 
 /**
@@ -90,7 +94,13 @@ export const ADMIN_OPS = Object.freeze([
  * Se dejan las de LEER a propósito: si se cortaran todas, la consola no podría ni
  * enterarse de por qué no funciona y parecería rota. Así puede decir «está cerrada».
  */
-export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars', 'var.set', 'var.setMany', 'var.recipients'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze([
+  'audit', 'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // Las dos de abrir, obviamente: son las únicas que solo tienen sentido con el candado
+  // echado. Que estén aquí NO las deja pasar sin más — siguen exigiendo cert, acta, nonce
+  // y frescura como todas, y además la contraseña dentro del sobre.
+  'unlock.begin', 'unlock'
+])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -133,6 +143,10 @@ export function authorBody (owner, key, e, ts) {
 export function createAdminDesk ({
   desk, verify, readActivity = () => [], deviceIdOf, vars = null,
   notify = async () => {}, audit = () => {}, isLocked = () => false,
+  // ABRIR A DISTANCIA. Va inyectado —como `vars`— porque abrir necesita cripto y disco, y
+  // este módulo es puro a propósito. `null` en una bóveda que no lo soporte: entonces la
+  // operación existe y contesta que no, en vez de romper con un TypeError.
+  unlockDesk = null,
   now = () => Date.now()
 }) {
   const ops = new Set(ADMIN_OPS)
@@ -193,6 +207,17 @@ export function createAdminDesk ({
 
     try {
 
+      // ABRIR A DISTANCIA. La bóveda hace el trabajo; aquí solo se enruta, porque este
+      // módulo es puro —sin cripto, sin disco— y abrir necesita las dos cosas.
+      if (data.op === 'unlock.begin') {
+        if (!unlockDesk) return { ok: false, error: 'admin: this vault cannot be opened remotely (update it)' }
+        return { ok: true, result: await unlockDesk.begin({ by, device: chk.device }) }
+      }
+      if (data.op === 'unlock') {
+        if (!unlockDesk) return { ok: false, error: 'admin: this vault cannot be opened remotely (update it)' }
+        return await unlockDesk.open({ nonce: data.nonce, enc: data.enc, by, device: chk.device })
+      }
+
       if (data.op === 'audit') {
         const limit = Math.min(Math.max(Number(data.limit) || 100, 1), AUDIT_MAX)
         return { ok: true, result: { entries: readActivity(limit) } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.109.0",
+  "version": "0.111.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/client.js

@@ -194,16 +194,29 @@ export async function requestStore ({ masterPubkey, proxyUrl, device, cert, meth
  * El `nonce` de un solo uso NO es decorativo: `approve` y `revoke` cambian estado, así
  * que la ventana de frescura de ±5 min no basta para descartar un replay.
  */
-export async function requestAdmin ({ masterPubkey, proxyUrl, device, cert, op, dir, ...rest } = {}) {
+export async function requestAdmin ({ masterPubkey, proxyUrl, device, cert, op, dir, nonce: dado, ...rest } = {}) {
   const client = await freshClient({ proxyUrl, dir })
   try {
-    const nonce = [...crypto.getRandomValues(new Uint8Array(16))].map((b) => b.toString(16).padStart(2, '0')).join('')
+    // EL NONCE SE PUEDE DAR. Abrir la bóveda a distancia lo mete TAMBIÉN dentro del sobre
+    // sellado —es lo que impide reenviar uno capturado con un nonce nuevo— y quien sella
+    // tiene que conocerlo antes de llamar.
+    const nonce = typeof dado === 'string' && dado.length >= 16
+      ? dado
+      : [...crypto.getRandomValues(new Uint8Array(16))].map((b) => b.toString(16).padStart(2, '0')).join('')
     const data = { op, ...rest, publickey: device.publickey, ts: Date.now(), nonce }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     const pending = waitFor(client, (p) => p.type === MSG.ADMIN_RESULT || p.type === MSG.ERROR)
     client.sendByPubkey(masterPubkey, { type: MSG.ADMIN, data, signature, cert })
     const res = await pending
-    if (res.type === MSG.ERROR) throw new Error(res.error)
+    if (res.type === MSG.ERROR) {
+      // CON LO QUE TRAE: el `code` y —al abrir— el freno. Emparejar por el TEXTO es lo que
+      // rompe en silencio en cuanto alguien lo traduce.
+      const e = new Error(res.error)
+      if (res.code) e.code = res.code
+      if (res.tries != null) e.tries = res.tries
+      if (res.waitSec != null) e.waitSec = res.waitSec
+      throw e
+    }
     return res.result
   } finally { client.close() }
 }

package/src/ctl.js

@@ -1582,8 +1582,28 @@ async function cmdProfile (rest) {
       reportProfiles(await profileRequest('password-set', { password: pwd, current: actual || undefined }))
       return
     }
+    // LA CONTRASEÑA DEL ADMIN. Otra, distinta, que solo sirve desde el admin remoto — aquí
+    // no abre nada. Pantalla administrativa: dice qué hace y qué no, y ya (§5.1).
+    case 'admin-password': {
+      const action = args[0]
+      if (action === 'rm') {
+        reportProfiles(await profileRequest('admin-password-rm', {}))
+        return
+      }
+      if (action && action !== 'set') { console.error('uso: dotrino-vault profile admin-password [set|rm]'); process.exit(2) }
+      console.log('Una contraseña APARTE, para abrir la bóveda desde el admin remoto.')
+      console.log('Aquí no abre nada: tecleada en esta máquina no vale. Y para usarla hace')
+      console.log('falta además un aparato tuyo que administre — la contraseña sola no basta.')
+      console.log('\nEl perfil tiene que estar abierto ahora mismo para poder ponerla.')
+      const pwd = await askPassword('\nContraseña del admin: ')
+      if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+      const again = await askPassword('Repítela: ')
+      if (pwd !== again) { console.error('Las contraseñas no coinciden.'); process.exit(1) }
+      reportProfiles(await profileRequest('admin-password-set', { password: pwd }))
+      return
+    }
     default:
-      console.error('uso: dotrino-vault profile {ls|add|rename|use|rm|password}'); process.exit(2)
+      console.error('uso: dotrino-vault profile {ls|add|rename|use|rm|password|admin-password}'); process.exit(2)
   }
 }
 

package/src/daemon.js

@@ -24,6 +24,7 @@ import { ipcRead, ipcWrite, migrateIpcDir } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
 import { watchBinary } from './selfupdate.js'
 import { VERSION } from './version.js'
+import crypto from 'node:crypto'
 
 const readJsonSafe = (f) => ipcRead(f, null)
 const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
@@ -400,6 +401,35 @@ export async function runDaemon () {
         mgr.profiles.removePassword(id)
         return { done: 'contraseña quitada · los secretos ahora se abren con la llave de esta máquina' }
       }
+      // ----- LA CONTRASEÑA DEL ADMIN (`docs/abrir-a-distancia.md`) -----
+      //
+      // Otra contraseña, distinta, que **solo sirve por el camino del admin**. Lo que se
+      // guarda es una copia de la llave del perfil cifrada con lo que sale de ella; por eso
+      // ponerla exige el perfil abierto: esa llave solo está en memoria con el candado
+      // descorrido.
+      //
+      // El molino se hace AQUÍ porque quien la pone está delante de la máquina y ya tecleó
+      // la principal. Cuando se USA a distancia lo hace el navegador, y por eso la bóveda
+      // publica los parámetros (`secondaryParams`).
+      case 'admin-password-set': {
+        const id = ref()
+        if (!req.password) throw new Error('an admin password is required')
+        // El salt se acuña ANTES de derivar (`mint`), para derivar una sola vez con el
+        // definitivo. El molino se hace aquí porque quien la pone está delante de la
+        // máquina y acaba de teclear la principal; cuando se USA a distancia lo hace el
+        // navegador, y por eso la bóveda publica estos mismos parámetros.
+        const params = mgr.profiles.secondaryParams(id, { mint: true })
+        const derivada = new Uint8Array(crypto.scryptSync(
+          String(req.password), Buffer.from(params.salt, 'base64'),
+          params.len, { N: params.N, r: params.r, p: params.p }))
+        try { mgr.profiles.setSecondary(id, derivada) } finally { wipe(derivada) }
+        return { done: 'contraseña del admin guardada · solo sirve desde el admin, no aquí' }
+      }
+      case 'admin-password-rm': {
+        const id = ref()
+        const r = mgr.profiles.clearSecondary(id)
+        return { done: r.had ? 'contraseña del admin quitada' : 'no había ninguna' }
+      }
       default: throw new Error('unknown profile operation: ' + req.op)
     }
   }

package/src/manager.js

@@ -98,6 +98,22 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       // 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),
+      // ABRIR A DISTANCIA (`docs/abrir-a-distancia.md`). La bóveda no toca el registro de
+      // perfiles: se le pasan las tres cosas que necesita y nada más — con qué números
+      // deriva el admin, cómo se abre con la derivada, y si hay contraseña de admin puesta.
+      secondaryParams: () => profiles.secondaryParams(id),
+      openWithSecondary: async (derivada) => {
+        const r = await profiles.openWithSecondary(id, derivada)
+        // Igual que `unlock`: abrir el perfil no basta, hay que traer la maestra a memoria.
+        // Sin esto el candado diría «abierto» y todo lo que la necesita fallaría en otro
+        // sitio y por otro motivo, que es el fallo que ya se pagó una vez.
+        try { await running.get(id)?.takeMasterKey?.() } catch (e) {
+          try { profiles.lock(id) } catch (_) {}
+          throw new Error(`opened the profile but could not open it: ${e.message}`)
+        }
+        return r
+      },
+      hasSecondary: () => profiles.hasSecondary(id),
       // La llave del perfil MIENTRAS esté abierto, o null. Con ella, enrolar un servicio
       // con la bóveda abierta le envuelve su cajón en el acto en vez de dejarlo entrar
       // sin poder leer nada (ver `profiles.js`, `llaves`).

package/src/profiles.js

@@ -24,12 +24,22 @@ 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, kekFor } from './atrest.js'
+import { atRestFor, migrateFile, kekFor, encryptText, decryptText } from './atrest.js'
 import { probe as probeKek, writeConfig as writeKekConfig, configFromEnv } from './atrest.js'
 import { keyDirName, keyOwnerOf } from './keyowner.js'
 
 const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // PBKDF2 del verificador v1 (heredado); v2 usa scrypt
+
+/**
+ * EL MOLINO, en un solo sitio. Estaba escrito a mano en cada llamada, y con la contraseña
+ * del admin eso deja de ser cosmética: **el navegador tiene que derivar con exactamente
+ * estos números**. Si aquí se cambia uno y allá no, la contraseña «deja de funcionar» sin
+ * que nada diga por qué, que es la clase de fallo que este proyecto viene evitando.
+ *
+ * Por eso también se le mandan al admin (`secondaryParams`) en vez de que los copie.
+ */
+export const SCRYPT = Object.freeze({ N: 16384, r: 8, p: 1, len: 32 })
 const MAX_NAME = 40
 /**
  * Lo MÍNIMO que se acepta al poner una contraseña.
@@ -98,7 +108,7 @@ const b64 = (buf) => Buffer.from(new Uint8Array(buf)).toString('base64')
  */
 function deriveScryptPwd (password, saltB64) {
   const salt = Buffer.from(saltB64, 'base64')
-  return b64(crypto2.scryptSync(String(password || ''), salt, 32, { N: 16384, r: 8, p: 1 }))
+  return b64(crypto2.scryptSync(String(password || ''), salt, SCRYPT.len, { N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p }))
 }
 
 /** PBKDF2-SHA256 → verificador base64 (v1, heredado). */
@@ -228,6 +238,35 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
     return p
   }
 
+  /**
+   * EL FRENO DE FUERZA BRUTA, en un solo sitio porque ahora hay DOS puertas.
+   *
+   * Tras 5 fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro. Los
+   * fallos VIEJOS se olvidan (`TRIES_FORGET_MS`): sigue frenando una ráfaga, pero no
+   * convierte un despiste de ayer en un vault que ya no se abre.
+   *
+   * **Las dos contraseñas cuentan en el MISMO contador**, y no es un detalle: si cada una
+   * llevara el suyo, probar por un camino no frenaría el otro y el freno valdría la mitad.
+   *
+   * Lanza con CÓDIGO: la TUI es bilingüe y lo traduce, y la CLI lo dice con sus palabras.
+   * Sin código, el rechazo llegaba como un texto suelto del daemon, indistinguible de
+   * «se volvió a pedir la contraseña porque sí».
+   */
+  function frenar (p) {
+    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 Object.assign(new Error(`too many tries: wait ${Math.ceil(left / 1000)} s`),
+        { code: 'TOO_MANY_TRIES', waitSec: Math.ceil(left / 1000) })
+    }
+    return tries
+  }
+
   const api = {
     get root () { return root },
     dirOf,
@@ -497,32 +536,13 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
         save()
       }
       const salt = Buffer.from(p.kdf.salt, 'base64')
-      return new Uint8Array(crypto2.scryptSync(String(password || ''), salt, 32, { N: 16384, r: 8, p: 1 }))
+      return new Uint8Array(crypto2.scryptSync(String(password || ''), salt, SCRYPT.len, { N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p }))
     },
 
     async unlock (id, password) {
       const p = assertExists(id)
       if (!p.pwd) { open(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.
-      // 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()
-      // 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 tries = frenar(p)
       const proof = p.pwd.v === 2
         ? deriveScryptPwd(password, p.pwd.salt)
         : await derivePwd(password, p.pwd.salt, p.pwd.iter)
@@ -547,6 +567,99 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
       return { ok: true, locked: false }
     },
 
+    // ----- LA SEGUNDA CONTRASEÑA: la del admin (`docs/abrir-a-distancia.md`) -----
+    //
+    // DOS PUERTAS AL MISMO SITIO. La llave del perfil sale de `scrypt(principal, p.kdf.salt)`
+    // y es lo que destapa la maestra. Una segunda contraseña NO puede derivar una llave
+    // distinta —tiene que llegar a la misma—, así que lo que se guarda es **una copia de esa
+    // llave, cifrada con lo que sale de la secundaria**. Es el mismo patrón que los cajones:
+    // varios sobres, un destinatario cada uno.
+    //
+    // EL MOLINO LO HACE QUIEN LLAMA, no esto. Aquí entra `derivada` ya calculada, y hay dos
+    // motivos: la bóveda nunca llega a ver la contraseña del admin, y adivinar le cuesta el
+    // scrypt AL QUE PRUEBA en vez de costarle CPU a la bóveda (que además sería una forma de
+    // ahogarla). El freno sigue contando los fallos igual — ver `frenar`.
+    //
+    // Y por eso `derivada` VALE TANTO COMO LA CONTRASEÑA: quien la capture abre igual. Viaja
+    // cifrada a una llave efímera de la bóveda y la petición va firmada por un aparato del
+    // acta; esas dos cosas son las que la protegen, no el hecho de estar derivada.
+
+    /**
+     * Los parámetros para que el admin derive EXACTAMENTE igual. Son públicos: un salt no es
+     * un secreto y ya vive en el disco junto a los datos. `null` si este perfil no tiene
+     * segunda contraseña — entonces abrir a distancia sencillamente no está disponible.
+     */
+    secondaryParams (id, { mint = false } = {}) {
+      const p = find(id)
+      if (!p) return null
+      // `mint`: acuña el salt si todavía no hay ninguno. Lo pide QUIEN LA PONE, para poder
+      // derivar una sola vez con el salt definitivo — si no, habría que derivar, guardar, y
+      // volver a derivar con el salt que salió, que es como lo escribí primero y era torpe.
+      if (!p.kdf2) {
+        if (!mint) return null
+        p.kdf2 = { v: 1, salt: b64(crypto.getRandomValues(new Uint8Array(32))), wrapped: null }
+        save()
+      }
+      return { salt: p.kdf2.salt, ...SCRYPT }
+    },
+
+    /** ¿Tiene puesta la del admin? Es estado, y se enseña donde se administra. */
+    hasSecondary: (id) => !!find(id)?.kdf2?.wrapped,
+
+    /**
+     * Pone o cambia la contraseña del admin. **Exige el perfil ABIERTO**, porque lo que se
+     * guarda es la llave del perfil y esa solo está en memoria con el candado descorrido.
+     * Es lo correcto además de lo posible: ponerla es una decisión del dueño, y el dueño
+     * acaba de teclear la principal.
+     */
+    setSecondary (id, derivada) {
+      const p = assertExists(id)
+      if (!p.pwd) throw Object.assign(new Error('this profile has no password: there is nothing to open remotely'), { code: 'NO_PASSWORD' })
+      const llave = api.openKey(id)
+      if (!llave) throw Object.assign(new Error('open the profile first (dotrino-vault unlock)'), { code: 'PROFILE_LOCKED' })
+      if (!(derivada instanceof Uint8Array) || derivada.length !== 32) throw new Error('the admin key must be 32 bytes')
+      const salt = p.kdf2?.salt || b64(crypto.getRandomValues(new Uint8Array(32)))
+      p.kdf2 = { v: 1, salt, wrapped: encryptText(b64(llave), Buffer.from(derivada)) }
+      save()
+      return { ok: true }
+    },
+
+    /** La quita. Revocar es borrar el sobre: al instante y sin tocar la principal. */
+    clearSecondary (id) {
+      const p = assertExists(id)
+      if (!p.kdf2?.wrapped) { if (p.kdf2) { delete p.kdf2; save() } ; return { ok: true, had: false } }
+      delete p.kdf2
+      save()
+      return { ok: true, had: true }
+    },
+
+    /**
+     * ABRE CON LA DEL ADMIN. Recibe la derivada, descifra el sobre y saca la llave del
+     * perfil: de ahí para abajo el estado es idéntico a `unlock`, porque es la misma llave.
+     *
+     * No hay verificador aparte y no hace falta: AES-GCM autentica, así que una derivada
+     * equivocada **no descifra**, y eso ES la comprobación.
+     *
+     * Comparte el contador de `unlock` (`frenar`): probar por aquí frena allá y al revés.
+     */
+    async openWithSecondary (id, derivada) {
+      const p = assertExists(id)
+      if (!p.kdf2?.wrapped) throw Object.assign(new Error('this profile has no admin password'), { code: 'NO_SECONDARY' })
+      const tries = frenar(p)
+      let llave = null
+      try { llave = Buffer.from(decryptText(p.kdf2.wrapped, Buffer.from(derivada)), 'base64') } catch (_) { llave = null }
+      if (!llave || llave.length !== 32) {
+        p.tries = { n: tries.n + 1, at: Date.now() }
+        save()
+        throw Object.assign(new Error('wrong admin password'), { code: 'WRONG_PASSWORD', tries: p.tries.n })
+      }
+      delete p.tries
+      save()
+      open(id)
+      llaves.set(id, new Uint8Array(llave))
+      return { ok: true, locked: false }
+    },
+
     lock (id) { assertExists(id); unlocked.delete(id); olvidar(id); return { ok: true, locked: api.isLocked(id) } },
 
     /**

package/src/vault.js

@@ -28,6 +28,7 @@ import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
 import { openSubacta } from './subacta.js'
+import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.js'
 import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
 import { loadManifest, brokenOf } from '@dotrino/roadmap'
@@ -63,7 +64,7 @@ const MAX_REPLY_BYTES = 768 * 1024
  *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
  *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
  */
-export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, hasPassword = () => true, deriveAdminKey = null, openKey = null, forAdoption = false, onAdopted } = {}) {
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, hasPassword = () => true, deriveAdminKey = null, openKey = null, secondaryParams = null, openWithSecondary = null, hasSecondary = () => false, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
   // CIFRADO EN REPOSO ligado a esta máquina: ningún archivo del dir queda en claro, así
   // que copiarlos a otro equipo no sirve de nada. La identidad se migra AQUÍ (verificando
@@ -746,6 +747,74 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * el motivo real por el que editar el perfil exigía abrirla, y es el síntoma que abrió
    * todo esto: se cerraba sola a los cinco minutos y editar dejaba de funcionar.
    */
+  /**
+   * ABRIR LA BÓVEDA DESDE EL ADMIN (`docs/abrir-a-distancia.md`).
+   *
+   * Dos pasos, y el segundo no se puede reproducir por DOS candados distintos:
+   *
+   *   · el **nonce** hace que se NIEGUE a atenderlo dos veces (memoria, 10 min);
+   *   · la **efímera** hace que no se PUEDA abrir dos veces — se tira al usarla, así que
+   *     ese sobre queda inabrible hasta para nosotros, incluso con el disco en la mano.
+   *
+   * Por qué una efímera y no la llave de cifrado fija de la bóveda: esa cede a la llave de
+   * la máquina (modelo de amenazas §4.2), o sea que cae con el disco. La contraseña es
+   * justo lo único que un ladrón de disco NO tiene — cifrarla con algo que el disco
+   * entrega sería regalársela a quien grabe el tráfico hoy y robe el disco mañana.
+   *
+   * Y el molino lo hace el ADMIN: aquí llega la derivada, nunca la contraseña.
+   */
+  const EPHEMERAL_TTL_MS = 60 * 1000
+  const aperturas = new Map()   // nonce -> { privateKey, exp }
+
+  const unlockDesk = (typeof openWithSecondary === 'function' && typeof secondaryParams === 'function')
+    ? {
+        async begin ({ by }) {
+          const params = secondaryParams()
+          if (!params) {
+            throw new Error('this profile has no admin password: set one with `dotrino-vault profile admin-password`')
+          }
+          // Se barre lo vencido aquí y no con un temporizador: es barato, y un temporizador
+          // más es una cosa más que puede quedarse corriendo cuando el perfil ya no existe.
+          const t = Date.now()
+          for (const [n, v] of aperturas) if (v.exp <= t) aperturas.delete(n)
+          const eph = await makeEphemeralKey()
+          aperturas.set('pendiente', { privateKey: eph.privateKey, exp: t + EPHEMERAL_TTL_MS })
+          audit('unlock.begin', { by })
+          return { ...params, ek: eph.ek }
+        },
+
+        async open ({ nonce, enc, by }) {
+          const guardada = aperturas.get('pendiente')
+          aperturas.delete('pendiente')
+          if (!guardada || guardada.exp <= Date.now()) {
+            return { ok: false, error: 'unlock: ask for a key first, and use it within a minute' }
+          }
+          let payload = null
+          try { payload = await openSealed({ privateKey: guardada.privateKey, enc }) } catch (_) { payload = null }
+          // EL NONCE VA DENTRO DEL SOBRE. Si fuera solo por fuera, un sobre capturado se
+          // reenvía con un nonce nuevo y el candado del nonce no sirve de nada.
+          if (!payload || payload.nonce !== nonce || typeof payload.key !== 'string') {
+            audit('rejected', { what: 'unlock', by, reason: 'sobre' })
+            return { ok: false, error: 'unlock: the envelope does not check out' }
+          }
+          const derivada = new Uint8Array(Buffer.from(payload.key, 'base64'))
+          try {
+            const r = await openWithSecondary(derivada)
+            audit('unlock', { by })
+            log(`[vault] opened from the admin by ${by || '????-????'}`)
+            return { ok: true, result: { ok: true, locked: false } }
+          } catch (e) {
+            audit('rejected', { what: 'unlock', by, reason: e.code || 'error' })
+            // El freno viaja con el rechazo: sin él, el admin reintenta contra una puerta
+            // que ya no responde y no sabe por qué.
+            return { ok: false, code: e.code || null, error: e.message, tries: e.tries ?? null, waitSec: e.waitSec ?? null }
+          } finally {
+            derivada.fill(0)
+          }
+        }
+      }
+    : null
+
   const PROFILE_METHODS = new Set(['profilePut', 'profileBundle', 'profilePublic', 'profileRecipients'])
 
   async function handleProfile (from, p, d) {
@@ -1897,7 +1966,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
           // llave de la máquina de la bóveda, cuyo material vive en ese mismo disco.
           // El comentario de aquí decía «la consola lo dice en voz alta» y la consola
           // no decía nada — el mismo error que el comentario mentiroso de `atrest.js`.
-          hasPassword: (() => { try { return !!hasPassword() } catch (_) { return true } })()
+          hasPassword: (() => { try { return !!hasPassword() } catch (_) { return true } })(),
+          // SI ESTÁ CERRADA, Y SI SE PUEDE ABRIR DESDE AQUÍ. La consola no tenía forma de
+          // saberlo: se enteraba solo al chocar con un `vault-locked` intentando algo. Y
+          // `remoteUnlock` distingue las dos razones por las que el formulario no aparece —
+          // «no está cerrada» y «no hay contraseña de admin puesta»— que son cosas
+          // distintas y llevan a acciones distintas.
+          locked: (() => { try { return !!isLocked() } catch (_) { return true } })(),
+          remoteUnlock: (() => { try { return !!hasSecondary() } catch (_) { return false } })()
         }))
       }
     },
@@ -1998,6 +2074,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     desk,
     deviceIdOf,
     audit,
+    // Abrir a distancia. Va inyectado porque `admin.js` es puro y esto necesita cripto y
+    // disco; `null` si este perfil no lo soporta, y entonces la operación contesta que no.
+    unlockDesk,
     // El MISMO candado que frena firmar y editar el perfil: revocar reescribe el acta y
     // configurar toca los secretos, y ninguna de las dos se hace con la bóveda cerrada.
     isLocked,
@@ -2104,7 +2183,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const r = await admin.handle(p.data, { signature: p.signature, cert: p.cert })
     // El `code` viaja aparte del texto: el texto está en inglés y puede cambiar, el código
     // es lo que empareja quien llama (`vault-locked` ≠ «no autorizado»).
-    if (!r.ok) return reply(from, { type: MSG.ERROR, error: r.error, ...(r.code ? { code: r.code } : {}) })
+    // EL FRENO VIAJA CON EL RECHAZO. `tries` y `waitSec` solo los trae abrir a distancia, y
+    // sin ellos el admin reintenta contra una puerta que ya no responde y no sabe por qué —
+    // el mismo silencio que se arregló en el resto del ecosistema.
+    if (!r.ok) {
+      return reply(from, {
+        type: MSG.ERROR,
+        error: r.error,
+        ...(r.code ? { code: r.code } : {}),
+        ...(r.tries != null ? { tries: r.tries } : {}),
+        ...(r.waitSec != null ? { waitSec: r.waitSec } : {})
+      })
+    }
     reply(from, { type: MSG.ADMIN_RESULT, op: p.data.op, result: r.result })
   }