@dotrino/identity 0.109.0 → 0.110.1

package/package.json

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

package/vault/core.js

@@ -1121,9 +1121,21 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // se hace al generar una propia — quién puede hacer qué con esta llave lo decide esta
       // casa, no una etiqueta que viajó dentro del paquete.
       const sinTopes = (jwk) => { const { key_ops: _o, ...resto } = jwk || {}; return resto }
-      await adoptJwkPair('sign', KEY_STORAGE, sinTopes(entrada.keys.sign), JSON.parse(entrada.publickey))
-      if (entrada.keys.enc && entrada.encPublickey) {
-        await adoptJwkPair('enc', ENC_KEY_STORAGE, sinTopes(entrada.keys.enc), JSON.parse(entrada.encPublickey))
+      if (keyStore?.importPair) {
+        // DENTRO DE UNA APP NATIVA: la llave que entrega la bóveda la guarda la app (cifrada
+        // con una llave del chip) y firma ella. Van las dos mitades juntas, bajo un mismo id.
+        // Si la bóveda no entrega llave de cifrado, la app estrena una (como hace el navegador).
+        const traeEnc = !!(entrada.keys.enc && entrada.encPublickey)
+        await keyStore.importPair({
+          sign: { name: _scoped(KEY_STORAGE), privateJwk: sinTopes(entrada.keys.sign), publickey: entrada.publickey },
+          enc: { name: _scoped(ENC_KEY_STORAGE), privateJwk: traeEnc ? sinTopes(entrada.keys.enc) : null, publickey: traeEnc ? entrada.encPublickey : null }
+        })
+        kv.removeItem(KEY_STORAGE); kv.removeItem(ENC_KEY_STORAGE)
+      } else {
+        await adoptJwkPair('sign', KEY_STORAGE, sinTopes(entrada.keys.sign), JSON.parse(entrada.publickey))
+        if (entrada.keys.enc && entrada.encPublickey) {
+          await adoptJwkPair('enc', ENC_KEY_STORAGE, sinTopes(entrada.keys.enc), JSON.parse(entrada.encPublickey))
+        }
       }
       saveActa(entrada.acta)
       kv.setItem(ACTA_HISTORY_STORAGE, '[]')
@@ -1147,6 +1159,18 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       list.push({ id: pid, name: entrada.user, pubkey: publickeyJwkStr })
       saveProfiles(list)
       emitVault({ phase: 'login', address: entrada.address, volatile: !remember })
+      // En una app nativa, la cuenta pasa también a su pantalla de Pedidos, con el mismo papel
+      // (como al emparejar). Si la app no la guarda, se dice: la entrada en sí ya está hecha.
+      if (keypair?.privateKey?.external) {
+        keypair.privateKey.paired({
+          cert: entrada.cert, vault: entrada.iss, proxy: proxy || DEFAULT_PROXY,
+          deviceId: await deviceIdDe(entrada.publickey),
+          name: entrada.acta?.name || entrada.address, profileId: entrada.acta?.profileId || null
+        }).then(
+          () => emitVault({ phase: 'native-account', ok: true }),
+          (e) => { console.warn('[identity] the phone did not save the account: ' + e.message); emitVault({ phase: 'native-account', ok: false, code: e.code || 'native-error', reason: e.message }) }
+        )
+      }
       return { id: pid, name: entrada.user, address: entrada.address, user: entrada.user, sid: entrada.sid, volatile: !remember }
     } catch (e) {
       // NADA DE MEDIAS CUENTAS: si algo falla, no se queda una identidad a medio adoptar en

package/vault/externalKeys.js

@@ -78,6 +78,22 @@ export function withExternalKeys (keyStore, bridge) {
       const other = sib ? await keyStore.get(sib) : null
       if (rec?.external && !(other?.external === rec.external)) await bridge.call('remove', { kid: rec.external })
     },
+    /**
+     * UNA LLAVE QUE YA EXISTE (entrar con usuario y contraseña): la bóveda la entrega y no se
+     * puede meter en el chip, así que la app la guarda cifrada con una llave del chip y firma
+     * ella. Desde aquí es una llave externa más: la página no se queda con la privada.
+     * `sign` y `enc`: `{ name, privateJwk, publickey }`, con la pública TAL CUAL la escribe el
+     * acta (es la cadena con la que esa llave es miembro). Si la bóveda no entrega la de
+     * cifrado (`enc.privateJwk` nulo), la app estrena una y devuelve su pública.
+     */
+    async importPair ({ sign, enc }) {
+      const params = { sign: sign.privateJwk, publickey: sign.publickey }
+      if (enc.privateJwk) { params.enc = enc.privateJwk; params.encPub = enc.publickey }
+      const k = await bridge.call('import', params)
+      if (!k?.kid || !k.encPub) throw Object.assign(new Error('the phone did not keep the key'), { code: 'native-no-key' })
+      await keyStore.set(sign.name, { external: k.kid, kind: 'sign', publicJwk: JSON.parse(sign.publickey) })
+      await keyStore.set(enc.name, { external: k.kid, kind: 'enc', publicJwk: JSON.parse(enc.publickey || k.encPub) })
+    },
     async create (kind, name) {
       // Las dos mitades del perfil van bajo la MISMA llave del chip: si la otra ya nació
       // allí, se reutiliza; si no, se crea una nueva.

package/vault/nativeStore.js

@@ -28,8 +28,9 @@ function plainKeyRecord (rec) {
   if (rec && typeof rec.external === 'string' && rec.publicJwk && (rec.kind === 'sign' || rec.kind === 'enc')) {
     return { external: rec.external, kind: rec.kind, publicJwk: rec.publicJwk }
   }
-  // Una llave de SOFTWARE (adoptar un perfil, entrar con contraseña) no cabe en el chip, y
-  // guardarla a medias sería perder la cuenta sin decirlo. Se para aquí y se dice.
+  // Una llave de SOFTWARE no se guarda aquí: guardarla a medias sería perder la cuenta sin
+  // decirlo. La de entrar con contraseña no llega a este punto: la guarda la app, cifrada con
+  // una llave del chip (`importPair` de `externalKeys.js`), y aquí queda su registro externo.
   throw Object.assign(new Error('this app keeps keys in the phone chip only: a software key cannot be stored here'), { code: 'native-no-import' })
 }
 

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.30.1 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.js).
+Copia vendorizada de @dotrino/proxy-client@0.30.4 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/proxy-client/stats-log.js

@@ -37,16 +37,27 @@ const pairs = (prefix, o) => PATHS.map((k) => `${prefix}.${k}=${o[k]}`).join(' '
  */
 export function formatStats (s, opts = {}) {
   const tag = opts.label ? `[net] ${opts.label}` : '[net]'
+  // QUIÉN CONTESTÓ Y QUIÉN NO. Un sondeo (un ping a cada aparato del acta) deja una entrada
+  // por destinatario aunque nadie responda: esas no son conexiones y van resumidas
+  // (`unanswered`), igual que en el informe del topbar y de las apps nativas.
+  // `unknown`: quien nos escribió, nunca recibió respuesta y no sabemos su llave (otro aparato
+  // sondeando qué máquinas están encendidas). Tampoco es una conexión.
+  const isUnknown = (p) => p.msgsIn > 0 && !(p.msgsOut > 0) && !p.pubkey
+  const unknown = s.peers.filter(isUnknown)
+  const talking = s.peers.filter((p) => p.msgsIn > 0 && !isUnknown(p))
+  const silent = s.peers.filter((p) => !(p.msgsIn > 0))
   const routes = {}
-  for (const p of s.peers) routes[p.route] = (routes[p.route] || 0) + 1
+  for (const p of talking) routes[p.route] = (routes[p.route] || 0) + 1
   const routeList = Object.keys(routes).sort().map((r) => `${r}=${routes[r]}`).join(',') || 'none'
   const lines = [
     `${tag} url=${s.url} connected=${s.connected ? 'yes' : 'no'} webrtc=${s.webrtc ? 'on' : 'off'}` +
     ` ws.in=${s.proxy.bytesIn} ws.out=${s.proxy.bytesOut}` +
     ` ${pairs('in', sum(s.peers, 'bytesIn'))} ${pairs('out', sum(s.peers, 'bytesOut'))}` +
-    ` peers=${s.peers.length} routes=${routeList}`
+    ` peers=${talking.length} routes=${routeList}` +
+    (silent.length ? ` unanswered=${silent.length} unanswered.out=${silent.reduce((n, p) => n + PATHS.reduce((m, k) => m + p.bytesOut[k], 0), 0)}` : '') +
+    (unknown.length ? ` unknown=${unknown.length} unknown.in=${unknown.reduce((n, p) => n + PATHS.reduce((m, k) => m + p.bytesIn[k], 0), 0)}` : '')
   ]
-  for (const p of s.peers) {
+  for (const p of talking) {
     lines.push(
       `${tag}   peer=${p.token || 'by-key'} route=${p.route}` +
       ` ${pairs('in', p.bytesIn)} ${pairs('out', p.bytesOut)} msgs.in=${p.msgsIn} msgs.out=${p.msgsOut}`

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.80.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
+Copia vendorizada de @dotrino/vault@0.82.1 (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