@dotrino/identity 0.16.1 → 0.20.0

package/package.json

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

package/src/index.d.ts

@@ -3,10 +3,29 @@ export interface IdentityOptions {
   timeoutMs?: number
 }
 
+export interface ProfileLink { id: string; type: string; value: string; visible?: boolean }
+export interface ProfileField { id: string; label: string; value: string; visible?: boolean }
+
 export interface Me {
   publickey: string
   encryptionPubkey?: string
   nickname?: string
+  avatar?: string | null
+  avatarVisible?: boolean
+  links?: ProfileLink[]
+  fields?: ProfileField[]
+  /** Campos personales estándar (fijos). */
+  nombres?: string
+  apellidos?: string
+  email?: string
+  telefono?: string
+  direccion?: string
+  /** Visibilidad por campo estándar. telefono/direccion ocultos por defecto. */
+  nombresVisible?: boolean
+  apellidosVisible?: boolean
+  emailVisible?: boolean
+  telefonoVisible?: boolean
+  direccionVisible?: boolean
 }
 
 export interface EnvelopeV1 {

package/src/index.js

@@ -32,9 +32,67 @@ export class Identity {
     // ready() es idempotente (devuelve la misma promesa), así que esto es
     // seguro de llamar en cada connect().
     await singleton.ready()
+    // Perfil protegido con contraseña/PIN (candado LOCAL del dispositivo): pedirla
+    // aquí, una vez por PESTAÑA (el iframe recuerda el desbloqueo en sessionStorage
+    // → no re-pide al refrescar). Las apps no tienen que hacer nada.
+    if (singleton._locked && typeof document !== 'undefined' && options.promptUnlock !== false) {
+      await singleton._promptUnlock()
+    }
     return singleton
   }
 
+  /** Overlay mínimo de desbloqueo (PIN/contraseña). Resuelve al desbloquear. */
+  async _promptUnlock () {
+    const es = !(navigator.language || 'es').startsWith('en')
+    const T = es
+      ? { t: 'Perfil protegido', p: 'PIN o contraseña', b: 'Desbloquear', e: 'Contraseña incorrecta' }
+      : { t: 'Protected profile', p: 'PIN or password', b: 'Unlock', e: 'Wrong password' }
+    return new Promise((resolve) => {
+      const back = document.createElement('div')
+      back.style.cssText = 'position:fixed;inset:0;background:rgba(10,8,20,.8);z-index:2147483000;display:flex;align-items:center;justify-content:center;font-family:system-ui,sans-serif'
+      back.innerHTML = `<form style="background:#171331;border:1px solid #2a2350;border-radius:16px;padding:22px;min-width:260px;max-width:90vw;color:#e7e3ff">
+        <div style="font-weight:700;margin-bottom:10px">🔒 ${T.t}</div>
+        <input type="password" inputmode="numeric" autocomplete="current-password" placeholder="${T.p}"
+               style="width:100%;box-sizing:border-box;padding:10px 12px;border-radius:10px;border:1px solid #2a2350;background:#0b0820;color:inherit;font:inherit" />
+        <div data-err style="color:#e5484d;font-size:13px;min-height:18px;margin:6px 0 8px"></div>
+        <button type="submit" style="width:100%;padding:10px;border-radius:10px;border:0;background:#7c3aed;color:#fff;font:inherit;font-weight:600;cursor:pointer">${T.b}</button>
+      </form>`
+      const form = back.firstElementChild
+      const input = form.querySelector('input')
+      const err = form.querySelector('[data-err]')
+      form.addEventListener('submit', async (e) => {
+        e.preventDefault()
+        err.textContent = ''
+        try {
+          await this._call('unlockProfile', { password: input.value })
+          this._locked = false
+          try { this._me = await this._call('getMe') } catch (_) {}
+          back.remove()
+          resolve(this)
+        } catch (ex) {
+          err.textContent = /incorrecta/.test(ex.message) ? T.e : ex.message
+          input.select()
+        }
+      })
+      document.body.appendChild(back)
+      input.focus()
+    })
+  }
+
+  /** Estado del candado del perfil activo: { protected, locked }. */
+  async profileLockStatus () { return this._call('profileLockStatus') }
+  /** Desbloquea el perfil (la prueba queda en sessionStorage: por pestaña). */
+  async unlockProfile (password) {
+    const r = await this._call('unlockProfile', { password })
+    this._locked = false
+    try { this._me = await this._call('getMe') } catch (_) {}
+    return r
+  }
+  /** Protege el perfil ACTIVO con contraseña/PIN — LOCAL de este dispositivo. */
+  async setProfilePassword (password) { return this._call('setProfilePassword', { password }) }
+  /** Quita la protección (requiere estar desbloqueado). */
+  async removeProfilePassword () { return this._call('removeProfilePassword') }
+
   static current () {
     return singleton
   }
@@ -64,7 +122,8 @@ export class Identity {
 
         if (msg.type === 'ready') {
           clearTimeout(timeout)
-          this._me = msg.me
+          this._me = msg.me || null
+          this._locked = !!msg.locked
           this._readyResolve(this)
           return
         }
@@ -306,6 +365,24 @@ export class Identity {
     return result
   }
 
+  /**
+   * Actualiza tu PERFIL (merge): `{ nickname?, avatar?, avatarVisible?, links?, fields?,
+   * nombres?, apellidos?, email?, telefono?, direccion? }` (+ sus flags `<campo>Visible`).
+   * `avatar` = data-URI 250×250 (o null para quitarla); `links`/`fields` = arrays con `visible`
+   * por ítem (oculto = no se comparte). `telefono`/`direccion` son sensibles: ocultos por
+   * defecto (solo se comparten si su flag === true). No pisa lo que no mandes.
+   */
+  async updateMe (patch) {
+    const result = await this._call('updateMe', { patch })
+    if (result?.me) this._me = result.me
+    return result
+  }
+
+  /** Tu `me` completo (incluye ocultos). */
+  async getMe () { return this._call('getMe') }
+  /** Subconjunto PÚBLICO de tu perfil (solo lo visible) — para compartir/publicar. */
+  async publicMe () { return this._call('publicMe') }
+
   /** Pubkey ECDH (JWK string) propio para encripción. */
   async getEncryptionPubkey () {
     return this._call('getEncryptionPubkey')

package/src/node.js

@@ -175,6 +175,9 @@ export class Identity {
     const result = await this._h('setMyNickname', { nickname })
     return result
   }
+  async updateMe (patch) { return this._h('updateMe', { patch }) }
+  getMe () { return this._h('getMe') }
+  publicMe () { return this._h('publicMe') }
   getEncryptionPubkey () { return this._h('getEncryptionPubkey') }
   encrypt (recipients, plaintext) { return this._h('encrypt', { recipients, plaintext }) }
   decrypt (senderEncryptionPubkey, myToken, envelope) {

package/vault/capabilities.js

@@ -175,10 +175,17 @@ export async function signDelegationWith (privateKey, iss, { sub, scope, iat, ex
  * Firma datos con la clave de DISPOSITIVO (formato byte-idéntico a `signData` del
  * vault → lo que el dispositivo/bridge usa para firmar cada pin/acción).
  */
-export async function signWithDevice ({ privateJwk, data }) {
+export async function signWithDevice ({ privateJwk, privateKey, publickey, data }) {
+  // `privateKey` (CryptoKey, posiblemente NO extractable) tiene prioridad: firma
+  // sin tocar bytes de la privada. Con CryptoKey es obligatorio pasar `publickey`.
+  if (privateKey) {
+    if (!publickey) throw new Error('signWithDevice: con privateKey (CryptoKey) se requiere publickey')
+    const signature = await rawSign(privateKey, enc(canonicalStringify(data)))
+    return { signature, publickey }
+  }
   const priv = await crypto.subtle.importKey('jwk', privateJwk, ECDSA, true, ['sign'])
   const signature = await rawSign(priv, enc(canonicalStringify(data)))
-  return { signature, publickey: JSON.stringify(publicOf(privateJwk)) }
+  return { signature, publickey: publickey || JSON.stringify(publicOf(privateJwk)) }
 }
 
 /**

package/vault/core.js

@@ -19,7 +19,7 @@
  */
 
 import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -108,7 +108,50 @@ async function verifyBytes (publicJwkStr, bytes, signatureBase64) {
  * @returns {Promise<{ handlers:Object, get me():Object, sync:Object|null,
  *                      onSyncStatus(fn):void }>}
  */
-export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null }) {
+// Campos personales estándar del perfil (escalares fijos), con su cap de longitud.
+// Cada uno tiene un flag `<campo>Visible` (booleano) para mostrar/ocultar al compartir.
+const STD_FIELD_CAPS = [
+  ['nombres', 60], ['apellidos', 60], ['email', 120], ['telefono', 40], ['direccion', 200]
+]
+// Datos sensibles: OCULTOS por defecto. `publicMe` solo los incluye si su flag === true
+// (los demás campos estándar se comparten salvo que su flag sea false).
+const STD_FIELDS_SENSITIVE = new Set(['telefono', 'direccion'])
+
+// Sanea un patch de perfil (avatar/links/fields/nickname + campos estándar). Cada link/field
+// lleva `visible` (oculto = no se comparte). Caps de tamaño para no inflar el `me`. Los ids los pone la UI.
+function sanitizeProfilePatch (patch = {}) {
+  const out = {}
+  if (typeof patch.nickname === 'string') out.nickname = patch.nickname.slice(0, 40)
+  // Campos personales estándar (Nombres/Apellidos/Correo/Teléfono/Dirección) + su visibilidad.
+  for (const [k, cap] of STD_FIELD_CAPS) {
+    if (typeof patch[k] === 'string') out[k] = patch[k].slice(0, cap)
+    const vk = k + 'Visible'
+    if (typeof patch[vk] === 'boolean') out[vk] = patch[vk]
+  }
+  if (patch.avatar === null) out.avatar = null
+  else if (typeof patch.avatar === 'string') out.avatar = patch.avatar.slice(0, 120000) // ~90KB: data-URI 250x250
+  if (typeof patch.avatarVisible === 'boolean') out.avatarVisible = patch.avatarVisible
+  if (Array.isArray(patch.links)) {
+    // Filtra vacíos ANTES del tope: un draft vacío no debe consumir cupo ni desplazar un enlace real.
+    out.links = patch.links.slice(0, 100).map((l) => ({
+      id: String(l?.id || '').slice(0, 24),
+      type: String(l?.type || 'web').slice(0, 16),
+      value: String(l?.value || '').slice(0, 200),
+      visible: l?.visible !== false
+    })).filter((l) => l.value).slice(0, 30)
+  }
+  if (Array.isArray(patch.fields)) {
+    out.fields = patch.fields.slice(0, 20).map((f) => ({
+      id: String(f?.id || '').slice(0, 24),
+      label: String(f?.label || '').slice(0, 40),
+      value: String(f?.value || '').slice(0, 280),
+      visible: f?.visible !== false
+    })).filter((f) => f.label || f.value)
+  }
+  return out
+}
+
+export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, keyStore = null, sessionKv = null }) {
   const {
     initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
   } = peers
@@ -129,42 +172,62 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
   const loadProfiles = () => { try { return JSON.parse(rawKv.getItem(PROFILES_STORAGE) || '[]') || [] } catch { return [] } }
   const saveProfiles = (list) => rawKv.setItem(PROFILES_STORAGE, JSON.stringify(list))
 
-  // ----- keypair loaders (kv-backed) -----
+  // ----- 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)
+  // puede leer sus bytes. Migración transparente: si existe el JWK plano viejo en
+  // kv, se importa como no extractable y se BORRA el plano. Sin keyStore
+  // (Node/tests) se conserva el comportamiento kv anterior.
 
-  async function loadOrCreateKeypair () {
-    const raw = kv.getItem(KEY_STORAGE)
-    if (raw) {
-      try {
-        const { privateJwk, publicJwk } = JSON.parse(raw)
-        const privateKey = await crypto.subtle.importKey('jwk', privateJwk, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign'])
-        const publicKey = await crypto.subtle.importKey('jwk', publicJwk, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['verify'])
-        return { privateKey, publicKey, publicJwk }
-      } catch (_) {}
-    }
-    const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
-    const privateJwk = await crypto.subtle.exportKey('jwk', pair.privateKey)
-    const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
-    kv.setItem(KEY_STORAGE, JSON.stringify({ privateJwk, publicJwk }))
-    return { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }
+  const ALGO_OF = {
+    sign: { algo: { name: 'ECDSA', namedCurve: 'P-256' }, privUses: ['sign'], pubUses: ['verify'], pairUses: ['sign', 'verify'] },
+    enc: { algo: { name: 'ECDH', namedCurve: 'P-256' }, privUses: ['deriveBits', 'deriveKey'], pubUses: [], pairUses: ['deriveBits', 'deriveKey'] }
   }
 
-  async function loadOrCreateEncKeypair () {
-    const raw = kv.getItem(ENC_KEY_STORAGE)
+  async function loadOrCreatePair (kind, storageKey) {
+    const { algo, privUses, pubUses, pairUses } = ALGO_OF[kind]
+    const importPub = (jwk) => crypto.subtle.importKey('jwk', jwk, algo, true, pubUses)
+    if (keyStore) {
+      const name = _scoped(storageKey)
+      const stored = await keyStore.get(name).catch(() => null)
+      if (stored?.privateKey && stored?.publicJwk) {
+        return { privateKey: stored.privateKey, publicKey: await importPub(stored.publicJwk), publicJwk: stored.publicJwk }
+      }
+      // migrar el JWK plano viejo (si hay) → no extractable + borrar el plano
+      const raw = kv.getItem(storageKey)
+      if (raw) {
+        try {
+          const { privateJwk, publicJwk } = JSON.parse(raw)
+          const privateKey = await crypto.subtle.importKey('jwk', privateJwk, algo, false, privUses)
+          await keyStore.set(name, { privateKey, publicJwk })
+          kv.removeItem(storageKey)
+          return { privateKey, publicKey: await importPub(publicJwk), publicJwk }
+        } catch (_) {}
+      }
+      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 })
+      return { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }
+    }
+    // ---- camino legado (sin keyStore): JWK en kv, extractable ----
+    const raw = kv.getItem(storageKey)
     if (raw) {
       try {
         const { privateJwk, publicJwk } = JSON.parse(raw)
-        const privateKey = await crypto.subtle.importKey('jwk', privateJwk, { name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveBits', 'deriveKey'])
-        const publicKey = await crypto.subtle.importKey('jwk', publicJwk, { name: 'ECDH', namedCurve: 'P-256' }, true, [])
-        return { privateKey, publicKey, publicJwk }
+        const privateKey = await crypto.subtle.importKey('jwk', privateJwk, algo, true, privUses)
+        return { privateKey, publicKey: await importPub(publicJwk), publicJwk }
       } catch (_) {}
     }
-    const pair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveBits', 'deriveKey'])
+    const pair = await crypto.subtle.generateKey(algo, true, pairUses)
     const privateJwk = await crypto.subtle.exportKey('jwk', pair.privateKey)
     const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
-    kv.setItem(ENC_KEY_STORAGE, JSON.stringify({ privateJwk, publicJwk }))
+    kv.setItem(storageKey, JSON.stringify({ privateJwk, publicJwk }))
     return { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }
   }
 
+  const loadOrCreateKeypair = () => loadOrCreatePair('sign', KEY_STORAGE)
+  const loadOrCreateEncKeypair = () => loadOrCreatePair('enc', ENC_KEY_STORAGE)
+
   // ----- nonce replay protection (kv-backed) -----
 
   function loadNonces () {
@@ -206,7 +269,48 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     throw e
   }
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
-  const loadVaultDevice = () => { try { return JSON.parse(kv.getItem(VAULT_DEVICE_STORAGE) || 'null') } catch (_) { return null } }
+  const loadVaultDevice = () => {
+    try {
+      const d = JSON.parse(kv.getItem(VAULT_DEVICE_STORAGE) || 'null')
+      if (!d) return null
+      // Marcador nuevo (o JWK legado que ES la llave del perfil): usar la CryptoKey
+      // no extractable del perfil para firmar; nada de privadas en claro.
+      if (d.useIdentityKey || (d.publickey === publickeyJwkStr && !d.privateJwk)) {
+        return { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+      }
+      // MIGRACIÓN: el emparejamiento viejo persistía la privada del perfil en
+      // claro aquí. Si es la misma llave del perfil, reemplazar por el marcador
+      // (borra el último JWK plano) y firmar con la CryptoKey.
+      if (d.privateJwk && d.publickey === publickeyJwkStr) {
+        kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
+        return { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+      }
+      return d // legado real (dispositivo con llave propia distinta)
+    } catch (_) { return null }
+  }
+
+  // ----- renovación AUTOMÁTICA del cert (sin QR ni aprobación) -----
+  // Con el cert aún vigente y quedando <15 días, cualquier uso del vault dispara en
+  // segundo plano un `vault.renew`: el vault firma un cert fresco (30 días) para la
+  // misma sub-clave y scope. Mientras uses el ecosistema ~1 vez al mes, nunca vence.
+  // Un cert YA vencido o revocado no puede renovarse (ahí sí, re-emparejar).
+  const RENEW_WINDOW_MS = 15 * 24 * 60 * 60 * 1000
+  const RENEW_RETRY_MS = 60 * 60 * 1000 // si falla (vault apagado), no insistir >1 vez/hora
+  let renewLastTry = 0
+  function maybeRenewVaultCert () {
+    try {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) return
+      const now = Date.now()
+      if (v.cert.exp <= now || v.cert.exp - now > RENEW_WINDOW_MS) return
+      if (now - renewLastTry < RENEW_RETRY_MS) return
+      renewLastTry = now
+      remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert }).then(({ cert }) => {
+        kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ ...v, cert, renewedAt: Date.now() }))
+        emitVault({ phase: 'renewed', exp: cert.exp })
+      }).catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
+    } catch (_) {}
+  }
 
   // ----- me (kv-backed) -----
 
@@ -292,26 +396,35 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
   }
 
   async function exportLocalForSync () {
-    const raw = kv.getItem(KEY_STORAGE)
-    const keys = raw ? JSON.parse(raw) : null
-    const encRaw = kv.getItem(ENC_KEY_STORAGE)
-    const encKeys = encRaw ? JSON.parse(encRaw) : null
+    // Las llaves privadas NO viajan al sync (no extractables): Drive respalda
+    // perfil+contactos; la identidad se recupera ENROLANDO el navegador al vault.
     return {
-      privateJwk: keys?.privateJwk || null,
-      publicJwk: keys?.publicJwk || null,
-      encPrivateJwk: encKeys?.privateJwk || null,
-      encPublicJwk: encKeys?.publicJwk || null,
+      privateJwk: null,
+      publicJwk: keypair?.publicJwk || null,
+      encPrivateJwk: null,
+      encPublicJwk: encKeypair?.publicJwk || null,
       me: loadMe(),
       peers: loadPeers()
     }
   }
 
+  async function adoptJwkPair (kind, storageKey, privateJwk, publicJwk) {
+    const { algo, privUses } = ALGO_OF[kind]
+    if (keyStore) {
+      const privateKey = await crypto.subtle.importKey('jwk', privateJwk, algo, false, privUses)
+      await keyStore.set(_scoped(storageKey), { privateKey, publicJwk })
+      kv.removeItem(storageKey)
+    } else {
+      kv.setItem(storageKey, JSON.stringify({ privateJwk, publicJwk }))
+    }
+  }
+
   async function applyMergedFromSync (merged) {
-    const localKeys = kv.getItem(KEY_STORAGE)
+    const localKeys = kv.getItem(KEY_STORAGE) || (keyStore && (await keyStore.get(_scoped(KEY_STORAGE)).catch(() => null)))
     if (!localKeys && merged.privateJwk && merged.publicJwk) {
-      kv.setItem(KEY_STORAGE, JSON.stringify({ privateJwk: merged.privateJwk, publicJwk: merged.publicJwk }))
+      await adoptJwkPair('sign', KEY_STORAGE, merged.privateJwk, merged.publicJwk)
       if (merged.encPrivateJwk && merged.encPublicJwk) {
-        kv.setItem(ENC_KEY_STORAGE, JSON.stringify({ privateJwk: merged.encPrivateJwk, publicJwk: merged.encPublicJwk }))
+        await adoptJwkPair('enc', ENC_KEY_STORAGE, merged.encPrivateJwk, merged.encPublicJwk)
       }
       keypair = await loadOrCreateKeypair()
       publickeyJwkStr = JSON.stringify(keypair.publicJwk)
@@ -354,7 +467,131 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
 
   // ----- handlers (idénticos a la versión iframe) -----
 
+  // Merge de un patch de perfil en `me` (preserva lo demás), saneado. Refleja el nombre en la
+  // meta del perfil (para el switcher). Devuelve el `me` resultante.
+  function applyMeUpdate (patch) {
+    const clean = sanitizeProfilePatch(patch || {})
+    me = { ...(me || {}), ...clean, publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, updatedAt: Date.now() }
+    if (clean.avatar === null) delete me.avatar
+    saveMe(me)
+    if (typeof clean.nickname === 'string') {
+      const list = loadProfiles(); const e = list.find((p) => p.id === currentPid)
+      if (e && e.name !== clean.nickname) { e.name = clean.nickname; saveProfiles(list) }
+    }
+    pushProfileToVault() // best-effort: mismo perfil en todos los dispositivos
+    return me
+  }
+
+  // ----- PERFIL COMPARTIDO entre dispositivos (vía el vault) -----
+  // El vault guarda la copia autoritativa del perfil (profileSet/profileGet en su
+  // store). Al editar aquí se EMPUJA; al arrancar se JALA y gana el más nuevo
+  // (updatedAt). Las llaves (publickey/encryptionPubkey) son POR dispositivo y
+  // nunca se sincronizan. Todo best-effort: sin vault encendido no molesta.
+  let profilePushTimer = null
+  function pushProfileToVault () {
+    const v = loadVaultCert(); const device = loadVaultDevice()
+    if (!v?.cert || !device || v.cert.exp <= Date.now()) return
+    clearTimeout(profilePushTimer)
+    profilePushTimer = setTimeout(() => {
+      const { publickey, encryptionPubkey, ...content } = me || {}
+      remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileSet', args: { me: content } })
+        .catch(() => {}) // el vault puede estar apagado; se reintenta en la próxima edición
+    }, 800) // debounce: ediciones seguidas = un solo push
+  }
+  async function pullProfileFromVault () {
+    try {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device || v.cert.exp <= Date.now()) return
+      const res = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileGet', args: {} })
+      const remoteMe = res?.me
+      if (!remoteMe) {
+        // el vault aún no tiene perfil: sembrar con el local (si tiene contenido)
+        if (me?.nickname || me?.avatar) pushProfileToVault()
+        return
+      }
+      if ((remoteMe.updatedAt || 0) > (me?.updatedAt || 0)) {
+        const { publickey, encryptionPubkey, ...content } = remoteMe
+        me = { ...(me || {}), ...content, publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr }
+        saveMe(me)
+        if (typeof content.nickname === 'string') {
+          const list = loadProfiles(); const e = list.find((p) => p.id === currentPid)
+          if (e && e.name !== content.nickname) { e.name = content.nickname; saveProfiles(list) }
+        }
+        emitVault({ phase: 'profile-sync', updatedAt: remoteMe.updatedAt })
+      }
+    } catch (_) { /* vault apagado: el perfil local sigue mandando */ }
+  }
+
+  // ----- CANDADO por contraseña (OPCIONAL, POR PERFIL, LOCAL de este dispositivo) -----
+  // El hash (PBKDF2) vive solo en el kv de ESTE navegador: no viaja al vault ni a
+  // otros dispositivos (cada uno decide si protege su acceso y con qué contraseña).
+  // Al desbloquear, la prueba va a sessionStorage (por PESTAÑA): sobrevive al
+  // refresco y muere al cerrar la pestaña. No cifra datos: es un gate de acceso.
+  const PWD_STORAGE = 'dotrino.identity.pwd'
+  const PWD_SESSION = 'dotrino.identity.pwd.proof'
+  const PWD_ITER = 300000
+  let locked = false
+  const b64 = (buf) => btoa(String.fromCharCode(...new Uint8Array(buf)))
+  async function derivePwd (password, saltB64, iter) {
+    const salt = Uint8Array.from(atob(saltB64), (c) => c.charCodeAt(0))
+    const km = await crypto.subtle.importKey('raw', new TextEncoder().encode(String(password)), 'PBKDF2', false, ['deriveBits'])
+    const bits = await crypto.subtle.deriveBits({ name: 'PBKDF2', hash: 'SHA-256', salt, iterations: iter }, km, 256)
+    return b64(bits)
+  }
+  const loadPwd = () => { try { return JSON.parse(kv.getItem(PWD_STORAGE) || 'null') } catch (_) { return null } }
+  const sessionProof = () => { try { return sessionKv?.getItem(_scoped(PWD_SESSION)) || null } catch (_) { return null } }
+  function refreshLockState () {
+    const pwd = loadPwd()
+    locked = !!pwd && sessionProof() !== pwd.verifier
+  }
+  // Métodos disponibles AUN bloqueado (gestionar perfiles y el propio candado;
+  // nada que lea datos o firme).
+  const LOCK_EXEMPT = new Set([
+    'profileLockStatus', 'unlockProfile', 'listProfiles', 'currentProfile',
+    'switchProfile', 'createProfile'
+  ])
+
   const handlers = {
+    async profileLockStatus () {
+      refreshLockState()
+      return { protected: !!loadPwd(), locked }
+    },
+    async unlockProfile ({ password }) {
+      const pwd = loadPwd()
+      if (!pwd) { locked = false; return { ok: true, locked: false } }
+      // Freno de fuerza bruta (un PIN de 4 dígitos se adivina probando): tras 5
+      // fallos, espera exponencial (2^n s, tope 5 min) persistida en el kv.
+      const tries = (() => { try { return JSON.parse(kv.getItem('dotrino.identity.pwd.tries') || 'null') } catch (_) { return null } })() || { n: 0, at: 0 }
+      const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
+      const left = tries.at + waitMs - Date.now()
+      if (left > 0) throw new Error(`demasiados intentos: espera ${Math.ceil(left / 1000)} s`)
+      const proof = await derivePwd(password, pwd.salt, pwd.iter)
+      if (proof !== pwd.verifier) {
+        kv.setItem('dotrino.identity.pwd.tries', JSON.stringify({ n: tries.n + 1, at: Date.now() }))
+        throw new Error('contraseña incorrecta')
+      }
+      kv.removeItem('dotrino.identity.pwd.tries')
+      try { sessionKv?.setItem(_scoped(PWD_SESSION), proof) } catch (_) {}
+      locked = false
+      return { ok: true, locked: false }
+    },
+    // Poner/cambiar contraseña (requiere estar desbloqueado; cambiar exige la actual vía unlock previo).
+    async setProfilePassword ({ password }) {
+      if (locked) throw new Error('perfil bloqueado')
+      if (!password || String(password).length < 4) throw new Error('la contraseña debe tener al menos 4 caracteres')
+      const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
+      const verifier = await derivePwd(password, salt, PWD_ITER)
+      kv.setItem(PWD_STORAGE, JSON.stringify({ v: 1, salt, iter: PWD_ITER, verifier }))
+      try { sessionKv?.setItem(_scoped(PWD_SESSION), verifier) } catch (_) {}
+      return { ok: true }
+    },
+    async removeProfilePassword () {
+      if (locked) throw new Error('perfil bloqueado')
+      kv.removeItem(PWD_STORAGE)
+      try { sessionKv?.removeItem(_scoped(PWD_SESSION)) } catch (_) {}
+      return { ok: true }
+    },
+
     async makeChallenge () {
       const nonce = crypto.randomUUID()
       rememberNonce(nonce)
@@ -585,6 +822,12 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
       for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations', 'vault.device', 'vault.cert']) {
         rawKv.removeItem(`dotrino.identity.p.${id}.${s}`)
       }
+      // …y sus CryptoKeys no extractables del keyStore (IndexedDB).
+      if (keyStore) {
+        for (const s of ['keypair', 'enc-keypair']) {
+          try { await keyStore.remove(`dotrino.identity.p.${id}.${s}`) } catch (_) {}
+        }
+      }
       if (currentPid === id) { currentPid = list[0].id; rawKv.setItem(CURRENT_STORAGE, currentPid) }
       return { ok: true, current: currentPid }
     },
@@ -595,18 +838,21 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     async vaultPair ({ qr }) {
       // 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).
-      let device
-      try { const k = JSON.parse(kv.getItem(KEY_STORAGE)); device = { publickey: JSON.stringify(k.publicJwk), privateJwk: k.privateJwk } } catch (_) { device = undefined }
+      // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
+      // y NO se persiste ningún JWK del dispositivo (marcador useIdentityKey).
+      const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
       const res = await remoteEnroll({ qr, device, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
-      kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify(res.device))
+      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() }))
       emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master })
+      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 }
     },
 
     async vaultStatus () {
       const v = loadVaultCert()
       if (!v?.cert) return { paired: false }
+      maybeRenewVaultCert()
       return { paired: true, deviceId: v.deviceId, master: v.master, proxy: v.proxy, scope: v.cert.scope, exp: v.cert.exp, pairedAt: v.pairedAt }
     },
 
@@ -623,6 +869,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     async vaultSign ({ payload }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      maybeRenewVaultCert()
       try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload }) }
       catch (e) { return handleVaultError(e) }
     },
@@ -632,6 +879,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     async vaultStore ({ method, args }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      maybeRenewVaultCert()
       try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args }) }
       catch (e) { return handleVaultError(e) }
     },
@@ -640,6 +888,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     async listVaultDevices () {
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      maybeRenewVaultCert()
       try { return await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert }) }
       catch (e) { return handleVaultError(e) }
     },
@@ -656,9 +905,30 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     },
 
     async setMyNickname ({ nickname }) {
-      const next = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: String(nickname || '').slice(0, 40) }
-      saveMe(next)
-      return { me: next }
+      return { me: applyMeUpdate({ nickname }) }
+    },
+
+    // Perfil completo (avatar 250x250, links de redes, datos), cada ítem con `visible`
+    // (oculto = no se comparte). Merge: no pisa lo que no venga en el patch.
+    async updateMe ({ patch } = {}) {
+      return { me: applyMeUpdate(patch || {}) }
+    },
+    async getMe () { return me },
+    // Subconjunto PÚBLICO del perfil (solo lo marcado visible) — para compartir/publicar.
+    async publicMe () {
+      const m = me || {}
+      const out = { publickey: m.publickey, encryptionPubkey: m.encryptionPubkey }
+      if (m.nickname) out.nickname = m.nickname
+      if (m.avatar && m.avatarVisible !== false) out.avatar = m.avatar
+      // Campos estándar: sensibles (telefono/direccion) solo si su flag === true; el resto salvo flag === false.
+      for (const [k] of STD_FIELD_CAPS) {
+        if (!m[k]) continue
+        const shown = STD_FIELDS_SENSITIVE.has(k) ? (m[k + 'Visible'] === true) : (m[k + 'Visible'] !== false)
+        if (shown) out[k] = m[k]
+      }
+      if (Array.isArray(m.links)) { const v = m.links.filter((l) => l.visible !== false).map(({ visible, ...r }) => r); if (v.length) out.links = v }
+      if (Array.isArray(m.fields)) { const v = m.fields.filter((f) => f.visible !== false).map(({ visible, ...r }) => r); if (v.length) out.fields = v }
+      return out
     },
 
     async getEncryptionPubkey () { return encPublickeyJwkStr },
@@ -700,7 +970,10 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
 
     async exportIdentity () {
       const raw = kv.getItem(KEY_STORAGE)
-      if (!raw) throw new Error('No keypair to export')
+      if (!raw) {
+        throw new Error('Este perfil guarda su llave de forma NO exportable (protección contra robo). ' +
+          'Para usar tu identidad en otro navegador, conecta ese navegador a tu bóveda (vault) desde profile.dotrino.com.')
+      }
       const keys = JSON.parse(raw)
       const encRaw = kv.getItem(ENC_KEY_STORAGE)
       const encKeys = encRaw ? JSON.parse(encRaw) : null
@@ -725,13 +998,10 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
 
     async importIdentity ({ privateJwk, publicJwk, encPrivateJwk, encPublicJwk, me: meIn, peers: peersIn }) {
       if (!privateJwk || !publicJwk) throw new Error('privateJwk and publicJwk required')
-      await crypto.subtle.importKey('jwk', privateJwk, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign'])
       await crypto.subtle.importKey('jwk', publicJwk, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['verify'])
-      kv.setItem(KEY_STORAGE, JSON.stringify({ privateJwk, publicJwk }))
+      await adoptJwkPair('sign', KEY_STORAGE, privateJwk, publicJwk)
       if (encPrivateJwk && encPublicJwk) {
-        await crypto.subtle.importKey('jwk', encPrivateJwk, { name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveBits', 'deriveKey'])
-        await crypto.subtle.importKey('jwk', encPublicJwk, { name: 'ECDH', namedCurve: 'P-256' }, true, [])
-        kv.setItem(ENC_KEY_STORAGE, JSON.stringify({ privateJwk: encPrivateJwk, publicJwk: encPublicJwk }))
+        await adoptJwkPair('enc', ENC_KEY_STORAGE, encPrivateJwk, encPublicJwk)
       } else {
         kv.removeItem(ENC_KEY_STORAGE)
       }
@@ -785,6 +1055,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
   encKeypair = await loadOrCreateEncKeypair()
   encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
 
+  // Purga del JWK legado SIN namespace (pre-multi-perfil): la migración a
+  // perfiles lo COPIABA sin borrarlo. Con keyStore (llaves no extractables) no
+  // puede quedar ninguna privada en claro: si la llave activa ya vive en el
+  // keyStore y coincide con la legada, se elimina el plano.
+  if (keyStore) {
+    try {
+      const legacy = JSON.parse(rawKv.getItem(KEY_STORAGE) || 'null')
+      if (legacy && JSON.stringify(legacy.publicJwk) === publickeyJwkStr) {
+        rawKv.removeItem(KEY_STORAGE)
+        rawKv.removeItem(ENC_KEY_STORAGE)
+      }
+    } catch (_) {}
+  }
+
   await initPeerStorage()
 
   const persistedMe = loadMe()
@@ -798,6 +1082,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr }
     kv.setItem(ME_STORAGE, JSON.stringify(me))
   }
+  // Perfil compartido: jalar del vault en background (gana el más nuevo).
+  pullProfileFromVault()
 
   // Registrar el pubkey (y nombre) del perfil activo en su meta → para avatar/listado sin abrir cada perfil.
   {
@@ -818,6 +1104,18 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null })
     onDirty(() => { if (sync) sync.markDirty() })
   }
 
+  // ----- gate del candado: TODO handler no exento exige perfil desbloqueado -----
+  refreshLockState()
+  for (const name of Object.keys(handlers)) {
+    if (LOCK_EXEMPT.has(name)) continue
+    const fn = handlers[name]
+    handlers[name] = async (params) => {
+      if (locked) refreshLockState() // otra pestaña pudo desbloquear… no: session es por pestaña; re-chequea por si se quitó el pwd
+      if (locked) throw new Error('perfil bloqueado: desbloquéalo con tu contraseña (unlockProfile)')
+      return fn(params)
+    }
+  }
+
   return {
     handlers,
     get me () { return me },

package/vault/remote.js

@@ -46,7 +46,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     // NO se manda el código ni un compromiso: el vault lo aprende SOLO cuando lo tipeás, y al
     // ECHARLO de vuelta el dispositivo confía. Un vault falso no conoce el código → no empareja.
     const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, data })
+    const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
       const off = client.on('message', (_from, p) => {
@@ -79,13 +79,13 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
  * @returns {Promise<{ signature:string, publickey:string }>}  publickey = la maestra.
  */
 export async function requestSign ({ master, proxy, device, cert, payload, timeoutMs = 15000 } = {}) {
-  if (!master || !proxy || !device?.privateJwk || !cert) throw new Error('faltan datos de emparejamiento')
+  if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
   try {
     const data = { op: 'sign', payload, publickey: device.publickey, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
     const pending = new Promise((resolve, reject) => {
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
@@ -103,13 +103,13 @@ export async function requestSign ({ master, proxy, device, cert, payload, timeo
 
 /** Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`. */
 async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, timeoutMs = 15000 }) {
-  if (!master || !proxy || !device?.privateJwk || !cert) throw new Error('faltan datos de emparejamiento')
+  if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
   try {
     const signed = { ...data, publickey: device.publickey, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data: signed })
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data: signed })
     const pending = new Promise((resolve, reject) => {
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
@@ -135,3 +135,14 @@ export async function requestDevices ({ master, proxy, device, cert } = {}) {
   const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
   return { devices: res.devices || [], revoked: res.revoked || [] }
 }
+
+/**
+ * RENUEVA el cert de este dispositivo (requiere el cert aún VIGENTE y no revocado):
+ * el vault firma uno fresco para la misma sub-clave y scope, sin QR ni aprobación.
+ * @returns {Promise<{ cert: object }>}
+ */
+export async function requestRenew ({ master, proxy, device, cert } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
+  if (!res.cert || res.cert.sub !== device.publickey || res.cert.iss !== master) throw new Error('cert renovado inválido')
+  return { cert: res.cert }
+}

package/vault/vault.js

@@ -15,26 +15,83 @@ import {
 import { createIdentityCore } from './core.js'
 
 ;(async () => {
-  // kv estilo localStorage (síncrono) para keypairs, me y nonces.
+  // kv estilo localStorage (síncrono) para me, nonces, delegaciones, certs.
   const kv = {
     getItem: (k) => localStorage.getItem(k),
     setItem: (k, v) => localStorage.setItem(k, v),
     removeItem: (k) => localStorage.removeItem(k)
   }
 
+  // keyStore: las llaves PRIVADAS viven como CryptoKey NO EXTRACTABLES en
+  // 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 req = indexedDB.open('dotrino-identity-keys', 1)
+    req.onupgradeneeded = () => req.result.createObjectStore('keys')
+    req.onsuccess = () => {
+      const db = req.result
+      const op = (mode, fn) => new Promise((res, rej) => {
+        const tx = db.transaction('keys', mode)
+        const r = fn(tx.objectStore('keys'))
+        r.onsuccess = () => res(r.result ?? null)
+        r.onerror = () => rej(r.error)
+      })
+      resolve({
+        get: (name) => op('readonly', (st) => st.get(name)),
+        set: (name, pair) => op('readwrite', (st) => st.put(pair, name)),
+        remove: (name) => op('readwrite', (st) => st.delete(name))
+      })
+    }
+    req.onerror = () => resolve(null) // sin IDB (raro): cae al modo kv legado
+  }))()
+
+  // sessionKv: la prueba de desbloqueo del candado por contraseña vive en
+  // sessionStorage — POR PESTAÑA: sobrevive al refresco, muere al cerrarla.
+  const sessionKv = {
+    getItem: (k) => sessionStorage.getItem(k),
+    setItem: (k, v) => sessionStorage.setItem(k, v),
+    removeItem: (k) => sessionStorage.removeItem(k)
+  }
+
   const core = await createIdentityCore({
     kv,
     peers: { initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty },
-    makeSync: createSync
+    makeSync: createSync,
+    keyStore,
+    sessionKv
   })
 
   const { handlers } = core
 
-  // Broadcast de eventos del vault (sync + emparejamiento) a todos los embebedores.
+  // ---- Control de ORIGEN (crítico): la identidad solo habla con el ecosistema. ----
+  // Sin esto, CUALQUIER web podía embeber este iframe y llamar `exportIdentity`
+  // (llave privada cruda), `signData` (suplantación) o leer tu perfil/contactos.
+  // Permitidos: *.dotrino.com (y apex), el mirror de la org en GitHub Pages, y
+  // orígenes de desarrollo (localhost / 127.0.0.1 / IPs de LAN privada).
+  const ALLOWED_ORIGIN = new RegExp(
+    '^(' +
+    'https://([a-z0-9-]+\\.)*dotrino\\.com' + '|' +
+    'https://imdotrino\\.github\\.io' + '|' +
+    'https?://localhost(:\\d+)?' + '|' +
+    'https?://127\\.0\\.0\\.1(:\\d+)?' + '|' +
+    'https?://192\\.168\\.\\d{1,3}\\.\\d{1,3}(:\\d+)?' + '|' +
+    'https?://10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}(:\\d+)?' + '|' +
+    'https?://172\\.(1[6-9]|2\\d|3[01])\\.\\d{1,3}\\.\\d{1,3}(:\\d+)?' +
+    ')$'
+  )
+  const isAllowed = (origin) => typeof origin === 'string' && ALLOWED_ORIGIN.test(origin)
+
+  // Broadcast de eventos del vault (sync + emparejamiento) SOLO a embebedores que
+  // ya hicieron una petición válida (ventana+origen verificados), nunca con '*'.
+  const embedders = [] // [{ win, origin }]
+  const rememberEmbedder = (win, origin) => {
+    if (!win || win === window) return
+    if (!embedders.some((e) => e.win === win)) embedders.push({ win, origin })
+  }
   const broadcast = (eventName, payload) => {
-    for (const w of [window.parent, ...Array.from(document.querySelectorAll('iframe')).map(f => f.contentWindow)]) {
-      if (!w || w === window) continue
-      try { w.postMessage({ _cci: true, type: 'event', event: eventName, payload }, '*') } catch {}
+    for (const { win, origin } of embedders) {
+      try { win.postMessage({ _cci: true, type: 'event', event: eventName, payload }, origin) } catch {}
     }
   }
   core.onSyncStatus((p) => broadcast('sync', p))
@@ -43,6 +100,8 @@ import { createIdentityCore } from './core.js'
   window.addEventListener('message', async (event) => {
     const msg = event.data
     if (!msg || msg._cci !== true || msg.type !== 'request') return
+    if (!isAllowed(event.origin)) return // origen ajeno: silencio total
+    rememberEmbedder(event.source, event.origin)
     const { id, method, params } = msg
     const reply = (payload) => event.source?.postMessage(
       { _cci: true, type: 'response', id, ...payload },
@@ -58,8 +117,22 @@ import { createIdentityCore } from './core.js'
     }
   })
 
-  // Avisar a todo padre que el vault está listo.
+  // Avisar al padre que el vault está listo — solo si su origen (referrer) es del
+  // ecosistema; a una página ajena no se le revela NADA (ni pubkey ni apodo).
   if (window.parent && window.parent !== window) {
-    window.parent.postMessage({ _cci: true, type: 'ready', me: core.me }, '*')
+    let parentOrigin = null
+    try { parentOrigin = new URL(document.referrer).origin } catch {}
+    if (parentOrigin && isAllowed(parentOrigin)) {
+      rememberEmbedder(window.parent, parentOrigin)
+      // Perfil BLOQUEADO por contraseña → ready sin datos (ni apodo ni pubkey):
+      // la app debe desbloquear (unlockProfile) y refrescar con getMe.
+      const lock = await handlers.profileLockStatus().catch(() => ({ locked: false }))
+      window.parent.postMessage({ _cci: true, type: 'ready', ...(lock.locked ? { locked: true } : { me: core.me }) }, parentOrigin)
+    } else {
+      // Sin referrer (política estricta del padre) no podemos verificar el origen:
+      // señalamos ready SIN datos (no revela nada; y las peticiones de orígenes
+      // ajenos se ignoran igual). Las apps del ecosistema refrescan `me` por RPC.
+      window.parent.postMessage({ _cci: true, type: 'ready' }, '*')
+    }
   }
 })()