@dotrino/identity 0.53.0 → 0.54.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.53.0",
+  "version": "0.54.1",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -39,7 +39,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test test/*.test.js"
+    "test": "node --test test/*.test.js",
+    "type-check": "tsc --noEmit"
   },
   "keywords": [
     "identity",
@@ -55,9 +56,11 @@
     "url": "git+https://github.com/imdotrino/dotrino-identity.git"
   },
   "dependencies": {
-    "@dotrino/proxy-client": "0.10.0"
+    "@dotrino/proxy-client": "0.10.1"
   },
   "devDependencies": {
-    "fake-indexeddb": "^6.2.5"
+    "fake-indexeddb": "^6.2.5",
+    "typescript": "5.9.3",
+    "@types/node": "^22.0.0"
   }
 }

package/vault/acta.js

@@ -30,7 +30,16 @@
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
-export const ACTA_V = 1
+export const ACTA_V = 2
+
+/**
+ * Versiones de acta que se ACEPTAN al leer. La 1 sigue entrando porque una v1 en el disco
+ * es un perfil con sus aparatos dentro: rechazarla dejaría al vault sin poder verificar a
+ * nadie —y a los servicios sin configuración— por un campo que ni siquiera existía. Se
+ * asciende sola: el acta siguiente que selle la maestra ya sale v2 (ver `applyChanges`).
+ * La única diferencia es la llave de sellado (§8.9), que en una v1 simplemente no hay.
+ */
+const ACTA_LEIBLES = Object.freeze([1, 2])
 
 /**
  * Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master.
@@ -126,7 +135,7 @@ export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
  * sellador, con todas las capacidades. `profileId` = su pubkey → el nombre del perfil es
  * estable para siempre y coincide con la identidad que el usuario ya tenía (cero migración).
  */
-export function genesisActa ({ pub, encPub = null, label = '', now = Date.now() }) {
+export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', now = Date.now() }) {
   if (!isPub(pub)) throw new Error('genesisActa: missing genesis pubkey')
   return {
     v: ACTA_V,
@@ -141,6 +150,14 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
     // a cada miembro (ver content.js). Envuelto es público: solo lo abre su destinatario.
     keyring: [],
+    // LLAVE DE SELLADO (§8.9 de dotrino-vault/docs/secretos-sellados.md): con ella la
+    // bóveda FIRMA los sobres de los secretos, para que se sepa que salieron de ella.
+    // Vive aquí y no en un certificado aparte porque rota con el acta: cada acta nueva
+    // puede nombrar una llave nueva, y quien selle el acta es —siempre— la maestra.
+    // Nace en null: un perfil no tiene por qué sellar secretos.
+    sealPub: sealPub || null,
+    sealSince: sealPub ? 1 : 0,
+    sealKeys: [],
     updatedAt: now
   }
 }
@@ -148,7 +165,7 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
 /** Comprobaciones de FORMA (sin cripto): que el acta sea un acta. */
 export function checkShape (acta) {
   if (!acta || typeof acta !== 'object') return 'no-acta'
-  if (acta.v !== ACTA_V) return 'version'
+  if (!ACTA_LEIBLES.includes(acta.v)) return 'version'
   if (!isPub(acta.profileId) || !isPub(acta.sealer) || !isPub(acta.sealedBy)) return 'shape'
   if (!Number.isInteger(acta.seq) || acta.seq < 1) return 'seq'
   if (acta.seq > 1 && typeof acta.prev !== 'string') return 'prev'
@@ -175,6 +192,20 @@ export function checkShape (acta) {
     // `encpub`), y cuando no quede ninguno sin ella se aprieta aquí.
     if (m.encPub != null && !isEncPub(m.encPub)) return 'encpub-invalido'
   }
+  // LA LLAVE DE SELLADO Y SU REGISTRO. `sealPub` puede no estar (un perfil que no sella
+  // secretos), pero si está tiene que decir DESDE QUÉ acta manda: sin `sealSince` no se
+  // puede decidir con qué llave verificar un sobre viejo.
+  if (acta.v >= 2) {
+  if (acta.sealPub != null) {
+    if (!isPub(acta.sealPub)) return 'sealpub-invalido'
+    if (!Number.isInteger(acta.sealSince) || acta.sealSince < 1 || acta.sealSince > acta.seq) return 'sealsince'
+  } else if (acta.sealSince) return 'sealsince'
+  if (!Array.isArray(acta.sealKeys)) return 'sealkeys'
+  for (const k of acta.sealKeys) {
+    if (!isPub(k?.pub)) return 'sealkey-invalida'
+    if (!Number.isInteger(k.from) || !Number.isInteger(k.to) || k.from < 1 || k.to < k.from) return 'sealkey-rango'
+  }
+  }
   if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
   if (!acta.members.some((m) => m.pub === acta.sealer)) return 'sealer-no-es-miembro'
   if (!acta.members.some((m) => m.caps.includes('sign'))) return 'sin-firmante'
@@ -216,17 +247,25 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
  * Van en ARRAY porque hay combinaciones que deben ser atómicas: admitir al nuevo sellador y
  * traspasarle el master ocurre en el MISMO `seq` (§2.1.3).
  */
-export async function applyChanges (acta, changes, { by, now = Date.now() } = {}) {
+export async function applyChanges (acta, changes, { by, now = Date.now(), sealPub = null } = {}) {
   const shape = checkShape(acta)
   if (shape) throw new Error('invalid record: ' + shape)
   if (!by) throw new Error('applyChanges: missing `by` (who seals)')
   if (by !== acta.sealer) throw new Error('only the master can change the record; this device is not the master')
 
-  const list = Array.isArray(changes) ? changes : [changes]
-  if (list.length === 0) throw new Error('applyChanges: no hay cambios')
+  const list = (Array.isArray(changes) ? changes : [changes]).filter(Boolean)
+  // Estrenar la llave de sellado ES un cambio del acta, aunque no toque a ningún miembro:
+  // rota con el acta (§8.9) y el acta es lo que le da autoridad. Por eso una lista vacía
+  // se acepta si viene con llave nueva, y solo entonces.
+  if (list.length === 0 && !sealPub) throw new Error('applyChanges: no hay cambios')
 
   const next = {
     ...acta,
+    // Asciende de v1 a v2 sin ceremonia: los campos de sellado nacen vacíos y la llave
+    // entra en cuanto quien sella pase una (`sealPub`).
+    v: ACTA_V,
+    sealPub: acta.sealPub || null,
+    sealSince: acta.sealPub ? acta.sealSince : 0,
     sealedBy: by,
     seq: acta.seq + 1,
     prev: await actaHash(acta),
@@ -234,10 +273,24 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
     revoked: [...(acta.revoked || [])],
     renounced: [...(acta.renounced || [])],
     keyring: (acta.keyring || []).map((g) => ({ ...g, wraps: { ...g.wraps } })),
+    sealKeys: (acta.sealKeys || []).map((k) => ({ ...k })),
     updatedAt: now
   }
   delete next.sig
 
+  // LA LLAVE DE SELLADO ROTA CON EL ACTA (§8.9 de `secretos-sellados.md`). Quien sella
+  // pasa la llave nueva; si no pasa ninguna, la de antes sigue mandando —un master que no
+  // sella secretos (el navegador) no tiene por qué inventarse una—.
+  //
+  // La anterior NO se tira: se guarda con el tramo de `seq` en el que estuvo en vigor,
+  // porque los sobres que firmó tienen que seguir verificando. Re-firmarlos al rotar
+  // sería recorrer todos los secretos en cada cambio de membresía.
+  if (sealPub && sealPub !== next.sealPub) {
+    if (next.sealPub) next.sealKeys.push({ pub: next.sealPub, from: next.sealSince, to: acta.seq })
+    next.sealPub = sealPub
+    next.sealSince = next.seq
+  }
+
   const find = (pub) => next.members.find((m) => m.pub === pub)
 
   for (const ch of list) {
@@ -368,6 +421,19 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
   return next
 }
 
+/**
+ * La llave que firmaba los sobres cuando el acta iba por `seq`. Es lo que necesita quien
+ * VERIFICA un sobre: el sobre dice con qué acta se selló, y esto dice con qué llave hay
+ * que comprobarlo. `null` si no había ninguna (perfil que no sellaba) o si el `seq` viene
+ * del futuro, que es un sobre que no puede ser bueno.
+ */
+export function sealKeyAt (acta, seq) {
+  if (!acta || !Number.isInteger(seq) || seq < 1 || seq > acta.seq) return null
+  if (acta.sealPub && seq >= acta.sealSince) return acta.sealPub
+  for (const k of acta.sealKeys || []) if (seq >= k.from && seq <= k.to) return k.pub
+  return null
+}
+
 // ----- renuncia (§2.2): el único cambio que no pasa por el master -----
 
 /** Crea el registro firmado con el que un miembro se QUITA capacidades a sí mismo. */

package/vault/core.js

@@ -542,6 +542,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   /** ¿Es ESTE dispositivo el master (el único que puede sellar)? */
   const amMaster = () => loadActa()?.sealer === publickeyJwkStr
 
+  /**
+   * Quien sella SOBRES (la bóveda) pone aquí una función que estrena una llave de sellado
+   * y devuelve su pública. Se llama en cada acta, porque esa llave rota con el acta.
+   * Un navegador no sella secretos: se queda en `null` y el acta no lleva llave.
+   */
+  let sealKeyProvider = null
+
   /** Sella con la llave del perfil (CryptoKey, puede ser no extractable). */
   const seal = (acta) => Acta.sealActa({ acta, privateKey: keypair.privateKey })
 
@@ -552,7 +559,15 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   async function sealChanges (changes) {
     const acta = loadActa()
     if (!acta) throw new Error('this profile has no record yet')
-    const next = await Acta.applyChanges(acta, changes, { by: publickeyJwkStr })
+    // LA LLAVE DE SELLADO ROTA CON EL ACTA (§8.9 de `secretos-sellados.md`): si quien usa
+    // esta identidad sella secretos —la bóveda—, le pedimos una llave nueva para nombrarla
+    // aquí. Si no hay proveedor, o falla, el acta sale igual con la llave de antes: no
+    // admitir un aparato porque no se pudo estrenar una llave sería el peor de los canjes.
+    let sealPub = null
+    if (sealKeyProvider) {
+      try { sealPub = await sealKeyProvider() } catch (_) { sealPub = null }
+    }
+    const next = await Acta.applyChanges(acta, changes, { by: publickeyJwkStr, sealPub })
     const sealed = await seal(next)
     pushHistory(acta) // la que deja de ser vigente entra en la ventana de retención
     saveActa(sealed)
@@ -1447,6 +1462,34 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { acta, isMaster: amMaster(), myCaps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()) }
     },
 
+    /**
+     * 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
+     * llama al sellar cada acta, que es cuando esa llave rota (§8.9).
+     *
+     * Es opt-in a propósito: una identidad de navegador no sella nada, y un acta sin llave
+     * de sellado es perfectamente válida.
+     */
+    setSealKeyProvider (fn) {
+      sealKeyProvider = typeof fn === 'function' ? fn : null
+    },
+
+    /**
+     * Estrena la llave de sellado sin tocar a nadie más: pide una al proveedor y la nombra
+     * en un acta nueva. Es lo que hace la bóveda al arrancar si el acta no tiene llave, o
+     * si la que nombra no es suya (el disco se restauró, otro master la puso…).
+     */
+    async rotateSealKey () {
+      if (!sealKeyProvider) throw new Error('this identity does not seal envelopes')
+      const acta = await sealChanges([])
+      return { ok: true, seq: acta.seq, sealPub: acta.sealPub }
+    },
+
+    /** La llave con la que se firmaron los sobres de un acta dada. Para VERIFICARLOS. */
+    sealKeyAt (seq) {
+      return Acta.sealKeyAt(loadActa(), seq)
+    },
+
     async profileMembers () {
       const acta = loadActa()
       if (!acta) return { members: [], profileId: null, seq: 0, sealer: null }

package/src/types.d.ts

@@ -1,5 +0,0 @@
-interface Element { [key: string]: any; }
-interface EventTarget { [key: string]: any; }
-interface HTMLElement { [key: string]: any; }
-interface Event { [key: string]: any; }
-interface Window { [key: string]: any; }