@dotrino/identity 0.106.0 → 0.107.1

package/package.json

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

package/vault/content.js

@@ -106,7 +106,26 @@ export async function myContentKey ({ keyring, myPub, myEncPrivateKey }) {
   return null
 }
 
-/** Cifra con la CEK. Devuelve un sobre `{ gen, iv, ct }` (el `gen` dice con cuál se cifró). */
+/**
+ * La marca de un sobre de la llave de la cuenta. La lleva todo sobre de `encryptWithCek`
+ * para que quien guarda datos ajenos —la bóveda con el almacén de las apps— lo RECONOZCA
+ * dentro de un JSON cualquiera sin adivinar por la forma, y pueda volver a cerrarlo con la
+ * generación vigente cuando la llave rota (`resealStale`).
+ */
+export const CEK_ENVELOPE = 'dotrino-cek'
+
+/** ¿Es un sobre de la llave de la cuenta? */
+export const isCekEnvelope = (v) => !!v && typeof v === 'object' && v.t === CEK_ENVELOPE &&
+  Number.isInteger(v.gen) && typeof v.iv === 'string' && typeof v.ct === 'string'
+
+/**
+ * Cifra con una clave simétrica. Devuelve `{ gen, iv, ct }` (el `gen` dice con cuál).
+ *
+ * Es GENÉRICA: la usan la llave de la cuenta y también llaves que no son de la cuenta (los
+ * cajones de secretos, cada entrada del gestor de contraseñas, el transporte). Por eso NO
+ * lleva la marca: la marca dice «esto es de la cuenta» y solo la pone `sealAccount`. En
+ * 0.107.0 la ponía aquí, y marcaba como de la cuenta sobres que la cuenta no abre.
+ */
 export async function encryptWithCek ({ cek, gen, plaintext }) {
   const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['encrypt'])
   const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
@@ -114,6 +133,12 @@ export async function encryptWithCek ({ cek, gen, plaintext }) {
   return { gen, iv: b64(iv), ct: b64(ct) }
 }
 
+/** Cierra con la LLAVE DE LA CUENTA (generación `gen`): el sobre lleva la marca. */
+export async function sealAccount ({ cek, gen, plaintext }) {
+  if (!Number.isInteger(gen) || gen < 1) throw new Error('sealAccount: the account key generation starts at 1')
+  return { t: CEK_ENVELOPE, ...(await encryptWithCek({ cek, gen, plaintext })) }
+}
+
 /**
  * Descifra un sobre teniendo YA la CEK. Es el inverso exacto de `encryptWithCek`.
  *
@@ -142,7 +167,81 @@ export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPriva
   return new TextDecoder().decode(pt)
 }
 
+/**
+ * MIGRACIÓN, con fecha de caducidad: hasta 0.107.0 los sobres de la cuenta salían SIN marca,
+ * como `{ gen, iv, ct }` a secas. Hasta esta fecha, `resealStale` también prueba esos: si
+ * abren con la llave de la cuenta, los vuelve a cerrar ya marcados; si no abren, no eran de
+ * la cuenta y se dejan como están. Pasada la fecha, un sobre sin marca ya no se toca. Se
+ * quita el código cuando pase (y su prueba con él).
+ */
+export const LEGACY_UNMARKED_UNTIL = Date.parse('2027-06-30T00:00:00Z')
+
+/** ¿Tiene la forma EXACTA de un sobre de la cuenta anterior a la marca? */
+export const isLegacyCekEnvelope = (v) => !!v && typeof v === 'object' && !Array.isArray(v) &&
+  Object.keys(v).length === 3 && Number.isInteger(v.gen) && v.gen >= 1 &&
+  typeof v.iv === 'string' && typeof v.ct === 'string'
+
+/**
+ * VUELVE A CERRAR con la generación vigente todo sobre de la cuenta de una generación
+ * anterior que haya dentro de `value`, a cualquier profundidad. Devuelve una copia (no toca
+ * el original) y cuántos sobres cambió.
+ *
+ * Es lo que hace la bóveda al abrirse y después de una rotación (dueño, 2026-09-30): lo que
+ * sirve va SIEMPRE con la llave vigente, así que un aparato que entra después —que solo
+ * recibe esa generación— abre todo, y la llave vieja deja de abrir nada porque ya no se le
+ * sirve nada cerrado con ella.
+ *
+ * `reseal(envelope)` abre y vuelve a cerrar un sobre con la llave de la cuenta; lo pone quien
+ * la tiene, y debe devolver un sobre MARCADO de la generación `gen`.
+ *
+ *  · Un sobre MARCADO que no abre PARA todo: es de la cuenta y algo va mal; no se deja a
+ *    medias ni se salta en silencio.
+ *  · Un sobre SIN MARCA (migración, hasta `LEGACY_UNMARKED_UNTIL`) se prueba aunque ya
+ *    tenga la generación vigente —hay que ponerle la marca—; si no abre, se deja y se
+ *    cuenta en `skipped`.
+ *
+ * @param {any} value
+ * @param {{ gen: number, reseal: (env: object) => Promise<object>, now?: number }} o
+ * @returns {Promise<{ value: any, changed: number, skipped: number }>}
+ */
+export async function resealStale (value, { gen, reseal, now = Date.now() }) {
+  if (!Number.isInteger(gen)) throw new Error('resealStale: the current generation is required')
+  const migrar = now < LEGACY_UNMARKED_UNTIL
+  let changed = 0; let skipped = 0
+  const comprobar = (nuevo) => {
+    if (!isCekEnvelope(nuevo) || nuevo.gen !== gen) throw new Error(`resealStale: reseal did not return a marked envelope of generation ${gen}`)
+    return nuevo
+  }
+  const walk = async (v) => {
+    if (isCekEnvelope(v)) {
+      if (v.gen === gen) return v
+      const nuevo = comprobar(await reseal(v))
+      changed++
+      return nuevo
+    }
+    if (migrar && isLegacyCekEnvelope(v)) {
+      let nuevo
+      try { nuevo = await reseal(v) } catch (_) { skipped++; return v }
+      changed++
+      return comprobar(nuevo)
+    }
+    if (Array.isArray(v)) {
+      const out = []
+      for (const x of v) out.push(await walk(x))
+      return out
+    }
+    if (v && typeof v === 'object') {
+      const out = {}
+      for (const [k, x] of Object.entries(v)) out[k] = await walk(x)
+      return out
+    }
+    return v
+  }
+  const out = await walk(value)
+  return { value: out, changed, skipped }
+}
+
 export default {
   makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
-  encryptWithCek, decryptWithCek, decryptWithKeyring
+  encryptWithCek, sealAccount, decryptWithCek, decryptWithKeyring, CEK_ENVELOPE, isCekEnvelope, isLegacyCekEnvelope, LEGACY_UNMARKED_UNTIL, resealStale
 }

package/vault/core.js

@@ -2695,13 +2695,14 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     async contentKey () { return myCek() },
 
     /**
-     * Cifra algo con la clave de contenido del perfil. Devuelve el sobre `{gen,iv,ct}`.
-     * La llave privada de cifrado NUNCA sale de aquí: se cifra y descifra dentro.
+     * Cifra algo con la clave de contenido del perfil. Devuelve el sobre MARCADO
+     * `{ t: 'dotrino-cek', gen, iv, ct }` (la marca deja a la bóveda reconocerlo y volver a
+     * cerrarlo al rotar). La llave privada de cifrado NUNCA sale de aquí.
      */
     async sealContent ({ plaintext } = {}) {
       const mine = await myCek()
       if (!mine) throw new Error('this device does not hold the profile content key yet')
-      return Content.encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: String(plaintext) })
+      return Content.sealAccount({ cek: mine.cek, gen: mine.gen, plaintext: String(plaintext) })
     },
 
     /**