@dotrino/vaultd 0.139.1 → 0.141.0

package/src/tui/app.js

@@ -36,6 +36,7 @@ import { createTerm, widthOf } from './term.js'
 import { qrToString } from '../qr.js'
 import { dict, otherLang, loadLang, saveLang } from './i18n.js'
 import * as vc from '../vaultControl.js'
+import * as hw from '../hwkeys.js'
 import { VERSION } from '../version.js'
 import { DEVICE_CAPS } from '@dotrino/identity/acta'
 
@@ -77,8 +78,17 @@ function humanErr (e, st) {
     JOIN_BUSY: t.errJoinBusy,
     APPROVE_FAILED: t.errWrongCode,
     MASTER_WITH_MEMBERS: t.errMasterWithMembers,
-    PROFILE_LOCKED: t.errProfileLocked
+    PROFILE_LOCKED: t.errProfileLocked,
+    NEEDS_SECURITY_KEY: t.errNeedsKey,
+    NEEDS_PASSWORD: t.errNeedsPassword,
+    MASTER_SEALED_ELSEWHERE: t.errMasterSealedElsewhere,
+    HWKEY_NO_DEVICE: t.hwNoDevice,
+    HWKEY_NOT_TOUCHED: t.hwNotTouched,
+    HWKEY_WRONG_KEY: t.hwWrongKey,
+    HWKEY_WRONG_PIN: t.hwWrongPin,
+    HWKEY_PIN_BLOCKED: t.hwPinBlocked
   }
+  if (e?.code === 'HWKEY_TOOLS_MISSING') return t.hwToolsMissing(e.tool, e.pkg)
   return byCode[e?.code] || e?.message || String(e)
 }
 
@@ -280,12 +290,49 @@ function profileRows (st, t) {
   const list = st.profiles?.profiles || []
   return list.map((p) => {
     const mark = p.current ? t.accent('●') : ' '
-    const lk = !p.protected ? t.muted(i.noPassword) : (p.locked ? t.warn(i.locked) : t.ok(i.unlocked))
+    const lk = !p.protected
+      ? t.muted(i.noPassword)
+      : `${p.locked ? t.warn(i.locked) : t.ok(i.unlocked)} ${t.muted('· ' + doorsSummary(i, p))}`
     const name = p.current ? t.bold(p.name || i.noName) : (p.name || i.noName)
     return { text: ` ${mark} ${name}   ${t.muted(p.id)}   ${t.muted(p.fingerprint || '—')}   ${lk}`, sel: true, meta: p }
   })
 }
 
+/** Una puerta dicha corta: «llave (toque) + contraseña». */
+function doorLabel (i, d) {
+  const base = d.kind === 'password' ? i.doorPassword : d.kind === 'fido2' ? i.doorTouch : d.kind === 'chalresp' ? i.doorNoTouch : d.kind
+  return d.withPassword ? base + i.doorPlusPassword : base
+}
+/** Con qué se abre un perfil: «contraseña o llave (toque)». */
+const doorsSummary = (i, p) => (p.doors || []).map((d) => doorLabel(i, d)).join(i.doorsOr) || i.doorPassword
+
+/**
+ * CON QUÉ SE ABRE LA BÓVEDA (`docs/llaves-de-hardware.md` §2bis). Las puertas que tiene y las
+ * que se le pueden añadir. La contraseña se sigue poniendo con `c` en Perfiles; aquí se ve y
+ * se puede quitar como cualquier otra puerta.
+ */
+function doorRows (st, t) {
+  const i = L(st)
+  const p = (st.profiles?.profiles || []).find((x) => x.id === st.doorsFor)
+  if (!p) return [{ text: t.muted(' —'), sel: false }]
+  const rows = [{ text: t.muted(' ' + i.doorsIntro(p.name || p.id)), sel: false }, { text: '', sel: false }]
+  if (!p.protected) rows.push({ text: ' ' + t.muted(i.doorsNone), sel: false })
+  for (const d of p.doors || []) {
+    const when = d.createdAt ? new Date(d.createdAt).toISOString().slice(0, 10) : ''
+    rows.push({ text: ` ${t.bold(doorLabel(i, d))}   ${t.muted(d.label || '')}   ${t.muted(when)}`, sel: true, meta: { door: d } })
+  }
+  rows.push({ text: '', sel: false })
+  for (const [add, label, hint] of [
+    ['touch', i.addTouchKey, i.addTouchKeyHint],
+    ['notouch', i.addNoTouchKey, i.addNoTouchKeyHint],
+    ['touchpwd', i.addKeyWithPassword, i.addKeyWithPasswordHint]
+  ]) {
+    rows.push({ text: ' ' + t.accent(label), sel: true, meta: { add } })
+    rows.push({ text: t.muted('     ' + hint), sel: false })
+  }
+  return rows
+}
+
 function deviceRows (st, t) {
   const i = L(st)
   const rows = []
@@ -957,7 +1004,7 @@ async function reunlockSilently (term, st, p, api = vc) {
  * que dura la sesión, no hasta que alguien reinicie el servicio. Lo que ya estaba abierto
  * antes de entrar no se toca — no lo abrió esta pantalla, no le toca cerrarlo.
  */
-async function ensureUnlocked (term, st, p, thenFn, reason = null, api = vc) {
+async function ensureUnlocked (term, st, p, thenFn, reason = null, api = vc, key = undefined) {
   if (!p.protected || !p.locked) return thenFn()
   // Cerrada, pero la contraseña ya se tecleó en esta sesión: se reabre sin molestar.
   if (await reunlockSilently(term, st, p, api)) {
@@ -965,8 +1012,34 @@ async function ensureUnlocked (term, st, p, thenFn, reason = null, api = vc) {
     return thenFn(fresh)
   }
   const i = L(st)
+  const fresh = () => (st.profiles?.profiles || []).find((x) => x.id === p.id) || p
+  const hasPassword = (p.doors || []).some((d) => d.kind === 'password')
+  // CON LA LLAVE DE SEGURIDAD, si la bóveda tiene una: se le pide antes que la contraseña.
+  // Una vez por intento (`key === undefined`); si no abre, se cae a la contraseña diciendo
+  // por qué, o se para si la bóveda no tiene contraseña.
+  const doors = hw.hardwareDoors(p)
+  if (key === undefined && doors.length) {
+    key = null
+    st.busy = i.lookingForKey
+    render(term, st)
+    try {
+      key = await hw.secretForDoors(doors, { onTouch: () => { st.busy = i.touchKey; render(term, st) } })
+    } catch (e) { reason = i.keyFailed(humanErr(e, st)) } finally { st.busy = null }
+    if (key && !key.withPassword) {
+      const r = await guard(term, st, i.unlocking, () => api.unlockProfile(p.id, null, { door: key.door, secret: Buffer.from(key.secret).toString('base64') }))
+      key.secret.fill(0)
+      if (r.ok) {
+        st.unlockedHere?.add(p.id)
+        await refreshProfiles(term, st, api)
+        return thenFn(fresh())
+      }
+      reason = humanErr(r.e, st)
+      key = null
+    }
+    if (!key && !hasPassword) { flash(st, reason || i.plugKey, 'danger'); render(term, st); return }
+  }
   setInput(st, {
-    label: i.passwordOf(p.name || p.id),
+    label: key ? i.passwordWithKey(p.name || p.id) : i.passwordOf(p.name || p.id),
     mask: true,
     // Si la anterior fue rechazada, el motivo se queda AQUÍ, pegado al campo, en vez de
     // irse en un aviso de cuatro segundos que se lleva el siguiente redibujado. Eso era lo
@@ -974,15 +1047,18 @@ async function ensureUnlocked (term, st, p, thenFn, reason = null, api = vc) {
     hint: reason || i.passwordToEdit,
     onSubmit: async (pwd) => {
       st.input = null
-      const r = await guard(term, st, i.unlocking, () => api.unlockProfile(p.id, pwd))
+      const extra = key ? { door: key.door, secret: Buffer.from(key.secret).toString('base64') } : null
+      const r = await guard(term, st, i.unlocking, () => api.unlockProfile(p.id, pwd, extra))
       // Rechazada: se vuelve a pedir en el acto, diciendo por qué. Cerrar el campo obligaba
       // a adivinar qué había pasado y a empezar de nuevo.
-      if (!r.ok) return ensureUnlocked(term, st, p, thenFn, humanErr(r.e, st), api)
+      if (!r.ok) return ensureUnlocked(term, st, p, thenFn, humanErr(r.e, st), api, key)
+      if (key) key.secret.fill(0)
       st.unlockedHere?.add(p.id)
-      st.sessionPwd?.set(p.id, pwd) // vale para toda la sesión (ver reunlockSilently)
+      // Solo la contraseña sola se recuerda para reabrir en silencio: la que va con llave
+      // necesita la llave otra vez, que es justo su gracia.
+      if (!key) st.sessionPwd?.set(p.id, pwd) // vale para toda la sesión (ver reunlockSilently)
       await refreshProfiles(term, st, api)
-      const fresh = (st.profiles.profiles || []).find((x) => x.id === p.id) || p
-      await thenFn(fresh)
+      await thenFn(fresh())
     },
     onCancel: () => { st.input = null }
   })
@@ -1098,7 +1174,7 @@ async function onKeyProfiles (term, st, key) {
       mask: true,
       onSubmit: async (pwd) => {
         st.input = null
-        if (pwd.length < 4) { flash(st, i.passwordTooShort, 'danger'); return }
+        if (pwd.length < 12) { flash(st, i.passwordTooShort, 'danger'); return }
         setInput(st, {
           label: i.repeatPassword,
           mask: true,
@@ -1115,8 +1191,15 @@ async function onKeyProfiles (term, st, key) {
       },
       onCancel: () => { st.input = null }
     }))
+  } else if (ch === 'y' && cur) { // las llaves: con qué se abre la bóveda
+    await ensureUnlocked(term, st, cur, async (p = cur) => {
+      st.doorsFor = p.id
+      st.sel.doors = 0
+      st.scroll.doors = { value: 0 }
+      st.screen = 'doors'
+    })
   } else if (ch === 'x' && cur) { // quitar contraseña
-    if (!cur.protected) { flash(st, i.noPasswordSet, 'warn'); return true }
+    if (!(cur.doors || []).some((d) => d.kind === 'password')) { flash(st, i.noPasswordSet, 'warn'); return true }
     await ensureUnlocked(term, st, cur, async (p = cur) => {
       const r = await guard(term, st, i.removingPassword, () => vc.removeProfilePassword(p.id, st.sessionPwd?.get(p.id)))
       if (r.ok) { st.sessionPwd?.delete(p.id); flash(st, i.passwordRemoved); await refreshProfiles(term, st) }
@@ -1461,6 +1544,113 @@ function choosePairCaps (st, { profile, service = null, label = null, after = nu
   return true
 }
 
+async function onKeyDoors (term, st, key) {
+  const i = L(st)
+  const rows = doorRows(st, term.t)
+  const sels = rows.filter((r) => r.sel).map((r) => r.meta)
+  moveSel(st, key, 'doors', sels.length)
+  const cur = sels[Math.min(st.sel.doors, sels.length - 1)]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+  const p = (st.profiles?.profiles || []).find((x) => x.id === st.doorsFor)
+  if (key.name === 'escape' || ch === 'b' || !p) { st.screen = 'profiles'; st.doorsFor = null; return true }
+
+  if ((key.name === 'delete' || ch === 'd') && cur?.door) {
+    const d = cur.door
+    const ultima = (p.doors || []).length <= 1
+    const what = d.label ? `${doorLabel(i, d)} · ${d.label}` : doorLabel(i, d)
+    setConfirm(st, {
+      text: ultima ? i.removeLastDoorConfirm(what) : i.removeDoorConfirm(what),
+      onYes: () => ensureUnlocked(term, st, p, async (q = p) => {
+        const r = await guard(term, st, i.removingDoor, () => vc.removeProfileDoor(q.id, d.kind === 'password' ? 'password' : d.id))
+        if (r.ok) {
+          if (d.kind === 'password') st.sessionPwd?.delete(q.id)
+          flash(st, i.doorRemoved)
+          st.sel.doors = 0
+          await refreshProfiles(term, st)
+        }
+      }),
+      onNo: () => { st.confirm = null }
+    })
+    return true
+  }
+  if (key.name === 'enter' && cur?.add) await ensureUnlocked(term, st, p, (q = p) => addKeyDoor(term, st, q, cur.add))
+  return true
+}
+
+/**
+ * Da de alta la llave como puerta, avisando en la barra de estado de cada toque ANTES de que
+ * la llave parpadee: si no se ve a tiempo, la llave rechaza la operación al medio minuto.
+ */
+async function addKeyDoor (term, st, p, mode) {
+  const i = L(st)
+  const busy = (msg) => { st.busy = msg; render(term, st) }
+  const fail = (e) => { st.busy = null; flash(st, i.keyFailed(humanErr(e, st)), 'danger') }
+  const send = async (spec) => {
+    const r = await guard(term, st, i.savingDoor, () => vc.addProfileDoor(p.id, { ...spec, secret: Buffer.from(spec.secret).toString('base64') }))
+    spec.secret.fill(0)
+    if (r.ok) { flash(st, spec.kind === 'chalresp' ? i.doorAddedNoTouch : i.doorAdded); await refreshProfiles(term, st) }
+  }
+  // Llave + contraseña: se pide dos veces, y con el mínimo dicho antes de mandar nada.
+  const withPassword = (spec) => setInput(st, {
+    label: i.keyPasswordLabel,
+    hint: i.keyPasswordHint,
+    mask: true,
+    onSubmit: (pwd) => {
+      st.input = null
+      if (pwd.length < 12) { spec.secret.fill(0); flash(st, i.passwordTooShort, 'danger'); return }
+      setInput(st, {
+        label: i.repeatPassword,
+        mask: true,
+        onSubmit: async (again) => {
+          st.input = null
+          if (again !== pwd) { spec.secret.fill(0); flash(st, i.passwordMismatch, 'danger'); return }
+          await send({ ...spec, password: pwd })
+        },
+        onCancel: () => { st.input = null; spec.secret.fill(0) }
+      })
+    },
+    onCancel: () => { st.input = null; spec.secret.fill(0) }
+  })
+
+  if (mode === 'notouch') {
+    let serial
+    try {
+      busy(i.lookingForKey)
+      serial = await hw.ykSerial()
+      if (!serial) throw Object.assign(new Error('no key'), { code: 'HWKEY_NO_DEVICE' })
+      const ocupada = await hw.ykSlot2Busy()
+      st.busy = null
+      const programar = async (overwrite) => {
+        try {
+          busy(i.programmingSlot)
+          await hw.ykProgramSlot2({ overwrite })
+          const challenge = hw.newChallenge()
+          const secret = await hw.ykChallenge({ challenge })
+          st.busy = null
+          await send({ kind: 'chalresp', challenge, serial, secret, label: `YubiKey ${serial}` })
+        } catch (e) { fail(e) }
+      }
+      // Sobrescribir la ranura borra lo que tenga: eso lo decide la persona, aquí y en voz alta.
+      if (ocupada) { setConfirm(st, { text: i.slotBusyConfirm(serial), onYes: () => programar(true), onNo: () => { st.confirm = null } }); return }
+      await programar(false)
+    } catch (e) { fail(e) }
+    return
+  }
+
+  let spec
+  try {
+    busy(i.touchKeyStep(1))
+    const { credId, device } = await hw.fido2MakeCredential({ label: 'dotrino-vault' })
+    const hsalt = hw.newHsalt()
+    busy(i.touchKeyStep(2))
+    const secret = await hw.fido2Secret({ credId, hsalt })
+    st.busy = null
+    spec = { kind: 'fido2', credId, hsalt, secret, label: device || 'YubiKey' }
+  } catch (e) { return fail(e) }
+  if (mode === 'touchpwd') return withPassword(spec)
+  await send(spec)
+}
+
 async function onKeyPairMode (term, st, key) {
   const i = L(st)
   const rows = pairModeRows(st, term.t)
@@ -2090,6 +2280,7 @@ const helpSegs = (i, screen, st = {}) => {
     logins: i.helpLogins,
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
+    doors: i.helpDoors,
     paircaps: i.helpPairCaps,
     join: i.helpJoin,
     me: i.helpMe,
@@ -2121,6 +2312,7 @@ const title = (i, screen) => ({
   profiles: i.titleProfiles,
   pairing: i.titlePairing,
   pairmode: i.titlePairMode,
+  doors: i.titleDoors,
   paircaps: i.titlePairCaps,
   join: i.titleJoin,
   caps: i.titleCaps,
@@ -2240,6 +2432,7 @@ function render (term, st) {
   else if (st.screen === 'caps') body = renderList(capsRows(st, t), st.sel.caps || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'devvars') body = renderList(devVarRows(st, t), st.sel.devvars || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairmode') body = renderList(pairModeRows(st, t), st.sel.pairmode, contentH, cols, t, scrollRef)
+  else if (st.screen === 'doors') body = renderList(doorRows(st, t), st.sel.doors || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'paircaps') body = renderList(pairCapsRows(st, t), st.sel.paircaps || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
@@ -2323,7 +2516,7 @@ export async function runTui () {
   const st = {
     screen: 'profiles', // se arranca en la lista de bóvedas: hay que ENTRAR a una
     lang: loadLang(), // es/en — se conmuta con `l` y se recuerda en prefs.json
-    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, paircaps: 0, devvars: 0, logins: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, paircaps: 0, devvars: 0, logins: 0, doors: 0 },
     // Permisos tocados y sin guardar, por llave del aparato (ver `setCapsDraft`).
     capsDrafts: {},
     // Las bóvedas que ha abierto ESTA sesión, para volver a cerrarlas al salir.
@@ -2428,6 +2621,7 @@ export async function runTui () {
       else if (st.screen === 'caps') running = await onKeyCaps(term, st, key)
       else if (st.screen === 'devvars') running = await onKeyDevVars(term, st, key)
       else if (st.screen === 'pairmode') running = await onKeyPairMode(term, st, key)
+      else if (st.screen === 'doors') running = await onKeyDoors(term, st, key)
       else if (st.screen === 'paircaps') running = await onKeyPairCaps(term, st, key)
       else if (st.screen === 'pairing') running = await onKeyPairing(term, st, key)
       else if (st.screen === 'join') running = await onKeyJoin(term, st, key)
@@ -2445,4 +2639,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, pairCapsRows, onKeyPairCaps, onKeyDevices, draftChanges, saveCapsDrafts, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, doorRows, onKeyDoors, pairCapsRows, onKeyPairCaps, onKeyDevices, draftChanges, saveCapsDrafts, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -167,15 +167,55 @@ const es = {
   titleProfiles: 'Bóvedas',
   titlePairing: 'Emparejar un dispositivo',
   titlePairMode: 'Emparejar: ¿a qué cuenta entra?',
+  titleDoors: 'Con qué se abre la bóveda',
+  doorsIntro: (name) => `Con qué se abre «${name}». Abre cualquiera de estas.`,
+  doorsNone: 'Sin candado: se abre sola en esta máquina.',
+  doorPassword: 'contraseña',
+  doorTouch: 'llave (toque)',
+  doorNoTouch: 'llave (sin toque)',
+  doorPlusPassword: ' + contraseña',
+  doorsOr: ' o ',
+  addTouchKey: '+ Llave de seguridad con toque',
+  addTouchKeyHint: 'Para abrir hay que tocarla. Es la recomendada.',
+  addNoTouchKey: '+ Llave de seguridad sin toque',
+  addNoTouchKeyHint: 'Basta con que esté enchufada: cualquier programa de esta máquina puede usarla. Usa la ranura 2 de la YubiKey.',
+  addKeyWithPassword: '+ Llave con toque y contraseña',
+  addKeyWithPasswordHint: 'Hacen falta las dos para abrir.',
+  touchKeyStep: (n) => `Toca la llave de seguridad (${n} de 2)…`,
+  programmingSlot: 'Programando la ranura 2 de la llave…',
+  slotBusyConfirm: (serial) => `La ranura 2 de la YubiKey ${serial} ya está programada. ¿Sobrescribirla? Se BORRA lo que tenga.`,
+  keyPasswordLabel: 'Contraseña para esta llave',
+  keyPasswordHint: 'esta llave abrirá solo junto con esta contraseña (mínimo 12 caracteres)',
+  savingDoor: 'Guardando la llave…',
+  doorAdded: 'Llave añadida. Deja otra forma de abrir de repuesto: perder la única es perder la bóveda.',
+  doorAddedNoTouch: 'Llave sin toque añadida. Desenchúfala cuando no la uses. Deja otra forma de abrir de repuesto.',
+  removeDoorConfirm: (what) => `¿Quitar «${what}» como forma de abrir?`,
+  removeLastDoorConfirm: (what) => `¿Quitar «${what}»? Es la última: la bóveda quedará sin candado.`,
+  removingDoor: 'Quitando…',
+  doorRemoved: 'Quitada',
   titleJoin: 'Entrar en la cuenta de otra bóveda',
 
   // bóvedas (perfiles)
-  noPassword: 'sin clave',
+  noPassword: 'sin candado',
   noPasswordWarn: 'Este perfil no tiene contraseña: una copia de este disco abre las variables privadas.',
   pendingSeal: (owner, kind, who) => kind === 'rotate' ? `${owner}: sin rotar (salió un aparato). Guarda una variable con la contraseña.` : `${owner}: sin llave todavía en ${who}. Se reparte sola con otro aparato del grupo encendido, o al abrir la bóveda.`,
   locked: '🔒 bloqueada',
   unlocked: '🔓 abierta',
   passwordOf: (name) => `Contraseña de "${name}"`,
+  passwordWithKey: (name) => `Contraseña de "${name}" (su llave la pide también)`,
+  lookingForKey: 'Buscando la llave de seguridad…',
+  touchKey: 'Toca la llave de seguridad…',
+  keyFailed: (why) => `La llave no abrió: ${why}`,
+  plugKey: 'Esta bóveda se abre con su llave de seguridad: enchúfala y vuelve a intentarlo',
+  errNeedsKey: 'Esta bóveda no se abre solo con contraseña: usa su llave de seguridad',
+  errNeedsPassword: 'Esta llave pide también la contraseña',
+  errMasterSealedElsewhere: 'La llave maestra quedó cerrada con una contraseña anterior: pon esa misma para recuperarla',
+  hwToolsMissing: (tool, pkg) => `falta ${tool} (instala ${pkg})`,
+  hwNoDevice: 'no hay ninguna llave enchufada',
+  hwNotTouched: 'no se tocó la llave a tiempo',
+  hwWrongKey: 'esta llave no es la de esta bóveda',
+  hwWrongPin: 'el PIN de la llave no es ese',
+  hwPinBlocked: 'el PIN de la llave está bloqueado',
   passwordToEdit: 'necesaria para abrir la bóveda: sin ella no se ve ni se toca',
   unlocking: 'Desbloqueando…',
   loading: 'Cargando…',
@@ -365,7 +405,7 @@ const es = {
   // INGLÉS: new/rename/delete/password/unlock/locK/pair/approve/revoke/refresh/
   // language/quit); lo único que se traduce es la palabra que las explica.
   // Segmentos, no una línea: si no caben en una, el render los reparte en varias.
-  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'j unirse', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
+  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'j unirse', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'y llaves', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
   // La barra dice lo que se PUEDE hacer AHORA, no todo lo que existe: aprobar/rechazar solo
   // valen si hay alguien esperando, y renombrar/revocar solo si hay un aparato seleccionado.
   // Anunciar teclas muertas confunde y además las quema para otros usos.
@@ -402,6 +442,7 @@ const es = {
   revealNoPwd: 'Este perfil no tiene contraseña: se abre con la llave de esta máquina.',
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', '↑↓ scroll', 'Esc atrás', 'l English'],
   helpPairMode: ['↑↓', 'Enter elegir', 'Esc atrás', 'l English', 'q salir'],
+  helpDoors: ['↑↓', 'Enter añadir', 'd quitar', 'Esc atrás', 'l English', 'q salir'],
   helpJoin: ['Esc bóvedas', 'l English', 'q salir'],
 
   // pantalla "daemon caído"
@@ -570,14 +611,54 @@ const en = {
   titleProfiles: 'Vaults',
   titlePairing: 'Pair a device',
   titlePairMode: 'Pairing: which account does it join?',
+  titleDoors: 'What opens this vault',
+  doorsIntro: (name) => `What opens “${name}”. Any of these opens it.`,
+  doorsNone: 'No lock: it opens by itself on this machine.',
+  doorPassword: 'password',
+  doorTouch: 'key (touch)',
+  doorNoTouch: 'key (no touch)',
+  doorPlusPassword: ' + password',
+  doorsOr: ' or ',
+  addTouchKey: '+ Security key with touch',
+  addTouchKeyHint: 'You have to touch it to open. The recommended one.',
+  addNoTouchKey: '+ Security key without touch',
+  addNoTouchKeyHint: 'Being plugged in is enough: any program on this machine can use it. Uses slot 2 of the YubiKey.',
+  addKeyWithPassword: '+ Key with touch and password',
+  addKeyWithPasswordHint: 'Both are needed to open.',
+  touchKeyStep: (n) => `Touch the security key (${n} of 2)…`,
+  programmingSlot: 'Programming slot 2 of the key…',
+  slotBusyConfirm: (serial) => `Slot 2 of YubiKey ${serial} is already programmed. Overwrite it? What it holds is ERASED.`,
+  keyPasswordLabel: 'Password for this key',
+  keyPasswordHint: 'this key will open only together with this password (at least 12 characters)',
+  savingDoor: 'Saving the key…',
+  doorAdded: 'Key added. Keep a spare way in: losing the only one means losing the vault.',
+  doorAddedNoTouch: 'No-touch key added. Unplug it when not in use. Keep a spare way in.',
+  removeDoorConfirm: (what) => `Remove “${what}” as a way in?`,
+  removeLastDoorConfirm: (what) => `Remove “${what}”? It is the last one: the vault will be left without a lock.`,
+  removingDoor: 'Removing…',
+  doorRemoved: 'Removed',
   titleJoin: 'Join the account of another vault',
 
-  noPassword: 'no password',
+  noPassword: 'no lock',
   noPasswordWarn: 'This profile has no password: a copy of this disk opens the private variables.',
   pendingSeal: (owner, kind, who) => kind === 'rotate' ? `${owner}: not rotated (a device left). Save a variable with the password.` : `${owner}: no key yet on ${who}. It is handed out by another device of the group that is on, or when the vault is opened.`,
   locked: '🔒 locked',
   unlocked: '🔓 unlocked',
   passwordOf: (name) => `Password for "${name}"`,
+  passwordWithKey: (name) => `Password for "${name}" (its key asks for it too)`,
+  lookingForKey: 'Looking for the security key…',
+  touchKey: 'Touch the security key…',
+  keyFailed: (why) => `The key did not open it: ${why}`,
+  plugKey: 'This vault opens with its security key: plug it in and try again',
+  errNeedsKey: 'This vault does not open with a password alone: use its security key',
+  errNeedsPassword: 'This key also needs the password',
+  errMasterSealedElsewhere: 'The master key was left sealed with an earlier password: set that same one to recover it',
+  hwToolsMissing: (tool, pkg) => `${tool} is missing (install ${pkg})`,
+  hwNoDevice: 'no key is plugged in',
+  hwNotTouched: 'the key was not touched in time',
+  hwWrongKey: 'this key is not the one for this vault',
+  hwWrongPin: 'wrong key PIN',
+  hwPinBlocked: 'the key PIN is blocked',
   passwordToEdit: 'needed to open this vault: without it, nothing is shown or touched',
   unlocking: 'Unlocking…',
   loading: 'Loading…',
@@ -745,7 +826,7 @@ const en = {
   helpInput: 'Enter confirm · Esc cancel · Ctrl-U clear',
   helpConfirm: 'y confirm · n/Esc cancel',
 
-  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'u unlock', 'k lock', 'l Español', 'q quit'],
+  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'y keys', 'u unlock', 'k lock', 'l Español', 'q quit'],
   helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
     '←→ tab', '↑↓', 'p pair',
     ...(drafts ? ['g save permissions'] : []),
@@ -776,6 +857,7 @@ const en = {
   revealNoPwd: 'This profile has no password: it opens with this machine key.',
   helpPairing: ['a approve', 'x reject', 'r restart', '↑↓ scroll', 'Esc back', 'l Español'],
   helpPairMode: ['↑↓', 'Enter choose', 'Esc back', 'l Español', 'q quit'],
+  helpDoors: ['↑↓', 'Enter add', 'd remove', 'Esc back', 'l Español', 'q quit'],
   helpJoin: ['Esc vaults', 'l Español', 'q quit'],
 
   downTitle: 'The vault daemon is not running.',

package/src/vaultControl.js

@@ -207,12 +207,12 @@ async function waitFor (name, { tries = 60, interval = 100, req = null, since =
  * OPERANDO (para use/rm/rename) como el DESTINO (para unlock/lock/password). La
  * contraseña viaja en un archivo 0600 que el daemon borra al leerlo.
  */
-async function profileOp (op, { profile, name, password } = {}) {
+async function profileOp (op, { profile, ...fields } = {}) {
   requireAlive() // nunca escribir la contraseña si no hay quien la consuma
   rm(F.profilesList)
-  const extra = {}
-  if (name != null) extra.name = name
-  if (password != null) extra.password = password
+  // TODO lo que se pase viaja, no una lista fija: con la lista fija se perdían en silencio
+  // `current` (cambiar la contraseña) y `door`/`secret` (abrir con la llave de seguridad).
+  const extra = Object.fromEntries(Object.entries(fields).filter(([, v]) => v != null))
   const since = Date.now()
   const id = await writeReq(F.profileReq, { op, ...extra }, profile)
   signalOrCleanup('SIGUSR2', [F.profileReq])
@@ -229,7 +229,8 @@ export const addProfile = (name) => profileOp('add', { name })
 export const useProfile = (profile) => profileOp('use', { profile })
 export const renameProfile = (profile, name) => profileOp('rename', { profile, name })
 export const removeProfile = (profile) => profileOp('rm', { profile })
-export const unlockProfile = (profile, password) => profileOp('unlock', { profile, password })
+// `key`: lo que devolvió la llave de seguridad para una puerta, `{ door, secret }` (base64).
+export const unlockProfile = (profile, password, key = null) => profileOp('unlock', { profile, password, ...(key ? { door: key.door, secret: key.secret } : {}) })
 export const lockProfile = (profile) => profileOp('lock', { profile })
 /**
  * «Sigo aquí»: estira el plazo del bloqueo automático sin hacer nada más.
@@ -246,6 +247,10 @@ export const touchProfile = (profile) => profileOp('touch', { profile })
 export const setProfilePassword = (profile, password, current) => profileOp('password-set', { profile, password, ...(current ? { current } : {}) })
 // Quitarla también la pide: se re-sella a la llave de la máquina antes de que se vaya.
 export const removeProfilePassword = (profile, password) => profileOp('password-rm', { profile, password })
+// LLAVES DE SEGURIDAD: `spec` lleva lo que devolvió la llave (`secret` en base64), nunca nada
+// que la abra sin ella. `door` es el id de la puerta, o 'password' para la contraseña.
+export const addProfileDoor = (profile, spec) => profileOp('door-add', { profile, spec })
+export const removeProfileDoor = (profile, door) => profileOp('door-rm', { profile, door })
 
 // ---------------------------------------------------------------------------
 // Inicios de sesión con contraseña (`docs/temporary-access.md`)