@dotrino/identity 0.30.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.30.0",
+  "version": "0.31.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,11 @@ 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 }) }
+  /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
+   *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
+  async profileCard () { return this._call('profileCard') }
+  /** Guarda la tarjeta de otra persona en su ficha de contacto (verificándola). */
+  async adoptPeerCard (card) { return this._call('adoptPeerCard', { card }) }
   /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
   async contentKey () { return this._call('contentKey') }
   /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */

package/src/node.js

@@ -173,6 +173,11 @@ export class Identity {
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
   absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
   adoptActa (acta) { return this._h('adoptActa', { acta }) }
+  /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
+   *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
+  profileCard () { return this._h('profileCard') }
+  /** Guarda la tarjeta de otra persona en su ficha de contacto (verificándola). */
+  adoptPeerCard (card) { return this._h('adoptPeerCard', { card }) }
   /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
   contentKey () { return this._h('contentKey') }
   /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */

package/vault/acta.js

@@ -70,9 +70,12 @@ const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart
 const isPub = (v) => typeof v === 'string' && v.length > 0
 const cleanCaps = (caps) => [...new Set((Array.isArray(caps) ? caps : []).filter((c) => CAPS.includes(c)))].sort()
 
-/** El acta SIN la firma: es lo que se sella y sobre lo que se calcula el hash. */
+/**
+ * El acta SIN la firma ni la tarjeta: es lo que se sella y sobre lo que se calcula el hash.
+ * La `card` va aparte porque lleva su propia firma y se comparte sola (ver `makeProfileCard`).
+ */
 export function actaBody (acta) {
-  const { sig, ...body } = acta || {}
+  const { sig, card, ...body } = acta || {}
   return body
 }
 
@@ -146,7 +149,11 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
   const shape = checkShape(acta)
   if (shape) throw new Error('acta inválida: ' + shape)
   const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: actaBody(acta) })
-  return { ...acta, sig: signature }
+  const sealed = { ...acta, sig: signature }
+  // La TARJETA se firma en el mismo gesto y viaja con el acta: así cualquier miembro puede
+  // entregársela a un contacto sin ser el master y sin contarle nada de más.
+  sealed.card = await makeProfileCard({ acta: sealed, privateKey, privateJwk })
+  return sealed
 }
 
 /**
@@ -351,6 +358,73 @@ export function memberCan (acta, pub, cap, extraRenounces = []) {
   return effectiveCaps(acta, pub, extraRenounces).includes(cap)
 }
 
+// ----- TARJETA DE PERFIL: lo mínimo que se comparte con otra persona -----
+
+/**
+ * Para escribirle a alguien cifrado hay que conocer las llaves de CIFRADO de todos sus
+ * dispositivos — si no, el mensaje solo lo abre el aparato desde el que hablaste. Pero
+ * pasarle el ACTA a un contacto le contaría de más: cuántos dispositivos tienes, cómo se
+ * llaman y qué puede cada uno. Nada de eso es asunto suyo.
+ *
+ * Así que se comparte una TARJETA: el mínimo imprescindible —el perfil, su versión y las
+ * llaves— firmada por el master, y por lo tanto verificable sin tener el acta. Sin
+ * etiquetas, sin permisos, sin certificados.
+ *
+ * La firma el MASTER al sellar, y viaja con el acta, para que cualquier miembro pueda
+ * entregarla aunque no sea él quien manda.
+ */
+export function cardBody (acta) {
+  return {
+    v: 1,
+    profileId: acta.profileId,
+    seq: acta.seq,
+    sealedBy: acta.sealedBy,
+    // Solo las llaves. Los servicios (con CN) NO van: no son la persona, y no tienen por
+    // qué recibir los mensajes de nadie.
+    keys: acta.members
+      .filter((m) => !m.cn && m.encPub)
+      .map((m) => ({ pub: m.pub, encPub: m.encPub }))
+      .sort((a, b) => (a.pub < b.pub ? -1 : 1)),
+    iat: acta.updatedAt
+  }
+}
+
+/** Firma la tarjeta de este acta (lo hace el master al sellar). */
+export async function makeProfileCard ({ acta, privateKey, privateJwk }) {
+  const body = cardBody(acta)
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: body })
+  return { ...body, sig: signature }
+}
+
+/** Verifica que la tarjeta la firmó quien dice (`sealedBy`). Que ÉSE sea el master de esa
+ * persona se decide al adoptarla, comparándola con la que ya tenías (`canAdoptCard`). */
+export async function verifyProfileCard (card) {
+  if (!card || card.v !== 1 || !isPub(card.profileId) || !isPub(card.sealedBy)) return false
+  if (!Number.isInteger(card.seq) || !Array.isArray(card.keys) || typeof card.sig !== 'string') return false
+  const { sig, ...body } = card
+  return verifyDeviceSig({ publickey: card.sealedBy, data: body, signature: sig })
+}
+
+/**
+ * ¿Me quedo con esta tarjeta en vez de la que tenía de esa persona?
+ *   · la primera vez, sí (confías en el contacto que agregaste: es el mismo criterio
+ *     que ya usas al añadirlo);
+ *   · después, solo si el `seq` es mayor o igual Y la firmó el mismo master que la
+ *     anterior — así nadie te cuela dispositivos ajenos en el perfil de tu contacto,
+ *     y nunca se retrocede a una versión vieja.
+ * Si el master cambió legítimamente (traspaso), la tarjeta nueva la firma el entrante y
+ * hay que re-confirmarla: se devuelve `master-cambiado` para que la app lo diga en vez de
+ * aceptarlo en silencio.
+ */
+export async function canAdoptCard ({ card, current }) {
+  if (!(await verifyProfileCard(card))) return { adopt: false, reason: 'firma-invalida' }
+  if (current && current.profileId !== card.profileId) return { adopt: false, reason: 'otro-perfil' }
+  if (!current) return { adopt: true, reason: 'primera-vez' }
+  if (card.seq < current.seq) return { adopt: false, reason: 'seq-menor' }
+  if (card.sealedBy !== current.sealedBy) return { adopt: false, reason: 'master-cambiado' }
+  return { adopt: true, reason: card.seq > current.seq ? 'seq-mayor' : 'igual' }
+}
+
 // ----- continuidad: unir una identidad que ya existía -----
 
 /**
@@ -424,5 +498,6 @@ export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
+  cardBody, makeProfileCard, verifyProfileCard, canAdoptCard,
   effectiveCaps, memberCan, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
 }

package/vault/core.js

@@ -21,6 +21,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 { pubkeyId as pubkeyIdOf } from './capabilities.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'
@@ -319,6 +320,9 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     if (e && /\brevoked\b/.test(e.message || '')) emitVault({ phase: 'rejected', reason: e.message })
     throw e
   }
+  /** Id estable y corto de una llave de cifrado: con esto se indexan las envolturas. */
+  const encKeyId = async (encPub) => (await pubkeyIdOf(encPub)).slice(0, 16)
+
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
   const loadVaultDevice = () => {
     try {
@@ -1208,6 +1212,28 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { chain: all.sort((a, b) => a.seq - b.seq), window: ACTA_WINDOW }
     },
 
+    /**
+     * MI tarjeta de perfil: lo mínimo que se le pasa a un contacto para que pueda cifrarme a
+     * todos mis dispositivos (perfil, versión y llaves de cifrado). Sin etiquetas, sin
+     * permisos, sin certificados: lo demás no es asunto de nadie.
+     */
+    async profileCard () { return loadActa()?.card || null },
+
+    /**
+     * Guarda la tarjeta de OTRA persona en su ficha de contacto. La primera vez se acepta
+     * (es el mismo criterio con el que agregaste el contacto); después solo si no retrocede
+     * y la firmó el mismo master. Si el master cambió, se avisa en vez de aceptarlo callando.
+     */
+    async adoptPeerCard ({ card } = {}) {
+      if (!card?.profileId) throw new Error('tarjeta inválida')
+      const peers = loadPeers()
+      const prev = peers[card.profileId]?.card || null
+      const r = await Acta.canAdoptCard({ card, current: prev })
+      if (!r.adopt) return { adopted: false, reason: r.reason, devices: (prev?.keys || []).length }
+      upsertPeer(card.profileId, { card, profileId: card.profileId })
+      return { adopted: true, reason: r.reason, devices: card.keys.length }
+    },
+
     /** Adopta un acta que llega de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
     async adoptActa ({ acta } = {}) { return adoptActa(acta) },
 
@@ -1361,6 +1387,15 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async getEncryptionPubkey () { return encPublickeyJwkStr },
 
+    /**
+     * Cifra para uno o varios destinatarios. Dos cosas que cambian respecto de antes:
+     *
+     * 1. **El sobre va atado a la LLAVE, no a la conexión.** Cada envoltura se indexa por un
+     *    id derivado de la llave de cifrado del destinatario, en vez del token del proxy: así
+     *    puede abrirla también un dispositivo que no estaba conectado cuando se envió.
+     * 2. **Se cifra a TODOS los dispositivos de esa persona**, si conocemos su tarjeta de
+     *    perfil (§tarjeta). Le escribes a la persona, no al aparato desde el que te habló.
+     */
     async encrypt ({ recipients, plaintext }) {
       if (!Array.isArray(recipients) || recipients.length === 0) throw new Error('recipients required')
       if (typeof plaintext !== 'string') throw new Error('plaintext required')
@@ -1368,26 +1403,40 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const kRaw = await crypto.subtle.exportKey('raw', k)
       const iv = crypto.getRandomValues(new Uint8Array(12))
       const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, k, new TextEncoder().encode(plaintext))
-      const wrap = {}
+
+      // Expandir cada destinatario a TODOS los dispositivos de su perfil que conozcamos.
+      const encPubs = new Set()
+      const peers = loadPeers()
       for (const r of recipients) {
-        if (!r || !r.token || !r.encryptionPubkey) continue
+        if (!r) continue
+        if (r.encryptionPubkey) encPubs.add(r.encryptionPubkey)
+        const card = (r.publickey && peers[r.publickey]?.card) || null
+        for (const kk of (card?.keys || [])) if (kk.encPub) encPubs.add(kk.encPub)
+      }
+
+      const wrap = {}
+      for (const encPub of encPubs) {
         try {
-          const peerPub = await importPeerEncPubkey(r.encryptionPubkey)
+          const peerPub = await importPeerEncPubkey(encPub)
           const sharedKey = await deriveSharedAesKey(encKeypair.privateKey, peerPub)
           const wrapIv = crypto.getRandomValues(new Uint8Array(12))
           const wrappedCt = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: wrapIv }, sharedKey, kRaw)
-          wrap[r.token] = { iv: bufToBase64(wrapIv), ct: bufToBase64(new Uint8Array(wrappedCt)) }
+          wrap[await encKeyId(encPub)] = { iv: bufToBase64(wrapIv), ct: bufToBase64(new Uint8Array(wrappedCt)) }
         } catch (e) { /* destinatario omitido */ }
       }
-      return { v: 1, iv: bufToBase64(iv), ct: bufToBase64(new Uint8Array(ct)), wrap }
+      return { v: 2, iv: bufToBase64(iv), ct: bufToBase64(new Uint8Array(ct)), wrap }
     },
 
+    /**
+     * Descifra. Busca MI envoltura por el id de mi llave de cifrado (v2); `myToken` ya no
+     * hace falta y se acepta solo por compatibilidad de llamada.
+     */
     async decrypt ({ senderEncryptionPubkey, myToken, envelope }) {
       if (!senderEncryptionPubkey) throw new Error('senderEncryptionPubkey required')
-      if (!myToken) throw new Error('myToken required')
-      if (!envelope || envelope.v !== 1) throw new Error('Unsupported envelope')
-      const myEntry = envelope.wrap && envelope.wrap[myToken]
-      if (!myEntry) throw new Error('No wrap entry for this recipient')
+      if (!envelope || (envelope.v !== 1 && envelope.v !== 2)) throw new Error('Unsupported envelope')
+      const myId = await encKeyId(encPublickeyJwkStr)
+      const myEntry = envelope.wrap && (envelope.wrap[myId] || (myToken ? envelope.wrap[myToken] : null))
+      if (!myEntry) throw new Error('este dispositivo no está entre los destinatarios del mensaje')
       const senderPub = await importPeerEncPubkey(senderEncryptionPubkey)
       const sharedKey = await deriveSharedAesKey(encKeypair.privateKey, senderPub)
       const kRaw = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: base64ToBuf(myEntry.iv) }, sharedKey, base64ToBuf(myEntry.ct))