@dotrino/identity 0.52.0 → 0.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.52.0",
+  "version": "0.54.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -56,11 +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",
-    "typescript": "^5.7.3",
+    "typescript": "5.9.3",
     "@types/node": "^22.0.0"
   }
 }

package/src/index.js

@@ -292,6 +292,8 @@ export class Identity {
 
   /** Admite un miembro nuevo (solo el master). */
   async admitMember (member) { return this._call('admitMember', member) }
+  /** Registra la llave de cifrado de un miembro ya admitido (evita re-enrolarlo). */
+  async setMemberEncPub (args) { return this._call('setMemberEncPub', args) }
 
   /** Cambia las capacidades de un miembro (solo el master). */
   async setCaps (pub, caps) { return this._call('setCaps', { pub, caps }) }
@@ -671,4 +673,4 @@ export class Identity {
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), reutilizables
 // por apps/bridges sin cargar el iframe del vault.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

package/src/node.js

@@ -184,6 +184,8 @@ export class Identity {
   actaHistory (opts) { return this._h('actaHistory', opts || {}) }
   isMaster () { return this._h('isMaster') }
   admitMember (member) { return this._h('admitMember', member) }
+  /** Registra la llave de cifrado de un miembro ya admitido (evita re-enrolarlo). */
+  setMemberEncPub (args) { return this._h('setMemberEncPub', args) }
   setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
   setLabel (pub, label) { return this._h('setLabel', { pub, label }) }
   removeMember (pub) { return this._h('removeMember', { pub }) }
@@ -269,4 +271,4 @@ export default Identity
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), para que
 // un bridge/bot Node pueda crear su clave, firmar acciones y verificar cadenas D←P.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, makePairingCode, commitCode, avatarSvg, avatarDataUri, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

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.
@@ -82,6 +91,20 @@ export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
 const isPub = (v) => typeof v === 'string' && v.length > 0
+
+/**
+ * La llave de CIFRADO de un miembro (`encPub`): JWK público de una ECDH P-256.
+ * Se valida de verdad —no basta con «es un string»— porque es lo que decide si a
+ * ese aparato se le puede envolver un secreto: una `encPub` mal formada no falla al
+ * escribir el acta, falla mucho después al intentar sellarle algo.
+ */
+const isEncPub = (v) => {
+  if (typeof v !== 'string' || !v) return false
+  try {
+    const j = JSON.parse(v)
+    return j?.kty === 'EC' && j?.crv === 'P-256' && typeof j?.x === 'string' && typeof j?.y === 'string'
+  } catch (_) { return false }
+}
 const cleanCaps = (caps) => [...new Set((Array.isArray(caps) ? caps : []).filter((c) => CAPS.includes(c)))].sort()
 
 /**
@@ -112,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,
@@ -127,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
   }
 }
@@ -134,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'
@@ -151,6 +182,29 @@ export function checkShape (acta) {
     } else if (m.caps.includes('secrets')) {
       return 'secretos-sin-cn'
     }
+    // La llave de cifrado: por ahora se valida la FORMA y solo si viene. NO se exige
+    // todavía, aunque el destino sea exigírsela a quien recibe secretos.
+    //
+    // El motivo es que `checkShape` corre en CADA `verifyActa`, también sobre actas ya
+    // selladas: exigirla hoy invalidaría de golpe las actas en las que un servicio
+    // entró sin ella —que son todas las anteriores a esto— y el vault dejaría de
+    // arrancar en vez de avisar. Primero los servicios registran su llave (op
+    // `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'
@@ -193,7 +247,7 @@ 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)')
@@ -204,6 +258,11 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
 
   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),
@@ -211,10 +270,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) {
@@ -239,6 +312,19 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         })
         break
       }
+      // Registra (o reemplaza) la llave de CIFRADO de un miembro que YA está admitido.
+      //
+      // Existe para no tener que expulsar y volver a admitir a un servicio solo porque
+      // le falta la llave: re-enrolar le cambia la pubkey, y con ella pierde su cajón de
+      // variables —que va indexado por esa llave— y se queda sin configuración en
+      // silencio. Registrar la llave en el sitio no toca ni `pub`, ni `cn`, ni `caps`.
+      case 'encpub': {
+        const m = find(ch.pub)
+        if (!m) throw new Error('encpub: that member is not in the record')
+        if (!isEncPub(ch.encPub)) throw new Error('encpub: invalid encryption key (expected a P-256 public JWK)')
+        m.encPub = ch.encPub
+        break
+      }
       case 'caps': {
         const m = find(ch.pub)
         if (!m) throw new Error('caps: that member is not in the record')
@@ -332,6 +418,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/capabilities.js

@@ -24,6 +24,7 @@ import { canonicalStringify, bufToBase64, base64ToBuf } from './core.js'
 import { pubkeyId, keyLabel } from './keyid.js'
 
 const ECDSA = { name: 'ECDSA', namedCurve: 'P-256' }
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
 const SIGN = { name: 'ECDSA', hash: { name: 'SHA-256' } }
 
 /** Tope DURO de vida de una delegación (aunque pidan más). */
@@ -120,6 +121,44 @@ export async function makeDeviceKey ({ label = '' } = {}) {
   return { publickey, privateJwk, publicJwk, label: String(label || ''), createdAt: Date.now(), deviceId: await pubkeyId(publickey) }
 }
 
+/**
+ * Genera la llave de CIFRADO del dispositivo (ECDH P-256): la hermana de
+ * `makeDeviceKey`, que es de FIRMA. Hacen falta las dos y no son intercambiables —
+ * con ECDSA no se puede cifrar.
+ *
+ * Es lo que permite escribirle a un aparato **por adelantado**, sin que esté
+ * conectado: su pública va al acta como `encPub` y cualquiera puede envolverle un
+ * secreto con `wrapForMember` (ver `./content.js`). La privada no sale de aquí.
+ *
+ * Sale EXTRAÍBLE porque un servicio headless la persiste en su archivo de identidad
+ * (cifrado en reposo). En el navegador la pareja del perfil vive como CryptoKey no
+ * extraíble en IndexedDB — eso lo hace `core.js`, no esto.
+ */
+export async function makeDeviceEncKey () {
+  const pair = await crypto.subtle.generateKey(ECDH, true, ['deriveBits'])
+  const encPrivateJwk = await crypto.subtle.exportKey('jwk', pair.privateKey)
+  const encPublicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
+  return {
+    encPublickey: JSON.stringify({ kty: encPublicJwk.kty, crv: encPublicJwk.crv, x: encPublicJwk.x, y: encPublicJwk.y }),
+    encPrivateJwk,
+    encPublicJwk,
+    createdAt: Date.now()
+  }
+}
+
+/**
+ * Reconstruye la llave privada de cifrado desde su JWK. Es lo que hay que pasarle a
+ * `openWrap({ myEncPrivateKey })` para abrir un sobre dirigido a este aparato.
+ *
+ * Existe para que nadie la importe a mano: `deriveBits` es el ÚNICO uso correcto, y
+ * pedir otro (`deriveKey`) hace fallar la importación en Node con un error que no
+ * dice nada útil.
+ */
+export async function importDeviceEncKey (encPrivateJwk) {
+  if (!encPrivateJwk || typeof encPrivateJwk !== 'object') throw new Error('importDeviceEncKey: falta el JWK de la privada')
+  return crypto.subtle.importKey('jwk', encPrivateJwk, ECDH, false, ['deriveBits'])
+}
+
 /**
  * Firma un certificado de delegación con una `privateKey` (CryptoKey) cuyo pubkey
  * es `iss`. Lo usa el handler del vault (con la clave maestra). Devuelve el cert

package/vault/content.js

@@ -111,6 +111,19 @@ export async function encryptWithCek ({ cek, gen, plaintext }) {
   return { gen, iv: b64(iv), ct: b64(ct) }
 }
 
+/**
+ * Descifra un sobre teniendo YA la CEK. Es el inverso exacto de `encryptWithCek`.
+ *
+ * Existe para quien administra: tiene la clave a mano (la sacó de donde la guarde) y no
+ * necesita el llavero ni ser miembro. El camino normal —el del aparato que solo tiene su
+ * propia llave— es `decryptWithKeyring`.
+ */
+export async function decryptWithCek ({ cek, envelope }) {
+  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)
+}
+
 /**
  * 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
@@ -128,5 +141,5 @@ export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPriva
 
 export default {
   makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
-  encryptWithCek, decryptWithKeyring
+  encryptWithCek, decryptWithCek, decryptWithKeyring
 }

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,23 @@ 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
+    },
+
+    /** 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 }
@@ -1460,7 +1492,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
         isMe: m.pub === publickeyJwkStr,
-        isMaster: m.pub === acta.sealer
+        isMaster: m.pub === acta.sealer,
+        // La llave de CIFRADO del miembro y, derivado, si se le puede envolver algo.
+        // Sale en la proyección porque sin ella ninguna interfaz (CLI, TUI, consola)
+        // puede decir «a este aparato no se le puede escribir», y ese silencio es
+        // justo el que hace que un secreto no llegue y nadie sepa por qué.
+        encPub: m.encPub || null,
+        canSeal: !!m.encPub
       })))
       return { members, profileId: acta.profileId, seq: acta.seq, sealer: acta.sealer, updatedAt: acta.updatedAt }
     },
@@ -1481,6 +1519,19 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async isMaster () { return amMaster() },
 
+    /**
+     * Registra la llave de CIFRADO de un miembro ya admitido (solo el master).
+     *
+     * Es la alternativa a expulsarlo y volver a admitirlo: un servicio re-enrolado
+     * estrena pubkey, y su cajón de variables va indexado por la vieja, así que
+     * arrancaría sin configuración y sin decirlo. Esto le pone la llave sin moverle
+     * nada más.
+     */
+    async setMemberEncPub ({ pub, encPub } = {}) {
+      const acta = await sealChanges([{ op: 'encpub', pub, encPub }])
+      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).

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; }