@dotrino/identity 0.85.0 → 0.86.0

package/README.md

@@ -160,6 +160,24 @@ const v = await verifySignedFor({ data: pin, signature, publickey, chain, audien
 `aud` es obligatorio igual que en la prueba; `exp` es opcional, porque la caducidad de lo
 publicado la lleva el servicio (el TTL del pin) y no el cuerpo.
 
+### Permiso por origen (0.86.0+)
+
+Una prueba dice **quién eres** sin preguntar nada: quien llega al iframe ya pasó el filtro
+de orígenes, y pedir permiso treinta veces al día por aplicaciones del mismo dueño es
+ceremonia, no seguridad. Cualquier **dato tuyo** —nombre, foto, correo, enlaces— es otra
+cosa: hace falta que lo concedas a ESE origen, y lo concedido se guarda y se puede retirar.
+
+```js
+await id.listGrants()          // [{ origin, scopes, at }]
+await id.revokeGrant(origin)   // y la próxima vez se vuelve a preguntar
+```
+
+**El panel lo pinta la bóveda, no la aplicación.** Vive en otro origen, así que la página
+que pide no puede pulsar ahí dentro ni leerlo; lo único que puede hacer es no mostrarlo, y
+entonces no consigue el permiso — que es el lado correcto en el que fallar. Sin nadie a
+quien preguntar (Node, o un cliente que no muestra nada), la respuesta es **no**: nunca se
+amplía en silencio.
+
 ### Entrar sin enrolar: las sesiones (0.85.0+)
 
 Enlazar un aparato y entrar en uno no son lo mismo. Enlazar mete una llave en el acta —hay

package/package.json

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

@@ -124,6 +124,10 @@ export class Identity {
   listContacts (): Promise<PeerInfo[]>
   signData (data: any): Promise<{ signature: string; publickey: string }>
   requestAssertion (args: { audience: string; nonce: string; scopes?: AssertionScope[]; ttlMs?: number }): Promise<Assertion>
+  /** Qué le has concedido a cada aplicación (permiso por origen). */
+  listGrants (): Promise<Array<{ origin: string; scopes: AssertionScope[]; at: number }>>
+  /** Retirar lo concedido a un origen: la próxima vez que pida, se vuelve a preguntar. */
+  revokeGrant (origin: string): Promise<{ ok: boolean }>
   setMyNickname (nickname: string): Promise<{ me: Me }>
   getEncryptionPubkey (): Promise<string>
   encrypt (recipients: EncryptRecipient[], plaintext: string): Promise<EnvelopeV1>

package/src/index.js

@@ -146,6 +146,12 @@ export class Identity {
         }
 
         if (msg.type === 'event') {
+          // MOSTRAR EL IFRAME PARA QUE PREGUNTE. El panel de permiso lo pinta la bóveda,
+          // en su propio origen: esta página no puede pulsar ahí dentro ni leerlo. Lo
+          // único que hace aquí es dejar sitio. Si una aplicación decidiera no hacerlo,
+          // no obtiene el permiso — que es el lado correcto en el que fallar.
+          if (msg.event === 'consent:open') this._showVault(true)
+          if (msg.event === 'consent:close') this._showVault(false)
           this._emit(msg.event, msg.payload)
         }
       }
@@ -157,6 +163,16 @@ export class Identity {
     return this._ready
   }
 
+  /** Deja ver la bóveda (a pantalla completa) mientras pregunta, y la devuelve a su sitio. */
+  _showVault (visible) {
+    const f = this._iframe
+    if (!f) return
+    f.style.cssText = visible
+      ? 'position:fixed;inset:0;width:100%;height:100%;border:0;z-index:2147483000'
+      : 'display:none'
+    f.setAttribute('aria-hidden', visible ? 'false' : 'true')
+  }
+
   destroy () {
     if (this._handler) window.removeEventListener('message', this._handler)
     if (this._iframe && this._iframe.parentNode) this._iframe.parentNode.removeChild(this._iframe)
@@ -256,6 +272,11 @@ export class Identity {
    * @returns {Promise<object>} la prueba, lista para mandar. Se comprueba con
    * `verifyAssertion(prueba, { audience, nonce })`.
    */
+  /** Qué le has concedido a cada aplicación. Sin esto, conceder no significaría nada. */
+  async listGrants () { return this._call('listGrants') }
+  /** Retirar lo concedido a un origen: la próxima vez que pida, se vuelve a preguntar. */
+  async revokeGrant (origin) { return this._call('revokeGrant', { origin }) }
+
   async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
     const { assertion } = await this._call('requestAssertion', { audience, nonce, scopes, ttlMs })
     return assertion

package/vault/core.js

@@ -37,6 +37,7 @@ export const ACTA_STORAGE = 'dotrino.identity.acta'                 // acta de p
 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
+export const GRANTS_STORAGE = 'dotrino.identity.grants'             // qué le concediste a cada origen (permiso por origen)
 // 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.).
 export const PROFILES_STORAGE = 'dotrino.identity.profiles' // [{ id, name, pubkey }]
@@ -183,7 +184,15 @@ function sanitizeProfilePatch (patch = {}) {
   return out
 }
 
-export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, keyStore = null, sessionKv = null, removeAccountOnExpulsion = true, keyLock = null }) {
+/**
+ * `askConsent` es CÓMO SE PREGUNTA, y lo pone quien monta el núcleo (el iframe pinta su
+ * propio panel; en Node no hay a quién preguntar). Se inyecta en vez de vivir aquí porque
+ * este módulo no toca interfaz — y porque QUIÉN pinta importa: un panel dibujado por la
+ * aplicación que pide sería la aplicación aprobándose a sí misma.
+ *
+ * Si no se inyecta, no se concede nada nuevo: sin forma de preguntar, la respuesta es no.
+ */
+export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, keyStore = null, sessionKv = null, removeAccountOnExpulsion = true, keyLock = null, askConsent = null }) {
   const {
     initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
   } = peers
@@ -594,6 +603,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // Diseño en `dotrino-vault/docs/acta-de-perfil.md`. Aquí solo se guarda, se lee y se
   // sella; las reglas (sellador único, seq/prev, no dejar el perfil sin firmante) viven en
   // `acta.js`, que es puro y está probado aparte.
+  // ----- PERMISO POR ORIGEN: qué le concedió el usuario a cada aplicación -----
+  //
+  // `{ [origin]: { scopes: [...], at } }`. Vive en el kv del PERFIL, así que cambiar de
+  // perfil cambia lo concedido: lo que le diste a una aplicación desde tu cuenta de trabajo
+  // no vale para la personal.
+  const loadGrants = () => { try { return JSON.parse(kv.getItem(GRANTS_STORAGE) || '{}') } catch (_) { return {} } }
+  const saveGrants = (g) => { try { kv.setItem(GRANTS_STORAGE, JSON.stringify(g)) } catch (_) {} }
+  /** Lo concedido a un origen, hoy. */
+  const grantedTo = (origin) => (loadGrants()[String(origin || '')]?.scopes) || []
+
   const loadActa = () => { try { return JSON.parse(kv.getItem(ACTA_STORAGE) || 'null') } catch (_) { return null } }
   const saveActa = (a) => kv.setItem(ACTA_STORAGE, JSON.stringify(a))
   // VENTANA DE RETENCIÓN (§1.3): el master conserva las últimas actas para que un miembro
@@ -1382,6 +1401,49 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     'profileActa', 'profileMembers', 'myMembership', 'isMaster', 'sealerChain'
   ])
 
+  /**
+   * ¿QUÉ SE LE DEJA VER A ESTE ORIGEN? El corazón del permiso por origen.
+   *
+   * `id:whoami` —solo quién eres, sin ningún dato— se concede sin preguntar: quien llega
+   * aquí ya pasó el filtro de orígenes del iframe, y preguntarlo treinta veces al día por
+   * aplicaciones del mismo dueño es ceremonia, no seguridad.
+   *
+   * Todo lo DEMÁS (nombre, foto, correo, redes) exige una concesión guardada, y si no la
+   * hay se pregunta. Lo que el usuario diga se guarda por origen y se puede retirar.
+   *
+   * Y si no hay a quién preguntar —Node, o un cliente que no muestra el panel— se devuelve
+   * lo que ya estuviera concedido y nada más. **No se amplía en silencio**: sin respuesta,
+   * la respuesta es no.
+   */
+  async function consentFor (origin, pedidos) {
+    const org = String(origin || '').trim()
+    const base = pedidos.filter((s) => s === 'id:whoami')
+    const extra = pedidos.filter((s) => s !== 'id:whoami')
+    if (!extra.length) return pedidos
+    // Sin origen no se puede llevar la cuenta de a quién se le concedió qué, así que no se
+    // concede nada más que el mínimo. Es el caso de Node y el de una llamada interna.
+    if (!org) return base.length ? base : ['id:whoami']
+
+    const yaTiene = grantedTo(org)
+    const faltan = extra.filter((s) => !yaTiene.includes(s))
+    if (!faltan.length) return pedidos
+
+    if (typeof askConsent !== 'function') {
+      const conocidos = [...base, ...extra.filter((s) => yaTiene.includes(s))]
+      return conocidos.length ? conocidos : ['id:whoami']
+    }
+    let ok = false
+    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene })) } catch (_) { ok = false }
+    if (!ok) {
+      const conocidos = [...base, ...extra.filter((s) => yaTiene.includes(s))]
+      return conocidos.length ? conocidos : ['id:whoami']
+    }
+    const g = loadGrants()
+    g[org] = { scopes: [...new Set([...yaTiene, ...faltan])].sort(), at: Date.now() }
+    saveGrants(g)
+    return pedidos
+  }
+
   const handlers = {
     async profileLockStatus () {
       refreshLockState()
@@ -1641,13 +1703,31 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * (`dotrino-vault/docs/inicio-de-sesion.md`); hasta entonces esto no entrega nada que
      * no se entregue ya, que es la forma de no adelantar una decisión del usuario.
      */
-    async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
+    /**
+     * QUÉ LE HAS CONCEDIDO A CADA APLICACIÓN. Es la mitad que hace que el permiso sea del
+     * usuario y no un trámite: si no se puede ver ni retirar, conceder no significa nada.
+     */
+    async listGrants () {
+      const g = loadGrants()
+      return Object.entries(g).map(([origin, v]) => ({ origin, scopes: v?.scopes || [], at: v?.at || 0 }))
+        .sort((a, b) => b.at - a.at)
+    },
+    /** Retirar lo concedido a un origen. La próxima vez que pida, se vuelve a preguntar. */
+    async revokeGrant ({ origin } = {}) {
+      const g = loadGrants()
+      const org = String(origin || '')
+      if (!(org in g)) return { ok: false }
+      delete g[org]; saveGrants(g)
+      return { ok: true }
+    },
+
+    async requestAssertion ({ audience, nonce, scopes, ttlMs, __origin } = {}) {
       if (typeof audience !== 'string' || !audience.trim()) throw new Error('audience required')
       if (typeof nonce !== 'string' || !nonce) throw new Error('nonce required')
       const acta = loadActa()
       // A NOMBRE DE QUIÉN va: la identidad es el `profileId`, no la llave de este aparato.
       const sub = acta?.profileId || publickeyJwkStr
-      const granted = cleanScopes(scopes)
+      const granted = await consentFor(__origin, cleanScopes(scopes))
       const permitido = claimsAllowed(granted)
       const claims = {}
       if (permitido.size) {

package/vault/vault.js

@@ -55,12 +55,62 @@ import { pubkeyId } from './capabilities.js'
     removeItem: (k) => sessionStorage.removeItem(k)
   }
 
+  /**
+   * EL PANEL DE PERMISO LO PINTA ESTE IFRAME, no la aplicación que pide.
+   *
+   * Es la diferencia entre un permiso y un trámite: la aplicación vive en otro origen, así
+   * que no puede pulsar aquí dentro ni leer lo que hay. Lo único que puede hacer es NO
+   * mostrarnos —y entonces no consigue el permiso, que es el lado correcto en el que
+   * fallar—. Por eso se le pide que nos muestre (`consent:open`) y, si no lo hace, la
+   * pregunta se queda sin responder y se deniega sola.
+   */
+  const T_CONSENT = (() => {
+    const en = (navigator.language || 'es').startsWith('en')
+    return en
+      ? { title: 'wants to see', allow: 'Allow', deny: 'No', who: 'Your Dotrino identity', once: 'Only what you allow leaves here.' }
+      : { title: 'quiere ver', allow: 'Permitir', deny: 'No', who: 'Tu identidad de Dotrino', once: 'De aquí solo sale lo que permitas.' }
+  })()
+  const SCOPE_TXT = (() => {
+    const en = (navigator.language || 'es').startsWith('en')
+    return en
+      ? { 'profile:name': 'your name', 'profile:avatar': 'your picture', 'profile:email': 'your email', 'profile:social': 'your links', 'id:whoami': 'who you are' }
+      : { 'profile:name': 'tu nombre', 'profile:avatar': 'tu foto', 'profile:email': 'tu correo', 'profile:social': 'tus enlaces', 'id:whoami': 'quién eres' }
+  })()
+
+  let consentAbierto = null
+  function askConsent ({ origin, scopes }) {
+    if (consentAbierto) return Promise.resolve(false)   // una pregunta a la vez
+    return new Promise((resolve) => {
+      const host = document.createElement('div')
+      host.style.cssText = 'position:fixed;inset:0;z-index:2147483647;display:flex;align-items:center;justify-content:center;background:rgba(10,8,20,.86);font-family:system-ui,-apple-system,Segoe UI,sans-serif'
+      const lista = scopes.map((x) => `<li>${SCOPE_TXT[x] || x}</li>`).join('')
+      host.innerHTML = `<div style="background:#171331;border:1px solid #2a2350;border-radius:16px;padding:22px;min-width:min(320px,90vw);max-width:90vw;color:#e7e3ff">
+        <div style="opacity:.7;font-size:13px">${T_CONSENT.who}</div>
+        <div style="font-weight:700;margin:8px 0 4px">${String(origin).replace(/^https?:\/\//, '')} ${T_CONSENT.title}:</div>
+        <ul style="margin:6px 0 12px 18px;padding:0">${lista}</ul>
+        <div style="opacity:.7;font-size:12px;margin-bottom:12px">${T_CONSENT.once}</div>
+        <div style="display:flex;gap:8px">
+          <button data-yes style="flex:1;padding:10px;border-radius:10px;border:0;background:#7c3aed;color:#fff;font:inherit;font-weight:600;cursor:pointer">${T_CONSENT.allow}</button>
+          <button data-no style="flex:1;padding:10px;border-radius:10px;border:1px solid #2a2350;background:transparent;color:inherit;font:inherit;cursor:pointer">${T_CONSENT.deny}</button>
+        </div></div>`
+      const cerrar = (v) => { try { host.remove() } catch (_) {} consentAbierto = null; broadcast('consent:close', {}); resolve(v) }
+      host.querySelector('[data-yes]').addEventListener('click', () => cerrar(true))
+      host.querySelector('[data-no]').addEventListener('click', () => cerrar(false))
+      consentAbierto = host
+      document.body.appendChild(host)
+      broadcast('consent:open', { origin })
+      // Si nadie contesta —porque nadie nos mostró—, se deniega. Nunca al revés.
+      setTimeout(() => { if (consentAbierto === host) cerrar(false) }, 60000)
+    })
+  }
+
   const core = await createIdentityCore({
     kv,
     peers: { initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty },
     makeSync: createSync,
     keyStore,
-    sessionKv
+    sessionKv,
+    askConsent
   })
 
   const { handlers } = core
@@ -290,7 +340,10 @@ import { pubkeyId } from './capabilities.js'
     const handler = selfHandlers[method] || handlers[method]
     if (!handler) return reply({ error: `Unknown method: ${method}` })
     try {
-      const result = await handler(params || {})
+      // EL ORIGEN LO PONE EL IFRAME, no quien llama: va pisado a propósito. Es el único
+      // dato que la aplicación no puede falsificar —el navegador lo garantiza— y de él
+      // depende a quién se le concedió qué.
+      const result = await handler({ ...(params || {}), __origin: event.origin })
       reply({ result })
     } catch (e) {
       // `code` (y su `detail`) CRUZAN. Sin ellos, al otro lado solo llegaba la frase, y una