@dotrino/identity 0.97.0 → 0.99.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.97.0",
+  "version": "0.99.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -561,6 +561,36 @@ export class Identity {
   /** Suscribe a eventos del self-vault ('selfVault'): { running?, pending?, error? }. */
   onSelfVault (handler) { return this.on('selfVault', handler) }
 
+  // ----- entrar con usuario y contraseña, cuando la bóveda es ESTA pestaña -----
+  //
+  // La pestaña ya atendía el inicio de sesión desde el primer día; lo que faltaba era poder
+  // CREARLO, y sin eso solo el binario daba de alta el aparato — que rompe la regla de las
+  // tres versiones. Todo esto exige que esta pestaña sea la bóveda activa; si no lo es, se
+  // dice con `code: 'not-the-vault'` en vez de contestar una lista vacía.
+
+  /** Los aparatos que se abren con usuario y contraseña, con sus sesiones abiertas. */
+  async selfVaultLogins () { return this._call('selfVaultLogins') }
+
+  /**
+   * Da de alta uno. La contraseña **no sale del iframe**: se comprueba con OPAQUE y de ella
+   * deriva la llave que cierra el paquete con las privadas del aparato nuevo.
+   *
+   * Devuelve su dirección `nombre@AB12-CD34-EF56`, que es lo que hay que teclear al entrar.
+   */
+  async selfVaultLoginAdd (opts) { return this._call('selfVaultLoginAdd', opts || {}, 60000) }
+
+  /** Cambia la contraseña: hace falta la vieja, y lo que estuviera abierto se cierra. */
+  async selfVaultLoginPasswd (opts) { return this._call('selfVaultLoginPasswd', opts || {}, 60000) }
+
+  /** Cierra un inicio de sesión abierto (sin `sid`, todos los de ese usuario). */
+  async selfVaultLoginClose (opts) { return this._call('selfVaultLoginClose', opts || {}) }
+
+  /** Quita la espera que dejan los intentos fallidos. */
+  async selfVaultLoginUnblock (user) { return this._call('selfVaultLoginUnblock', { user }) }
+
+  /** Lo quita, y saca su llave del acta: las dos cosas, o ninguna. */
+  async selfVaultLoginRemove (user) { return this._call('selfVaultLoginRemove', { user }, 30000) }
+
   // ----- multi-perfil por dispositivo -----
   // Podés tener varios perfiles (identidades) en el mismo navegador, cada uno conectado o no
   // a su propio vault. Crear/cambiar setea el perfil activo; la app RECARGA la página y toma

package/vault/vault.js

@@ -383,7 +383,119 @@ import { pubkeyId } from './capabilities.js'
     },
     // Presencia online (ping/pong) de las máquinas enroladas. Requiere que ESTE
     // iframe sea el daemon activo (tiene el cliente del proxy); si no, devuelve [].
-    selfVaultProbe: async ({ pubkeys }) => ({ online: [...(await probeOnline(pubkeys || []))] })
+    selfVaultProbe: async ({ pubkeys }) => ({ online: [...(await probeOnline(pubkeys || []))] }),
+
+    // ----- ENTRAR CON USUARIO Y CONTRASEÑA, desde la PESTAÑA -----
+    //
+    // La bóveda-pestaña ya sabía ATENDER un inicio de sesión desde el primer día; lo que no
+    // había era forma de CREAR uno: el mostrador estaba montado y sus operaciones no
+    // asomaban por aquí, así que solo el binario podía dar de alta el aparato. Eso rompe la
+    // regla de las tres versiones (`sealed-passwords.md` §2.7), y esto la cumple.
+    //
+    // El OPAQUE de las dos puntas corre AQUÍ DENTRO: el alta necesita la mitad del cliente
+    // —la que tiene la contraseña— y la mitad del servidor, y las dos están en esta pestaña
+    // cuando es bóveda. La contraseña cruza el `postMessage` como ya lo hace la del perfil
+    // (`unlockProfile`), y no sale de este origen.
+    selfVaultLogins: async () => (daemon ? daemon.listLogins() : []),
+
+    /**
+     * DAR DE ALTA un aparato que se abre con usuario y contraseña.
+     *
+     * Las llaves del aparato NACEN aquí y salen ya cerradas con lo que deriva la contraseña:
+     * la bóveda guarda un paquete que no puede abrir. Es el mismo camino que `logins add`
+     * del binario, con la misma pieza compartida.
+     */
+    selfVaultLoginAdd: async ({ user, password, label = '', scope = null, unattended = false } = {}) => {
+      const d = pidaDaemon()
+      const { client: opaque } = await import('@dotrino/opaque')
+      const { makeDeviceKey, makeDeviceEncKey } = await import('@dotrino/identity/capabilities')
+      const { sealDeviceKeys, loginAddress, accountFingerprint } = await import('@dotrino/vault/password-logins')
+      if (typeof password !== 'string' || password.length < 12) {
+        throw Object.assign(new Error('the password must be at least 12 characters'), { code: 'weak-password' })
+      }
+      const nombre = String(label || 'equipo prestado')
+      const reg = opaque.registrationStart({ password })
+      const { response } = await d.loginRegisterBegin({ user, request: reg.request })
+      const fin = opaque.registrationFinish({ state: reg.state, response, password })
+      const device = await makeDeviceKey({ label: nombre })
+      const enc = await makeDeviceEncKey()
+      const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.encPrivateJwk })
+      const r = await d.loginRegisterFinish({
+        user, upload: fin.upload, pub: device.publickey, encPub: enc.encPublickey,
+        label: nombre, blob, ...(Array.isArray(scope) && scope.length ? { scope } : {}), unattended: !!unattended
+      })
+      return { ...r, address: loginAddress(user, await accountFingerprint(selfIdentity)) }
+    },
+
+    /**
+     * CAMBIAR LA CONTRASEÑA es abrir y volver a cerrar: el aparato, su llave y su papel
+     * siguen siendo los mismos. Por eso hace falta la vieja — sin ella no hay nada que
+     * volver a cerrar — y por eso lo que estuviera abierto se cierra.
+     */
+    selfVaultLoginPasswd: async ({ user, oldPassword, newPassword } = {}) => {
+      const d = pidaDaemon()
+      const { client: opaque } = await import('@dotrino/opaque')
+      const { sealDeviceKeys, openDeviceKeys } = await import('@dotrino/vault/password-logins')
+      if (typeof newPassword !== 'string' || newPassword.length < 12) {
+        throw Object.assign(new Error('the password must be at least 12 characters'), { code: 'weak-password' })
+      }
+      const start = opaque.loginStart({ password: oldPassword })
+      const begun = await d.loginBegin({ user, request: start.request })
+      let fin
+      try { fin = opaque.loginFinish({ state: start.state, response: begun.response, password: oldPassword }) }
+      catch (_) { throw Object.assign(new Error('wrong password'), { code: 'login-failed' }) }
+      const entered = await d.loginEnd({ lid: begun.lid, finalization: fin.finalization, label: 'consola' })
+      const keys = await openDeviceKeys(fin.exportKey, entered.blob)
+
+      const reg = opaque.registrationStart({ password: newPassword })
+      const { response } = await d.loginRegisterBegin({ user, request: reg.request, replace: true })
+      const nueva = opaque.registrationFinish({ state: reg.state, response, password: newPassword })
+      await d.loginRegisterFinish({
+        user, upload: nueva.upload, blob: await sealDeviceKeys(nueva.exportKey, keys), replace: true
+      })
+      return { ok: true, user }
+    },
+
+    /** Cerrar un inicio de sesión abierto (sin `sid`, todos los de ese usuario). */
+    selfVaultLoginClose: async ({ user, sid = null } = {}) => {
+      const d = pidaDaemon()
+      if (sid) return d.closeLogin({ user, sid })
+      const fila = d.listLogins().find((x) => x.user === user)
+      for (const s of fila?.sessions || []) d.closeLogin({ user, sid: s.sid })
+      return { ok: true, closed: (fila?.sessions || []).length }
+    },
+
+    /** Quitar la espera de los intentos fallidos, desde la máquina de la bóveda. */
+    selfVaultLoginUnblock: async ({ user } = {}) => pidaDaemon().clearLoginBlock({ user }),
+
+    /**
+     * QUITARLO. Se va de aquí **y su llave sale del acta**: borrar solo el inicio de sesión
+     * dejaba un miembro que ya no puede entrar y sigue siendo de la cuenta.
+     */
+    selfVaultLoginRemove: async ({ user } = {}) => {
+      const d = pidaDaemon()
+      const fila = d.listLogins().find((x) => x.user === user)
+      const r = d.removeLogin({ user })
+      if (r?.ok && fila?.pub) {
+        try { await handlers.revokeDevice({ sub: fila.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, deviceId: fila?.deviceId || null }
+    }
+  }
+
+  /**
+   * El mostrador solo existe mientras ESTA pestaña sea la bóveda activa. Se dice con esas
+   * palabras porque es lo que hay que hacer: abrirla y dejarla visible.
+   */
+  function pidaDaemon () {
+    if (!daemon) {
+      throw Object.assign(
+        new Error('this tab is not the active vault: open it as a visible tab and turn on «this device is a vault»'),
+        { code: 'not-the-vault' })
+    }
+    return daemon
   }
 
   window.addEventListener('message', async (event) => {

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.67.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
+Copia vendorizada de @dotrino/vault@0.68.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y

package/vault/vendor/vault/index.js

@@ -394,7 +394,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   async function handleLoginStart (from, p) {
     if (!logins) return noLogins(from)
     try {
-      const { lid, response } = logins.loginBegin({ user: p?.user, request: p?.request })
+      const { lid, response } = await logins.loginBegin({ user: p?.user, request: p?.request })
       send(from, { type: MSG.LOGIN_RESPONSE, lid, response })
     } catch (e) { loginError(from, e) }
   }
@@ -402,7 +402,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   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 r = await 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) }

package/vault/vendor/vault/passwordLogins.js

@@ -24,7 +24,7 @@
  * 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 { server as opaquePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { deviceIdOf, scopeToCaps, scopeToCn } from './enroll.js'
 import { SCOPE } from './protocol.js'
@@ -181,10 +181,25 @@ export async function openDeviceKeys (exportKey, blob) {
  *   `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
+ *   `opaque`  la mitad de SERVIDOR de OPAQUE. Por defecto la del paquete, que es WASM y
+ *     corre en el mismo hilo. Se puede inyectar OTRA porque en una extensión MV3 el WASM
+ *     vive al otro lado de un `postMessage` —en una página sandbox, para no tener que
+ *     abrirle la CSP a toda la extensión—, y desde allí solo puede contestar una promesa.
+ *
+ * **Por eso los métodos que tocan OPAQUE son ASÍNCRONOS**, también con la implementación de
+ * casa: una firma que cambia según quién la use son dos mostradores, y de eso va la regla
+ * de las tres versiones.
  */
-export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
+export function createLoginDesk ({ load, save, now = () => Date.now(), opaque = opaquePorDefecto } = {}) {
   if (typeof load !== 'function' || typeof save !== 'function') throw new Error('createLoginDesk: load and save are required')
 
+  /**
+   * QUÉ SUITE se está usando, dicha por quien hace el cálculo. Con el OPAQUE de casa es la
+   * del paquete; con uno inyectado, la suya — preguntárselo a él es lo único que no miente,
+   * porque el registro que queda guardado lo hizo él.
+   */
+  const suite = () => (typeof opaque.suiteId === 'function' ? opaque.suiteId() : suitePorDefecto())
+
   /** Intercambios a medias: viven en memoria, y por eso un reinicio los tira. */
   const exchanges = new Map()
 
@@ -195,9 +210,9 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
   }
 
   /** La preparación del servidor nace con el primer usuario y no se toca nunca más. */
-  function setupOf (state) {
+  async function setupOf (state) {
     if (state.setup) return state.setup
-    state.setup = opaque.createSetup()
+    state.setup = await opaque.createSetup()
     return state.setup
   }
 
@@ -234,30 +249,30 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
      * 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 } = {}) {
+    async 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 })
+      const setup = await setupOf(state)
+      const response = await opaque.registrationResponse({ setup, request, credentialId: user })
       save(state)
-      return { response, suite: suiteId() }
+      return { response, suite: await suite() }
     },
 
     /**
      * 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 } = {}) {
+    async 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 record = await opaque.registrationFinish({ upload })
       const t = now()
       state.users[user] = {
         ...(existing || {}),
@@ -267,7 +282,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
         label: label || existing?.label || '',
         record,
         blob,
-        suite: suiteId(),
+        suite: await suite(),
         createdAt: existing?.createdAt || t,
         passwordChangedAt: t,
         // Cambiar la contraseña cierra lo abierto: si alguien entró con la vieja, deja de
@@ -277,7 +292,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
         nextTryAt: 0
       }
       save(state)
-      return { user, suite: suiteId() }
+      return { user, suite: await suite() }
     },
 
     /** El certificado del aparato, que firma la bóveda al admitirlo en el acta. Es público. */
@@ -298,7 +313,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
      * 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 } = {}) {
+    async loginBegin ({ user, request } = {}) {
       sweepExchanges()
       const state = read()
       if (typeof request !== 'string' || !request) throw err('bad-input', 'request required')
@@ -314,8 +329,8 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
         u.fails = (u.fails || 0) + 1
         u.nextTryAt = t + backoffFor(u.fails)
       }
-      const setup = setupOf(state)
-      const { state: serverState, response } = opaque.loginStart({
+      const setup = await setupOf(state)
+      const { state: serverState, response } = await opaque.loginStart({
         setup,
         record: u?.record || null,
         request,
@@ -332,7 +347,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
      * 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 = '' } = {}) {
+    async 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')
@@ -341,7 +356,7 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
       const u = x.known ? state.users[x.user] : null
 
       try {
-        opaque.loginFinish({ state: x.state, finalization })
+        await 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
@@ -438,7 +453,7 @@ export async function registerLogin ({
   scope, unattended = false, replace = false
 } = {}) {
   if (replace) {
-    logins.registerFinish({ user, upload, blob, replace: true })
+    await 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ó
@@ -452,7 +467,7 @@ export async function registerLogin ({
     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 })
+  await 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)