@dotrino/vaultd 0.52.0 → 0.56.0

package/lib/src/service.js

@@ -458,8 +458,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // verdad llega cuando el aparato que aprueba firme — por esta misma conexión, que
     // sigue identificada. Se espera lo que dura el pedido; denegado o vencido es error.
     if (res.body?.op === 'secrets.pending' && res.body.ns === ns) {
-      const okPending = await verifyDeviceSig({ publickey: masterPubkey, data: res.body, signature: res.signature })
-      if (!okPending) throw new Error('invalid master signature on the pending reply')
+      await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey })
       try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
       res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
@@ -467,14 +466,20 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       if (res.type === MSG.ERROR) throw new Error(res.error)
     }
 
-    // Autenticidad: el cuerpo viene firmado por la MAESTRA pineada.
+    // AUTENTICIDAD: la firma NO es de la maestra. El acta dice qué llave vale para esto
+    // (`sealPub`, buscada por `seq`), que es la misma regla que ya gobierna los sobres.
+    // La maestra solo sella el acta y reenvuelve; servir no es cosa suya, y por eso puede
+    // quedarse cerrada.
     const body = res.body
     if (!body || body.op !== 'secrets.result' || body.ns !== ns) throw new Error('malformed secrets reply')
     if (typeof body.ts !== 'number' || Math.abs(Date.now() - body.ts) > FRESH_WINDOW_MS) throw new Error('stale secrets reply')
-    const ok = await verifyDeviceSig({ publickey: masterPubkey, data: body, signature: res.signature })
-    if (!ok) throw new Error('invalid master signature on the secrets reply')
 
+    // Se abre ANTES de comprobar la firma, y no es un descuido: el sobre de fuera va
+    // sellado a la efímera que acabamos de estrenar, así que abrirlo no prueba nada ni
+    // confía en nadie — solo saca el acta con la que SÍ se comprueba. Nada de lo que hay
+    // dentro se usa hasta después de verificar.
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
+    await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey })
 
     // DOS CAPAS DE SOBRE, y hacen cosas distintas:
     //   · la de fuera (`ek` efímera, recién abierta) tapa el TRAMO — el proxio no ve
@@ -499,6 +504,40 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
  * omitido: silenciarlo convertiría una rotación mal sellada en «el servicio sigue
  * con el valor viejo y nadie se entera», que es el peor modo de fallo de todo esto.
  */
+/**
+ * ¿QUIÉN CONTESTÓ, Y PUEDE? La misma regla que gobierna los sobres, aplicada al
+ * transporte: **el acta dice qué llave firma qué**.
+ *
+ * La maestra no entra aquí. Sus dos trabajos son sellar el acta y reenvolver los sobres
+ * de todos los aparatos; servir una petición no es ninguno de los dos, así que exigir su
+ * firma la obligaba a estar despierta todo el tiempo — y de paso hacía imposible que
+ * sirviera nadie más.
+ *
+ * Lo que se comprueba, en orden:
+ *   1. el acta que llega va firmada por la maestra que este agente lleva pineada desde
+ *      que se enroló (o por la que aquella nombró al traspasar);
+ *   2. la firma del cuerpo cuadra con la llave de sellado que ESA acta nombra para el
+ *      `seq` con el que se firmó.
+ *
+ * Sin el paso 1 el paso 2 no vale nada: un acta cualquiera nombraría la llave que
+ * quisiera.
+ */
+export async function verifyResponder ({ body, seal, acta, masterPubkey }) {
+  if (!seal?.sig || typeof seal.seq !== 'number') {
+    throw new Error('the reply carries no sealing signature: this vault is too old to serve (update it)')
+  }
+  if (!acta) throw new Error('the reply carries no record: cannot tell which key was allowed to sign it')
+  if (acta.sealedBy !== masterPubkey) {
+    throw new Error('the record was not sealed by the master this agent knows: refusing the reply')
+  }
+  if (!(await verifyActa({ acta })).ok) throw new Error('the record does not verify')
+  const pub = sealKeyAt(acta, seal.seq)
+  if (!pub) throw new Error(`the record names no sealing key for #${seal.seq}`)
+  if (!(await verifyDeviceSig({ publickey: pub, data: body, signature: seal.sig }))) {
+    throw new Error('the reply signature does not check out against the key the record names')
+  }
+}
+
 /**
  * ¿SALIÓ ESTE SOBRE DE MI BÓVEDA? (§8.8 de `dotrino-vault/docs/secretos-sellados.md`)
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.52.0",
+  "version": "0.56.0",
   "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": {
@@ -20,8 +20,8 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.61.0",
-    "@dotrino/passmanager": "^0.1.0",
+    "@dotrino/identity": "^0.63.0",
+    "@dotrino/passmanager": "^0.9.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"
   },
@@ -44,7 +44,7 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "^0.3.2",
+    "@dotrino/remote-agent": "^0.5.3",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
   }

package/src/ctl.js

@@ -30,7 +30,8 @@ import { assertVar } from './secretsStore.js'
 import { isValidSecretsNs } from './protocol.js'
 import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
-import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
+import { encodeInvite, inviteUrl, parseInvite } from '../lib/src/invite.js'
+import { readConfig as readKekConfig, probe as probeKek, rekeyDir, encryptedFilesIn, CONFIG_FILE as KEK_CONFIG_FILE } from '../lib/src/atrest.js'
 import { VERSION } from './version.js'
 
 const dir = dataDir()
@@ -190,6 +191,32 @@ async function cmdPair (args = []) {
   // --approval: el aparato que entre pedirá tu aprobación (teléfono) en cada petición de
   // claves privadas. Por defecto NO pide; se cambia después con `caps <ID> +permiso`.
   const approval = args.includes('--approval')
+  // --admin: el aparato que entre por esta invitación podrá ADMINISTRAR (la consola).
+  // El QR no lleva nada: es una nota local de la bóveda y el permiso se aplica al aprobar
+  // con el código que tecleas aquí. Ahorra el `caps <ID> +administra` de después, que en un
+  // contenedor es otro `docker exec` y una vuelta a buscar el ID.
+  const admin = args.includes('--admin')
+  // --quiet: escupe SOLO la invitación (una línea) y termina. Sin QR y sin esperar.
+  // Para desplegar: en un contenedor no hay quien mire un QR pintado en una terminal, y un
+  // `pair` que se queda 2 minutos y medio esperando no se puede meter en un script.
+  const quiet = args.includes('--quiet')
+  // --kms <config.json>: el sitio que se va a crear (--new-account o --adopt) NACE con
+  // su clave de disco en el KMS. Va aquí y no en un paso posterior porque es el único
+  // momento que sirve: la llave de este aparato se genera al crear el perfil, y una
+  // migración posterior no deshace que haya existido bajo la clave de la máquina.
+  const kmsIdx = args.indexOf('--kms')
+  let pairKek = null
+  if (kmsIdx >= 0) {
+    const f = args[kmsIdx + 1]
+    if (!f || f.startsWith('-')) { console.error('uso: dotrino-vault pair --adopt --kms <config.json>'); process.exit(2) }
+    try { pairKek = JSON.parse(fs.readFileSync(f, 'utf8')) } catch (e) {
+      console.error('No se pudo leer %s: %s', f, e.message); process.exit(2)
+    }
+    try { probeKek(dataDir(), pairKek) } catch (e) {
+      console.error('El KMS no respondió (%s): %s', e.code || 'error', e.message)
+      console.error('No se creó ninguna cuenta.'); process.exit(1)
+    }
+  }
   const scIdx = args.indexOf('--scope')
   let scope = null
   if (scIdx >= 0) {
@@ -201,6 +228,7 @@ async function cmdPair (args = []) {
       const t = ALIAS[tok] || tok
       if (t === 'admin' || t === 'administra') { console.error('`admin` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +administra'); process.exit(2) }
       if (t === 'approve' || t === 'aprueba') { console.error('`approve` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +aprueba'); process.exit(2) }
+      if (t === 'sealer' || t === 'sella') { console.error('`sella` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +sella'); process.exit(2) }
       if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
       // El gestor de contraseñas SÍ se empareja con su permiso puesto: es lo único que
       // va a hacer ese aparato, y pedirlo en dos pasos era el paso que nadie daba.
@@ -220,11 +248,11 @@ async function cmdPair (args = []) {
   if (naIdx >= 0) {
     const next = args[naIdx + 1]
     const name = (next && !next.startsWith('-')) ? next : `cuenta ${new Date().toISOString().slice(0, 10)}`
-    const d = await profileRequest('add', { name })
+    const d = await profileRequest('add', { name, ...(pairKek ? { kek: pairKek } : {}) })
     if (d.error) { console.error('%s', d.error); process.exit(1) }
     if (!d.id) { console.error('El daemon no dijo qué cuenta creó.'); process.exit(1) }
     PROFILE = d.id // el emparejamiento y los comandos siguientes apuntan a ELLA
-    console.log('Cuenta nueva: %s  (%s)', name, d.id)
+    console.log('Cuenta nueva%s: %s  (%s)', pairKek ? ' (clave del disco en el KMS)' : '', name, d.id)
   }
   // `--adopt [nombre]`: la TERCERA respuesta a «¿de qué cuenta hablamos?» — el camino A.
   // Aquí la cuenta NO sale de esta bóveda: la trae el aparato y esta bóveda pasa a
@@ -235,15 +263,28 @@ async function cmdPair (args = []) {
   if (adopt) {
     const next = args[adIdx + 1]
     const name = (next && !next.startsWith('-')) ? next : `cuenta del dispositivo`
-    const d = await profileRequest('add', { name, adopt: true })
+    const d = await profileRequest('add', { name, adopt: true, ...(pairKek ? { kek: pairKek } : {}) })
     if (d.error) { console.error('%s', d.error); process.exit(1) }
     if (!d.id) { console.error('El daemon no dijo qué cuenta creó.'); process.exit(1) }
     PROFILE = d.id
-    console.log('Cuenta a la espera de adoptar la del dispositivo: %s  (%s)', name, d.id)
+    console.log('Cuenta a la espera de adoptar la del dispositivo%s: %s  (%s)', pairKek ? ' (clave del disco en el KMS)' : '', name, d.id)
   }
+  // `--kms` sin un sitio que crear no hace NADA, y callárselo es lo peor que se puede
+  // hacer aquí: el dueño se quedaría creyendo que su aparato nació en el KMS.
+  if (pairKek && !adopt && naIdx < 0) {
+    console.error('--kms solo sirve cuando se crea el sitio, porque la llave del aparato')
+    console.error('se genera en ese momento. Úsalo con una de las dos:')
+    console.error('  dotrino-vault pair --adopt      --kms <config.json>   (la cuenta la trae el aparato)')
+    console.error('  dotrino-vault pair --new-account --kms <config.json>  (cuenta nueva, nacida aquí)')
+    console.error('')
+    console.error('Emparejar contra una cuenta que ya vive en esta bóveda no cambia su clave de')
+    console.error('disco: esa ya se escribió cuando se creó. Ver docs/llaves-de-hardware.md.')
+    process.exit(2)
+  }
+
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
-  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}), ...(approval ? { approval: true } : {}) })
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}), ...(approval ? { approval: true } : {}), ...(admin ? { admin: true } : {}) })
   sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
@@ -264,9 +305,12 @@ async function cmdPair (args = []) {
   // UNA (la activa, o la de --profile). Decirlo evita enrolar el dispositivo en la
   // equivocada; es la misma línea que muestra la TUI.
   const acct = pair.profileName || pair.profile
+  // --quiet: la invitación y nada más, para poder capturarla desde un script.
+  if (quiet) { console.log(url); return }
   if (acct) console.log('\nCuenta que se comparte: %s%s', acct, pair.profileName && pair.profile ? `  (${pair.profile})` : '')
   console.log('\nEscanea este QR con el dispositivo que quieres conectar (válido %d min):\n', mins)
   console.log(qrToString(url)) // el QR abre la consola de dispositivos y empareja solo
+  if (admin) console.log(`${R}${B}⚠ Y además podrá ADMINISTRAR: admitir y quitar aparatos.${Z}`)
   console.log(`${R}${B}⚠ Este código deja LEER tus datos y FIRMAR con tu identidad.${Z}`)
   console.log(`${R}  NO lo compartas con nadie, ni con "soporte". Solo escanéalo en TU dispositivo.${Z}`)
   console.log('\nO abre esta dirección en el dispositivo:\n  ' + url)
@@ -306,6 +350,80 @@ function cmdApprove (code) {
   console.log('Aprobando con el código %s… verifica con: dotrino-vault devices', code)
 }
 
+/**
+ * `dotrino-vault join <invitación>` — ESTA bóveda entra en la cuenta de OTRA.
+ *
+ * Es el papel contrario a `pair`: aquí no se invita, se acepta. Y lo que entra en el acta
+ * es la llave de ESTA bóveda, no una de aparato inventada — por eso después se le puede
+ * dar `+sella` y que sea el respaldo de verdad de la otra.
+ *
+ * El código que sale por pantalla hay que TIPEARLO en la otra bóveda (`approve`): una
+ * invitación interceptada no basta para entrar.
+ */
+async function cmdJoin (rest) {
+  const args = rest || []
+  // `--name <n>`: cómo se va a llamar aquí la cuenta ajena. Es un perfil MÁS de esta
+  // bóveda, y en una máquina que respalda a varias hace falta distinguirlas.
+  const nIdx = args.indexOf('--name')
+  const name = nIdx >= 0 && args[nIdx + 1] && !args[nIdx + 1].startsWith('-') ? args[nIdx + 1] : null
+  // `--kms <config.json>`: el perfil que se cree para la cuenta ajena NACE con su clave de
+  // disco en el KMS. Va aquí por la misma razón que en `pair`: es el único momento que
+  // sirve, porque la llave de esta bóveda para esa cuenta se genera al crear el perfil.
+  const kIdx = args.indexOf('--kms')
+  let kek = null
+  if (kIdx >= 0) {
+    const f = args[kIdx + 1]
+    if (!f || f.startsWith('-')) { console.error('uso: dotrino-vault join <invitación> --kms <config.json>'); process.exit(2) }
+    try { kek = JSON.parse(fs.readFileSync(f, 'utf8')) } catch (e) {
+      console.error('No se pudo leer %s: %s', f, e.message); process.exit(2)
+    }
+    try { probeKek(dataDir(), kek) } catch (e) {
+      console.error('El KMS no respondió (%s): %s', e.code || 'error', e.message)
+      console.error('No se creó ninguna cuenta.'); process.exit(1)
+    }
+  }
+  // Lo que queda tras quitar las banderas Y SUS VALORES es la invitación.
+  const consumidos = new Set()
+  for (const [i, v] of [[nIdx, name], [kIdx, kek]]) if (i >= 0) { consumidos.add(i); if (v != null) consumidos.add(i + 1) }
+  const texto = args.filter((a, i) => !consumidos.has(i) && !a.startsWith('-')).join(' ').trim()
+  if (!texto) {
+    console.error('uso: dotrino-vault join <invitación> [--name <n>] [--kms <config.json>]')
+    console.error('     (la invitación es lo que imprime «pair» en la otra bóveda)')
+    process.exit(2)
+  }
+  const qr = parseInvite(texto)
+  if (!qr?.sn || !qr?.iss || !qr?.proxy) {
+    console.error('Esa invitación no se entiende. Pega la línea completa que imprime «dotrino-vault pair».')
+    process.exit(2)
+  }
+  const s = requireDaemon()
+  const res = path.join(dir, 'join.json')
+  try { fs.rmSync(res, { force: true }) } catch (_) {}
+  writeReq('join-request.json', { qr, label: 'bóveda', ...(name ? { name } : {}), ...(kek ? { kek } : {}) })
+  sendSignal(s.pid, 'SIGUSR2')
+
+  console.log('Entrando en la cuenta de la otra bóveda…')
+  let visto = null
+  for (let i = 0; i < 900; i++) {          // hasta 3 min: hay un humano tipeando al otro lado
+    await sleep(200)
+    const d = readJson(res, null)
+    if (!d) continue
+    if (d.code && d.code !== visto) {
+      visto = d.code
+      console.log('\n  Tipea este código en la OTRA bóveda:   dotrino-vault approve %s\n', d.code)
+    }
+    if (d.state === 'done') {
+      console.log('Listo: esta bóveda ya es miembro de esa cuenta (acta #%s).', d.seq ?? '?')
+      if (d.profile) console.log('La cuenta vive aquí como el perfil %s  (dotrino-vault profile ls).', d.profile)
+      console.log('Para que además pueda SELLAR, en la otra:  dotrino-vault caps <ID> +sella')
+      return
+    }
+    if (d.state === 'error') { console.error('No se pudo entrar: %s', d.error); process.exit(1) }
+  }
+  console.error('Se agotó la espera. ¿Se aprobó el código en la otra bóveda?')
+  process.exit(1)
+}
+
 function cmdReject (deviceId) {
   if (!deviceId) { console.error('uso: dotrino-vault reject <deviceId>'); process.exit(2) }
   const s = requireDaemon()
@@ -407,7 +525,7 @@ async function cmdMembers () {
     // se mira quién es quién — y en la lista de variables ya seria tarde.
     if (m.cn && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
   }
-  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +permiso')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +permiso')
   console.log('  «Permiso»: ese aparato solo recibe claves privadas cuando lo apruebas desde un aparato con «aprueba» (en cada arranque).')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
   console.log('  No deja cambiar permisos ni traspasar el mando: eso solo se hace en esta máquina.')
@@ -470,11 +588,15 @@ async function cmdApproval (args = []) {
 async function cmdCaps (args = []) {
   const [id, ...changes] = args
   if (!id || !changes.length) {
-    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+permiso|-permiso')
+    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+sella|-sella|+permiso|-permiso')
     process.exit(2)
   }
   const CAP_BY_WORD = {
     firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
+    // `sella`: SELLAR EL ACTA. Es lo que convierte a otra bóveda en respaldo de esta —
+    // podrá admitir aparatos y cambiar permisos si esta se pierde. No es un traspaso:
+    // quien manda sigue mandando. Como `administra`, no se empareja: se concede aquí.
+    sella: 'sealer', sealer: 'sealer',
     // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
     // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
     contrasenas: 'passwords', 'contraseñas': 'passwords',
@@ -593,6 +715,124 @@ function profileDir () {
   return path.join(dir, 'p', p.id)
 }
 
+// DE DÓNDE SALE la clave que cifra el disco (`lib/src/kek.js`). Por defecto se deriva de
+// esta máquina; se puede pasar a un KMS, y entonces una copia del disco deja de servir.
+function cmdAtrest (rest) {
+  // OJO: la clave es POR PERFIL. `dir` aquí dentro es el del perfil al que apunta el
+  // comando (--profile, o el activo); la raíz de la bóveda es otra cosa y tiene la suya.
+  const vaultRoot = dataDir()
+  const dir = profileDir()
+  const sub = rest[0] || 'status'
+
+  if (sub === 'status') {
+    const cfg = readKekConfig(dir)
+    const archivos = encryptedFilesIn(dir)
+    if (cfg.provider === 'machine') {
+      console.log('Clave del disco: derivada de ESTA máquina (machine-id + salt).')
+      console.log('  Aviso: el material vive en el mismo disco que los datos, así que una')
+      console.log('  copia del disco entero la abre. Para cerrarlo: dotrino-vault atrest rekey <config.json>')
+    } else {
+      console.log('Clave del disco: envuelta por ' + (cfg.label || cfg.wrap?.cmd || 'un programa externo') + '.')
+      console.log('  Una copia del disco NO basta: hace falta además poder desenvolverla.')
+    }
+    console.log('Archivos cifrados: ' + (archivos.length ? archivos.join(', ') : 'ninguno todavía'))
+
+    // ES POR PERFIL, y eso hay que verlo: en la misma bóveda un perfil puede ir con KMS
+    // y el de al lado con la clave de la máquina. Sin esta lista, «lo puse en el KMS» es
+    // una creencia y no un hecho comprobable.
+    const otros = (readState().profiles || [])
+    if (otros.length > 1) {
+      console.log('')
+      console.log('Los demás perfiles de esta bóveda (cada uno lleva su propia clave):')
+      for (const q of otros) {
+        let pv = 'machine'
+        try { pv = readKekConfig(path.join(vaultRoot, 'p', q.id)).provider } catch (_) { pv = '?' }
+        const marca = q.current ? ' (activo)' : ''
+        console.log('  ' + (q.name || q.id) + marca + ': ' + (pv === 'machine' ? 'esta máquina' : 'programa externo / KMS'))
+      }
+    }
+    // El REGISTRO de perfiles vive en la raíz y tiene su propia clave: poner un perfil en
+    // el KMS no lo cubre. Dentro está el verificador del candado y la lista de perfiles,
+    // no el contenido de ninguno — pero conviene no creer que ya está protegido.
+    let raiz = 'machine'
+    try { raiz = readKekConfig(vaultRoot).provider } catch (_) {}
+    if (raiz === 'machine' && cfg.provider !== 'machine') {
+      console.log('')
+      console.log('Ojo: el registro de perfiles (la raíz de la bóveda) sigue con la clave de')
+      console.log('esta máquina. No guarda el contenido de ningún perfil, pero no está en el KMS.')
+    }
+    return
+  }
+
+  if (sub === 'test') {
+    // Comprueba el ida y vuelta SIN tocar los datos: es lo que hay que correr ANTES de
+    // un rekey, y lo que dice si el KMS sigue respondiendo.
+    try {
+      const r = probeKek(dir)
+      if (r.provider === 'machine') console.log('OK — proveedor «machine»: no hay nada externo que probar.')
+      else console.log('OK — ' + (r.label || 'el programa externo') + ' envuelve y desenvuelve (' + r.wrappedBytes + ' bytes).')
+    } catch (e) {
+      console.error('FALLA (' + (e.code || 'error') + '): ' + e.message)
+      process.exitCode = 1
+    }
+    return
+  }
+
+  if (sub === 'rekey') {
+    const file = rest[1]
+    if (!file) {
+      console.error('Falta el archivo de configuración: dotrino-vault atrest rekey <config.json>')
+      console.error('Para volver a la clave de la máquina: dotrino-vault atrest rekey --machine')
+      process.exitCode = 1; return
+    }
+    let cfg
+    if (file === '--machine') cfg = { provider: 'machine' }
+    else {
+      try { cfg = JSON.parse(fs.readFileSync(file, 'utf8')) } catch (e) {
+        console.error('No se pudo leer ' + file + ': ' + e.message); process.exitCode = 1; return
+      }
+    }
+    // FRENO: recifrar un perfil que YA tiene identidad no le da raíz de hardware, y
+    // dejar creer que sí es peor que no ofrecerlo. Su maestra se escribió bajo la clave
+    // vieja; cualquier copia del disco anterior a este momento la sigue abriendo, y eso
+    // no hay recifrado que lo deshaga. Lo que sí sirve está en el mensaje.
+    const tieneIdentidad = fs.existsSync(path.join(dir, 'identity.json'))
+    if (tieneIdentidad && cfg.provider !== 'machine' && !rest.includes('--anyway')) {
+      console.error('Este perfil ya tiene identidad, así que recifrarlo NO le da raíz en el KMS.')
+      console.error('')
+      console.error('Su maestra se generó y se escribió bajo la clave de esta máquina. Una copia')
+      console.error('del disco anterior a este momento la sigue abriendo, para siempre, y eso no')
+      console.error('lo deshace ningún recifrado: solo protege de aquí en adelante.')
+      console.error('')
+      console.error('Para una identidad con raíz en el KMS, tiene que NACER así:')
+      console.error('  1. dotrino-vault profile add <nombre> --kms <config.json>')
+      console.error('  2. enrólalo al acta de la cuenta como un aparato más')
+      console.error('  3. pásale el sellado y revoca el aparato viejo')
+      console.error('  (el profileId no cambia: la génesis sigue siendo el nombre de la cuenta)')
+      console.error('')
+      console.error('Si aun así quieres recifrar —porque el disco nunca salió de tu control—:')
+      console.error('  dotrino-vault atrest rekey %s --anyway', file)
+      process.exitCode = 1; return
+    }
+    try {
+      const r = rekeyDir(dir, cfg)
+      console.log('Listo: ' + r.from + ' → ' + r.to + '. Recifrados ' + r.files.length + ' archivos.')
+      if (r.backups.length) {
+        console.log('Copias de seguridad (bórralas cuando compruebes que todo abre):')
+        for (const b of r.backups) console.log('  ' + b)
+      }
+      console.log('Reinicia el servicio para que tome la clave nueva.')
+    } catch (e) {
+      console.error('NO se cambió nada (' + (e.code || 'error') + '): ' + e.message)
+      process.exitCode = 1
+    }
+    return
+  }
+
+  console.error('Uso: dotrino-vault atrest [status|test|rekey <config.json>|rekey --machine]')
+  process.exitCode = 1
+}
+
 // Bitácora de actividad de seguridad (quién firmó/renovó/enroló y qué se rechazó).
 function cmdActivity (n = 30) {
   const f = path.join(profileDir(), 'activity.log')
@@ -1049,7 +1289,13 @@ function reportProfiles (d) {
 }
 
 async function cmdProfile (rest) {
-  const [sub, ...args] = rest
+  const [sub, ...rawArgs] = rest
+  // `--kms <archivo>` se saca ANTES de armar el nombre: el nombre se compone juntando
+  // los argumentos sueltos, así que si no se quita acabaría llamándose «midevault --kms
+  // cfg.json».
+  const kmsAt = rawArgs.indexOf('--kms')
+  const kmsFile = kmsAt !== -1 ? rawArgs[kmsAt + 1] : null
+  const args = kmsAt !== -1 ? rawArgs.filter((_, i) => i !== kmsAt && i !== kmsAt + 1) : rawArgs
   const name = args.join(' ').trim()
   switch (sub || 'ls') {
     case 'ls': {
@@ -1061,8 +1307,24 @@ async function cmdProfile (rest) {
       return
     }
     case 'add': {
-      if (!name) { console.error('uso: dotrino-vault profile add <nombre>'); process.exit(2) }
-      reportProfiles(await profileRequest('add', { name }))
+      if (!name) { console.error('uso: dotrino-vault profile add <nombre> [--kms <config.json>]'); process.exit(2) }
+      // NACER con el KMS es la única forma de que la maestra no haya existido nunca bajo
+      // la clave de esta máquina. Migrar después no da lo mismo y no se ofrece como si
+      // lo diera (ver el freno de `atrest rekey`).
+      let kek = null
+      if (kmsAt !== -1) {
+        if (!kmsFile || kmsFile.startsWith('-')) { console.error('uso: --kms <config.json>'); process.exit(2) }
+        try { kek = JSON.parse(fs.readFileSync(kmsFile, 'utf8')) } catch (e) {
+          console.error('No se pudo leer %s: %s', kmsFile, e.message); process.exit(2)
+        }
+        // Probar aquí ANTES de mandar la orden: si el KMS no responde, mejor enterarse
+        // sin haber creado nada.
+        try { probeKek(dataDir(), kek) } catch (e) {
+          console.error('El KMS no respondió (%s): %s', e.code || 'error', e.message)
+          console.error('No se creó ningún perfil.'); process.exit(1)
+        }
+      }
+      reportProfiles(await profileRequest('add', { name, ...(kek ? { kek } : {}) }))
       console.log('Conecta un dispositivo a este perfil:  dotrino-vault pair --profile "%s"', name)
       return
     }
@@ -1141,8 +1403,13 @@ function askText (prompt) {
 
 async function cmdUnlock () {
   const pwd = await askPassword('Contraseña del perfil: ')
-  reportProfiles(await profileRequest('unlock', { password: pwd }))
-  console.log('Ya puedes editar el perfil. Se vuelve a bloquear al reiniciar el servicio (o con: dotrino-vault lock).')
+  // El daemon devuelve cuánto aguanta abierto: se dice AQUÍ, al abrirlo, que es cuando
+  // sirve de algo. Encontrárselo cerrado sin haberlo leído nunca parece una avería.
+  const out = await profileRequest('unlock', { password: pwd })
+  reportProfiles(out)
+  const min = Math.max(1, Math.round((out?.autoLockMs || 5 * 60 * 1000) / 60000))
+  console.log(`Ya puedes editar el perfil. Se vuelve a bloquear solo tras ${min} min sin usarse` +
+    ' (o al reiniciar el servicio, o con: dotrino-vault lock).')
 }
 
 async function cmdLock () {
@@ -1167,11 +1434,19 @@ function help () {
   tui                 interfaz de terminal a pantalla completa (bóvedas, pares, secretos)
   status              estado del servicio + fingerprint
   pair [--save <f>]   inicia un emparejamiento (QR + espera); --save escribe la invitación (.dpair)
+  pair --kms <config.json>
+                      el sitio que se cree (--adopt o --new-account) NACE con su clave
+                      de disco en el KMS. Es el único momento que sirve: la llave del
+                      aparato se genera al crear el perfil
   pair --new-account [nombre]
                       estrena una cuenta VACÍA en este vault y mete ahí al dispositivo
                       (sin la bandera entra a la cuenta activa, o a la de --profile)
   pair --service <ns> empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
   pair --approval       el aparato que entre pedirá tu aprobación (teléfono) al recibir claves
+  pair --admin          el aparato que entre podrá ADMINISTRAR (es lo que es una consola).
+                      El QR no lleva nada: el permiso se aplica al aprobar el código aquí
+  pair --quiet          escupe SOLO la invitación (una línea) y termina: sin QR y sin
+                      esperar. Para desplegar (un contenedor no mira un QR en pantalla)
   pair --scope <lista>  los PERMISOS del cert: sign,read,store,contrasenas,secrets:<ns> (sin esto: sign,read,store;
                       se combina con --service: --service eco --scope sign = bot que firma y lee su cajón)
   secret set <ns> <CLAVE> <valor>   variable del scope <ns>: la comparten TODOS los
@@ -1204,6 +1479,14 @@ function help () {
                                     y una privada NO se vuelve pública (bórrala y créala).
   secret visibility <ns> <CLAVE> private               tapa una pública sin tocar el valor
   secret device visibility <ID> <CLAVE> private
+  join <invitación> [--name <n>] [--kms <config.json>]
+                      ESTA bóveda ENTRA en la cuenta de otra (el papel contrario a pair).
+                      Entra con su propia llave, así que después se le puede dar +sella
+                      y ser el respaldo de esa cuenta. La cuenta ajena queda aquí como un
+                      PERFIL más (--name la nombra; --kms le pone la clave de disco en el
+                      KMS, y solo vale ahora: el perfil se está creando)
+                      Al desplegar, esto mismo va por el entorno y sin entrar a nada:
+                      DOTRINO_JOIN (o DOTRINO_JOIN_FILE) + DOTRINO_JOIN_NAME
   pending             muestra el dispositivo pendiente + su código a comparar
   approve <código>    aprueba el dispositivo tipeando el código que MUESTRA (el vault no lo sabe)
   reject <deviceId>   rechaza un dispositivo pendiente
@@ -1212,7 +1495,14 @@ function help () {
   members             el acta del perfil: quién es tuyo y qué puede hacer
   label <ID> <nombre> renombra un dispositivo (el nombre con el que lo reconoces)
   caps <ID> ±permiso  cambia permisos (+firma -guarda +administra +contrasenas …)
+                      +sella = OTRA BÓVEDA que puede sellar el acta de esta cuenta, para
+                      que perder una máquina no se la lleve. No es un traspaso
   revoke <ID|nonce>   quita un dispositivo (con el ID, todos sus certificados)
+  atrest status       de dónde sale la clave que cifra el disco (esta máquina, o un KMS)
+  atrest test         comprueba que el KMS envuelve y desenvuelve, SIN tocar los datos
+  atrest rekey <f>    cambia de proveedor: descifra con la vieja y recifra con la nueva
+                      (--machine para volver a la clave de esta máquina). Editar
+                      atrest.json a mano NO vale: dejaría el perfil ilegible
   activity [n]        bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
   logs                últimos logs del servicio
   version             muestra la versión instalada
@@ -1220,6 +1510,10 @@ function help () {
 Perfiles (varias identidades tuyas en el mismo PC; todas atienden a la vez):
   profile ls                        lista los perfiles (* = el activo, el destino por defecto)
   profile add <nombre>              crea un perfil (identidad nueva, vacía)
+  profile add <nombre> --kms <f>    ...y su clave de disco NACE en el KMS que diga <f>.
+                                    Es la única forma de que la maestra no exista nunca
+                                    bajo la clave de esta máquina: migrar después no da
+                                    lo mismo (una copia vieja del disco la sigue abriendo)
   profile use <id|nombre>           elige el perfil activo
   profile rename <nombre>           renombra un perfil
   profile rm <id|nombre>            BORRA un perfil y su identidad (irreversible)
@@ -1231,7 +1525,8 @@ dispositivos siguen firmando y leyendo aunque esté bloqueado):
   profile password [set]            pone o cambia la contraseña
   profile password rm               la quita
   unlock                            desbloquea para poder editar
-  lock                              vuelve a bloquear (también al reiniciar el servicio)
+  lock                              vuelve a bloquear (también solo, a los 5 min sin
+                                    usarse, y al reiniciar el servicio)
 
 Arrancar y parar, según dónde corra:
   Linux (servicio)  systemctl --user {start,stop,restart} dotrino-vault
@@ -1250,6 +1545,7 @@ export async function runCtl (argv) {
     case 'lock': return cmdLock()
     case 'status': return cmdStatus()
     case 'pair': return cmdPair(rest)
+    case 'join': return cmdJoin(rest)
     case 'pending': return cmdPending()
     case 'approve': return cmdApprove(rest[0])
     case 'reject': return cmdReject(rest[0])
@@ -1261,6 +1557,7 @@ export async function runCtl (argv) {
     case 'revoke': return cmdRevoke(rest[0])
     case 'secret': return cmdSecret(rest)
     case 'approval': return cmdApproval(rest)
+    case 'atrest': return cmdAtrest(rest)
     case 'activity': return cmdActivity(Number(rest[0]) || 30)
     case 'logs': return cmdLogs()
     case 'version':