@dotrino/identity 0.96.1 → 0.98.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.96.1",
+  "version": "0.98.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/acta.js

@@ -103,7 +103,7 @@ const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
  * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
  * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -117,6 +117,15 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * pedirle algo a la bóveda es exactamente lo que decide el acta — tener dos registros
  * de lo mismo obliga a acordarse de los dos al quitar un aparato.
  *
+ * `passkeys` es ABRIR LA PRIVADA DE UNA PASSKEY. Una passkey no se parece a una
+ * contraseña: es una llave privada que firma el reto de un sitio, y si se copia sirve
+ * **hasta que la borres en cada sitio** donde la registraste — no hay nada que «cambiar».
+ * Por eso su envoltura solo se le hace a quien tenga `passwords` **y** esto
+ * (`dotrino-passmanager/docs/sealed-passwords.md` §2.8).
+ *
+ * Sin `passwords` no significa nada: la passkey vive en una entrada de contraseñas. Y una
+ * SESIÓN no lo lleva nunca, como `passwords` (`session.js`).
+ *
  * `replica` es REPARTIR, NO DECIDIR. Un replicador no tiene maestra: guarda el acta y los
  * sobres —que ya vienen sellados a su destinatario, así que tampoco puede abrirlos— y los
  * entrega cuando la bóveda no está. Firma su respuesta con su propia llave de aparato, y
@@ -140,7 +149,7 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * de la cuenta, se ve en la pantalla de permisos como los demás, y se quita quitándolo —
  * sin acordarse de un segundo registro escondido.
  */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
 
 /**
  * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se

package/vault/session.js

@@ -57,7 +57,7 @@ export const SESSION_SCOPES = Object.freeze(['id:whoami', 'vault:store'])
  * blanca a propósito: si mañana alguien añade un alcance a `SESSION_SCOPES` sin pensarlo,
  * esto sigue cortando lo que no puede pasar.
  */
-export const SESSION_FORBIDDEN = Object.freeze(['secrets', 'admin', 'approve', 'sealer', 'passwords', 'unattended', 'replica'])
+export const SESSION_FORBIDDEN = Object.freeze(['secrets', 'admin', 'approve', 'sealer', 'passwords', 'passkeys', 'unattended', 'replica'])
 
 /** Qué capacidad del acta hace falta para conceder cada alcance de sesión. */
 const SCOPE_NEEDS = Object.freeze({ 'id:whoami': null, 'vault:store': 'store' })

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 } = 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 = 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 = 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 } = 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) => {