@dotrino/vaultd 0.119.0 → 0.122.0

package/src/ctl.js

@@ -13,6 +13,7 @@
  *   reject <id>       rechaza un dispositivo pendiente
  *   devices           lista dispositivos enrolados / revocados
  *   revoke <nonce>    revoca un dispositivo (y le ordena autoborrarse)
+ *   logins …          aparatos que se abren con usuario y contraseña (equipo prestado)
  *   profile …         perfiles (varias identidades en el mismo PC) y su contraseña
  *   unlock / lock     candado del perfil (la contraseña solo hace falta para EDITAR)
  *   logs              últimos logs del servicio
@@ -1479,6 +1480,199 @@ async function profileRequest (op, extra = {}) {
   console.error('El daemon no respondió.'); process.exit(1)
 }
 
+// ---------------------------------------------------------------------------
+// ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`)
+//
+// LA CONTRASEÑA NO SALE DE ESTA TERMINAL. Aquí se hace la mitad del cliente de OPAQUE, se
+// generan las llaves del aparato y se cierran con la llave que sale de la contraseña; al
+// daemon solo le llegan mensajes del protocolo y un paquete que no puede abrir. Por eso el
+// alta va en dos viajes y cambiar la contraseña en cuatro, y no en uno: si el daemon
+// hiciera la parte del cliente, la contraseña tendría que cruzar hasta él.
+// ---------------------------------------------------------------------------
+
+const loginsFile = path.join(dir, 'logins-list.json')
+let loginsSeq = 0
+
+/**
+ * Un viaje al daemon. La respuesta lleva el `id` de la petición, para no quedarse con la
+ * del intento anterior, y se BORRA al leerla: puede traer el paquete de llaves del aparato.
+ */
+async function loginsRequest (op, extra = {}) {
+  const s = requireDaemon()
+  try { fs.rmSync(loginsFile, { force: true }) } catch (_) {}
+  const id = `${process.pid}-${++loginsSeq}`
+  writeReq('logins-request.json', { op, id, ...extra })
+  sendSignal(s.pid, 'SIGUSR2')
+  for (let i = 0; i < 100; i++) {
+    await sleep(100)
+    const d = ipcRead(loginsFile, null)
+    if (!d?.at || (d.req && d.req !== id)) continue
+    try { fs.rmSync(loginsFile, { force: true }) } catch (_) {}
+    if (d.ok === false) {
+      if (d.code === 'PROFILE_LOCKED') { console.error('Perfil bloqueado. Ábrelo con:  dotrino-vault unlock'); process.exit(1) }
+      // `too-many-tries` trae cuánto falta: es el único dato que cambia lo que se hace.
+      if (d.code === 'too-many-tries') console.error('Demasiados intentos. Espera %d s, o quita la espera con:  dotrino-vault logins unblock <usuario>', Math.ceil((d.waitMs || 0) / 1000))
+      else console.error('%s', d.error)
+      process.exit(1)
+    }
+    return d
+  }
+  console.error('El daemon no respondió.'); process.exit(1)
+}
+
+/**
+ * Pide la contraseña dos veces y comprueba que coinciden.
+ *
+ * El mínimo no es una manía: quien tenga una COPIA DEL DISCO de la bóveda puede probar
+ * contraseñas contra el registro de OPAQUE sin límite y sin que nadie se entere
+ * (`temporary-access.md` §4). Contra eso lo único que aguanta es la contraseña.
+ */
+const MIN_PASSWORD = 12
+async function askNewPassword (user) {
+  const pw = await askPassword(`Contraseña para ${user} (mínimo ${MIN_PASSWORD} caracteres): `)
+  if (pw.length < MIN_PASSWORD) {
+    console.error('Demasiado corta. Con una copia del disco de esta bóveda se pueden probar contraseñas sin límite, así que lo único que aguanta es su largo.')
+    process.exit(2)
+  }
+  if (await askPassword('Repítela: ') !== pw) { console.error('No coinciden.'); process.exit(2) }
+  return pw
+}
+
+/**
+ * Entrar de verdad, desde aquí: es la única forma de conseguir la llave que abre el paquete.
+ *
+ * Con la contraseña equivocada quien se entera es ESTA punta, al recibir la respuesta —así
+ * funciona OPAQUE, y por eso los intentos se cuentan al empezar—. Se dice y se para: sin la
+ * contraseña vieja no hay nada que volver a cerrar.
+ */
+async function loginHere (opaqueClient, user, password) {
+  const start = opaqueClient.loginStart({ password })
+  const begun = await loginsRequest('login-begin', { user, request: start.request })
+  let fin
+  try { fin = opaqueClient.loginFinish({ state: start.state, response: begun.response, password }) }
+  catch (e) { console.error('Contraseña incorrecta (o ese usuario no existe).'); process.exit(1) }
+  const done = await loginsRequest('login-end', { lid: begun.lid, finalization: fin.finalization, label: 'consola' })
+  return { ...done, exportKey: fin.exportKey }
+}
+
+const LOGINS_USAGE = `uso: dotrino-vault logins <orden>
+
+  logins [ls]                 los aparatos que se abren con usuario y contraseña
+  logins add <usuario> [nombre del equipo]
+  logins passwd <usuario>     cambia la contraseña (cierra lo que estuviera abierto)
+  logins close <usuario> [sid]  cierra una sesión abierta (sin sid, todas)
+  logins unblock <usuario>    quita la espera de los intentos fallidos
+  logins rm <usuario>         lo quita y saca su llave del acta`
+
+async function cmdLogins (rest) {
+  const [sub, ...args] = rest
+  const user = args[0]
+  const needUser = () => { if (!user) { console.error(LOGINS_USAGE); process.exit(2) } return user }
+
+  switch (sub || 'ls') {
+    case 'ls': {
+      const { logins, fingerprint } = await loginsRequest('list')
+      if (!logins.length) {
+        console.log('No hay ningún inicio de sesión con contraseña.')
+        console.log('Crea uno con:  dotrino-vault logins add <usuario>')
+        return
+      }
+      const { loginAddress } = await import('../lib/src/passwordLogins.js')
+      console.log('Inicios de sesión con contraseña: %d', logins.length)
+      for (const l of logins) {
+        const espera = l.blockedUntil > Date.now() ? `  ${R}espera ${Math.ceil((l.blockedUntil - Date.now()) / 1000)} s${Z}` : ''
+        console.log('  · %s%s%s  %s%s  creado %s%s', B, loginAddress(l.user, fingerprint), Z, l.deviceId || '????-????',
+          l.label ? '  «' + l.label + '»' : '', fechaCorta(l.createdAt), espera)
+        for (const s of l.sessions || []) {
+          console.log('      %sabierto%s %s  %s  usado %s', D, Z, s.sid.slice(0, 8), s.label || '(sin nombre)', fechaCorta(s.lastUsedAt))
+        }
+      }
+      console.log('\nCerrar una sesión:  dotrino-vault logins close <usuario> [sid]')
+      return
+    }
+    case 'add': {
+      needUser()
+      const label = args.slice(1).join(' ').trim() || 'equipo prestado'
+      const { client: opaqueClient } = await import('@dotrino/opaque')
+      const { makeDeviceKey, makeDeviceEncKey } = await import('@dotrino/identity/capabilities')
+      const { sealDeviceKeys } = await import('../lib/src/passwordLogins.js')
+      const password = await askNewPassword(user)
+
+      const start = opaqueClient.registrationStart({ password })
+      const begun = await loginsRequest('register-begin', { user, request: start.request })
+      // La bóveda contesta con su mitad; el registro se termina AQUÍ, con la contraseña.
+      const fin = opaqueClient.registrationFinish({ state: start.state, response: begun.response, password })
+      // Las llaves del aparato NACEN en esta terminal y salen de aquí ya cerradas.
+      const device = await makeDeviceKey({ label })
+      const enc = await makeDeviceEncKey()
+      const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.privateJwk })
+      const r = await loginsRequest('register-finish', {
+        user, upload: fin.upload, pub: device.publickey, encPub: enc.publickey, label, blob
+      })
+      const { loginAddress } = await import('../lib/src/passwordLogins.js')
+      console.log('\nListo. Se entra con esta dirección y esa contraseña:')
+      console.log('  %s%s%s', B, loginAddress(user, r.fingerprint), Z)
+      console.log('  aparato : %s  «%s»', r.deviceId, label)
+      console.log('  permisos: %s', (r.caps || []).join(', ') || '(ninguno)')
+      console.log('\nLa dirección no es secreta: dice DÓNDE está tu cuenta, no quién eres.')
+      return
+    }
+    // CAMBIAR LA CONTRASEÑA ES ABRIR Y VOLVER A CERRAR. El aparato, su llave y su
+    // certificado siguen siendo los mismos: lo único que cambia es con qué se abre el
+    // paquete. Por eso hace falta la vieja — sin ella no hay nada que volver a cerrar.
+    case 'passwd': {
+      needUser()
+      const { client: opaqueClient } = await import('@dotrino/opaque')
+      const { sealDeviceKeys, openDeviceKeys } = await import('../lib/src/passwordLogins.js')
+      const old = await askPassword(`Contraseña ACTUAL de ${user}: `)
+      const entered = await loginHere(opaqueClient, user, old)
+      const keys = await openDeviceKeys(entered.exportKey, entered.blob)
+
+      const password = await askNewPassword(user)
+      const start = opaqueClient.registrationStart({ password })
+      const begun = await loginsRequest('register-begin', { user, request: start.request, replace: true })
+      const fin = opaqueClient.registrationFinish({ state: start.state, response: begun.response, password })
+      await loginsRequest('register-finish', {
+        user, upload: fin.upload, blob: await sealDeviceKeys(fin.exportKey, keys), replace: true
+      })
+      console.log('Listo: %s entra con la contraseña nueva, y lo que estuviera abierto se cerró.', user)
+      return
+    }
+    case 'close': {
+      needUser()
+      const sid = args[1]
+      if (sid) {
+        const r = await loginsRequest('close', { user, sid })
+        console.log(r.ok ? `Sesión cerrada: ${sid}` : 'Esa sesión ya no estaba abierta.')
+        return
+      }
+      const { logins } = await loginsRequest('list')
+      const fila = logins.find((x) => x.user === user)
+      if (!fila) { console.error('No hay ningún inicio de sesión con ese usuario. Míralos con: dotrino-vault logins'); process.exit(1) }
+      const abiertas = fila.sessions || []
+      if (!abiertas.length) { console.log('No tiene ninguna sesión abierta.'); return }
+      for (const s of abiertas) await loginsRequest('close', { user, sid: s.sid })
+      console.log('Cerradas %d sesión(es) de %s. Para entrar otra vez hace falta la contraseña.', abiertas.length, user)
+      return
+    }
+    case 'unblock': {
+      needUser()
+      await loginsRequest('unblock', { user })
+      console.log('Listo: %s puede volver a intentarlo. La contraseña no cambió.', user)
+      return
+    }
+    case 'rm': {
+      needUser()
+      const r = await loginsRequest('rm', { user })
+      if (!r.ok) { console.error('No hay ningún inicio de sesión con ese usuario. Míralos con: dotrino-vault logins'); process.exit(1) }
+      console.log('Quitado %s (aparato %s). Su llave sale del acta y se autoborrará al reconectar.', user, r.deviceId || '????-????')
+      return
+    }
+    default:
+      console.error(LOGINS_USAGE); process.exit(2)
+  }
+}
+
 function reportProfiles (d) {
   if (d.error) {
     // Los dos rechazos del candado se dicen con palabras y con el dato que hace falta; el
@@ -1728,6 +1922,15 @@ function help () {
                       +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)
+  logins              los aparatos que se abren con usuario y contraseña (para un equipo
+                      prestado, donde no puedes emparejar nada)
+  logins add <usuario> [nombre del equipo]
+                      crea uno. La contraseña se teclea aquí y no sale de esta terminal:
+                      la bóveda guarda un paquete de llaves que solo ella abre
+  logins passwd <usuario>       cambia la contraseña (cierra lo que estuviera abierto)
+  logins close <usuario> [sid]  cierra una sesión abierta (sin sid, todas)
+  logins unblock <usuario>      quita la espera de los intentos fallidos
+  logins rm <usuario>           lo quita y saca su llave del acta
   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
@@ -1863,6 +2066,7 @@ export async function runCtl (argv) {
     case 'label': return cmdLabel(rest)
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])
+    case 'logins': return cmdLogins(rest)
     case 'secret': return cmdSecret(rest)
     // `approval` se quitó el 2026-09-01 (ahora es el permiso `unattended`), pero la ruta se
     // quedó apuntando a una función que ya no existía: reventaba con un ReferenceError. Se

package/src/daemon.js

@@ -324,6 +324,12 @@ export async function runDaemon () {
   let lastSecretValue = null
   /** Y las versiones anteriores que se acaban de pedir. Mismo camino, mismo volcado. */
   let lastSecretHistory = null
+  // ENTRAR CON USUARIO Y CONTRASEÑA, desde esta máquina (`dotrino-vault logins`).
+  //
+  // La respuesta NO se llama `logins.json`: ese nombre ya es el almacén del escritorio en
+  // el dir del perfil, y pisarlo sería borrar los inicios de sesión al listarlos.
+  const loginsReqFile = path.join(dir, 'logins-request.json')
+  const loginsFile = path.join(dir, 'logins-list.json')
   const profileReqFile = path.join(dir, 'profile-request.json')
   const dumpReqFile = path.join(dir, 'dump-request.json')
   const meReqFile = path.join(dir, 'me-request.json')
@@ -366,6 +372,54 @@ export async function runDaemon () {
    */
   const wipe = (k) => { try { if (k instanceof Uint8Array) k.fill(0) } catch (_) {} }
 
+  /**
+   * Los inicios de sesión con contraseña de ESTA máquina (`dotrino-vault logins`).
+   *
+   * LA CONTRASEÑA NO PASA POR AQUÍ, y esa es la razón de que el alta vaya en dos viajes en
+   * vez de uno: quien la teclea es la CLI, que hace su mitad de OPAQUE, genera las llaves
+   * del aparato y las cierra con la llave que sale de la contraseña. Aquí solo entran
+   * mensajes del protocolo y un paquete que esta máquina no puede abrir.
+   */
+  async function handleLoginsRequest (req) {
+    const vault = targetOf(req)
+    if (!vault) throw Object.assign(new Error('profile locked'), { code: 'PROFILE_LOCKED' })
+    // La huella de la CUENTA viaja en cada respuesta: es la mitad de después de la `@` de
+    // la dirección, y quien pregunta no puede sacarla por su cuenta sin adivinar a qué
+    // perfil apuntaba la petición.
+    return { fingerprint: vault.fingerprint || null, ...(await loginsOp(vault, req)) }
+  }
+
+  async function loginsOp (vault, req) {
+    switch (req.op) {
+      case 'list': return { logins: vault.listLogins() }
+      case 'register-begin': return vault.loginRegisterBegin({ user: req.user, request: req.request, replace: !!req.replace })
+      case 'register-finish': return vault.loginRegisterFinish({
+        user: req.user, upload: req.upload, pub: req.pub, encPub: req.encPub || null,
+        label: req.label || '', blob: req.blob, scope: req.scope, unattended: !!req.unattended, replace: !!req.replace
+      })
+      // Entrar desde la propia máquina de la bóveda. Lo usa `logins passwd`: para volver a
+      // cerrar el paquete de llaves hay que ABRIRLO antes, y eso solo puede hacerlo quien
+      // sabe la contraseña vieja. Pasa por el mismo freno que cualquier otro intento.
+      case 'login-begin': return vault.loginBegin({ user: req.user, request: req.request })
+      case 'login-end': return vault.loginEnd({ lid: req.lid, finalization: req.finalization, label: req.label || '' })
+      case 'close': return vault.closeLogin({ user: req.user, sid: req.sid })
+      case 'unblock': return vault.clearLoginBlock({ user: req.user })
+      // QUITARLO ES QUITARLO: el usuario se va y su llave sale del acta. Borrar solo el
+      // inicio de sesión dejaba un miembro que ya no puede entrar pero sigue siendo de la
+      // cuenta — media baja, que es peor que ninguna.
+      case 'rm': {
+        const r = await vault.removeLogin({ user: req.user })
+        if (r.ok && r.pub) {
+          try { await vault.revokeDevice({ sub: r.pub }) } catch (e) {
+            throw Object.assign(new Error(`the login is gone but its key is still in the record: ${e.message}`), { code: 'REVOKE_FAILED' })
+          }
+        }
+        return r
+      }
+      default: throw Object.assign(new Error(`unknown logins op: ${req.op}`), { code: 'BAD_OP' })
+    }
+  }
+
   async function handleProfileRequest (req) {
     // Resolver el destino de una orden de perfil CUENTA COMO USO: estira el plazo del
     // bloqueo automático igual que cualquier otra cosa que se haga desde la consola.
@@ -662,6 +716,19 @@ export async function runDaemon () {
           console.error('[vault] secret failed:', e.message)
         } finally { wipe(ak) }
       }
+      // Inicios de sesión con contraseña (`dotrino-vault logins`). La respuesta lleva el
+      // `id` de la petición, para que quien espera no lea la de la vuelta anterior.
+      const lreq = readJsonSafe(loginsReqFile)
+      if (lreq?.op) {
+        rm(loginsReqFile)
+        const answer = (extra) => ipcWrite(loginsFile, { at: Date.now(), req: lreq.id || null, ...extra })
+        try { answer({ ok: true, ...(await handleLoginsRequest(lreq)) }) } catch (e) {
+          console.error('[vault] logins: %s', e.message)
+          // `waitMs` viaja con el error: cuánto falta es el único dato que cambia lo que
+          // hace quien lo lee, y sin él «demasiados intentos» no dice nada accionable.
+          answer({ ok: false, error: e.message, code: e.code || 'LOGINS_FAILED', ...(e.waitMs ? { waitMs: e.waitMs } : {}) })
+        }
+      }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)
       if (preq?.op) {

package/src/transport.js

@@ -36,7 +36,7 @@ export async function masterPubkeyOf (identity) {
  * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
  * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
  */
-export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null }) {
+export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null }) {
   installNodeGlobals(dir)
   // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
   // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
@@ -160,12 +160,34 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
    * intento se dice en voz alta: una bóveda inalcanzable en silencio es el fallo que ya
    * costó un día entero (`CLAUDE.md`, el apagón del 1-2 de septiembre).
    */
+  /**
+   * EL ANUNCIO DE LA CUENTA (`temporary-access.md` §3.2).
+   *
+   * Quien entra con usuario y contraseña no tiene ninguna llave todavía: no sabe la pubkey
+   * de esta bóveda y no puede escribirle. Lo único que trae es el código de la dirección
+   * (`nombre@AB12-CD34-EF56`), y con él lista este canal para encontrar a quien atiende esa
+   * cuenta — esta bóveda, o cualquiera de sus réplicas.
+   *
+   * Va PEGADO a `identify` y no en el arranque, porque la pertenencia a un canal es del
+   * token, y el token cambia en cada reconexión: anunciarse una sola vez deja a la bóveda
+   * fuera del canal en cuanto se cae el socket, y eso se ve desde fuera como «esa cuenta no
+   * existe». Si el anuncio falla, la bóveda sigue sirviendo a todo lo demás y se dice en voz
+   * alta: lo que se pierde es que la encuentren por su dirección, no que deje de funcionar.
+   */
+  const announceAccount = async () => {
+    if (!announce || !identificado) return
+    try { await client.publish(announce) } catch (e) {
+      log(`[vault] could not announce this account on the proxy (${e.message}) — a borrowed machine will not find this vault by its address`)
+    }
+  }
+
   let reintento = null
   let fallos = 0
   const identifyWithRetry = async () => {
     if (reintento) { clearTimeout(reintento); reintento = null }
     try {
       await identify()
+      await announceAccount()
       if (fallos) log(`[vault] identified on the proxy after ${fallos + 1} attempt(s)`)
       fallos = 0
     } catch (e) {
@@ -180,5 +202,50 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
   // Re-identificar al reconectar (el token cambia).
   client.on('token', () => { fallos = 0; identifyWithRetry() })
 
+  /**
+   * QUE NO SE PUEDA VOLVER A QUEDAR MUDA.
+   *
+   * El 16 de septiembre esta bóveda se cayó del proxio y no volvió en 36 HORAS, con el
+   * proceso vivo y sin una sola línea en el log: el cliente del transporte se rendía tras
+   * un reintento fallido (arreglado en `@dotrino/proxy-client` 0.23.0). Desde fuera eso se
+   * ve igual que «no pasa nada»: el teléfono no timbra y nadie sabe por qué.
+   *
+   * El arreglo del pilar quita ESA causa. Esto quita el SILENCIO, que es lo que costó las
+   * 36 horas — con cualquier causa, futura incluida:
+   *
+   *   · se dice cuándo se cae y cuándo vuelve, una vez cada cosa (no una línea cada 4 s);
+   *   · y si lleva 5 minutos fuera, se vuelve a marcar en vez de esperar sentada.
+   *
+   * `connect()` es seguro de repetir: si ya está conectado devuelve el token y no abre
+   * nada.
+   */
+  const RECHECK_MS = 60_000
+  const PATIENCE_MS = 5 * 60_000
+  let downSince = 0
+  let saidDown = false
+  client.on('disconnect', ({ code, reason } = {}) => {
+    if (!downSince) downSince = Date.now()
+    if (saidDown) return
+    saidDown = true
+    log(`[vault] off the proxy (${code || '?'}${reason ? ': ' + reason : ''}) — nobody can reach this vault while this lasts`)
+  })
+  client.on('reconnect_failed', (attempts) => {
+    log(`[vault] the transport gave up reconnecting after ${attempts} attempt(s) — this vault is unreachable until it is restarted`)
+  })
+  const watchdog = setInterval(async () => {
+    if (identificado && client.token) {
+      if (downSince) log(`[vault] back on the proxy after ${Math.round((Date.now() - downSince) / 1000)}s`)
+      downSince = 0; saidDown = false
+      return
+    }
+    if (!downSince) downSince = Date.now()
+    const downMs = Date.now() - downSince
+    if (downMs < PATIENCE_MS) return
+    log(`[vault] ${Math.round(downMs / 60000)} min off the proxy — dialling again`)
+    try { await client.connect() } catch (e) { log(`[vault] could not reconnect: ${e.message}`) }
+    await identifyWithRetry()
+  }, RECHECK_MS)
+  watchdog.unref?.()
+
   return { client, token: client.token, identify: identifyWithRetry, isIdentified: () => identificado }
 }

package/src/vault.js

@@ -15,8 +15,9 @@ import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain as verifyChainRaw, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
+import { createLoginDesk, registerLogin, vaultChannel, accountFingerprint } from '../lib/src/passwordLogins.js'
 import * as ActaPilar from '@dotrino/identity/acta'
-import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
+import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, scopeToCaps, scopeToCn } from '../lib/src/enroll.js'
 import { createAdminDesk, authorBody } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
 // El sobre del gestor, el mismo que usan la bóveda-en-pestaña y la extensión.
@@ -218,6 +219,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     },
   }
 
+  // ENTRAR CON USUARIO Y CONTRASEÑA (`passwordLogins.js`). Va cifrado en reposo con la llave
+  // de la MÁQUINA y no con la de la contraseña del perfil, por lo mismo que la llave de
+  // comunicación: entrar tiene que funcionar con el perfil cerrado. Lo que hay dentro no
+  // abre nada por sí solo — el registro de OPAQUE no deja probar contraseñas sin el
+  // protocolo, y el paquete de llaves está cerrado con la llave que sale de la contraseña.
+  const loginsFile = path.join(dir, 'logins.json')
+  const loginsAtRest = atRestFor(dir)
+  const logins = createLoginDesk({
+    load: () => { try { return JSON.parse(loginsAtRest.decrypt(fs.readFileSync(loginsFile, 'utf8'))) } catch (_) { return null } },
+    save: (state) => fs.writeFileSync(loginsFile, loginsAtRest.encrypt(JSON.stringify(state)), { mode: 0o600 })
+  })
+
   /** Los aparatos que el acta autoriza a pedir credenciales (`caps <ID> +contraseñas`). */
   const passwordDevices = () => (actaCache?.members || []).filter((m) => Acta.memberCan(actaCache, m.pub, 'passwords'))
 
@@ -287,7 +300,17 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   } catch (_) {}
 
   const master = await masterPubkeyOf(identity)
-  const fp = (await pubkeyId(master)).slice(0, 16)
+  /**
+   * LA HUELLA DE LA CUENTA, no la de esta bóveda. Sale del `profileId` del acta (la pieza
+   * compartida la calcula), y con ella se arman la dirección `nombre@AB12-CD34-EF56` y el
+   * canal donde se anuncia esta cuenta.
+   *
+   * Antes salía de la llave de ESTA bóveda. Coinciden mientras la cuenta haya nacido aquí,
+   * y dejan de coincidir en cuanto hay una réplica o la bóveda adoptó la cuenta de otro
+   * aparato: cada bóveda daba entonces una dirección distinta para la misma cuenta, y el
+   * canal las separaba justo cuando lo que hace falta es que se junten.
+   */
+  const fp = await accountFingerprint(identity)
 
   /**
    * El acta tiene que nombrar una llave de sellado QUE SEA NUESTRA. Si no nombra ninguna
@@ -362,7 +385,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   await ensureCommKeyInActa()
 
-  const { client, identify: reidentificar, isIdentified } = await createTransport({ identity, dir, url: proxyUrl, commKey, log })
+  // `announce`: el canal de ESTA cuenta, para que una máquina prestada —que no tiene
+  // ninguna llave y solo sabe la dirección `nombre@AB12-CD34-EF56`— pueda encontrar a quien
+  // la atiende. Lo construye la pieza compartida, porque quien lo busca es la extensión.
+  const { client, identify: reidentificar, isIdentified } = await createTransport({
+    identity, dir, url: proxyUrl, commKey, log, announce: vaultChannel(fp)
+  })
 
   // El registro público de cadenas de selladores: deposita, si hay a dónde, los eslabones
   // que le dicen a un tercero si esta cuenta sigue sellada por quien él cree. Ver
@@ -1071,6 +1099,66 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * nombre de SU propia llave, que no le sirve contra nadie más (`verifyRevoke` exige que
    * el aviso nombre al aparato que lo recibe).
    */
+  // --- ENTRAR CON USUARIO Y CONTRASEÑA ---------------------------------------------------
+  //
+  // Los tres únicos mensajes que se atienden SIN certificado, porque quien pregunta todavía
+  // no tiene llaves: están dentro del paquete que solo abre su contraseña. La bóveda no ve
+  // la contraseña en ningún momento (OPAQUE), y responde igual exista o no el usuario.
+  //
+  // Funcionan con el perfil CERRADO: el paquete se devuelve tal cual, sin abrir nada. Lo que
+  // sí exige la bóveda abierta es CREAR el aparato, porque eso sella el acta.
+
+  function loginError (from, e) {
+    if (e?.code === 'too-many-tries') {
+      return reply(from, { type: MSG.ERROR, error: e.message, code: e.code, waitMs: e.waitMs || 0 })
+    }
+    if (e?.code === 'login-failed' || e?.code === 'no-exchange' || e?.code === 'bad-input' || e?.code === 'bad-user') {
+      return reply(from, { type: MSG.ERROR, error: e.message, code: e.code })
+    }
+    log('[vault] login: %s', e?.message || e)
+    reply(from, { type: MSG.ERROR, error: 'login failed', code: 'login-error' })
+  }
+
+  async function handleLoginStart (from, p) {
+    try {
+      const { lid, response } = logins.loginBegin({ user: p?.user, request: p?.request })
+      audit('login.start', { user: String(p?.user || '').slice(0, 32) })
+      reply(from, { type: MSG.LOGIN_RESPONSE, lid, response })
+    } catch (e) { loginError(from, e) }
+  }
+
+  async function handleLoginFinish (from, p) {
+    try {
+      const r = logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      audit('login.ok', { user: r.user, sid: r.sid.slice(0, 8) })
+      log('[vault] login: %s entered (session %s)', r.user, r.sid.slice(0, 8))
+      reply(from, { type: MSG.LOGIN_OK, sid: r.sid, blob: r.blob, cert: r.cert, iss: r.iss || identity.me?.publickey || null, acta: record })
+    } catch (e) { loginError(from, e) }
+  }
+
+  /**
+   * SALIR. Va firmado con la llave del propio aparato —la que acaba de abrir— porque cerrar
+   * la sesión de otro sería echarlo de su cuenta.
+   */
+  async function handleLoginClose (from, p) {
+    if (!isFresh(p?.data)) return staleReply(from)
+    const d = p.data
+    if (d?.op !== 'login.close' || typeof d.publickey !== 'string' || typeof d.user !== 'string' || typeof d.sid !== 'string') {
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: shape', code: 'bad-input' })
+    }
+    if (!(await verifyDeviceSig({ publickey: d.publickey, data: d, signature: p.signature }))) {
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: bad-signature', code: 'bad-signature' })
+    }
+    const mine = logins.list().find((x) => x.user === d.user)
+    if (!mine || mine.pub !== d.publickey) {
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: that key does not own this login', code: 'not-yours' })
+    }
+    const r = logins.closeSession({ user: d.user, sid: d.sid })
+    audit('login.close', { user: d.user, sid: d.sid.slice(0, 8), by: 'device' })
+    reply(from, { type: MSG.LOGIN_CLOSED, ok: r.ok })
+  }
+
   async function handleCheck (from, p) {
     if (!isFresh(p?.data)) return staleReply(from)
     const pub = p.data.publickey
@@ -1632,6 +1720,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
       if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
       if (payload.type === MSG.REPLICA_ACK) return await handleReplicaAck(from, payload)
+      if (payload.type === MSG.LOGIN_START) return await handleLoginStart(from, payload)
+      if (payload.type === MSG.LOGIN_FINISH) return await handleLoginFinish(from, payload)
+      if (payload.type === MSG.LOGIN_CLOSE) return await handleLoginClose(from, payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
@@ -3375,6 +3466,42 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // llave. Lo que no puede es listarla un aparato.
     passwordDevices,
     passwordsVault: () => passwords?.vault || null,
+    // --- ENTRAR CON USUARIO Y CONTRASEÑA -------------------------------------------------
+    //
+    // El alta va en DOS pasos porque la contraseña no pasa por aquí: quien crea el aparato
+    // (la CLI, en esta máquina) hace su mitad de OPAQUE, genera las llaves del aparato y las
+    // cierra con la llave que sale de la contraseña. La bóveda solo guarda lo que no puede
+    // abrir, sella el acta y firma el certificado — y eso último sí pide el perfil abierto.
+    listLogins: () => logins.list(),
+    loginRegisterBegin: ({ user, request, replace = false }) => logins.registerBegin({ user, request, replace }),
+    // El alta es la MISMA pieza que usa la bóveda-pestaña (`registerLogin`): aquí solo se
+    // añade lo que es del binario — la bitácora y el aviso a los demás aparatos.
+    loginRegisterFinish: async (opts) => {
+      const r = await registerLogin({ ...opts, identity, logins })
+      if (r.replaced) { audit('login.passwd', { user: r.user }); return r }
+      audit('login.create', { user: r.user, device: r.deviceId, caps: r.caps })
+      await notifyMembers('enrolled', { deviceId: r.deviceId, by: 'login' })
+      return r
+    },
+    // ENTRAR DESDE ESTA MISMA MÁQUINA. Es el mismo intercambio que hace un navegador por el
+    // proxio, y pasa por el mismo freno: lo usa `logins passwd`, que necesita abrir el
+    // paquete de llaves con la contraseña vieja antes de volver a cerrarlo con la nueva.
+    loginBegin: ({ user, request }) => logins.loginBegin({ user, request }),
+    loginEnd: ({ lid, finalization, label }) => logins.loginEnd({ lid, finalization, label }),
+    closeLogin: ({ user, sid }) => {
+      const r = logins.closeSession({ user, sid })
+      if (r.ok) audit('login.close', { user, sid: String(sid).slice(0, 8), by: 'console' })
+      return r
+    },
+    clearLoginBlock: ({ user }) => logins.clearBlock({ user }),
+    removeLogin: async ({ user }) => {
+      const found = logins.list().find((x) => x.user === user)
+      if (!found) return { ok: false }
+      logins.remove({ user })
+      audit('login.remove', { user, device: found.deviceId })
+      // Quitarlo de aquí no lo saca del acta: lo suyo es revocar el aparato, y eso ya existe.
+      return { ok: true, pub: found.pub, deviceId: found.deviceId }
+    },
     listApprovals: () => approvals.list(),
     // LAS CONCESIONES VIVAS, para verlas y para cortarlas. Se enseñan en la máquina del
     // dueño (TUI/CLI), donde el contexto ya es suyo y no hay nada que sellar.