@dotrino/identity 0.91.0 → 0.93.0

package/package.json

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

@@ -126,8 +126,11 @@ export class Identity {
   requestAssertion (args: { audience: string; nonce: string; scopes?: AssertionScope[]; ttlMs?: number; onBehalfOf?: string }): Promise<Assertion>
   /** Qué le has concedido a cada aplicación (permiso por origen). */
   listGrants (): Promise<Array<{ origin: string; scopes: AssertionScope[]; at: number; lastUsed: number; onBehalfOf?: string }>>
-  /** Retirar lo concedido a un origen: la próxima vez que pida, se vuelve a preguntar. */
-  revokeGrant (origin: string): Promise<{ ok: boolean }>
+  /**
+   * Retirar lo concedido a una aplicación: la próxima vez que pida, se vuelve a preguntar.
+   * `onBehalfOf` identifica a una aplicación que entra por el puente (el mismo origen para todas).
+   */
+  revokeGrant (origin: string, onBehalfOf?: string): Promise<{ ok: boolean }>
   setMyNickname (nickname: string): Promise<{ me: Me }>
   getEncryptionPubkey (): Promise<string>
   encrypt (recipients: EncryptRecipient[], plaintext: string): Promise<EnvelopeV1>

package/src/index.js

@@ -274,8 +274,12 @@ export class Identity {
    */
   /** 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 }) }
+  /**
+   * Retirar lo concedido a una aplicación: la próxima vez que pida, se vuelve a preguntar.
+   * Las que entran por el puente llegan todas desde el mismo origen, así que a esas se las
+   * nombra con `onBehalfOf` (el que trae su fila de `listGrants`).
+   */
+  async revokeGrant (origin, onBehalfOf) { return this._call('revokeGrant', { origin, ...(onBehalfOf ? { onBehalfOf } : {}) }) }
 
   async requestAssertion ({ audience, nonce, scopes, ttlMs, onBehalfOf } = {}) {
     // ESPERA LO QUE TARDE UNA PERSONA. Los cinco segundos de siempre valen para una

package/vault/acta.js

@@ -35,7 +35,7 @@
  * Módulo PURO: sin kv, sin red, sin disco. Cripto de `./capabilities.js`.
  */
 import { canonicalStringify } from './core.js'
-import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
+import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
 
 export const ACTA_V = 5
 
@@ -649,6 +649,52 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
   return mal ? { ok: false, reason: mal } : { ok: true }
 }
 
+/**
+ * ¿ES DE FIAR LO QUE CONTESTA LA BÓVEDA CON LA QUE TE EMPAREJASTE? El papel y el acta que
+ * llegan al enrolarse o al renovar, juzgados contra la llave de ESA bóveda (`vault`: la
+ * `iss` del QR, o la que quedó guardada al enrolarse).
+ *
+ * Antes cada cliente comparaba `acta.profileId` con esa llave. Eso solo es verdad en una
+ * cuenta de una bóveda que además nació en ella: el `profileId` es la llave del GÉNESIS, y
+ * en una cuenta que la bóveda ADOPTÓ, o en la SEGUNDA bóveda de un multivault, la llave de
+ * la bóveda es otra. Ahí ningún aparato podía entrar ni renovar. Y encima no protegía: el
+ * acta no se verificaba, así que bastaba con escribir ese `profileId` en una inventada.
+ *
+ * Lo que se comprueba ahora, y por qué alcanza:
+ *   1. el acta está bien firmada por quien dice haberla sellado;
+ *   2. esa bóveda PUEDE SELLAR esta acta — es de la cuenta, con el permiso, y una llave
+ *      está en una sola cuenta, así que esto también fija la cuenta;
+ *   3. el papel lo firmó ESA bóveda y no otra selladora: la respuesta es suya, porque nadie
+ *      por el camino puede firmar con su llave;
+ *   4. y el papel vale según esa acta (para esta llave, este permiso, un `seq` que no viene
+ *      del futuro).
+ *
+ * `justSealed` es para el ENROLAMIENTO: aprobar es admitir al aparato, así que el acta que
+ * vuelve la acaba de sellar esa misma bóveda. Exigirlo ata el acta a su llave y no solo el
+ * papel — el llavero que el aparato va a usar viaja ahí dentro. Al RENOVAR no se pide: la
+ * última acta pudo sellarla otra selladora de la cuenta.
+ *
+ * @returns {Promise<{ok:true}|{ok:false, reason:string}>}
+ */
+export async function checkVaultReply ({ acta, cert, vault, sub, scope = null, justSealed = false } = {}) {
+  if (!acta) return { ok: false, reason: 'sin-acta' }
+  if (!isPub(vault)) return { ok: false, reason: 'sin-boveda' }
+  // Para QUÉ llave es el papel no es opcional: sin ella `verifyDelegation` no lo mira, y un
+  // papel emitido para otra llave pasaría por bueno.
+  if (!isPub(sub)) return { ok: false, reason: 'sin-llave-del-aparato' }
+  const v = await verifyActa({ acta })
+  if (!v.ok) return { ok: false, reason: 'acta:' + v.reason }
+  if (!canSeal(acta, vault)) return { ok: false, reason: 'boveda-no-sella' }
+  if (justSealed && !samePubkey(acta.sealedBy, vault)) return { ok: false, reason: 'acta-de-otra-selladora' }
+  if (!cert || !samePubkey(cert.iss, vault)) return { ok: false, reason: 'papel-de-otra-llave' }
+  const d = await verifyDelegation({
+    cert, expectedSub: sub, actaSeq: acta.seq, sealers: sealersOf(acta),
+    ...(scope ? { expectedScope: scope } : {})
+  })
+  if (!d.ok) return { ok: false, reason: 'papel:' + d.reason }
+  return { ok: true }
+}
+
 /**
  * Aplica cambios y devuelve el acta SIGUIENTE, **sin firmar** (hay que `sealActa`).
  * `by` es quien va a sellar: si no es el sellador vigente, se rechaza (regla 1).
@@ -1218,7 +1264,7 @@ export async function canAdopt ({ candidate, current }) {
 
 export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain, verifySignedBy,
-  sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
+  sealActa, verifyActa, checkVaultReply, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
   effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt,

package/vault/core.js

@@ -725,13 +725,34 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // `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 {} } }
+  // `{ [grantKey]: { scopes: [...], at, lastUsed, onBehalfOf? } }`. 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.
+  //
+  // LA CLAVE ES EL ORIGEN Y, SI PIDE POR OTRO, TAMBIÉN EN NOMBRE DE QUIÉN (dueño,
+  // 2026-09-17). Hasta 0.92 era solo el origen, y todas las aplicaciones que entran por el
+  // puente OIDC llegan desde el MISMO: `sso.dotrino.com`. Lo que el usuario le concedía a
+  // una lo heredaban todas las demás sin que saliera el panel, y en «dónde se usó mi
+  // identidad» se veían como una sola fila con el nombre de la última.
+  //
+  // Separar por `onBehalfOf` no le da a nadie más de lo que tenía: el nombre lo pone el
+  // origen, así que un origen que mintiera solo conseguiría una concesión aparte —vacía—,
+  // nunca la de otro origen. `|` no aparece en un origen, así que la clave no es ambigua.
+  const grantKey = (origin, onBehalfOf) => onBehalfOf ? `${origin}|${onBehalfOf}` : origin
+  const behalfName = (onBehalfOf) => onBehalfOf ? String(onBehalfOf).slice(0, 60) : ''
+  const loadGrants = () => {
+    let g
+    try { g = JSON.parse(kv.getItem(GRANTS_STORAGE) || '{}') } catch (_) { return {} }
+    // MIGRACIÓN DECLARADA (identity 0.93.0) — quitar después del 2026-10-17.
+    // Una entrada guardada bajo el origen A SECAS pero con `onBehalfOf` es de antes de 0.93:
+    // la compartían todas las aplicaciones del puente, así que no se puede atribuir a
+    // ninguna. Se tira, y cada aplicación vuelve a preguntar — que es el lado seguro.
+    for (const k of Object.keys(g)) if (!k.includes('|') && g[k]?.onBehalfOf) delete g[k]
+    return g
+  }
   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) || []
+  /** Lo concedido a un origen (y a nombre de quién pide), hoy. */
+  const grantedTo = (key) => (loadGrants()[key]?.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))
@@ -1537,6 +1558,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function consentFor (origin, pedidos, onBehalfOf = null) {
     const org = String(origin || '').trim()
+    const behalf = behalfName(onBehalfOf)
+    const key = grantKey(org, behalf)
     // APUNTA CUÁNDO SE USÓ. Sin esto, «dónde se usó mi identidad» solo puede decir qué
     // concediste, no si sigue usándose — y eso es lo que hace que uno se decida a retirar
     // un permiso que ya no hace falta. Se apunta aunque solo se pida el mínimo: entrar es
@@ -1544,8 +1567,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const marcarUso = () => {
       if (!org) return
       const g = loadGrants()
-      const prev = g[org] || { scopes: [], at: Date.now() }
-      g[org] = { ...prev, lastUsed: Date.now(), ...(onBehalfOf ? { onBehalfOf: String(onBehalfOf).slice(0, 60) } : {}) }
+      const prev = g[key] || { scopes: [], at: Date.now() }
+      g[key] = { ...prev, lastUsed: Date.now(), ...(behalf ? { onBehalfOf: behalf } : {}) }
       saveGrants(g)
     }
     const base = pedidos.filter((s) => s === 'id:whoami')
@@ -1555,7 +1578,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // 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 yaTiene = grantedTo(key)
     const faltan = extra.filter((s) => !yaTiene.includes(s))
     if (!faltan.length) { marcarUso(); return pedidos }
 
@@ -1565,17 +1588,17 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return conocidos.length ? conocidos : ['id:whoami']
     }
     let ok = false
-    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene, onBehalfOf })) } catch (_) { ok = false }
+    try { ok = !!(await askConsent({ origin: org, scopes: faltan, already: yaTiene, onBehalfOf: behalf || null })) } catch (_) { ok = false }
     if (!ok) {
       const conocidos = [...base, ...extra.filter((s) => yaTiene.includes(s))]
       marcarUso()
       return conocidos.length ? conocidos : ['id:whoami']
     }
     const g = loadGrants()
-    g[org] = {
+    g[key] = {
       scopes: [...new Set([...yaTiene, ...faltan])].sort(),
-      at: (g[org]?.at) || Date.now(), lastUsed: Date.now(),
-      ...(onBehalfOf ? { onBehalfOf: String(onBehalfOf).slice(0, 60) } : {})
+      at: (g[key]?.at) || Date.now(), lastUsed: Date.now(),
+      ...(behalf ? { onBehalfOf: behalf } : {})
     }
     saveGrants(g)
     return pedidos
@@ -1846,18 +1869,22 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async listGrants () {
       const g = loadGrants()
-      return Object.entries(g).map(([origin, v]) => ({
-        origin, scopes: v?.scopes || [], at: v?.at || 0,
+      return Object.entries(g).map(([key, v]) => ({
+        origin: key.split('|')[0], scopes: v?.scopes || [], at: v?.at || 0,
         lastUsed: v?.lastUsed || v?.at || 0,
         ...(v?.onBehalfOf ? { onBehalfOf: v.onBehalfOf } : {})
       })).sort((a, b) => b.lastUsed - a.lastUsed)
     },
-    /** Retirar lo concedido a un origen. La próxima vez que pida, se vuelve a preguntar. */
-    async revokeGrant ({ origin } = {}) {
+    /**
+     * Retirar lo concedido a una aplicación. La próxima vez que pida, se vuelve a preguntar.
+     * `onBehalfOf` es obligatorio para las que piden por otro (el puente): retirar el permiso
+     * de UNA no puede quitárselo a todas las que entran por el mismo sitio.
+     */
+    async revokeGrant ({ origin, onBehalfOf } = {}) {
       const g = loadGrants()
-      const org = String(origin || '')
-      if (!(org in g)) return { ok: false }
-      delete g[org]; saveGrants(g)
+      const key = grantKey(String(origin || ''), behalfName(onBehalfOf))
+      if (!(key in g)) return { ok: false }
+      delete g[key]; saveGrants(g)
       return { ok: true }
     },
 

package/vault/remote.js

@@ -13,8 +13,8 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
-import { sealersOf } from './acta.js'
+import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
+import { checkVaultReply } from './acta.js'
 
 const MSG = {
   HELLO: 'vault.hello',
@@ -218,14 +218,12 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // (Aquí vivía el margen de reloj: el cert lo sellaba la bóveda con SU reloj y lo validaba
     // este aparato con el suyo, y 850 ms de diferencia bastaban para no poder enrolarse. Sin
     // vencimiento no hay ventana que ajustar y el problema no puede volver.)
-    if (!res.acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    if (res.acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw')
-    const v = await verifyDelegation({
-      cert: res.cert, expectedSub: dev.publickey,
-      actaSeq: res.acta.seq, sealers: sealersOf(res.acta)
-    })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.sub !== dev.publickey) throw new Error('cert issued for a different device')
+    //
+    // Se juzga contra la llave de LA BÓVEDA con la que hablas, no contra el `profileId`:
+    // eso solo coincidía en una cuenta que nació en esa bóveda, y dejaba fuera a quien se
+    // emparejaba con una segunda bóveda o con una que adoptó la cuenta (`checkVaultReply`).
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: qr.iss, sub: dev.publickey, justSealed: true })
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
     return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
   } finally { try { client.close() } catch (_) {} }
 }
@@ -381,12 +379,17 @@ export async function requestDevices ({ master, proxy, device, cert, sinceSeq, o
  */
 export async function requestRenew ({ master, proxy, device, cert, onRevoked } = {}) {
   const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
-  if (!res.cert || res.cert.sub !== device.publickey) throw new Error('invalid renewed cert')
   // EL ACTA VIAJA CON EL PAPEL y hay que dejarla pasar: quien lo recibe la necesita para
   // comprobar que lo firmó una SELLADORA de este perfil. Aquí se comparaba `cert.iss` con
   // la maestra y se tiraba el acta, así que arriba no había con qué juzgar y la renovación
   // fallaba con «the vault did not send its record» — con el papel correcto en la mano.
-  return { cert: res.cert, acta: res.acta || null }
+  //
+  // Y se juzga AQUÍ, en el pilar: antes lo hacía cada cliente por su cuenta —uno comparando
+  // el `profileId`, que con dos bóvedas no vale, y el navegador guardando el papel sin mirar
+  // nada—. `master` es la bóveda a la que se le pidió.
+  const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: master, sub: device.publickey })
+  if (!chk.ok) throw new Error('invalid renewed cert: ' + chk.reason)
+  return { cert: res.cert, acta: res.acta }
 }
 
 /**

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.63.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
+Copia vendorizada de @dotrino/vault@0.64.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y