@dotrino/identity 0.31.0 → 0.33.0

package/package.json

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

package/src/index.js

@@ -323,8 +323,8 @@ export class Identity {
    * código a comparar; resuelve cuando el dueño aprueba en su PC (espera hasta 3 min).
    * @returns {Promise<{ ok:boolean, deviceId:string, master:string, exp:number, scope:string[] }>}
    */
-  async enrollDevice (qr) {
-    return this._call('vaultPair', { qr }, 200000)
+  async enrollDevice (qr, { label = '' } = {}) {
+    return this._call('vaultPair', { qr, label }, 200000)
   }
 
   /** Estado de emparejamiento: { paired, deviceId?, master?, scope?, exp?, pairedAt? }. */

package/src/node.js

@@ -187,7 +187,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) { return this._h('vaultPair', { qr }) }
+  enrollDevice (qr, { label = '' } = {}) { return this._h('vaultPair', { qr, label }) }
   vaultStatus () { return this._h('vaultStatus') }
   unpairDevice () { return this._h('vaultUnpair') }
   vaultSign (payload) { return this._h('vaultSign', { payload }) }

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

@@ -1005,8 +1005,21 @@ 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 (_) {}
+        return { id: p.id, name: p.name || '', pubkey: p.pubkey || null, avatar, current: p.id === currentPid }
+      })
     },
     async currentProfile () {
       const e = loadProfiles().find((p) => p.id === currentPid) || {}
@@ -1246,7 +1259,7 @@ 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 }) {
+    async vaultPair ({ qr, label = '' }) {
       // 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`
@@ -1258,7 +1271,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const continuity = (mio && mio.members.length === 1)
         ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
         : null
-      const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
+      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.

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 }