@dotrino/identity 0.102.2 → 0.104.0

package/package.json

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

package/vault/capabilities.js

@@ -52,6 +52,9 @@ export const LEGACY_CERTS_UNTIL = Date.parse('2026-10-01T00:00:00Z')
 const enc = (s) => new TextEncoder().encode(s)
 
 async function rawSign (privateKey, bytes) {
+  // Una llave EXTERNA (el chip del teléfono, `vault/vault.js`) firma ella misma: aquí no
+  // hay CryptoKey que pasarle a WebCrypto. Devuelve la misma firma P1363 en base64.
+  if (privateKey?.external) return privateKey.sign(bytes)
   return bufToBase64(await crypto.subtle.sign(SIGN, privateKey, bytes))
 }
 async function rawVerify (publicJwkStr, bytes, sigB64) {

package/vault/content.js

@@ -37,8 +37,11 @@ const fromB64 = (str) => {
 }
 
 async function sharedKey (privateKey, peerPubJwkStr) {
-  const pub = await subtle.importKey('jwk', JSON.parse(peerPubJwkStr), ECDH, false, [])
-  const bits = await subtle.deriveBits({ name: 'ECDH', public: pub }, privateKey, 256)
+  // Llave EXTERNA: el acuerdo ECDH lo hace el chip y devuelve los 32 bytes del secreto
+  // (lo mismo que `deriveBits(…, 256)`); la privada no sale de allí.
+  const bits = privateKey?.external
+    ? await privateKey.deriveBits(peerPubJwkStr)
+    : await subtle.deriveBits({ name: 'ECDH', public: await subtle.importKey('jwk', JSON.parse(peerPubJwkStr), ECDH, false, []) }, privateKey, 256)
   return subtle.importKey('raw', bits, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt'])
 }
 

package/vault/core.js

@@ -88,6 +88,13 @@ async function importPeerEncPubkey (jwkStr) {
 }
 
 async function deriveSharedAesKey (myPriv, peerPub) {
+  if (myPriv?.external) {
+    // Llave EXTERNA: el chip da los 32 bytes del secreto ECDH, que es exactamente lo que
+    // `deriveKey` ECDH→AES-256 usa por dentro. Mismo AES, sin que la privada salga.
+    const { kty, crv, x, y } = await crypto.subtle.exportKey('jwk', peerPub)
+    const bits = await myPriv.deriveBits(JSON.stringify({ kty, crv, x, y }))
+    return crypto.subtle.importKey('raw', bits, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])
+  }
   return crypto.subtle.deriveKey(
     { name: 'ECDH', public: peerPub },
     myPriv,
@@ -98,6 +105,7 @@ async function deriveSharedAesKey (myPriv, peerPub) {
 }
 
 async function signBytes (privateKey, bytes) {
+  if (privateKey?.external) return privateKey.sign(bytes) // el chip del teléfono (ver rawSign)
   const sig = await crypto.subtle.sign({ name: 'ECDSA', hash: { name: 'SHA-256' } }, privateKey, bytes)
   return bufToBase64(sig)
 }
@@ -330,6 +338,13 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
           return { privateKey, publicKey: await importPub(publicJwk), publicJwk }
         } catch (_) {}
       }
+      // El ANFITRIÓN puede crear la llave fuera (dentro de la app de Android: en el chip del
+      // teléfono, `vault/vault.js`). Guarda él su registro y devuelve un asa externa. Sin
+      // `create` —el navegador y las ~30 apps— el camino es el de siempre.
+      if (keyStore.create) {
+        const made = await keyStore.create(kind, name)
+        return { privateKey: made.privateKey, publicKey: await importPub(made.publicJwk), publicJwk: made.publicJwk }
+      }
       const pair = await crypto.subtle.generateKey(algo, false, pairUses) // privada NO extractable
       const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
       await keyStore.set(name, { privateKey: pair.privateKey, publicJwk })
@@ -1282,6 +1297,18 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     // Conectarse a una bóveda es ENTRAR A SU CUENTA: el acta viene con el cert.
     const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
     emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join: unido })
+    // LA LLAVE ES DEL CHIP DEL TELÉFONO (app de Android): la app guarda la cuenta para su
+    // pantalla nativa de Pedidos, con el MISMO papel. Así el teléfono es un solo aparato en
+    // el acta. Si la app no la guarda, se dice: el emparejamiento en sí ya está hecho.
+    if (keypair?.privateKey?.external) {
+      keypair.privateKey.paired({
+        cert: res.cert, vault: res.master, proxy: res.proxy, deviceId: res.deviceId,
+        name: res.account || res.acta?.name || '', profileId: res.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 }) }
+      )
+    }
     pullProfileFromVault() // adoptar el perfil que ya viva en el vault (si hay)
     return { ok: true, deviceId: res.deviceId, master: res.master, seq: res.cert.seq, scope: res.cert.scope, join: unido }
   }

package/vault/externalKeys.js

@@ -0,0 +1,129 @@
+/**
+ * LLAVES QUE NO VIVEN AQUÍ: el chip del teléfono, dentro de la app de Dotrino.
+ *
+ * En la app de Android el iframe corre en un WebView, y el teléfono ya tiene su llave de
+ * cada cuenta en el Keystore (la que aprueba en la pantalla nativa de Pedidos). Si el
+ * WebView se hiciera la suya, el teléfono serían DOS aparatos en el acta: uno con perfil y
+ * sin aprobar, otro aprobando y sin perfil (dueño, 2026-09-25: «es como si el perfil viviera
+ * solo en nativo y no en el webview»). Con esto hay UNA llave: el WebView firma y descifra
+ * con la del chip, y la privada nunca entra en esta página.
+ *
+ * Este módulo envuelve el `keyStore` de IndexedDB. Lo que guarda por llave es un registro
+ * sin nada secreto: `{ external: kid, kind, publicJwk }`. Al leerlo lo convierte en un ASA,
+ * que es lo que `core.js` trata como privada: `{ external: true, sign, deriveBits }`. Las
+ * cuatro funciones que usan una privada (`rawSign`, `signBytes`, `sharedKey`,
+ * `deriveSharedAesKey`) saben qué hacer con ella.
+ *
+ * `bridge.call(method, params)` habla con la app: `create`, `open`, `sign`, `deriveBits`,
+ * `save`, `remove`. La app solo le enseña el puente a `https://id.dotrino.com`.
+ */
+
+const b64 = (buf) => {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf)
+  let s = ''
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
+  return btoa(s)
+}
+const fromB64 = (str) => {
+  const bin = atob(str)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+const SIGN_SUFFIX = '.keypair'
+const ENC_SUFFIX = '.enc-keypair'
+
+/** El nombre de la OTRA mitad del mismo perfil: firma y cifrado comparten llave en el chip. */
+function siblingName (name) {
+  if (name.endsWith(ENC_SUFFIX)) return name.slice(0, -ENC_SUFFIX.length) + SIGN_SUFFIX
+  if (name.endsWith(SIGN_SUFFIX)) return name.slice(0, -SIGN_SUFFIX.length) + ENC_SUFFIX
+  return null
+}
+
+/** El asa de una llave del chip. Lo que la app no pueda hacer sale con su `code`, sin plan B. */
+export function externalHandle (bridge, kid) {
+  return {
+    external: true,
+    kid,
+    async sign (bytes) {
+      const { signature } = await bridge.call('sign', { kid, data: b64(bytes) })
+      return signature
+    },
+    async deriveBits (peerPubJwkStr) {
+      const { bits } = await bridge.call('deriveBits', { kid, peer: peerPubJwkStr })
+      return fromB64(bits).buffer
+    },
+    /** Tras emparejar: la app guarda la cuenta para su pantalla de Pedidos. */
+    async paired (account) { return bridge.call('save', { kid, ...account }) }
+  }
+}
+
+/**
+ * Envuelve `keyStore` para que las llaves NUEVAS nazcan en el chip. Las que ya existían
+ * (CryptoKey de IndexedDB) siguen igual: una llave no extraíble no se puede mover.
+ */
+export function withExternalKeys (keyStore, bridge) {
+  const toHandle = (rec) => (rec && rec.external
+    ? { privateKey: externalHandle(bridge, rec.external), publicJwk: rec.publicJwk }
+    : rec)
+  return {
+    async get (name) { return toHandle(await keyStore.get(name)) },
+    set: (name, pair) => keyStore.set(name, pair),
+    async remove (name) {
+      const rec = await keyStore.get(name)
+      await keyStore.remove(name)
+      // Se borra del chip cuando ya no queda ninguna de las dos mitades del perfil.
+      const sib = siblingName(name)
+      const other = sib ? await keyStore.get(sib) : null
+      if (rec?.external && !(other?.external === rec.external)) await bridge.call('remove', { kid: rec.external })
+    },
+    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.
+      const sib = siblingName(name)
+      const other = sib ? await keyStore.get(sib) : null
+      const k = other?.external
+        ? await bridge.call('open', { kid: other.external })
+        : await bridge.call('create', {})
+      const publicJwk = kind === 'enc' ? k.encPub : k.publickey
+      if (!k?.kid || !publicJwk) throw Object.assign(new Error('the phone did not return a key'), { code: 'native-no-key' })
+      const rec = { external: k.kid, kind, publicJwk: typeof publicJwk === 'string' ? JSON.parse(publicJwk) : publicJwk }
+      await keyStore.set(name, rec)
+      return { privateKey: externalHandle(bridge, k.kid), publicJwk: rec.publicJwk }
+    }
+  }
+}
+
+/**
+ * El puente de la app visto desde la página: `window.DotrinoIdentityKeys` (un
+ * `addWebMessageListener` de Android). Mensajes `{ id, method, params }` → `{ id, result }`
+ * o `{ id, error, code }`.
+ */
+export function appBridge (port, { timeoutMs = 20000 } = {}) {
+  let seq = 0
+  const waiting = new Map()
+  port.onmessage = (ev) => {
+    let m
+    try { m = JSON.parse(ev.data) } catch (_) { return }
+    const w = waiting.get(m?.id)
+    if (!w) return
+    waiting.delete(m.id)
+    clearTimeout(w.t)
+    if (m.error) w.reject(Object.assign(new Error(m.error), { code: m.code || 'native-error' }))
+    else w.resolve(m.result)
+  }
+  return {
+    call (method, params = {}) {
+      const id = 'k' + (++seq)
+      return new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+          waiting.delete(id)
+          reject(Object.assign(new Error(`the phone did not answer ${method}`), { code: 'native-no-reply' }))
+        }, timeoutMs)
+        waiting.set(id, { resolve, reject, t })
+        port.postMessage(JSON.stringify({ id, method, params }))
+      })
+    }
+  }
+}

package/vault/nativeStore.js

@@ -0,0 +1,80 @@
+/**
+ * TODO LO DE LA IDENTIDAD EN LA APP, NO EN LA PÁGINA (app de iOS, 2026-09-26).
+ *
+ * WebKit guarda el localStorage y el IndexedDB de un iframe de otro origen APARTE por cada
+ * página que lo contiene. Dentro de la app de iOS eso partía la identidad en tantas como
+ * páginas: `dotrino.com`, `profile.dotrino.com` y `vault.dotrino.com` veían cada una un
+ * perfil distinto, recién inventado (dueño: «todas deberían tener el perfil/perfiles
+ * cargados nativamente»). El WebView de Android no separa así, y por eso allí no pasaba.
+ *
+ * Con esto, cuando la app lo ofrece (`bridge.storage`), las tres piezas que la identidad
+ * guarda —el `kv` síncrono, los registros de llaves y el libro de contactos— viven en UN
+ * almacén de la app, el mismo para todas las páginas. Nada secreto viaja: las llaves son del
+ * chip (el registro es `{ external: kid, kind, publicJwk }`) y el resto es lo que ya se
+ * guardaba en el disco de la página.
+ *
+ * Cómo: al arrancar se trae TODO de una vez (`storeLoad`) y se sirve desde memoria, que es
+ * lo que el `kv` necesita para seguir siendo síncrono. Cada cambio se escribe en la app al
+ * momento, en orden. Solo hay un iframe de identidad vivo a la vez (la app tiene un solo
+ * WebView), así que no hay dos memorias que se pisen.
+ */
+
+const KV = 'kv:'
+const KEY = 'key:'
+const PEERS = 'peers:'
+
+/** El asa de una llave no se puede guardar en la app: solo su registro, que no tiene nada secreto. */
+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.
+  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' })
+}
+
+export async function nativeBackends (bridge) {
+  const { items } = await bridge.call('storeLoad', {})
+  if (!items || typeof items !== 'object') {
+    throw Object.assign(new Error('the app did not return its store'), { code: 'native-no-store' })
+  }
+  const mem = new Map(Object.entries(items))
+
+  // Escrituras EN ORDEN: un `remove` que adelantara a su `set` resucitaría el dato. Una que
+  // falla se dice en la consola con su código (sin tragársela) y no frena a las siguientes.
+  let chain = Promise.resolve()
+  const write = (method, params) => {
+    chain = chain.then(() => bridge.call(method, params)).catch((e) => {
+      console.error(`[cc-identity] native store ${method} failed (${e?.code || 'error'}): ${e?.message}`)
+    })
+    return chain
+  }
+  const set = (k, v) => { mem.set(k, v); return write('storeSet', { k, v }) }
+  const del = (k) => { mem.delete(k); return write('storeRemove', { k }) }
+
+  const kv = {
+    getItem: (k) => (mem.has(KV + k) ? mem.get(KV + k) : null),
+    setItem: (k, v) => { set(KV + k, String(v)) },
+    removeItem: (k) => { del(KV + k) }
+  }
+
+  const keyStore = {
+    async get (name) {
+      const raw = mem.get(KEY + name)
+      return raw ? JSON.parse(raw) : null
+    },
+    async set (name, rec) { await set(KEY + name, JSON.stringify(plainKeyRecord(rec))) },
+    async remove (name) { await del(KEY + name) }
+  }
+
+  // El libro de contactos por perfil (`peerStore.useBackend`).
+  const peers = {
+    async get (key) {
+      const raw = mem.get(PEERS + key)
+      return raw ? JSON.parse(raw) : null
+    },
+    async put (key, val) { await set(PEERS + key, JSON.stringify(val)) }
+  }
+
+  return { kv, keyStore, peers, flush: () => chain }
+}

package/vault/peerStore.js

@@ -40,6 +40,14 @@ let _pid = null
  */
 let _volatile = false
 
+/**
+ * Otro almacén para el libro, en vez del IndexedDB de la página: el de la app de iOS
+ * (`nativeStore.js`), que es uno para todas las páginas. `{ get(key), put(key, val) }`.
+ * Se pone antes de `initPeerStorage`.
+ */
+let _backend = null
+export function useBackend (b) { _backend = b || null }
+
 /** Registra el callback que marca el estado como "sucio" para el sync. */
 export function onDirty (fn) { _markDirty = fn }
 
@@ -53,6 +61,7 @@ function peersKey () { return _pid ? `peers.${_pid}.v1` : IDB_PEERS_KEY }
 
 /** Migración: copia el peer book VIEJO (pre-multi-perfil, sin namespace) al perfil `pid`. */
 export async function adoptLegacy (pid) {
+  if (_backend) return   // el almacén de la app nació después: no hay libro viejo que adoptar
   try {
     _idb = _idb || await openIdb()
     let legacy = await idbGet(_idb, IDB_PEERS_KEY) // 'peers.v1' (viejo)
@@ -103,6 +112,11 @@ export async function initPeerStorage () {
   try { if (typeof navigator !== 'undefined' && navigator.storage?.persist) await navigator.storage.persist() }
   catch (_) { /* best-effort */ }
   if (_volatile) { _peers = {}; return _peers }
+  if (_backend) {
+    const stored = await _backend.get(peersKey())
+    _peers = (stored && typeof stored === 'object') ? stored : {}
+    return _peers
+  }
   try {
     _idb = await openIdb()
     const stored = await idbGet(_idb, peersKey()) // peer book DEL perfil activo (namespaceado)
@@ -120,6 +134,13 @@ export async function initPeerStorage () {
 function persistPeers () {
   if (_volatile) return _writeChain   // cuenta volátil: en memoria y en ningún disco
   const key = peersKey()
+  if (_backend) {
+    const snapshot = _peers
+    _writeChain = _writeChain
+      .then(() => _backend.put(key, snapshot))
+      .catch(e => console.warn('[cc-identity] persist (app) failed:', e?.message))
+    return _writeChain
+  }
   if (_fallback || !_idb) {
     try { localStorage.setItem(key, JSON.stringify(_peers)) }
     catch (e) { console.warn('[cc-identity] persist (ls) failed:', e?.message) }

package/vault/vault.js

@@ -14,10 +14,21 @@ import {
 } from './peerStore.js'
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
+import { withExternalKeys, appBridge } from './externalKeys.js'
+import { nativeBackends } from './nativeStore.js'
+import { useBackend as usePeerBackend } from './peerStore.js'
 
 ;(async () => {
+  // DENTRO DE LA APP, el puente con el teléfono. En un navegador no está y nada cambia.
+  const idKeys = typeof window !== 'undefined' ? window.DotrinoIdentityKeys : null
+  const bridge = idKeys ? appBridge(idKeys) : null
+  // Y si la app GUARDA la identidad (`storage`, la de iOS): todo vive allí, uno para todas
+  // las páginas, porque WebKit parte el almacén de este iframe por página (`./nativeStore.js`).
+  const native = bridge && idKeys.storage === true ? await nativeBackends(bridge) : null
+  if (native) usePeerBackend(native.peers)
+
   // kv estilo localStorage (síncrono) para me, nonces, delegaciones, certs.
-  const kv = {
+  const kv = native ? native.kv : {
     getItem: (k) => localStorage.getItem(k),
     setItem: (k, v) => localStorage.setItem(k, v),
     removeItem: (k) => localStorage.removeItem(k)
@@ -27,7 +38,7 @@ import { pubkeyId } from './capabilities.js'
   // IndexedDB (clonado estructurado). Nadie —ni este código, ni un XSS en este
   // origen— puede leer sus bytes; solo firmar/derivar con ellas. Las llaves
   // planas (JWK) viejas de localStorage se migran y se borran (core.js).
-  const keyStore = await (() => new Promise((resolve) => {
+  const baseKeyStore = native ? native.keyStore : await (() => new Promise((resolve) => {
     const req = indexedDB.open('dotrino-identity-keys', 1)
     req.onupgradeneeded = () => req.result.createObjectStore('keys')
     req.onsuccess = () => {
@@ -46,6 +57,10 @@ import { pubkeyId } from './capabilities.js'
     }
     req.onerror = () => resolve(null) // sin IDB (raro): cae al modo kv legado
   }))()
+  // DENTRO DE LA APP (Android e iOS), las llaves nuevas nacen en el chip del teléfono: una sola
+  // llave por cuenta, la misma que aprueba en la pantalla nativa (`./externalKeys.js`). El
+  // puente solo existe en este origen; en un navegador no está y nada cambia.
+  const keyStore = bridge && baseKeyStore ? withExternalKeys(baseKeyStore, bridge) : baseKeyStore
 
   // sessionKv: la prueba de desbloqueo del candado por contraseña vive en
   // sessionStorage — POR PESTAÑA: sobrevive al refresco, muere al cerrarla.