@dotrino/identity 0.102.2 → 0.103.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.102.2",
+  "version": "0.103.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/vault.js

@@ -14,6 +14,7 @@ import {
 } from './peerStore.js'
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
+import { withExternalKeys, appBridge } from './externalKeys.js'
 
 ;(async () => {
   // kv estilo localStorage (síncrono) para me, nonces, delegaciones, certs.
@@ -27,7 +28,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 = await (() => new Promise((resolve) => {
     const req = indexedDB.open('dotrino-identity-keys', 1)
     req.onupgradeneeded = () => req.result.createObjectStore('keys')
     req.onsuccess = () => {
@@ -46,6 +47,11 @@ import { pubkeyId } from './capabilities.js'
     }
     req.onerror = () => resolve(null) // sin IDB (raro): cae al modo kv legado
   }))()
+  // DENTRO DE LA APP DE ANDROID, 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 idKeys = typeof window !== 'undefined' ? window.DotrinoIdentityKeys : null
+  const keyStore = idKeys && baseKeyStore ? withExternalKeys(baseKeyStore, appBridge(idKeys)) : baseKeyStore
 
   // sessionKv: la prueba de desbloqueo del candado por contraseña vive en
   // sessionStorage — POR PESTAÑA: sobrevive al refresco, muere al cerrarla.