@dotrino/identity 0.25.0 → 0.26.0

package/package.json

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

@@ -299,6 +299,10 @@ export class Identity {
 
   /** Adopta un acta recibida de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
   async adoptActa (acta) { return this._call('adoptActa', { acta }) }
+  /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
+  async contentKey () { return this._call('contentKey') }
+  /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
+  async rotateContentKey () { return this._call('rotateContentKey') }
 
   // ----- Emparejar ESTE navegador/dispositivo con el vault del usuario (Fase 1) -----
 

package/src/node.js

@@ -162,6 +162,10 @@ export class Identity {
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
   absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
   adoptActa (acta) { return this._h('adoptActa', { acta }) }
+  /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
+  contentKey () { return this._h('contentKey') }
+  /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
+  rotateContentKey () { return this._h('rotateContentKey') }
   // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
   enrollDevice (qr) { return this._h('vaultPair', { qr }) }
   vaultStatus () { return this._h('vaultStatus') }

package/vault/acta.js

@@ -80,6 +80,9 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     members: [{ pub, encPub, label: String(label || '').slice(0, 60), caps: [...CAPS], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
+    // 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: [],
     updatedAt: now
   }
 }
@@ -150,6 +153,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
     members: acta.members.map((m) => ({ ...m, caps: [...m.caps] })),
     revoked: [...(acta.revoked || [])],
     renounced: [...(acta.renounced || [])],
+    keyring: (acta.keyring || []).map((g) => ({ ...g, wraps: { ...g.wraps } })),
     updatedAt: now
   }
   delete next.sig
@@ -184,7 +188,13 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         const i = next.members.findIndex((m) => m.pub === ch.pub)
         if (i < 0) throw new Error('remove: ese miembro no está en el acta')
         if (next.members[i].pub === next.sealer) throw new Error('remove: no puedes expulsar al master; primero traspasa el sellado')
-        next.members.splice(i, 1)
+        const fuera = next.members.splice(i, 1)[0]
+        // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
+        // acceso al contenido FUTURO se corta rotando, ver content.js; lo ya leído no vuelve.)
+        next.keyring = next.keyring.map((g) => {
+          const { [fuera.pub]: _, ...resto } = g.wraps || {}
+          return { ...g, wraps: resto }
+        })
         break
       }
       case 'handover': {
@@ -192,6 +202,20 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         next.sealer = ch.to
         break
       }
+      case 'keyring': {
+        // Generación NUEVA de la clave de contenido (al rotar: expulsar a alguien).
+        const g = ch.generation
+        if (!g || !Number.isInteger(g.gen)) throw new Error('keyring: generación inválida')
+        next.keyring = [...next.keyring.filter((x) => x.gen !== g.gen), g].sort((a, b) => a.gen - b.gen)
+        break
+      }
+      case 'wrap': {
+        // Envolver la clave YA existente para un miembro nuevo (al admitir: no hace falta rotar).
+        const g = next.keyring.find((x) => x.gen === ch.gen)
+        if (!g) throw new Error('wrap: esa generación no está en el llavero')
+        g.wraps = { ...g.wraps, [ch.pub]: ch.wrap }
+        break
+      }
       case 'revoke': {
         if (typeof ch.nonce !== 'string') throw new Error('revoke: falta el nonce')
         next.revoked.push({ nonce: ch.nonce, until: ch.until || (now + 30 * 24 * 60 * 60 * 1000) })

package/vault/content.js

@@ -0,0 +1,132 @@
+/**
+ * content.js — la LLAVE DE CONTENIDO del perfil, para que todos tus dispositivos lean lo
+ * mismo sin que ninguna llave de identidad se mueva.
+ *
+ * La distinción que ordena esto (y que conviene decir en voz alta):
+ *
+ *   · Las llaves de FIRMA son intransferibles. Nacen y mueren en su dispositivo.
+ *   · La llave de CONTENIDO se comparte por diseño — si no, dos dispositivos tuyos no
+ *     podrían leer el mismo archivo, que es justo lo que se quiere.
+ *
+ * Cómo: el perfil tiene una clave simétrica (la CEK) que se ENVUELVE hacia la llave de
+ * cifrado de cada miembro (ECDH P-256 efímero + AES-GCM, la misma cripto que ya usa el
+ * ecosistema para los sobres sellados). Cada miembro abre su envoltura con su propia
+ * privada; nadie más puede. Admitir un miembro = envolverle la CEK. Expulsarlo = ROTAR la
+ * CEK y envolver la nueva al resto.
+ *
+ * Lo que esto protege y lo que no: rotar corta el acceso al contenido FUTURO. Lo que el
+ * expulsado ya leyó, ya lo leyó — eso no se puede deshacer y no se promete.
+ *
+ * Módulo PURO (WebCrypto, sin kv/red/disco).
+ */
+
+const subtle = globalThis.crypto.subtle
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+
+const b64 = (buf) => {
+  const bytes = new Uint8Array(buf)
+  let s = ''
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
+  return btoa(s)
+}
+const fromB64 = (str) => {
+  const bin = atob(str)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+async function sharedKey (privateKey, peerPubJwkStr) {
+  const pub = await subtle.importKey('jwk', JSON.parse(peerPubJwkStr), ECDH, false, [])
+  const bits = await subtle.deriveBits({ name: 'ECDH', public: pub }, privateKey, 256)
+  return subtle.importKey('raw', bits, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt'])
+}
+
+/** Genera una clave de contenido nueva (AES-256-GCM). Devuelve los bytes en base64. */
+export async function makeContentKey () {
+  const k = await subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
+  return b64(await subtle.exportKey('raw', k))
+}
+
+/**
+ * Envuelve la CEK hacia la llave de cifrado de un miembro. La envoltura es pública: solo
+ * la abre quien tenga la privada de `memberEncPub`, así que puede viajar en el acta.
+ * @returns {Promise<{epk:string, iv:string, ct:string}>}
+ */
+export async function wrapForMember ({ cek, memberEncPub }) {
+  if (typeof cek !== 'string' || !cek) throw new Error('wrapForMember: falta la clave de contenido')
+  if (typeof memberEncPub !== 'string' || !memberEncPub) throw new Error('wrapForMember: el miembro no tiene llave de cifrado')
+  const eph = await subtle.generateKey(ECDH, false, ['deriveBits'])
+  const key = await sharedKey(eph.privateKey, memberEncPub)
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, key, new TextEncoder().encode(cek))
+  const epk = await subtle.exportKey('jwk', eph.publicKey)
+  return {
+    epk: JSON.stringify({ kty: epk.kty, crv: epk.crv, x: epk.x, y: epk.y }),
+    iv: b64(iv),
+    ct: b64(ct)
+  }
+}
+
+/** Abre la envoltura con la llave de cifrado privada de ESTE miembro. */
+export async function openWrap ({ wrap, myEncPrivateKey }) {
+  if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('envoltura inválida')
+  const key = await sharedKey(myEncPrivateKey, wrap.epk)
+  const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(wrap.iv) }, key, fromB64(wrap.ct))
+  return new TextDecoder().decode(pt)
+}
+
+/**
+ * Genera la CEK de una generación y la envuelve a TODOS los miembros que tengan llave de
+ * cifrado. Un miembro sin `encPub` simplemente no recibe envoltura (y por tanto no lee el
+ * contenido): se devuelve la lista para que la consola lo diga en vez de fallar en silencio.
+ */
+export async function makeGeneration ({ members, gen = 1, cek = null, now = Date.now() }) {
+  const key = cek || await makeContentKey()
+  const wraps = {}
+  const sinLlave = []
+  for (const m of members || []) {
+    if (!m?.encPub) { sinLlave.push(m?.pub); continue }
+    wraps[m.pub] = await wrapForMember({ cek: key, memberEncPub: m.encPub })
+  }
+  return { generation: { gen, createdAt: now, wraps }, cek: key, sinLlave }
+}
+
+/** La CEK vigente para mí, sacada del llavero del acta. `null` si no tengo envoltura. */
+export async function myContentKey ({ keyring, myPub, myEncPrivateKey }) {
+  const gens = [...(keyring || [])].sort((a, b) => (b.gen || 0) - (a.gen || 0))
+  for (const g of gens) {
+    const w = g.wraps?.[myPub]
+    if (!w) continue
+    try { return { gen: g.gen, cek: await openWrap({ wrap: w, myEncPrivateKey }) } } catch (_) {}
+  }
+  return null
+}
+
+/** Cifra con la CEK. Devuelve un sobre `{ gen, iv, ct }` (el `gen` dice con cuál se cifró). */
+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))
+  const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, k, new TextEncoder().encode(plaintext))
+  return { gen, iv: b64(iv), ct: b64(ct) }
+}
+
+/**
+ * Descifra un sobre. Hay que darle el llavero porque el contenido viejo está cifrado con
+ * generaciones anteriores: por eso las CEK antiguas se conservan (32 bytes cada una) en vez
+ * de re-cifrarlo todo de golpe al rotar.
+ */
+export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPrivateKey }) {
+  const g = (keyring || []).find((x) => x.gen === envelope?.gen)
+  const w = g?.wraps?.[myPub]
+  if (!w) throw new Error('este dispositivo no tiene la llave de esa generación de contenido')
+  const cek = await openWrap({ wrap: w, myEncPrivateKey })
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['decrypt'])
+  const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(envelope.iv) }, k, fromB64(envelope.ct))
+  return new TextDecoder().decode(pt)
+}
+
+export default {
+  makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
+  encryptWithCek, decryptWithKeyring
+}

package/vault/core.js

@@ -20,6 +20,7 @@
 
 import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
 import * as Acta from './acta.js'
+import * as Content from './content.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
@@ -374,11 +375,48 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function ensureActa (label = '') {
     if (loadActa()) return loadActa()
-    const acta = await seal(Acta.genesisActa({
+    const base = Acta.genesisActa({
       pub: publickeyJwkStr, encPub: encPublickeyJwkStr, label: label || me?.nickname || ''
-    }))
-    saveActa(acta)
-    return acta
+    })
+    // La primera generación de la clave de contenido va DENTRO del acta de génesis, no en
+    // un cambio aparte: un perfil recién nacido está en `seq 1`, no en `seq 2`.
+    try {
+      const { generation } = await Content.makeGeneration({ members: base.members, gen: 1 })
+      base.keyring = [generation]
+    } catch (e) { console.warn('[identity] no se pudo crear la clave de contenido:', e.message) }
+    saveActa(await seal(base))
+    return loadActa()
+  }
+
+  // ----- CLAVE DE CONTENIDO del perfil (para que todos tus dispositivos lean lo mismo) -----
+  // Las llaves de FIRMA no se mueven nunca; la de CONTENIDO se comparte por diseño,
+  // envuelta a la llave de cifrado de cada miembro (ver content.js).
+
+  /** Mi copia de la clave de contenido vigente, o null si aún no me la han envuelto. */
+  const myCek = () => Content.myContentKey({
+    keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
+  })
+
+  /** Envuelve la clave vigente para un miembro recién admitido (no hace falta rotar). */
+  async function wrapForNewMember (pub) {
+    const acta = loadActa()
+    const gen = (acta?.keyring || []).at(-1)
+    const m = acta?.members.find((x) => x.pub === pub)
+    if (!gen || !m?.encPub) return false
+    const mine = await myCek()
+    if (!mine) return false
+    const wrap = await Content.wrapForMember({ cek: mine.cek, memberEncPub: m.encPub })
+    await sealChanges([{ op: 'wrap', gen: mine.gen, pub, wrap }])
+    return true
+  }
+
+  /** Rota la clave: generación nueva envuelta SOLO a los miembros actuales. */
+  async function rotateCek () {
+    const acta = loadActa()
+    const gen = ((acta.keyring || []).at(-1)?.gen || 0) + 1
+    const { generation, sinLlave } = await Content.makeGeneration({ members: acta.members, gen })
+    await sealChanges([{ op: 'keyring', generation }])
+    return { gen, sinLlave }
   }
 
   /**
@@ -1027,10 +1065,17 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async isMaster () { return amMaster() },
 
-    /** Admite un miembro (solo el master). El cert lo emite quien llama, antes o después. */
-    async admitMember ({ pub, encPub = null, label = '', caps = ['store', 'read'], cert = null } = {}) {
-      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, caps, cert } }])
-      return { ok: true, seq: acta.seq }
+    /**
+     * Admite un miembro (solo el master). El cert lo emite quien llama, antes o después.
+     * `continuity`: si esa identidad ya existía por su cuenta, su puente firmado (F3).
+     */
+    async admitMember ({ pub, encPub = null, label = '', caps = ['store', 'read'], cert = null, continuity = null } = {}) {
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, caps, cert, continuity } }])
+      // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
+      // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
+      let wrapped = false
+      try { wrapped = await wrapForNewMember(pub) } catch (_) {}
+      return { ok: true, seq: acta.seq, wrapped }
     },
 
     async setCaps ({ pub, caps } = {}) {
@@ -1040,7 +1085,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async removeMember ({ pub } = {}) {
       const acta = await sealChanges([{ op: 'remove', pub }])
-      return { ok: true, seq: acta.seq }
+      // Expulsar rota la clave: el que sale no podrá abrir el contenido NUEVO. Lo que ya
+      // leyó no vuelve — eso no se puede deshacer y no se promete.
+      let rotated = null
+      try { rotated = await rotateCek() } catch (_) {}
+      return { ok: true, seq: acta.seq, rotated }
     },
 
     /**
@@ -1081,6 +1130,21 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, seq: acta.seq }
     },
 
+    /**
+     * La clave de contenido de este perfil, ya abierta con la llave de cifrado de este
+     * dispositivo. `null` si todavía no te la han envuelto (o si te expulsaron).
+     */
+    async contentKey () { return myCek() },
+
+    /**
+     * Rota la clave de contenido: generación nueva envuelta solo a los miembros de ahora.
+     * Corta el acceso al contenido FUTURO de quien ya no está; lo que ya leyó, ya lo leyó.
+     */
+    async rotateContentKey () {
+      const r = await rotateCek()
+      return { ok: true, ...r }
+    },
+
     /** Adopta un acta que llega de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
     async adoptActa ({ acta } = {}) { return adoptActa(acta) },