@dotrino/identity 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.34.0",
+  "version": "0.36.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

@@ -306,6 +306,8 @@ export class Identity {
    * `{ joined: false, reason: 'perfil-con-datos' }` y no escribe nada.
    */
   async joinProfile (acta) { return this._call('joinProfile', { acta }) }
+  /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A). */
+  async prepareForAdoption () { return this._call('prepareForAdoption') }
   /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
    *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
   async profileCard () { return this._call('profileCard') }

package/src/node.js

@@ -175,6 +175,8 @@ export class Identity {
   adoptActa (acta) { return this._h('adoptActa', { acta }) }
   /** Une ESTE perfil a la cuenta de otro (solo si nació para eso: `createProfile(n, { forVault: true })`). */
   joinProfile (acta) { return this._h('joinProfile', { acta }) }
+  /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A: lo usa la bóveda). */
+  prepareForAdoption () { return this._h('prepareForAdoption') }
   /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
    *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
   profileCard () { return this._h('profileCard') }

package/vault/core.js

@@ -34,6 +34,7 @@ export const VAULT_DEVICE_STORAGE = 'dotrino.identity.vault.device' // sub-clave
 export const VAULT_CERT_STORAGE = 'dotrino.identity.vault.cert'     // { cert, master, proxy, deviceId, pairedAt }
 export const ACTA_STORAGE = 'dotrino.identity.acta'                 // acta de perfil vigente (quién es del perfil y qué puede)
 export const ACTA_HISTORY_STORAGE = 'dotrino.identity.acta.history' // últimas actas selladas (§1.3)
+export const PENDING_JOIN_STORAGE = 'dotrino.identity.pendingJoin'  // «nací para adoptar la cuenta de otro»
 export const RENOUNCE_STORAGE = 'dotrino.identity.renounced'        // renuncias propias aún no absorbidas por el master
 // Multi-perfil por dispositivo: lista de perfiles + el activo. Cada perfil tiene su propio
 // namespace `dotrino.identity.p.<id>.<suffix>` para TODAS las claves de arriba (keypair, me, etc.).
@@ -185,8 +186,15 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // Además identity NO PUEDE ver el contenido del store (vive en otro origen), así que
   // «vacío» no es algo que pueda comprobar por su cuenta.
   // Ver `dotrino-vault/docs/vinculacion-de-cuentas.md` §5.1.
-  const isPendingJoin = (pid = currentPid) => !!loadProfiles().find((p) => p.id === pid)?.pendingJoin
+  // La marca vive en DOS sitios porque hay dos formas de tener perfiles: en el
+  // navegador son entradas de una lista dentro del mismo almacén (`pendingJoin` en la
+  // entrada), y en la bóveda es UN directorio por perfil, donde esa lista está vacía y
+  // no hay ninguna entrada que marcar. El kv es lo único que existe siempre y ya está
+  // acotado al perfil abierto, así que ahí va la marca de la bóveda.
+  const isPendingJoin = (pid = currentPid) =>
+    kv.getItem(PENDING_JOIN_STORAGE) === '1' || !!loadProfiles().find((p) => p.id === pid)?.pendingJoin
   const clearPendingJoin = (pid = currentPid) => {
+    try { kv.removeItem(PENDING_JOIN_STORAGE) } catch (_) {}
     const list = loadProfiles(); const e = list.find((p) => p.id === pid)
     if (e?.pendingJoin) { delete e.pendingJoin; saveProfiles(list) }
   }
@@ -1318,8 +1326,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      *                   (`forVault`) o si ya está emparejada con ESA misma bóveda
      *                   (re-emparejar). En cualquier otro caso falla **antes de tocar la
      *                   red**, en vez de traerse un acta ajena y pisar la tuya.
+     *   · `'adopt'`    → camino A: la cuenta que YA vive en este aparato pasa a vivir en la
+     *                   bóveda. Sigue siendo la misma cuenta para todo el mundo (mismo
+     *                   `profileId`); lo que cambia es quién sella. Solo puede hacerlo el
+     *                   master: si esta cuenta ya la manda otra bóveda, no hay nada que
+     *                   regalar y falla en voz alta.
      */
     async vaultPair ({ qr, label = '', join = 'current' }) {
+      if (join === 'adopt') return handlers.vaultAdopt({ qr, label })
       if (join === 'new') {
         await handlers.createProfile({ name: label || me?.nickname || '', forVault: true })
       } else {
@@ -1351,6 +1365,76 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join: unido }
     },
 
+    /**
+     * CAMINO A — «esta cuenta que tengo aquí, que la guarde mi computadora».
+     *
+     * La cuenta no se muda ni se copia: sigue siendo la misma (mismo `profileId`, misma
+     * reputación, lo mismo firmado). Lo único que cambia es **quién sella el acta**. Este
+     * aparato admite a la bóveda como miembro, le envuelve la clave de contenido para que
+     * pueda leer lo que ya hay, y le traspasa el mando — los tres cambios en un **único
+     * `seq`**, que es la regla que existe justamente para que no haya un momento raro en
+     * el que la cuenta tenga dos sellador​es o ninguno.
+     *
+     * Requisito (§2 del doc): solo puede hacerlo el master. Si esta cuenta ya la manda otra
+     * bóveda, este aparato no puede regalar lo que no tiene; el traspaso se hace desde la
+     * que manda hoy.
+     */
+    async vaultAdopt ({ qr, label = '' } = {}) {
+      const mio = loadActa()
+      if (!mio) throw new Error('este aparato todavía no tiene ninguna cuenta que entregar')
+      if (!amMaster()) throw new Error('no-eres-el-master: esta cuenta ya la manda otro dispositivo o bóveda; el traspaso se hace desde ahí')
+
+      const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+      const res = await remoteEnroll({
+        qr,
+        device,
+        intent: 'adopt',
+        profileId: mio.profileId,
+        encPub: encPublickeyJwkStr,
+        label: label || me?.nickname || '',
+        onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }),
+        // Admitir + envolver + traspasar, en UN solo sello. Se ejecuta cuando la bóveda ya
+        // fue aprobada por un humano (el código de 6 dígitos volvió correcto).
+        onAdopt: async ({ pub, encPub, label: vlabel }) => {
+          const cambios = [{ op: 'admit', member: { pub, encPub, label: vlabel || 'bóveda', caps: ['sign', 'store', 'read'] } }]
+          // Sin la clave de contenido envuelta, la bóveda entraría mandando pero sin poder
+          // leer nada de lo que guarda la cuenta que acaba de recibir.
+          const mine = await myCek()
+          if (mine && encPub) {
+            const wrap = await Content.wrapForMember({ cek: mine.cek, memberEncPub: encPub })
+            cambios.push({ op: 'wrap', gen: mine.gen, pub, wrap })
+          }
+          cambios.push({ op: 'handover', to: pub })
+          return sealChanges(cambios)
+        }
+      })
+      // La bóveda devuelve el acta ya sellada por ella (y con los certs re-emitidos): se
+      // adopta por las reglas de siempre (§2.4.1) — encaja porque el sellador es el que
+      // este mismo aparato nombró hace un momento.
+      // `misma-acta` = la bóveda guardó exactamente la que este aparato acababa de sellar
+      // y no la cambió. No hay nada que adoptar, y es justo lo que se esperaba: el
+      // traspaso ya iba dentro de esa acta.
+      const r = await adoptActa(res.acta)
+      const ok = r.adopted || r.reason === 'misma-acta'
+      emitVault({ phase: 'adopted', master: res.master, seq: res.acta?.seq, ok })
+      if (!ok) throw new Error('la bóveda devolvió un acta que no encaja: ' + r.reason)
+      return { ok: true, adopted: true, profileId: mio.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }
+    },
+
+    /**
+     * Marca este perfil como **nacido para adoptar** la cuenta de otro (la marca que
+     * `joinProfile` exige, §5.1). Lo usa la BÓVEDA al abrir un perfil vacío para el camino
+     * A: sin la marca, adoptar la cuenta del aparato se leería como pisar una cuenta con
+     * datos y se rechazaría, que es exactamente lo que tiene que pasar cuando nadie lo pidió.
+     */
+    async prepareForAdoption () {
+      kv.setItem(PENDING_JOIN_STORAGE, '1')
+      const list = loadProfiles()
+      const e = list.find((p) => p.id === currentPid)
+      if (e) { e.pendingJoin = true; saveProfiles(list) }
+      return { ok: true, pending: true }
+    },
+
     async vaultStatus () {
       const v = loadVaultCert()
       if (!v?.cert) return { paired: false }

package/vault/remote.js

@@ -16,12 +16,21 @@
 import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
 
 const MSG = {
+  HELLO: 'vault.hello',
+  HELLO_OK: 'vault.hello.ok',
   ENROLL: 'vault.enroll',
   ENROLL_CHALLENGE: 'vault.enroll.challenge',
   ENROLLED: 'vault.enrolled',
+  // --- camino A (la cuenta del aparato pasa a vivir en la bóveda) ---
+  // La bóveda, en vez del cert, manda QUIÉN es ella para que el aparato la meta en su
+  // acta; el aparato responde con el acta sellada y la bóveda devuelve la definitiva.
+  ENROLL_ADOPT: 'vault.enroll.adopt',
+  ACTA_SEALED: 'vault.acta.sealed',
+  ACTA_ADOPTED: 'vault.acta.adopted',
   REVOKED: 'vault.revoked',
   ERROR: 'vault.error'
 }
+export { MSG as VAULT_MSG }
 
 /**
  * ¿Es AUTÉNTICO este `vault.revoked`? Solo lo es si va firmado por la maestra PINEADA al
@@ -49,6 +58,36 @@ async function identifyAsDevice (client, device, { cert = null, acta = null } =
   await client.identify({ data, signature, cert, acta })
 }
 
+
+/**
+ * La respuesta al `hello` va firmada y con el `sn` DENTRO de lo firmado. Comprobarlo
+ * ata la respuesta a ESTA sesión: no vale la de otro emparejamiento ni la de otra
+ * bóveda. Ojo con lo que NO prueba: cualquiera puede firmar con una llave suya, así
+ * que esto no dice que sea TU bóveda — eso lo dice el código de 6 dígitos, que solo
+ * aprende la bóveda donde tú lo tecleas.
+ */
+async function verificarHola (p, sn) {
+  const b = p?.body
+  if (!b?.iss || b.sn !== sn) throw new Error('la bóveda contestó a otro emparejamiento')
+  if (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
+    throw new Error('la respuesta de la bóveda no está bien firmada')
+  }
+  return b
+}
+
+/** «¿Quién eres?» del QR corto: devuelve `{ iss, proxy, acct, m }` de la bóveda. */
+async function askVault (client, qr) {
+  return new Promise((resolve, reject) => {
+    const off = client.on('message', (_from, p) => {
+      if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then((b) => resolve({ iss: b.iss, proxy: b.proxy || qr.proxy, acct: b.acct || '', m: b.m || qr.m }), reject) }
+      else if (p?.type === MSG.ERROR) { fin(); reject(new Error(p.error)) }
+    })
+    const t = setTimeout(() => { fin(); reject(new Error('la bóveda no contestó: ese código pudo caducar')) }, 15000)
+    const fin = () => { off(); clearTimeout(t) }
+    try { client.send(qr.conn, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
+  })
+}
+
 /**
  * @param {Object} opts
  * @param {{v:number, iss:string, proxy:string, token:string, sn:string}} opts.qr  QR v2 del vault.
@@ -57,12 +96,17 @@ async function identifyAsDevice (client, device, { cert = null, acta = null } =
  * @param {number} [opts.approveTimeoutMs]  Espera de la aprobación humana (def 3 min).
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string}>}
  */
-export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000 } = {}) {
-  if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null } = {}) {
+  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('qr inválido: falta la bóveda o el nonce')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: qr.proxy, enableWebRTC: false, autoReconnect: false })
+  const client = new WebSocketProxyClient({ url: qr.proxy || 'wss://proxy.dotrino.com', enableWebRTC: false, autoReconnect: false })
   await client.connect()
   try {
+    // QR CORTO: no trae la llave, solo la dirección de la bóveda en el proxy. Se le
+    // pregunta quién es, punto a punto, presentando el `sn`; solo contesta si esa sesión
+    // de emparejamiento sigue abierta. Lo que acredita la llave no es el QR: es la firma
+    // del certificado y el código de 6 dígitos, que solo aprende la bóveda donde lo tecleas.
+    if (!qr.iss) qr = { ...qr, ...(await askVault(client, qr)) }
     // Por defecto genera una sub-clave nueva; pero el iframe pasa SU PROPIA llave de
     // identidad (P) como `device` → el cert delega tu identidad y hay UNA sola (signData/
     // identify/cert son la misma P).
@@ -80,16 +124,40 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // que hizo antes se pueda seguir atribuyendo a la misma persona (ver acta.js).
     // `encPub`: la llave de CIFRADO de este dispositivo. Sin ella la bóveda no puede
     // envolverle la clave de contenido del perfil, y entraría sin poder leer nada.
-    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {}) }
+    // `intent` (V7 de `vinculacion-de-cuentas.md`): va DENTRO de lo firmado, y la bóveda
+    // rechaza el que no coincida con el modo con el que ella abrió el emparejamiento. Así
+    // ninguno de los dos puede hacer, a mitad de camino, algo distinto de lo que el humano
+    // vio anunciado en las dos pantallas.
+    const adoptar = intent === 'adopt'
+    if (adoptar && typeof onAdopt !== 'function') throw new Error('enrollDevice(adopt): falta onAdopt')
+    const data = {
+      op: 'enroll', dpub: dev.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now(), intent,
+      ...(adoptar && profileId ? { profileId } : {}),
+      ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {})
+    }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
+      let sellando = false
       const off = client.on('message', (_from, p) => {
         if (!p || typeof p !== 'object') return
         if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, code }) } catch (_) {} }
         // El vault ECHA el código que tipeaste; aceptamos SOLO si coincide con el que generamos.
         // (Un código distinto = un vault que no lo conoce → lo ignoramos y seguimos esperando.)
         else if (p.type === MSG.ENROLLED) { if (p.code === code) { cleanup(); resolve(p) } }
+        // CAMINO A · la bóveda dice quién es (con el código de vuelta, misma defensa que el
+        // ENROLLED): este aparato la admite en SU acta, le envuelve la clave de contenido y
+        // le traspasa el mando, todo en un solo `seq`, y le manda el acta sellada.
+        else if (p.type === MSG.ENROLL_ADOPT && adoptar) {
+          if (p.code !== code || sellando) return
+          sellando = true
+          Promise.resolve(onAdopt({ pub: p.pub, encPub: p.encPub || null, label: p.label || '' }))
+            .then((acta) => { client.sendByPubkey(qr.iss, { type: MSG.ACTA_SEALED, acta, code }) })
+            .catch((e) => { cleanup(); reject(e) })
+        }
+        // La bóveda ya se vio como sellador y devuelve el acta definitiva (con los certs
+        // re-emitidos, §D9). Es la que este aparato adopta.
+        else if (p.type === MSG.ACTA_ADOPTED && adoptar) { cleanup(); resolve(p) }
         else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('timeout esperando la aprobación en el vault')) }, approveTimeoutMs)
@@ -98,6 +166,14 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
     const res = await enrolled
 
+    // Camino A: aquí no hay cert que validar — este aparato NO delega su identidad, sigue
+    // siendo la cuenta. Lo que vuelve es el acta ya sellada por la bóveda.
+    if (adoptar) {
+      if (!res.acta) throw new Error('la bóveda no devolvió el acta adoptada')
+      if (res.acta.sealer !== qr.iss) throw new Error('el acta la sella una bóveda distinta a la que viste')
+      return { device: dev, cert: null, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta, adopted: true }
+    }
+
     // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
     const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey })
     if (!v.ok) throw new Error('cert inválido: ' + v.reason)