@dotrino/identity 0.67.0 → 0.69.0

package/package.json

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

package/src/index.js

@@ -278,6 +278,8 @@ export class Identity {
 
   /** El acta vigente + si este dispositivo es el master + sus capacidades efectivas. */
   async profileActa () { return this._call('profileActa') }
+  /** La cadena de selladores, para mandarla con una firma (ver `vault/acta.js`). */
+  async sealerChain () { return this._call('sealerChain') }
 
   /** Miembros del perfil, ya con id legible y capacidades efectivas. */
   async profileMembers () { return this._call('profileMembers') }

package/src/node.js

@@ -169,6 +169,8 @@ export class Identity {
   listDelegations () { return this._h('listDelegations') }
   // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
   profileActa () { return this._h('profileActa') }
+  /** La cadena de selladores, para mandarla con una firma (ver `vault/acta.js`). */
+  sealerChain () { return this._h('sealerChain') }
   profileMembers () { return this._h('profileMembers') }
   /**
    * Quien SELLA SOBRES (la bóveda) registra aquí cómo estrenar su llave de sellado: se

package/vault/acta.js

@@ -37,7 +37,7 @@
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
-export const ACTA_V = 3
+export const ACTA_V = 4
 
 /**
  * Versiones de acta que se ACEPTAN al leer. La 1 sigue entrando porque una v1 en el disco
@@ -57,7 +57,11 @@ export const ACTA_V = 3
  * entiende; la PRIMERA vez que esa cuenta cambie algo, la nueva sale ya en v3 y el campo
  * desaparece solo.
  */
-const ACTA_LEIBLES = Object.freeze([1, 2, 3])
+const ACTA_LEIBLES = Object.freeze([1, 2, 3, 4])
+/** Desde esta versión, el acta lleva su eslabón de la cadena de selladores. */
+const V_CON_CADENA = 4
+/** ¿Esta acta lleva el eslabón? Las anteriores se leen igual; no pueden encadenar. */
+const conCadena = (acta) => Number(acta?.v) >= V_CON_CADENA
 /** Desde esta versión, sellar es solo un permiso y no hay campo `sealer`. */
 const V_SIN_CAMPO_SELLADOR = 3
 /** ¿Este acta es de las viejas, con el campo? */
@@ -225,6 +229,12 @@ export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', n
     sealedBy: pub,
     seq: 1,
     prev: null,
+    // LA CADENA DE SELLADORES. El génesis es el ancla: está autofirmado por la llave que
+    // da nombre al perfil, así que no apunta a nada y no hay nada que falsificar sin ella.
+    sealerAnchor: null,
+    // `true` porque el génesis ESTABLECE el primer conjunto de selladores: es el eslabón
+    // 1 de la cadena, y por eso la siguiente acta tiene que apuntarle a él.
+    sealerChanged: true,
     members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS, 'sealer'], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
@@ -294,6 +304,18 @@ export function checkShape (acta) {
   // Es el hermano del cierre de `sign`, y sustituye a «el sellador tiene que ser miembro»
   // ahora que sellar es solo un permiso y los permisos ya son de miembros por definición.
   if (!sealersOf(acta).length) return 'sin-sellador'
+  // La cadena de selladores: el génesis es el ancla (`null`); cualquier otra apunta a un
+  // eslabón anterior. Sin `hash` no se puede encadenar nada, así que se exige la forma.
+  if (acta.sealerAnchor != null) {
+    const a = acta.sealerAnchor
+    if (typeof a !== 'object' || !Number.isInteger(a.seq) || a.seq < 1 || a.seq >= acta.seq) return 'sealeranchor'
+    if (typeof a.hash !== 'string' || !/^[0-9a-f]{64}$/.test(a.hash)) return 'sealeranchor'
+  }
+  // El ancla NO se exige: una cuenta que viene de antes de v4 escribe su primera acta
+  // nueva sin poder apuntar a nada (su padre no era eslabón), y exigirla la dejaría
+  // inválida. Lo que sostiene la cadena no es el ancla sino que **cada eslabón lo selle
+  // alguien a quien el anterior autorizaba**; el ancla añade que no se pueda empalmar un
+  // eslabón de otra rama, y se comprueba cuando viene (ver `verifySealerChain`).
   if (!acta.members.some((m) => m.caps.includes('sign'))) return 'sin-firmante'
   return null
 }
@@ -315,6 +337,60 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
  * decide aquí sino al adoptarla (`canAdopt`), comparándola con la que ya tienes.
  * @returns {{ok:boolean, reason?:string}}
  */
+/**
+ * ¿HABLA ESTA ACTA POR ESTA IDENTIDAD? Lo que comprueba un EXTRAÑO, sin saber nada de ti.
+ *
+ * Recibe la cadena de selladores: `[génesis, …cambios de sellador…, acta actual]`. No son
+ * todas tus actas —eso crecería con cada emparejamiento— sino solo los eslabones donde
+ * cambió quién sella, que casi nunca pasa. Lo normal es longitud 1 o 2.
+ *
+ * Qué se comprueba, y por qué basta:
+ *   1. el primer eslabón es el GÉNESIS y está autofirmado por `profileId`. Ese es el
+ *      ancla: sin esa llave no se puede fabricar, y el `profileId` ya lo conoce quien
+ *      verifica (viaja en cada firma tuya);
+ *   2. cada eslabón siguiente lo selló alguien a quien el ANTERIOR autorizaba;
+ *   3. y apunta al anterior por `seq` + hash, así que no se puede colar uno de otra rama.
+ *
+ * Sin esto, un acta suelta es falsificable: con tu `profileId` cualquiera fabrica una
+ * donde él sella, y `verifyActa` la da por buena — está firmada, solo que por él.
+ *
+ * Lo que NO resuelve, y no lo esconde: la frescura. Quien guardó una cadena vieja sigue
+ * aceptando a un sellador que ya retiraste. Es el problema de siempre y hace falta un
+ * oráculo, no más firmas.
+ */
+export async function verifySealerChain (chain, { expectedProfileId = null } = {}) {
+  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
+  const [raiz] = chain
+
+  if (raiz.seq !== 1 || raiz.sealerAnchor != null) return { ok: false, reason: 'no-empieza-en-genesis' }
+  // El ancla: el génesis se firma a sí mismo con la llave que da nombre al perfil.
+  if (raiz.sealedBy !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
+  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  const vr = await verifyActa({ acta: raiz })
+  if (!vr.ok) return { ok: false, reason: 'genesis:' + vr.reason }
+
+  for (let i = 1; i < chain.length; i++) {
+    const previo = chain[i - 1]
+    const actual = chain[i]
+    if (actual.profileId !== raiz.profileId) return { ok: false, reason: 'otro-perfil' }
+    const v = await verifyActa({ acta: actual })
+    if (!v.ok) return { ok: false, reason: `eslabon-${i}:` + v.reason }
+    // Encadena con el anterior: mismo `seq` y mismo hash. Sin el hash bastaría con
+    // acertar un número para colar un eslabón de otra rama.
+    // El ancla, SI viene: fija que este eslabón sale del anterior y no de otra rama. Una
+    // cuenta anterior a v4 puede no traerla, y entonces lo que sostiene la cadena es lo de
+    // abajo — que es lo que de verdad impide falsificarla.
+    const a = actual.sealerAnchor
+    if (a && (a.seq !== previo.seq || a.hash !== await actaHash(previo))) {
+      return { ok: false, reason: `eslabon-${i}:no-encadena` }
+    }
+    // Y lo que da la autoridad: quien la selló tenía permiso SEGÚN EL ESLABÓN ANTERIOR.
+    if (!canSeal(previo, actual.sealedBy)) return { ok: false, reason: `eslabon-${i}:sellador-no-autorizado` }
+  }
+  const ultima = chain[chain.length - 1]
+  return { ok: true, profileId: raiz.profileId, seq: ultima.seq, sealers: sealersOf(ultima) }
+}
+
 export async function verifyActa ({ acta, expectedProfileId } = {}) {
   const shape = checkShape(acta)
   if (shape) return { ok: false, reason: shape }
@@ -513,6 +589,35 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
   if (!sealersOf(next).length) {
     throw new Error('the change would leave the record with nobody able to seal it')
   }
+
+  /**
+   * LA CADENA DE SELLADORES. Es lo que deja a un EXTRAÑO comprobar que quien firmó esto
+   * habla por esta identidad, sin tener que mandarle todas las actas.
+   *
+   * El problema: el acta suelta es falsificable —con tu `profileId`, que es público,
+   * cualquiera fabrica una donde él sella—. Y mandar la cadena entera no sale a cuenta
+   * porque crece con cada emparejamiento, que es lo que más cambia.
+   *
+   * La salida: solo encadenar los eslabones donde CAMBIA quién sella, que casi nunca pasa.
+   * Un usuario normal tiene cadena de longitud 1 —el génesis— para siempre; con una
+   * segunda bóveda, 2. Ese es el tamaño real, no el número de actas.
+   *
+   * Cada acta apunta al último cambio ANTERIOR a ella, nunca a sí misma (sería circular:
+   * el puntero va dentro de lo que se firma). Y `sealerChanged` dice si ELLA es uno, para
+   * que la siguiente sepa a dónde apuntar teniendo solo a su padre delante.
+   *
+   * Y lo que esto resuelve y el génesis firmando no resolvía: **no hace falta la llave del
+   * génesis para sumar un sellador.** La bóveda que ya está autorizada sella el acta que
+   * autoriza a la siguiente, y ese eslabón vale porque el anterior la autorizaba a ella.
+   * El génesis firmó el eslabón 1 y puede estar perdido desde entonces — que es justo el
+   * desastre para el que existe el multivault.
+   */
+  const antes = sealersOf(acta).slice().sort().join('|')
+  const despues = sealersOf(next).slice().sort().join('|')
+  next.sealerChanged = antes !== despues
+  next.sealerAnchor = acta.sealerChanged
+    ? { seq: acta.seq, hash: await actaHash(acta) }
+    : (acta.sealerAnchor || null)
   // EL DOBLE FILTRO (dueño, 2026-08-31): un acta nueva tiene que pasar el filtro de la
   // ANTERIOR —quién podía sellar, arriba— y también el de LA QUE SE VA A FIRMAR. Si no
   // pasa los dos, no se firma.
@@ -804,7 +909,7 @@ export async function canAdopt ({ candidate, current }) {
 }
 
 export default {
-  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape,
+  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,

package/vault/core.js

@@ -528,12 +528,48 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // que la nueva desciende de la que uno tenía. Más viejo que la ventana ⇒ re-admitirse.
   const ACTA_WINDOW = 50
   const loadHistory = () => { try { return JSON.parse(kv.getItem(ACTA_HISTORY_STORAGE) || '[]') || [] } catch (_) { return [] } }
+  /**
+   * LOS ESLABONES DE LA CADENA DE SELLADORES NO CADUCAN (dueño, 2026-08-31).
+   *
+   * El resto sí: la ventana existe para que un miembro que estuvo apagado compruebe el
+   * encadenamiento al volver, y para eso las últimas bastan. Pero los eslabones donde
+   * CAMBIÓ quién sella son otra cosa — son lo que deja a un EXTRAÑO anclar en el génesis
+   * y saber que hablas tú. Si la poda se los lleva, nadie de fuera puede verificar nada
+   * tuyo nunca más, y no hay forma de reconstruirlos.
+   *
+   * El comentario de la ventana decía «un tercero no las necesita, le basta el snapshot
+   * actual». Era cierto mientras el ancla fuera una llave fija; dejó de serlo en cuanto
+   * varias llaves pueden sellar.
+   *
+   * No crecen: solo suman al añadir o quitar una bóveda, que casi nunca pasa. Un usuario
+   * normal guarda uno —el génesis— para siempre.
+   */
   const pushHistory = (acta) => {
     if (!acta) return
     const h = loadHistory().filter((a) => a.seq !== acta.seq)
     h.push(acta)
     h.sort((a, b) => a.seq - b.seq)
-    kv.setItem(ACTA_HISTORY_STORAGE, JSON.stringify(h.slice(-ACTA_WINDOW)))
+    const ventana = h.slice(-ACTA_WINDOW)
+    const enVentana = new Set(ventana.map((a) => a.seq))
+    const eslabones = h.filter((a) => a.sealerChanged && !enVentana.has(a.seq))
+    kv.setItem(ACTA_HISTORY_STORAGE, JSON.stringify([...eslabones, ...ventana].sort((a, b) => a.seq - b.seq)))
+  }
+
+  /**
+   * La CADENA DE SELLADORES para mandarla con una firma: `[génesis, …cambios…, actual]`.
+   * Es lo que un extraño necesita para anclar en el `profileId`, y es corta a propósito —
+   * no lleva las actas de emparejar aparatos, que son casi todas.
+   */
+  const sealerChain = () => {
+    const cur = loadActa()
+    if (!cur) return []
+    // La vigente cuenta como parte del material aunque todavía no esté en la historia
+    // (ahí entra al dejar de serlo). Sin esto, una cuenta recién creada devolvía [].
+    const porSeq = new Map([...loadHistory(), cur].map((a) => [a.seq, a]))
+    const eslabones = [...porSeq.values()].filter((a) => a.sealerChanged).sort((a, b) => a.seq - b.seq)
+    // Y la actual va al final si ella misma no es un eslabón: el verificador necesita ver
+    // la cabeza para saber en qué `seq` está y quién la selló.
+    return eslabones.length && eslabones[eslabones.length - 1].seq === cur.seq ? eslabones : [...eslabones, cur]
   }
 
   const loadRenounces = () => { try { return JSON.parse(kv.getItem(RENOUNCE_STORAGE) || '[]') || [] } catch (_) { return [] } }
@@ -596,7 +632,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const { generation } = await Content.makeGeneration({ members: base.members, gen: 1 })
       base.keyring = [generation]
     } catch (e) { console.warn('[identity] could not create the content key:', e.message) }
-    saveActa(await seal(base))
+    const genesis = await seal(base)
+    saveActa(genesis)
+    // EL GÉNESIS VA A LA HISTORIA DESDE EL PRIMER DÍA. Es el ancla de la cadena de
+    // selladores —el único eslabón autofirmado por la llave que da nombre al perfil— y
+    // sin él nadie de fuera puede verificar nada de esta cuenta, nunca. Antes solo se
+    // guardaba lo que DEJABA de ser vigente, así que una cuenta que nunca cambió su acta
+    // no tenía génesis guardado y su cadena salía vacía.
+    pushHistory(genesis)
     return loadActa()
   }
 
@@ -1113,7 +1156,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const LOCK_EXEMPT = new Set([
     'profileLockStatus', 'unlockProfile', 'listProfiles', 'currentProfile',
     'switchProfile', 'createProfile',
-    'profileActa', 'profileMembers', 'myMembership', 'isMaster'
+    'profileActa', 'profileMembers', 'myMembership', 'isMaster', 'sealerChain'
   ])
 
   const handlers = {
@@ -1467,6 +1510,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { acta, isMaster: amMaster(), myCaps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()) }
     },
 
+    /**
+     * LA CADENA DE SELLADORES, para mandarla junto con una firma.
+     *
+     * Es lo que deja a un EXTRAÑO comprobar que quien firmó habla por esta identidad, sin
+     * preguntarle a nadie: `[génesis, …cambios de sellador…, acta actual]`. No son todas
+     * las actas —eso crecería con cada emparejamiento— sino solo los eslabones donde
+     * cambió quién sella, que casi nunca pasa. Lo normal es longitud 1: el génesis.
+     *
+     * Una cuenta de una sola bóveda devuelve SIEMPRE eso y nada más, y no puede quedarse
+     * obsoleta: su conjunto de selladores no puede cambiar, porque el único no puede
+     * quitarse a sí mismo y no hay otro que se lo quite.
+     */
+    async sealerChain () { return sealerChain() },
+
     /**
      * Quien sella sobres de secretos (la bóveda) registra aquí cómo estrenar su LLAVE DE
      * SELLADO: una función que crea el par, se guarda la privada y devuelve la pública. Se