@dotrino/vaultd 0.119.0 → 0.121.0

package/lib/src/b64.js

@@ -0,0 +1,36 @@
+/**
+ * b64.js — base64url a mano, sin `Buffer` ni `btoa`.
+ *
+ * Vive aparte porque lo usan piezas que corren en los tres sitios: el binario (Node), la
+ * pestaña y la extensión. `Buffer` no existe en el navegador y `btoa` no existe en algunos
+ * workers, así que la única forma de tener UNA implementación es esta.
+ */
+
+const B64_STD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+export function bytesToB64url (bytes) {
+  let out = ''
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i]; const b = bytes[i + 1]; const c = bytes[i + 2]
+    out += B64_STD[a >> 2]
+    out += B64_STD[((a & 3) << 4) | ((b ?? 0) >> 4)]
+    if (b === undefined) break
+    out += B64_STD[((b & 15) << 2) | ((c ?? 0) >> 6)]
+    if (c === undefined) break
+    out += B64_STD[c & 63]
+  }
+  return out.replace(/\+/g, '-').replace(/\//g, '_')
+}
+
+export function b64urlToBytes (s) {
+  const clean = String(s).replace(/-/g, '+').replace(/_/g, '/').replace(/[^A-Za-z0-9+/]/g, '')
+  const out = []
+  let acc = 0; let bits = 0
+  for (const ch of clean) {
+    const v = B64_STD.indexOf(ch)
+    if (v < 0) return null
+    acc = (acc << 6) | v; bits += 6
+    if (bits >= 8) { bits -= 8; out.push((acc >> bits) & 0xff) }
+  }
+  return Uint8Array.from(out)
+}

package/lib/src/index.js

@@ -46,11 +46,16 @@ export { deviceIdOf }
  *   `me.publickey`, `signData`, `signDelegation`, `listDelegations`, `revokeDelegation`.
  * @param {object} [opts]
  * @param {string} [opts.proxyUrl='wss://proxy.dotrino.com']
+ * @param {object} [opts.logins]  escritorio de `createLoginDesk` (`./password-logins`) para
+ *   ENTRAR CON USUARIO Y CONTRASEÑA. Lo monta quien levanta esta bóveda, porque en el
+ *   navegador no hay archivos y el estado tiene que guardarlo él. Sin él, esta bóveda
+ *   contesta `logins-unavailable` — no se inventa un almacén.
  * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, stopPairing,
- *   approve, reject, listPending, listMachines, revoke, getSelfCert, onPendingChange,
- *   onAdopted, close }
+ *   approve, reject, listPending, listMachines, revoke, getSelfCert, listLogins,
+ *   loginRegisterBegin, loginRegisterFinish, loginBegin, loginEnd, closeLogin,
+ *   clearLoginBlock, removeLogin, onPendingChange, onAdopted, close }
  */
-export async function startDeviceVault (identity, { proxyUrl, client: injectedClient } = {}) {
+export async function startDeviceVault (identity, { proxyUrl, client: injectedClient, logins = null } = {}) {
   const iss = identity.me?.publickey
   if (!iss) throw new Error('no identity: create/unlock your identity before using this device as a vault')
   const proxy = proxyUrl || 'wss://proxy.dotrino.com'
@@ -328,8 +333,72 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     else if (p.type === MSG.GET) handle('get', handleGet(_from, p), _from)
     else if (p.type === MSG.STORE) handle('store', handleStore(_from, p), _from)
     else if (p.type === MSG.CHECK) handle('check', handleCheck(_from, p), _from)
+    // ENTRAR CON USUARIO Y CONTRASEÑA. La misma pieza que usa el binario
+    // (`passwordLogins.js`), con el almacén que le ponga quien monta esta bóveda: en el
+    // navegador no hay archivos, así que lo pone el iframe de identidad.
+    else if (p.type === MSG.LOGIN_START) handle('login', handleLoginStart(_from, p), _from)
+    else if (p.type === MSG.LOGIN_FINISH) handle('login', handleLoginFinish(_from, p), _from)
+    else if (p.type === MSG.LOGIN_CLOSE) handle('login', handleLoginClose(_from, p), _from)
   })
 
+  // --- ENTRAR CON USUARIO Y CONTRASEÑA ---------------------------------------------------
+  //
+  // Sin almacén no se inventa nada: se contesta que aquí no hay inicios de sesión. Es una
+  // bóveda que no atiende esto, no una que dice que la contraseña está mal.
+  const noLogins = (from) => send(from, { type: MSG.ERROR, error: 'this vault does not keep password logins', code: 'logins-unavailable' })
+
+  /** Lo mismo desde la consola: sin almacén no se administra nada, y se dice. */
+  function needLogins () {
+    if (!logins) throw Object.assign(new Error('this vault does not keep password logins: no store was given to startDeviceVault'), { code: 'logins-unavailable' })
+    return logins
+  }
+
+  function loginError (from, e) {
+    const code = e?.code
+    if (code === 'too-many-tries') return send(from, { type: MSG.ERROR, error: e.message, code, waitMs: e.waitMs || 0 })
+    if (code === 'login-failed' || code === 'no-exchange' || code === 'bad-input' || code === 'bad-user') {
+      return send(from, { type: MSG.ERROR, error: e.message, code })
+    }
+    send(from, { type: MSG.ERROR, error: 'login failed', code: 'login-error' })
+  }
+
+  async function handleLoginStart (from, p) {
+    if (!logins) return noLogins(from)
+    try {
+      const { lid, response } = logins.loginBegin({ user: p?.user, request: p?.request })
+      send(from, { type: MSG.LOGIN_RESPONSE, lid, response })
+    } catch (e) { loginError(from, e) }
+  }
+
+  async function handleLoginFinish (from, p) {
+    if (!logins) return noLogins(from)
+    try {
+      const r = logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
+      const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+      send(from, { type: MSG.LOGIN_OK, sid: r.sid, blob: r.blob, cert: r.cert, iss: r.iss || iss, acta })
+    } catch (e) { loginError(from, e) }
+  }
+
+  /** Salir va firmado con la llave que acaba de abrir: cerrar la de otro sería echarlo. */
+  async function handleLoginClose (from, p) {
+    if (!logins) return noLogins(from)
+    const d = p?.data
+    if (typeof d?.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
+      return send(from, { type: MSG.ERROR, error: 'stale request', code: 'stale' })
+    }
+    if (d?.op !== 'login.close' || typeof d.publickey !== 'string' || typeof d.user !== 'string' || typeof d.sid !== 'string') {
+      return send(from, { type: MSG.ERROR, error: 'unauthorized: shape', code: 'bad-input' })
+    }
+    if (!(await verifyDeviceSig({ publickey: d.publickey, data: d, signature: p.signature }))) {
+      return send(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 send(from, { type: MSG.ERROR, error: 'unauthorized: that key does not own this login', code: 'not-yours' })
+    }
+    send(from, { type: MSG.LOGIN_CLOSED, ok: logins.closeSession({ user: d.user, sid: d.sid }).ok })
+  }
+
   /**
    * Máquinas enroladas bajo esta identidad (P), vigentes, con scope de firma y label
    * propio (excluye navegadores enrolados con label 'cli', que no atienden peticiones).
@@ -368,6 +437,31 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     // exactamente esto.
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
+    // ENTRAR CON USUARIO Y CONTRASEÑA, desde la consola de esta bóveda. Es la misma pieza
+    // que el binario (`registerLogin`), para que el aparato que sale de aquí sea idéntico.
+    // Sin almacén no hay nada que administrar, y se dice en vez de contestar una lista vacía.
+    listLogins: () => needLogins().list(),
+    loginRegisterBegin: (opts) => needLogins().registerBegin(opts),
+    // El alta se trae cuando se usa: arrastra el OPAQUE en WASM (unos 260 KB) y la mayoría
+    // de las apps que usan este módulo no crean ningún inicio de sesión.
+    loginRegisterFinish: async (opts) => {
+      const { registerLogin } = await import('./passwordLogins.js')
+      return registerLogin({ ...opts, identity, logins: needLogins() })
+    },
+    // Entrar desde la propia consola, sin pasar por el proxio. Hace falta para cambiar la
+    // contraseña: el paquete de llaves se abre con la vieja y se vuelve a cerrar con la nueva.
+    loginBegin: ({ user, request }) => needLogins().loginBegin({ user, request }),
+    loginEnd: ({ lid, finalization, label }) => needLogins().loginEnd({ lid, finalization, label }),
+    closeLogin: ({ user, sid }) => needLogins().closeSession({ user, sid }),
+    clearLoginBlock: ({ user }) => needLogins().clearBlock({ user }),
+    removeLogin: ({ user }) => {
+      const store = needLogins()
+      const found = store.list().find((x) => x.user === user)
+      if (!found) return { ok: false }
+      store.remove({ user })
+      // 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 }
+    },
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },
     /** Camino A: la cuenta del aparato quedó adoptada por esta bóveda. */
     onAdopted (fn) { _onAdopted = fn || (() => {}) },

package/lib/src/invite.js

@@ -80,37 +80,11 @@ export const PAIR_URL = 'https://vault.dotrino.com/d#v='
 
 // ---------------------------------------------------------------------------
 // Conversiones (sin dependencias: esto corre en el navegador, en Node y dentro
-// del binario SEA)
+// del binario SEA). El base64url vive en `b64.js`, porque el paquete de llaves de
+// los inicios de sesión usa el mismo.
 // ---------------------------------------------------------------------------
 
-const B64_STD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-
-function bytesToB64url (bytes) {
-  let out = ''
-  for (let i = 0; i < bytes.length; i += 3) {
-    const a = bytes[i]; const b = bytes[i + 1]; const c = bytes[i + 2]
-    out += B64_STD[a >> 2]
-    out += B64_STD[((a & 3) << 4) | ((b ?? 0) >> 4)]
-    if (b === undefined) break
-    out += B64_STD[((b & 15) << 2) | ((c ?? 0) >> 6)]
-    if (c === undefined) break
-    out += B64_STD[c & 63]
-  }
-  return out.replace(/\+/g, '-').replace(/\//g, '_')
-}
-
-function b64urlToBytes (s) {
-  const clean = String(s).replace(/-/g, '+').replace(/_/g, '/').replace(/[^A-Za-z0-9+/]/g, '')
-  const out = []
-  let acc = 0; let bits = 0
-  for (const ch of clean) {
-    const v = B64_STD.indexOf(ch)
-    if (v < 0) return null
-    acc = (acc << 6) | v; bits += 6
-    if (bits >= 8) { bits -= 8; out.push((acc >> bits) & 0xff) }
-  }
-  return Uint8Array.from(out)
-}
+import { bytesToB64url, b64urlToBytes } from './b64.js'
 
 const utf8 = (s) => new TextEncoder().encode(s)
 const fromUtf8 = (b) => new TextDecoder().decode(b)

package/lib/src/passwordLogins.js

@@ -0,0 +1,431 @@
+/**
+ * EL APARATO QUE SE ABRE CON USUARIO Y CONTRASEÑA.
+ *
+ * Es un miembro del acta como cualquier otro —su llave de firma, su llave de cifrado, sus
+ * permisos—, y lo único distinto es dónde vive su llave privada: aquí, **cifrada con algo
+ * que solo sale de la contraseña**. Diseño en
+ * `dotrino-passmanager/docs/temporary-access.md`.
+ *
+ * Lo que esta pieza guarda y lo que NO:
+ *
+ *   · el registro OPAQUE del usuario y la preparación del servidor — con ellos NO se puede
+ *     comprobar una contraseña sin el protocolo, ni sacarla de ahí;
+ *   · el paquete con las llaves privadas del aparato, **cerrado por quien lo creó** con la
+ *     llave que sale de la contraseña (`exportKey`). La bóveda no lo abre nunca: lo guarda
+ *     y lo devuelve cuando alguien demuestra saber la contraseña;
+ *   · el certificado del aparato y su acta, que son públicos.
+ *
+ * **La bóveda nunca ve la contraseña.** OPAQUE (`@dotrino/opaque`, RFC 9807) la comprueba
+ * sin recibirla y sin entregar nada con qué adivinarla desde fuera: solo se puede probar en
+ * línea, contra el freno de abajo.
+ *
+ * El escritorio (`createLoginDesk`) es puro: recibe el estado, lo devuelve cambiado y no toca
+ * el disco ni la red. Quien lo guarda y quien lo sirve es cada bóveda —`src/vault.js` en el
+ * binario, `lib/src/index.js` en la pestaña—. Lo único que no es puro es `registerLogin`, al
+ * final, porque hace falta la identidad que firma.
+ */
+import { server as opaque, suiteId } from '@dotrino/opaque'
+import { deviceIdOf, scopeToCaps, scopeToCn } from './enroll.js'
+import { SCOPE } from './protocol.js'
+import { bytesToB64url, b64urlToBytes } from './b64.js'
+
+/** Un usuario es la parte de antes de la `@` en `nombre@AB12-CD34-EF56`. */
+export const isValidUser = (u) => typeof u === 'string' && /^[a-z0-9][a-z0-9._-]{0,31}$/.test(u)
+
+/**
+ * LA DIRECCIÓN: `nombre@AB12-CD34-EF56` (`temporary-access.md` §3.2). Lo de después de la
+ * `@` son los primeros **48 bits de la huella de la cuenta** — el mismo `pubkeyId` que ya
+ * identifica cualquier llave, con un grupo más que `keyLabel`.
+ *
+ * Se ata a la CUENTA y no a una máquina porque la cuenta no cambia nunca y la bóveda puede
+ * mudarse o tener réplicas. Y son 48 bits y no 32 porque este código es lo único que ata la
+ * dirección a la cuenta de verdad: fabricar otra cuenta con la misma huella corta cuesta
+ * siglos con 48 bits y horas con los 32 de `keyLabel`.
+ *
+ * Vive aquí, y no en cada bóveda, porque una dirección que se escriba distinta en el binario
+ * y en la extensión no es la misma dirección.
+ */
+export const ACCOUNT_CODE_HEX = 12
+export function accountCode (fingerprint) {
+  const hex = String(fingerprint || '').replace(/[^0-9a-fA-F]/g, '').toUpperCase()
+  if (hex.length < ACCOUNT_CODE_HEX) throw err('bad-account', 'the account fingerprint is too short to build an address')
+  return hex.slice(0, ACCOUNT_CODE_HEX).match(/.{4}/g).join('-')
+}
+export const loginAddress = (user, fingerprint) => `${user}@${accountCode(fingerprint)}`
+
+/**
+ * EL CANAL DONDE SE ANUNCIA CADA BÓVEDA DE ESA CUENTA, réplicas incluidas.
+ *
+ * Quien entra con usuario y contraseña no tiene ninguna llave todavía, así que no puede
+ * escribirle a la bóveda por su pubkey: no la sabe. Lo único que tiene es el código de la
+ * dirección, y con él lista este canal y encuentra a quien atiende.
+ *
+ * **El canal no prueba nada**: cualquiera puede publicarse en uno. Lo que ata la bóveda a
+ * la cuenta es el acta que enseña después — su huella tiene que empezar por ese mismo
+ * código. Por eso son 48 bits, y por eso mirar este canal solo deja ver que detrás de un
+ * código hay una bóveda encendida: ni de quién es, ni qué guarda.
+ */
+export const vaultChannel = (fingerprint) => `dotrino-vault-${accountCode(fingerprint)}`
+
+/**
+ * EL FRENO. Cinco intentos y, a partir de ahí, una espera que se DUPLICA con cada fallo
+ * (decidido por el dueño el 2026-09-17). Se eligió frente a bloquear la cuenta porque un
+ * bloqueo deja que cualquiera que sepa tu usuario te impida entrar a propósito.
+ *
+ * **Se cuenta al EMPEZAR el intento, no al terminarlo**, y no es un detalle: en OPAQUE quien
+ * prueba una contraseña se entera ÉL SOLO al recibir la respuesta, sin mandar el último
+ * mensaje. Contando al final, quien prueba contraseñas no gastaría ni un intento y el freno
+ * no frenaría nada. Un inicio de sesión que termina bien reinicia la cuenta.
+ *
+ * El precio, dicho claro: quien sepa tu usuario puede gastarte los intentos y hacerte
+ * esperar. Por eso hay tope de una hora y `clearBlock`, que lo quita desde la máquina de la
+ * bóveda. No hay forma de evitarlo del todo: para saber si una contraseña es la buena hay
+ * que dejar intentar.
+ */
+export const FREE_TRIES = 5
+export const BACKOFF_BASE_MS = 60_000
+export const BACKOFF_CAP_MS = 60 * 60_000
+export const backoffFor = (fails) =>
+  fails < FREE_TRIES ? 0 : Math.min(BACKOFF_BASE_MS * 2 ** (fails - FREE_TRIES), BACKOFF_CAP_MS)
+
+/** Un intercambio de inicio de sesión a medias no puede quedarse abierto para siempre. */
+export const EXCHANGE_TTL_MS = 2 * 60_000
+
+const err = (code, message) => Object.assign(new Error(message), { code })
+
+// ---------------------------------------------------------------------------
+// EL PAQUETE DE LLAVES
+//
+// Lo cierra y lo abre QUIEN SABE LA CONTRASEÑA: la CLI al crear el aparato, y el
+// navegador al entrar. La bóveda solo lo guarda y lo devuelve — nunca tiene con qué
+// abrirlo, y por eso esto no está en ninguna de las tres bóvedas sino aquí, donde las
+// tres lo importan y cierran el paquete EXACTAMENTE igual.
+//
+// AES-GCM con los primeros 32 bytes de la llave que sale de la contraseña (`exportKey`
+// de OPAQUE). El formato lleva marca de versión porque este blob se guarda durante años
+// y lo leen tres programas distintos: sin ella, cambiarlo sería adivinar.
+// ---------------------------------------------------------------------------
+
+const BLOB_V = 'k1'
+
+/** La llave AES que sale del `exportKey` del intercambio. No se guarda en ningún sitio. */
+async function keyFrom (exportKey, use) {
+  const raw = b64urlToBytes(exportKey)
+  if (!raw || raw.length < 32) throw err('bad-key', 'the key that opens the package is not valid')
+  return crypto.subtle.importKey('raw', raw.subarray(0, 32), 'AES-GCM', false, [use])
+}
+
+/** Cierra las llaves privadas del aparato. `keys` es JSON: `{ sign, enc }` en JWK. */
+export async function sealDeviceKeys (exportKey, keys) {
+  const key = await keyFrom(exportKey, 'encrypt')
+  const iv = crypto.getRandomValues(new Uint8Array(12))
+  const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, new TextEncoder().encode(JSON.stringify(keys)))
+  return [BLOB_V, bytesToB64url(iv), bytesToB64url(new Uint8Array(ct))].join('.')
+}
+
+/**
+ * Abre el paquete. Una contraseña equivocada NO llega hasta aquí —OPAQUE la para antes—,
+ * así que si esto falla es que el paquete está roto o es de otra versión, y se dice.
+ */
+export async function openDeviceKeys (exportKey, blob) {
+  const [v, iv, ct] = String(blob || '').split('.')
+  if (v !== BLOB_V || !iv || !ct) throw err('bad-blob', 'the key package is not in a format this version understands')
+  const key = await keyFrom(exportKey, 'decrypt')
+  let plain
+  try {
+    plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: b64urlToBytes(iv) }, key, b64urlToBytes(ct))
+  } catch (_) { throw err('bad-blob', 'the key package did not open with that key') }
+  return JSON.parse(new TextDecoder().decode(plain))
+}
+
+/**
+ * @param {object} opts
+ *   `load()`  devuelve el estado guardado (o `null` la primera vez)
+ *   `save(s)` lo guarda
+ *   `now()`   el reloj, para poder probar el freno sin esperar una hora
+ */
+export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
+  if (typeof load !== 'function' || typeof save !== 'function') throw new Error('createLoginDesk: load and save are required')
+
+  /** Intercambios a medias: viven en memoria, y por eso un reinicio los tira. */
+  const exchanges = new Map()
+
+  const read = () => {
+    const s = load()
+    if (s && typeof s === 'object') return s
+    return { v: 1, setup: null, users: {} }
+  }
+
+  /** La preparación del servidor nace con el primer usuario y no se toca nunca más. */
+  function setupOf (state) {
+    if (state.setup) return state.setup
+    state.setup = opaque.createSetup()
+    return state.setup
+  }
+
+  const userOf = (state, user) => {
+    if (!isValidUser(user)) throw err('bad-user', 'a user name is lowercase letters, digits, dot, dash or underscore (1-32)')
+    return state.users[user] || null
+  }
+
+  const sweepExchanges = () => {
+    const t = now()
+    for (const [lid, x] of exchanges) if (t - x.at > EXCHANGE_TTL_MS) exchanges.delete(lid)
+  }
+
+  return {
+    /** Lo que se puede enseñar: ni el registro, ni el paquete de llaves, ni la preparación. */
+    list () {
+      const state = read()
+      return Object.entries(state.users).map(([user, u]) => ({
+        user,
+        deviceId: u.deviceId || null,
+        label: u.label || '',
+        pub: u.pub,
+        createdAt: u.createdAt || 0,
+        passwordChangedAt: u.passwordChangedAt || u.createdAt || 0,
+        fails: u.fails || 0,
+        blockedUntil: u.nextTryAt || 0,
+        sessions: Object.entries(u.sessions || {}).map(([sid, s]) => ({
+          sid, openedAt: s.openedAt, lastUsedAt: s.lastUsedAt || s.openedAt, label: s.label || ''
+        })).sort((a, b) => b.lastUsedAt - a.lastUsedAt)
+      })).sort((a, b) => a.user.localeCompare(b.user))
+    },
+
+    /**
+     * ALTA, primer paso. La contraseña no llega hasta aquí: lo que llega es el mensaje de
+     * registro de OPAQUE, que no la lleva ni permite adivinarla.
+     */
+    registerBegin ({ user, request, replace = false } = {}) {
+      const state = read()
+      const existing = userOf(state, user)
+      if (existing && !replace) throw err('user-exists', `there is already a login called "${user}"`)
+      if (!existing && replace) throw err('no-user', `there is no login called "${user}"`)
+      if (typeof request !== 'string' || !request) throw err('bad-input', 'request required')
+      const setup = setupOf(state)
+      const response = opaque.registrationResponse({ setup, request, credentialId: user })
+      save(state)
+      return { response, suite: suiteId() }
+    },
+
+    /**
+     * ALTA, segundo paso. `blob` son las llaves privadas del aparato, ya cerradas por quien
+     * creó el aparato con la llave que sale de la contraseña: aquí no se abre nunca.
+     */
+    registerFinish ({ user, upload, pub, encPub = null, deviceId = null, label = '', blob, replace = false } = {}) {
+      const state = read()
+      const existing = userOf(state, user)
+      if (existing && !replace) throw err('user-exists', `there is already a login called "${user}"`)
+      if (!existing && replace) throw err('no-user', `there is no login called "${user}"`)
+      if (typeof blob !== 'string' || !blob) throw err('bad-input', 'blob required (the device keys, sealed with the password)')
+      if (!replace && (typeof pub !== 'string' || !pub)) throw err('bad-input', 'pub required')
+      const record = opaque.registrationFinish({ upload })
+      const t = now()
+      state.users[user] = {
+        ...(existing || {}),
+        pub: replace ? existing.pub : pub,
+        encPub: replace ? existing.encPub : encPub,
+        deviceId: replace ? existing.deviceId : deviceId,
+        label: label || existing?.label || '',
+        record,
+        blob,
+        suite: suiteId(),
+        createdAt: existing?.createdAt || t,
+        passwordChangedAt: t,
+        // Cambiar la contraseña cierra lo abierto: si alguien entró con la vieja, deja de
+        // valer. Y el freno se reinicia, que si no la cuenta vieja castigaría a la nueva.
+        sessions: {},
+        fails: 0,
+        nextTryAt: 0
+      }
+      save(state)
+      return { user, suite: suiteId() }
+    },
+
+    /** El certificado del aparato, que firma la bóveda al admitirlo en el acta. Es público. */
+    setCert ({ user, cert, iss = null } = {}) {
+      const state = read()
+      const u = userOf(state, user)
+      if (!u) throw err('no-user', `there is no login called "${user}"`)
+      u.cert = cert
+      if (iss) u.iss = iss
+      save(state)
+      return { ok: true }
+    },
+
+    /**
+     * INICIO DE SESIÓN, primer paso.
+     *
+     * Un usuario que no existe recibe una respuesta **igual por fuera**, hecha con un
+     * registro inventado: desde fuera no se puede averiguar qué usuarios hay. Y cuenta
+     * contra el mismo freno, para que tampoco se pueda medir por el tiempo.
+     */
+    loginBegin ({ user, request } = {}) {
+      sweepExchanges()
+      const state = read()
+      if (typeof request !== 'string' || !request) throw err('bad-input', 'request required')
+      const u = isValidUser(user) ? state.users[user] || null : null
+      const t = now()
+      if (u?.nextTryAt && u.nextTryAt > t) {
+        throw Object.assign(err('too-many-tries', 'too many tries: wait before trying again'), { waitMs: u.nextTryAt - t })
+      }
+      // EL INTENTO SE CUENTA AQUÍ. Ver el comentario del freno: quien prueba una contraseña
+      // puede no mandar nunca el último mensaje, así que si se contara al final no se
+      // contaría nada. `loginEnd` lo reinicia cuando el intento sale bien.
+      if (u) {
+        u.fails = (u.fails || 0) + 1
+        u.nextTryAt = t + backoffFor(u.fails)
+      }
+      const setup = setupOf(state)
+      const { state: serverState, response } = opaque.loginStart({
+        setup,
+        record: u?.record || null,
+        request,
+        credentialId: String(user || ''),
+        identifiers: {}
+      })
+      const lid = crypto.randomUUID()
+      exchanges.set(lid, { user: String(user || ''), known: !!u, state: serverState, at: t })
+      save(state)
+      return { lid, response }
+    },
+
+    /**
+     * INICIO DE SESIÓN, segundo paso. Si la contraseña es la buena, devuelve el paquete de
+     * llaves —que solo abre esa contraseña—, el certificado y el acta.
+     */
+    loginEnd ({ lid, finalization, label = '' } = {}) {
+      sweepExchanges()
+      const x = exchanges.get(lid)
+      if (!x) throw err('no-exchange', 'that login is not in flight any more: start again')
+      exchanges.delete(lid)
+      const state = read()
+      const u = x.known ? state.users[x.user] : null
+
+      try {
+        opaque.loginFinish({ state: x.state, finalization })
+      } catch (e) {
+        // Contraseña equivocada, usuario inexistente o mensaje alterado: el MISMO error.
+        // Distinguirlos diría qué usuarios existen. El intento ya está contado desde
+        // `loginBegin`, así que aquí no se vuelve a contar.
+        throw err('login-failed', 'wrong user or password')
+      }
+
+      const t = now()
+      const sid = crypto.randomUUID()
+      u.fails = 0
+      u.nextTryAt = 0
+      u.sessions = { ...(u.sessions || {}), [sid]: { openedAt: t, lastUsedAt: t, label: String(label || '').slice(0, 60) } }
+      save(state)
+      return { sid, user: x.user, blob: u.blob, cert: u.cert || null, iss: u.iss || null, pub: u.pub }
+    },
+
+    /**
+     * QUITAR LA ESPERA, desde la máquina de la bóveda. Existe porque el freno se cuenta al
+     * empezar el intento (ver arriba): quien sepa tu usuario puede gastártelos, y el dueño
+     * tiene que poder devolverte la entrada sin cambiar la contraseña.
+     */
+    clearBlock ({ user } = {}) {
+      const state = read()
+      const u = userOf(state, user)
+      if (!u) throw err('no-user', `there is no login called "${user}"`)
+      u.fails = 0
+      u.nextTryAt = 0
+      save(state)
+      return { ok: true }
+    },
+
+    /**
+     * Un inicio de sesión NO vence solo: lo decide el cliente (dueño, 2026-09-17). Se cierra
+     * al salir, al cambiar la contraseña, al quitar el aparato, o desde la consola — que es
+     * la única forma de cortar el que quedó abierto en un equipo prestado.
+     */
+    closeSession ({ user, sid } = {}) {
+      const state = read()
+      const u = userOf(state, user)
+      if (!u || !u.sessions?.[sid]) return { ok: false }
+      delete u.sessions[sid]
+      save(state)
+      return { ok: true }
+    },
+
+    /** «Se usó»: es lo que deja ver en la consola cuál sigue vivo y cuál se olvidó abierto. */
+    touch ({ user, sid } = {}) {
+      const state = read()
+      const u = userOf(state, user)
+      if (!u || !u.sessions?.[sid]) return { ok: false }
+      u.sessions[sid].lastUsedAt = now()
+      save(state)
+      return { ok: true }
+    },
+
+    /** ¿Tiene esta llave algún inicio de sesión abierto? Lo pregunta quien sirve al aparato. */
+    hasOpenSession ({ pub } = {}) {
+      const state = read()
+      for (const u of Object.values(state.users)) {
+        if (u.pub === pub && Object.keys(u.sessions || {}).length) return true
+      }
+      return false
+    },
+
+    /** Quitar el aparato de aquí. Sacarlo del acta es aparte, y también hay que hacerlo. */
+    remove ({ user } = {}) {
+      const state = read()
+      if (!userOf(state, user)) return { ok: false }
+      delete state.users[user]
+      save(state)
+      return { ok: true }
+    }
+  }
+}
+
+/**
+ * EL ALTA ENTERA: guardar el registro, firmar el certificado y meter al aparato en el acta.
+ *
+ * Vive aquí —y no en cada bóveda— porque las tres versiones tienen que crear exactamente el
+ * mismo aparato: el binario, la pestaña y la extensión. Lo que cambia entre ellas es lo que
+ * hacen DESPUÉS (la bitácora, avisar a los demás aparatos), y eso se queda fuera.
+ *
+ * `replace: true` es cambiar la contraseña: el aparato, su llave y su certificado siguen
+ * siendo los mismos; lo que cambia es con qué se abre el paquete.
+ *
+ * @param {object} opts
+ *   `identity` la identidad que firma (`signDelegation`, `admitMember`)
+ *   `logins`   el escritorio de `createLoginDesk`
+ *   `scope`    permisos del aparato; por defecto firmar, leer y guardar
+ *   `unattended` si además puede trabajar sin que nadie apruebe
+ */
+export async function registerLogin ({
+  identity, logins, user, upload, pub, encPub = null, label = '', blob,
+  scope, unattended = false, replace = false
+} = {}) {
+  if (replace) {
+    logins.registerFinish({ user, upload, blob, replace: true })
+    return { ok: true, user, replaced: true }
+  }
+  // PERMISOS, no tipos: los del scope, más `unattended` si quien lo crea lo eligió
+  // (temporary-access.md §3.1). `passwords` no entra todavía — hasta que existan las
+  // contraseñas selladas, este aparato se llevaría TODAS (sealed-passwords.md).
+  const scopes = Array.isArray(scope) && scope.length ? scope : [SCOPE.SIGN, SCOPE.READ, SCOPE.STORE]
+  if (scopes.includes(SCOPE.PASSWORDS)) {
+    throw Object.assign(new Error('a password login cannot take `contrasenas` yet: the sealed passwords come first'), { code: 'passwords-not-yet' })
+  }
+  if (typeof identity?.admitMember !== 'function') {
+    throw Object.assign(new Error('this vault cannot add devices to the account record: no login was created'), { code: 'admit-unavailable' })
+  }
+  const deviceId = await deviceIdOf(pub)
+  logins.registerFinish({ user, upload, pub, encPub, deviceId, label, blob })
+  try {
+    const { cert } = await identity.signDelegation(pub, scopes, { label: label || `login:${user}` })
+    const cn = scopeToCn(scopes)
+    const caps = [...new Set([...scopeToCaps(scopes), ...(unattended ? ['unattended'] : [])])]
+    await identity.admitMember({ pub, encPub, label: label || `login:${user}`, cn, caps, cert })
+    logins.setCert({ user, cert, iss: identity.me?.publickey || null })
+    return { ok: true, user, deviceId, cert, caps }
+  } catch (e) {
+    // NADA DE MEDIAS ALTAS: si no entra en el acta, no queda un usuario que pueda entrar a
+    // una cuenta que no lo reconoce. Se deshace y se dice.
+    logins.remove({ user })
+    throw e
+  }
+}

package/lib/src/protocol.js

@@ -90,6 +90,19 @@ export const MSG = Object.freeze({
   // firmados de antes y no se pueden falsificar) y la réplica acusa hasta qué `seq` tiene.
   REPLICA_PUSH: 'vault.replica.push',         // master → réplica: { body:{seq,acta,secrets,ts}, signature }
   REPLICA_ACK: 'vault.replica.ack',           // réplica → master: { body:{seq,ts}, signature }
+  // ENTRAR CON USUARIO Y CONTRASEÑA (`src/passwordLogins.js`,
+  // `dotrino-passmanager/docs/temporary-access.md`). Es lo ÚNICO que se atiende sin
+  // certificado y sin firma: quien pregunta todavía no tiene llaves — vienen dentro del
+  // paquete que solo abre su contraseña. La contraseña NO viaja: viajan los mensajes de
+  // OPAQUE, que no la llevan ni dejan adivinarla.
+  LOGIN_START: 'vault.login.start',           // aparato → vault: { user, request }
+  LOGIN_RESPONSE: 'vault.login.response',     // vault → aparato: { lid, response }
+  LOGIN_FINISH: 'vault.login.finish',         // aparato → vault: { lid, finalization, label }
+  LOGIN_OK: 'vault.login.ok',                 // vault → aparato: { sid, blob, cert, iss, acta }
+  // Salir SÍ va firmado, con la llave que acaba de abrir: cerrar la sesión de otro sería
+  // una forma de echar a alguien de su cuenta.
+  LOGIN_CLOSE: 'vault.login.close',           // aparato → vault: { data:{op,user,sid,publickey,ts}, signature }
+  LOGIN_CLOSED: 'vault.login.closed',         // vault → aparato: { ok }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.119.0",
+  "version": "0.121.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -23,8 +23,9 @@
   "dependencies": {
     "@dotrino/compat": "0.4.0",
     "@dotrino/identity": "0.92.0",
+    "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "^0.10.1",
-    "@dotrino/proxy-client": "0.18.2",
+    "@dotrino/proxy-client": "0.23.1",
     "@dotrino/roadmap": "0.3.3",
     "@dotrino/store": "0.11.0",
     "ws": "^8.18.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 } 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'))
 
@@ -362,7 +375,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 +1089,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 +1710,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 +3456,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.