@dotrino/vaultd 0.118.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/enroll.js

@@ -349,23 +349,50 @@ export function createEnrollDesk ({
       return { ok: true, deviceId: pend.deviceId, adopting: true }
     }
 
-    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
-
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
     // credencial y el acta es la política, y no tiene sentido emitir una sin la otra.
     // Las capacidades salen del scope que se pidió al emparejar (cert ∩ acta, §2.3).
-    let record = null
+    //
+    // NADA DE REPLIEGUES (2026-09-17). Esto antes estaba envuelto en un `catch` que solo
+    // anotaba el error, y además se saltaba en silencio si la identidad no sabía admitir o si
+    // el scope no daba ninguna capacidad: el aparato recibía su certificado SIN estar en el
+    // acta, y el fallo aparecía después y en otro sitio. Ahora, si no se puede admitir, no
+    // se entrega nada y se dice.
+    if (typeof identity.admitMember !== 'function') {
+      throw Object.assign(new Error('this vault cannot add devices to the account record: no certificate was issued'), { code: 'admit-unavailable' })
+    }
+    // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
+    // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
+    // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    const cn = scopeToCn(pend.scope)
+    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    if (!caps.length) {
+      throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
+    }
+
+    const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
+
     try {
-      if (typeof identity.admitMember === 'function') {
-        // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
-        // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
-        // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
-        const cn = scopeToCn(pend.scope)
-        const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+    } catch (e) {
+      // El certificado ya está firmado y no se entrega: se revoca, para que no quede uno
+      // válido suelto. Si ni eso sale, se dice también.
+      let revoked = true
+      try { await identity.revokeDelegation(cert.nonce) } catch (re) {
+        revoked = false
+        log('[vault] could not revoke the undelivered certificate %s: %s', cert.nonce, re.message)
       }
-      record = (await identity.profileActa?.())?.acta || null
-    } catch (e) { log('[vault] could not admit into the record:', e.message) }
+      audit('rejected', { what: 'approve', device: pend.deviceId, reason: 'admit-failed' })
+      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not add this device to the account: pairing failed, try again' })
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      log('[vault] could not add %s to the record, no certificate was delivered: %s', pend.deviceId, e.message)
+      throw Object.assign(
+        new Error(`could not add the device to the account record (${e.message}): no certificate was delivered${revoked ? '' : ', and the signed one could not be revoked'}`),
+        { code: 'admit-failed', cause: e }
+      )
+    }
+    const record = (await identity.profileActa?.())?.acta || null
 
     audit('enroll', { device: pend.deviceId, label: pend.label || '', scope: pend.scope })
     // Echamos el código tipeado junto al cert: el DISPOSITIVO acepta solo si coincide

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)