@dotrino/identity 0.67.0 → 0.68.0

package/package.json

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

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,43 @@ 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 []
+    const eslabones = loadHistory().filter((a) => a.sealerChanged).sort((a, b) => a.seq - b.seq)
+    return cur.sealerChanged ? eslabones : [...eslabones, cur]
   }
 
   const loadRenounces = () => { try { return JSON.parse(kv.getItem(RENOUNCE_STORAGE) || '[]') || [] } catch (_) { return [] } }