@dotrino/vaultd 0.53.0 → 0.58.0

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()
@@ -67,6 +68,20 @@ const writeReq = (name, obj) => {
 }
 
 const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
+const D = '\x1b[2m' // apagado: para el dato que acompaña sin competir con el nombre
+
+/**
+ * La fecha en que entró un aparato, corta y en local. Sin hora: lo que se busca al mirar
+ * esta lista es «¿de cuándo es este?», no el minuto exacto — y una fecha larga en cada
+ * línea convierte la lista en un muro.
+ *
+ * En español, como el resto de esta CLI: con el idioma del sistema salía «Jul 29, 2026»
+ * en medio de una frase en español, que es peor que cualquiera de los dos por separado.
+ */
+function fechaCorta (ms) {
+  try { return new Date(ms).toLocaleDateString('es', { year: 'numeric', month: 'short', day: 'numeric' }) }
+  catch (_) { return '' }
+}
 // La versión se inyecta en build (esbuild --define); en dev cae a 'dev'.
 
 /**
@@ -190,6 +205,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 +242,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 +262,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 +277,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 +319,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 +364,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()
@@ -387,7 +519,14 @@ async function cmdMembers () {
   assertOpen(record)
   if (!record.members?.length) { console.log('Este perfil todavía no tiene acta.'); return }
 
-  const CAP = { sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves', admin: `${B}administra el perfil${Z}`, approve: `${B}aprueba pedidos${Z}` }
+  // `sealer` y `passwords` faltaban y salían crudos, en inglés, entre los demás en
+  // español. Se resaltan como `admin` y `approve`: los cuatro cambian lo que ese aparato
+  // puede hacerle a la cuenta, y eso se lee de un vistazo o no se lee.
+  const CAP = {
+    sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves',
+    admin: `${B}administra el perfil${Z}`, approve: `${B}aprueba pedidos${Z}`,
+    sealer: `${B}sella el acta${Z}`, passwords: `${B}pide contraseñas${Z}`
+  }
   // El nombre del perfil es una pubkey JWK. Recortarla no la hace legible: la deja
   // pareciendo un error (`{"key_ops":["verify"],"e…`). Se muestra su huella corta, la
   // misma que se enseña al emparejar y en la lista de miembros.
@@ -401,13 +540,19 @@ async function cmdMembers () {
       m.cn ? `servicio «${m.cn}»` : null
     ].filter(Boolean)
     const caps = m.caps.length ? m.caps.map((c) => CAP[c] || c).join(', ') : '(sin permisos)'
-    console.log('  %s  %s%s\n      %s', m.id, who, marks.length ? '  [' + marks.join(' · ') + ']' : '', caps)
+    // CUÁNDO ENTRÓ. El nombre lo pone el propio aparato al emparejarse y muchas veces no
+    // distingue nada —dos teléfonos con el mismo apodo, o «cli» a secas—, así que la fecha
+    // es lo que deja reconocer cuál es cuál y ver si hay uno que no recuerdas haber
+    // conectado. El acta ya la guardaba (`addedAt`); solo no se enseñaba.
+    console.log('  %s  %s%s%s\n      %s', m.id, who,
+      m.addedAt ? `  ${D}· conectado el ${fechaCorta(m.addedAt)}${Z}` : '',
+      marks.length ? '  [' + marks.join(' · ') + ']' : '', caps)
     // Un servicio SIN llave de cifrado no puede leer ninguna variable privada: van
     // selladas a esa llave. Se dice aquí, junto a él, porque es el único sitio donde
     // 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 +615,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 +742,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 +1316,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 +1334,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
     }
@@ -1172,11 +1461,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
@@ -1209,6 +1506,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
@@ -1217,7 +1522,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
@@ -1225,6 +1537,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)
@@ -1256,6 +1572,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])
@@ -1267,6 +1584,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':