@dotrino/identity 0.32.0 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -27,6 +27,9 @@
     },
     "./content": {
       "import": "./vault/content.js"
+    },
+    "./keyid": {
+      "import": "./vault/keyid.js"
     }
   },
   "files": [
@@ -52,7 +55,7 @@
     "url": "git+https://github.com/imdotrino/dotrino-identity.git"
   },
   "dependencies": {
-    "@dotrino/proxy-client": "0.6.3"
+    "@dotrino/proxy-client": "0.8.0"
   },
   "devDependencies": {
     "fake-indexeddb": "^6.2.5"

package/src/index.js

@@ -299,6 +299,13 @@ export class Identity {
 
   /** Adopta un acta recibida de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
   async adoptActa (acta) { return this._call('adoptActa', { acta }) }
+  /**
+   * Une ESTE perfil a la cuenta de otro (la de una bóveda). No es adoptar una versión nueva
+   * de la tuya: esta llave pasa a ser de OTRA cuenta y deja de tener la suya, así que solo
+   * procede sobre un perfil creado con `{ forVault: true }`. Si no, devuelve
+   * `{ joined: false, reason: 'perfil-con-datos' }` y no escribe nada.
+   */
+  async joinProfile (acta) { return this._call('joinProfile', { acta }) }
   /** 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') }
@@ -321,10 +328,16 @@ export class Identity {
    * nunca sale), hace el emparejamiento endurecido por el proxy y guarda el cert.
    * Emite un evento 'vault' { phase:'challenge', deviceId, sas } para que muestres el
    * código a comparar; resuelve cuando el dueño aprueba en su PC (espera hasta 3 min).
+   *
+   * `join` dice **de qué cuenta se está hablando** (`vinculacion-de-cuentas.md` §3):
+   *   · `'new'`     → crea aquí una cuenta MÁS, con llave nueva, y es esa la que entra en la
+   *                   bóveda. La que estabas usando no se toca. **Es lo normal.**
+   *   · `'current'` → sigue con la cuenta abierta; solo vale si nació para adoptar o si ya
+   *                   está emparejada con esa misma bóveda. Si no, falla antes de tocar la red.
    * @returns {Promise<{ ok:boolean, deviceId:string, master:string, exp:number, scope:string[] }>}
    */
-  async enrollDevice (qr, { label = '' } = {}) {
-    return this._call('vaultPair', { qr, label }, 200000)
+  async enrollDevice (qr, { label = '', join = 'current' } = {}) {
+    return this._call('vaultPair', { qr, label, join }, 200000)
   }
 
   /** Estado de emparejamiento: { paired, deviceId?, master?, scope?, exp?, pairedAt? }. */
@@ -410,8 +423,14 @@ export class Identity {
   async listProfiles () { return this._call('listProfiles') }
   /** El perfil activo: { id, name, pubkey }. */
   async currentProfile () { return this._call('currentProfile') }
-  /** Crea un perfil nuevo (identidad fresca) y lo deja activo. La app debe recargar. */
-  async createProfile (name) { return this._call('createProfile', { name }) }
+  /**
+   * Crea un perfil nuevo (identidad fresca) y lo deja activo. La app debe recargar.
+   *
+   * `forVault: true` lo marca como **nacido para adoptar** la cuenta de una bóveda (camino B
+   * de `vinculacion-de-cuentas.md`): es el único permiso que acepta `joinProfile`, y se
+   * consume al unirse. Sin esa marca, la cuenta es de este dispositivo y nadie se la lleva.
+   */
+  async createProfile (name, { forVault = false } = {}) { return this._call('createProfile', { name, forVault }) }
   /** Cambia el perfil activo. La app debe recargar la página. */
   async switchProfile (id) { return this._call('switchProfile', { id }) }
   /** Renombra un perfil (o el activo si no se pasa id). */

package/src/node.js

@@ -173,6 +173,8 @@ export class Identity {
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
   absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
   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 }) }
   /** 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') }
@@ -187,7 +189,7 @@ export class Identity {
   /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
   rotateContentKey () { return this._h('rotateContentKey') }
   // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
-  enrollDevice (qr, { label = '' } = {}) { return this._h('vaultPair', { qr, label }) }
+  enrollDevice (qr, { label = '', join = 'current' } = {}) { return this._h('vaultPair', { qr, label, join }) }
   vaultStatus () { return this._h('vaultStatus') }
   unpairDevice () { return this._h('vaultUnpair') }
   vaultSign (payload) { return this._h('vaultSign', { payload }) }
@@ -198,7 +200,7 @@ export class Identity {
   // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
   listProfiles () { return this._h('listProfiles') }
   currentProfile () { return this._h('currentProfile') }
-  createProfile (name) { return this._h('createProfile', { name }) }
+  createProfile (name, { forVault = false } = {}) { return this._h('createProfile', { name, forVault }) }
   switchProfile (id) { return this._h('switchProfile', { id }) }
   renameProfile (id, name) { return this._h('renameProfile', { id, name }) }
   deleteProfile (id) { return this._h('deleteProfile', { id }) }

package/vault/capabilities.js

@@ -21,6 +21,7 @@
  * servidor de geo sin cargar el iframe.
  */
 import { canonicalStringify, bufToBase64, base64ToBuf } from './core.js'
+import { pubkeyId, keyLabel } from './keyid.js'
 
 const ECDSA = { name: 'ECDSA', namedCurve: 'P-256' }
 const SIGN = { name: 'ECDSA', hash: { name: 'SHA-256' } }
@@ -46,12 +47,9 @@ async function rawVerify (publicJwkStr, bytes, sigB64) {
 const publicOf = (privateJwk) => ({ kty: privateJwk.kty, crv: privateJwk.crv, x: privateJwk.x, y: privateJwk.y })
 const scopeAllows = (scope, expected) => Array.isArray(scope) ? scope.includes(expected) : scope === expected
 
-/** id corto y estable de un pubkey (sha-256 hex de los campos canónicos del JWK). */
-export async function pubkeyId (publicJwkStr) {
-  const jwk = typeof publicJwkStr === 'string' ? JSON.parse(publicJwkStr) : publicJwkStr
-  const h = await crypto.subtle.digest('SHA-256', enc(canonicalStringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y })))
-  return [...new Uint8Array(h)].map(b => b.toString(16).padStart(2, '0')).join('')
-}
+// El id de una llave y su huella legible viven en `./keyid.js`, que no tiene dependencias:
+// así una interfaz puede mostrar `AB12-CD34` sin arrastrar todo esto. Una sola implementación.
+export { pubkeyId, keyLabel }
 
 /**
  * Verifica que `signature` (base64) sobre `data` fue hecha por la privada de

package/vault/core.js

@@ -178,6 +178,19 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const loadProfiles = () => { try { return JSON.parse(rawKv.getItem(PROFILES_STORAGE) || '[]') || [] } catch { return [] } }
   const saveProfiles = (list) => rawKv.setItem(PROFILES_STORAGE, JSON.stringify(list))
 
+  // ----- la MARCA de «este perfil nació para adoptar la cuenta de una bóveda» -----
+  // Unirse a otra cuenta borra la que este perfil tenía, así que no puede pasar por
+  // accidente ni deducirse de heurísticas tipo «parece vacío»: se pide a propósito con
+  // `createProfile({ forVault: true })` y esa marca es el único permiso que vale.
+  // 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
+  const clearPendingJoin = (pid = currentPid) => {
+    const list = loadProfiles(); const e = list.find((p) => p.id === pid)
+    if (e?.pendingJoin) { delete e.pendingJoin; saveProfiles(list) }
+  }
+
   // ----- keypair loaders -----
   // Con `keyStore` (IndexedDB del navegador): la privada vive como CryptoKey
   // NO EXTRACTABLE — puede FIRMAR/DERIVAR pero nadie (ni este código, ni un XSS)
@@ -440,13 +453,18 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   }
 
   /**
-   * UNIRSE a otro perfil (el de la bóveda a la que te acabas de conectar). No es adoptar
-   * una versión nueva de TU acta: es cambiar de perfil, así que solo procede si aquí no
-   * hay nada que perder — es decir, si este dispositivo es el único miembro del suyo.
+   * UNIRSE a la cuenta de la bóveda con la que te acabas de emparejar (camino B de
+   * `dotrino-vault/docs/vinculacion-de-cuentas.md`). NO es adoptar una versión nueva de TU
+   * acta: es que ESTA llave pase a ser de OTRA cuenta, y por lo tanto **deja de tener la
+   * suya**.
+   *
+   * Por eso solo procede sobre un perfil que **nació para esto** (`createProfile({ forVault:
+   * true })`). Sin la marca no se une: se devuelve el conflicto para que la consola ofrezca
+   * crear una cuenta nueva, y **no se escribe nada**.
    *
-   * Si ya tienes otros dispositivos, los dos lados tienen master y hay que ELEGIR cuál
-   * manda (§2.4.3): eso es una decisión del dueño, no un efecto colateral de escanear un
-   * código, así que se devuelve el conflicto para que lo resuelva la consola.
+   * Antes bastaba con ser el único miembro del acta propia, y entonces se sobrescribía el
+   * acta sin preguntar: una cuenta con su contenido pasaba a colgar de otra en silencio —
+   * justo la fusión de cuentas que el modelo prohíbe (§4). Eso se acabó.
    */
   async function joinProfile (candidate) {
     const v = await Acta.verifyActa({ acta: candidate })
@@ -455,10 +473,29 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { joined: false, reason: 'no-soy-miembro' }
     }
     const current = loadActa()
-    if (current && current.profileId !== candidate.profileId && current.members.length > 1) {
-      return { joined: false, reason: 'ya-tienes-perfil-propio', members: current.members.length }
+
+    // Misma cuenta: no es unirse, es ponerse al día. Va por las reglas de adopción (§2.4.1).
+    if (current && current.profileId === candidate.profileId) {
+      const r = await adoptActa(candidate)
+      return { joined: r.adopted, reason: r.reason, profileId: candidate.profileId, seq: r.seq }
+    }
+
+    if (current && !isPendingJoin()) {
+      return {
+        joined: false,
+        reason: 'perfil-con-datos',
+        profileId: current.profileId,
+        seq: current.seq,
+        members: current.members.length
+      }
     }
+
     saveActa(candidate)
+    // El historial era de la cuenta anterior y no encadena con esta. La que se abandona es
+    // siempre una génesis recién nacida (lo garantiza la marca), así que no hay nada que
+    // retener; guardarla aquí solo mezclaría dos cuentas en la misma ventana (§1.3).
+    kv.setItem(ACTA_HISTORY_STORAGE, '[]')
+    clearPendingJoin()
     emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, joined: true })
     return { joined: true, profileId: candidate.profileId, seq: candidate.seq }
   }
@@ -1005,14 +1042,36 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // ----- perfiles (multi-perfil por dispositivo) -----
     // Cambiar/crear setea el perfil activo; la app RECARGA la página y re-inicializa con él
     // (no reactivo, por diseño). Las apps abiertas conservan el perfil con el que cargaron.
+    /**
+     * Los perfiles de este dispositivo, para el conmutador. Incluye el AVATAR de cada uno:
+     * sin él, la lista caía siempre al identicon automático y tu foto no aparecía —aunque la
+     * hubieras subido— porque el avatar vive en el `me` de cada perfil, no en el registro.
+     */
     async listProfiles () {
-      return loadProfiles().map((p) => ({ id: p.id, name: p.name || '', pubkey: p.pubkey || null, current: p.id === currentPid }))
+      return loadProfiles().map((p) => {
+        let avatar = null
+        try {
+          const raw = p.id === currentPid ? JSON.stringify(me || null) : rawKv.getItem(`dotrino.identity.p.${p.id}.me`)
+          const m = raw ? JSON.parse(raw) : null
+          if (m && typeof m.avatar === 'string') avatar = m.avatar
+        } catch (_) {}
+        // `pendingJoin`: nació para adoptar la cuenta de una bóveda y todavía no se unió.
+        // La consola lo usa para no ofrecerlo como una cuenta normal a medio hacer.
+        return { id: p.id, name: p.name || '', pubkey: p.pubkey || null, avatar, current: p.id === currentPid, pendingJoin: !!p.pendingJoin }
+      })
     },
     async currentProfile () {
       const e = loadProfiles().find((p) => p.id === currentPid) || {}
       return { id: currentPid, name: e.name || me?.nickname || '', pubkey: publickeyJwkStr }
     },
-    async createProfile ({ name } = {}) {
+    /**
+     * Crea una cuenta más en este dispositivo, con su propia llave.
+     *
+     * `forVault: true` la marca como **nacida para adoptar** la cuenta de una bóveda
+     * (camino B): es el único permiso que acepta `joinProfile`, y se consume al unirse.
+     * Sin la marca, la cuenta es de este dispositivo y nadie se la puede llevar.
+     */
+    async createProfile ({ name, forVault = false } = {}) {
       const pid = 'p' + crypto.randomUUID().slice(0, 8)
       currentPid = pid
       rawKv.setItem(CURRENT_STORAGE, pid)
@@ -1022,9 +1081,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       encKeypair = await loadOrCreateEncKeypair(); encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
       me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: String(name || '').slice(0, 40) }
       saveMe(me)
-      const list = loadProfiles(); list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr }); saveProfiles(list)
+      const list = loadProfiles()
+      list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr, ...(forVault ? { pendingJoin: true } : {}) })
+      saveProfiles(list)
       await ensureActa(me.nickname) // el perfil nuevo nace con su acta (él mismo es el master)
-      return { id: pid, name: me.nickname, pubkey: publickeyJwkStr }
+      return { id: pid, name: me.nickname, pubkey: publickeyJwkStr, pendingJoin: !!forVault }
     },
     async switchProfile ({ id } = {}) {
       if (!loadProfiles().find((p) => p.id === id)) throw new Error('perfil no existe')
@@ -1246,7 +1307,27 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // ----- emparejar ESTE dispositivo con el vault del usuario (Fase 1) -----
     // Genera D aquí dentro (su privada NUNCA sale de la identidad), hace el enroll
     // endurecido por el proxy y guarda el cert. NO cambia signData todavía (Fase 2).
-    async vaultPair ({ qr, label = '' }) {
+    /**
+     * Empareja este dispositivo con una bóveda.
+     *
+     * `join` dice **de qué cuenta estamos hablando** (V7: la intención es explícita, nunca
+     * se adivina):
+     *   · `'new'`     → camino B: crea aquí una cuenta más, con llave nueva, y ES ESA la que
+     *                   entra al acta de la bóveda. La que estabas usando **no se toca**.
+     *   · `'current'` → sigue con la cuenta abierta. Solo vale si nació para adoptar
+     *                   (`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.
+     */
+    async vaultPair ({ qr, label = '', join = 'current' }) {
+      if (join === 'new') {
+        await handlers.createProfile({ name: label || me?.nickname || '', forVault: true })
+      } else {
+        const yaConEsta = loadVaultCert()?.master === qr?.iss
+        if (loadActa() && !isPendingJoin() && !yaConEsta) {
+          throw new Error('este aparato ya está usando una cuenta: para usar también la de tu bóveda, crea una cuenta nueva aquí (la que tienes abierta no se toca)')
+        }
+      }
       // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
       // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
       // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
@@ -1254,18 +1335,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
       // Si esta identidad ya existía por su cuenta, se lleva un certificado de continuidad
       // firmado por ella misma: es el puente para que su reputación previa siga contando.
+      // Solo si esta llave tenía vida propia. Una recién creada para adoptar (camino B) no
+      // tiene pasado que salvar: mandarle un puente de continuidad sería puro ruido.
       const mio = loadActa()
-      const continuity = (mio && mio.members.length === 1)
+      const continuity = (mio && mio.members.length === 1 && !isPendingJoin())
         ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
         : null
       const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
       kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
       kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
-      // Conectarse a una bóveda es ENTRAR A SU PERFIL: el acta viene con el cert.
-      const join = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
-      emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join })
+      // 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 })
       pullProfileFromVault() // adoptar el perfil que ya viva en el vault (si hay)
-      return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join }
+      return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join: unido }
     },
 
     async vaultStatus () {

package/vault/keyid.js

@@ -0,0 +1,41 @@
+/**
+ * keyid.js — el identificador LEGIBLE de una llave.
+ *
+ * Una pubkey es un JWK: `{"crv":"P-256","kty":"EC","x":"…","y":"…"}`. Eso no se le enseña a
+ * nadie — ni entero ni recortado, que es peor: parece un error. Para que una persona pueda
+ * reconocer y comparar una llave se usa su huella corta, `AB12-CD34`, que es la misma que
+ * ya se muestra al emparejar («aprueba el dispositivo AB12-CD34») y en el acta del perfil.
+ *
+ * Módulo aparte y sin dependencias a propósito: cualquier interfaz que necesite mostrar una
+ * llave puede importarlo sin arrastrar el resto de la identidad. `capabilities.js` reexporta
+ * `pubkeyId` desde aquí para que haya UNA sola implementación.
+ */
+
+const enc = (s) => new TextEncoder().encode(s)
+
+/** Serialización canónica de los campos que identifican la llave (mismo orden siempre). */
+function canonicalJwk (jwk) {
+  return JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y })
+    .replace(/^{/, '{').replace(/}$/, '}')
+}
+
+/** id corto y estable de un pubkey (sha-256 hex de los campos canónicos del JWK). */
+export async function pubkeyId (publicJwkStr) {
+  const jwk = typeof publicJwkStr === 'string' ? JSON.parse(publicJwkStr) : publicJwkStr
+  const h = await crypto.subtle.digest('SHA-256', enc(canonicalJwk(jwk)))
+  return [...new Uint8Array(h)].map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+/**
+ * La huella que SÍ se le enseña a una persona: `AB12-CD34`. Corta, comparable de un vistazo
+ * y la misma en todo el ecosistema (emparejamiento, acta, lista de dispositivos).
+ */
+export async function keyLabel (publicJwkStr) {
+  if (!publicJwkStr) return ''
+  try {
+    const id = (await pubkeyId(publicJwkStr)).slice(0, 8).toUpperCase()
+    return id.slice(0, 4) + '-' + id.slice(4, 8)
+  } catch (_) { return '' }
+}
+
+export default { pubkeyId, keyLabel }