@dotrino/identity 0.98.0 → 0.100.0

package/package.json

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

package/vault/vault.js

@@ -405,7 +405,7 @@ import { pubkeyId } from './capabilities.js'
      * 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 } = {}) => {
+    selfVaultLoginAdd: async ({ user, password, label = '', caps } = {}) => {
       const d = pidaDaemon()
       const { client: opaque } = await import('@dotrino/opaque')
       const { makeDeviceKey, makeDeviceEncKey } = await import('@dotrino/identity/capabilities')
@@ -415,14 +415,15 @@ import { pubkeyId } from './capabilities.js'
       }
       const nombre = String(label || 'equipo prestado')
       const reg = opaque.registrationStart({ password })
-      const { response } = d.loginRegisterBegin({ user, request: reg.request })
+      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
+        // Los PERMISOS del acta, cualquiera de ellos: los traduce a scopes el pilar del vault.
+        label: nombre, blob, ...(caps ? { caps } : {})
       })
       return { ...r, address: loginAddress(user, await accountFingerprint(selfIdentity)) }
     },
@@ -440,15 +441,15 @@ import { pubkeyId } from './capabilities.js'
         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 })
+      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 = d.loginEnd({ lid: begun.lid, finalization: fin.finalization, label: 'consola' })
+      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 } = d.loginRegisterBegin({ user, request: reg.request, replace: true })
+      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

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.71.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/loginClient.js

@@ -34,7 +34,7 @@
  * Si algo de eso falla, se PARA con un `code` propio. No hay repliegue: entrar «a medias»
  * en una cuenta es peor que no entrar.
  */
-import { client as opaque } from '@dotrino/opaque'
+import { client as opaquePorDefecto } from '@dotrino/opaque'
 import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
 import { checkVaultReply } from '@dotrino/identity/acta'
 import { MSG } from './protocol.js'
@@ -82,11 +82,16 @@ const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null
  * @param {string} opts.password
  * @param {string} [opts.label]    de dónde se entra («el cyber de la esquina»): es lo que
  *   el dueño va a leer en su consola para decidir si cerrarlo.
+ * @param {object} [opts.opaque]   el OPAQUE a usar. Por defecto el de casa, que va en este
+ *   mismo hilo. Se inyecta porque en una EXTENSIÓN el WASM vive en una página sandbox, al
+ *   otro lado de un `postMessage`, y entonces sus métodos devuelven promesas — igual que en
+ *   `createLoginDesk`, y por el mismo motivo. Aquí se espera siempre: esperar a algo que no
+ *   es una promesa no cuesta nada, y dos firmas serían dos clientes.
  * @returns {Promise<{user:string,address:string,code:string,sid:string,cert:object,
  *   iss:string,acta:object,vaultToken:string,publickey:string,encPublickey:(string|null),
  *   keys:{sign:object,enc:(object|null)}}>}
  */
-export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS, opaque = opaquePorDefecto } = {}) {
   if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
     throw err('no-transport', 'loginWithPassword: a connected transport is required')
   }
@@ -104,7 +109,7 @@ export async function loginWithPassword ({ transport, address, password, label =
   let ultimo = null
   for (const token of tokens) {
     try {
-      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs, opaque })
     } catch (e) {
       // Se para: son cosas del que entra, y probar con otra bóveda no las arregla.
       if (e?.code === 'login-failed' || e?.code === 'too-many-tries' || e?.code === 'wrong-account' ||
@@ -115,15 +120,15 @@ export async function loginWithPassword ({ transport, address, password, label =
   throw ultimo || err('no-vault', 'none of the vaults on that address could let you in')
 }
 
-async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs }) {
-  const start = opaque.loginStart({ password })
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs, opaque }) {
+  const start = await opaque.loginStart({ password })
   transport.send(token, { type: MSG.LOGIN_START, user, request: start.request })
   const r1 = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_RESPONSE || p.type === MSG.ERROR, timeoutMs)
   if (r1.type === MSG.ERROR) throw deVuelta(r1)
 
   let fin
   try {
-    fin = opaque.loginFinish({ state: start.state, response: r1.response, password })
+    fin = await opaque.loginFinish({ state: start.state, response: r1.response, password })
   } catch (_) {
     // OPAQUE comprueba a las dos partes: aquí se sabe que el otro lado NO conoce el
     // registro de este usuario. Contraseña equivocada, usuario que no existe o una bóveda
@@ -198,11 +203,26 @@ function deVuelta (p) {
  * quedarse bloqueado esperándola. La sesión sigue abierta allí hasta que se cierre desde la
  * consola, y eso ya está dicho en el diseño (§3.2).
  */
-export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, sign, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
   if (!transport || typeof transport.send !== 'function') throw err('no-transport', 'closeLogin: transport required')
   if (!token || !user || !sid || !publickey) throw err('bad-input', 'closeLogin: token, user, sid and publickey are required')
   const data = { op: 'login.close', publickey, user, sid, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk, privateKey, publickey, data })
+  // CON LA LLAVE O CON QUIEN LA TIENE. `sign(data)` es lo normal en el ecosistema —el
+  // transporte se identifica con `identity.signData` y no con una llave suelta— y aquí hace
+  // falta de verdad: en una extensión la llave vive en el service worker y quien tiene el
+  // socket es la página, así que o se firma a distancia o la llave privada tendría que
+  // cruzar para nada. Sin ninguna de las dos no se firma, y salir no se puede fingir.
+  //
+  // Se comprueba ANTES de firmar: sin nada con qué hacerlo, WebCrypto revienta con un error
+  // suyo que no dice qué falta («code: 0»), y el de arriba es el que se puede buscar.
+  if (typeof sign !== 'function' && !privateJwk && !privateKey) {
+    throw err('no-signature', 'closeLogin: give it the device key (privateJwk/privateKey) or a sign(data)')
+  }
+  const firmado = typeof sign === 'function'
+    ? await sign(data)
+    : await signWithDevice({ privateJwk, privateKey, publickey, data })
+  const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+  if (typeof signature !== 'string') throw err('no-signature', 'closeLogin: sign(data) returned no signature')
   transport.send(token, { type: MSG.LOGIN_CLOSE, data, signature })
   try {
     const r = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_CLOSED || p.type === MSG.ERROR, timeoutMs)

package/vault/vendor/vault/passwordLogins.js

@@ -24,10 +24,10 @@
  * 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'
+import { DEVICE_CAPS, capScope } from '@dotrino/identity/acta'
+import { deviceIdOf } from './enroll.js'
 import { bytesToB64url, b64urlToBytes } from './b64.js'
 
 /** Un usuario es la parte de antes de la `@` en `nombre@AB12-CD34-EF56`. */
@@ -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
@@ -430,36 +445,45 @@ export function createLoginDesk ({ load, save, now = () => Date.now() } = {}) {
  * @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
+ *   `caps`     los PERMISOS del acta que lleva el aparato, cualquiera de `DEVICE_CAPS`;
+ *              por defecto firmar, leer y guardar
  */
 export async function registerLogin ({
   identity, logins, user, upload, pub, encPub = null, label = '', blob,
-  scope, unattended = false, replace = false
+  caps = ['sign', 'read', 'store'], scope, 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ó
-  // (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' })
+  // CUALQUIER PERMISO, y todos por el mismo camino (dueño, 2026-09-21: «al crear debe
+  // poder asignársele cualquier permiso»; regla dura «simplificar los procesos»). Antes
+  // llegaban como scopes del certificado con `unattended` aparte, `passwords` se rechazaba
+  // con `passwords-not-yet` y `passkeys` —que no tiene scope— no se podía asignar.
+  //
+  // `scope` ya no se acepta, y se dice: ignorarlo daría al aparato los permisos por defecto
+  // en vez de los que se eligieron, y nadie lo notaría.
+  if (scope !== undefined) {
+    throw Object.assign(new Error('registerLogin takes `caps` (account record permissions), not `scope`'), { code: 'use-caps' })
+  }
+  const pedidos = [...new Set(Array.isArray(caps) ? caps : [])]
+  const raros = pedidos.filter((c) => !DEVICE_CAPS.includes(c))
+  if (!pedidos.length || raros.length) {
+    throw Object.assign(new Error(`not device permissions: ${raros.join(', ') || '(none)'} — expected any of ${DEVICE_CAPS.join(', ')}`), { code: 'bad-caps' })
   }
+  // El certificado lleva el scope de los permisos que lo tienen; los demás (`unattended`,
+  // `passkeys`) viven solo en el acta, que es quien decide.
+  const scopes = pedidos.map((c) => capScope(c)).filter(Boolean)
   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 })
+  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)
-    const caps = [...new Set([...scopeToCaps(scopes), ...(unattended ? ['unattended'] : [])])]
-    await identity.admitMember({ pub, encPub, label: label || `login:${user}`, cn, caps, cert })
+    await identity.admitMember({ pub, encPub, label: label || `login:${user}`, cn: null, caps: pedidos, cert })
     logins.setCert({ user, cert, iss: identity.me?.publickey || null })
-    return { ok: true, user, deviceId, cert, caps }
+    return { ok: true, user, deviceId, cert, caps: pedidos }
   } 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.