@dotrino/identity 0.52.0 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -39,8 +39,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test test/*.test.js",
-    "type-check": "tsc --noEmit"
+    "test": "node --test test/*.test.js"
   },
   "keywords": [
     "identity",
@@ -59,8 +58,6 @@
     "@dotrino/proxy-client": "0.10.0"
   },
   "devDependencies": {
-    "fake-indexeddb": "^6.2.5",
-    "typescript": "^5.7.3",
-    "@types/node": "^22.0.0"
+    "fake-indexeddb": "^6.2.5"
   }
 }

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

@@ -82,6 +82,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()
 
 /**
@@ -151,6 +165,15 @@ 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'
   }
   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'
@@ -239,6 +262,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')

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

@@ -1460,7 +1460,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 +1487,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).