@dotrino/identity 0.68.0 → 0.70.0

package/package.json

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

@@ -278,6 +278,8 @@ export class Identity {
 
   /** El acta vigente + si este dispositivo es el master + sus capacidades efectivas. */
   async profileActa () { return this._call('profileActa') }
+  /** La cadena de selladores, para mandarla con una firma (ver `vault/acta.js`). */
+  async sealerChain () { return this._call('sealerChain') }
 
   /** Miembros del perfil, ya con id legible y capacidades efectivas. */
   async profileMembers () { return this._call('profileMembers') }

package/src/node.js

@@ -169,6 +169,8 @@ export class Identity {
   listDelegations () { return this._h('listDelegations') }
   // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
   profileActa () { return this._h('profileActa') }
+  /** La cadena de selladores, para mandarla con una firma (ver `vault/acta.js`). */
+  sealerChain () { return this._h('sealerChain') }
   profileMembers () { return this._h('profileMembers') }
   /**
    * Quien SELLA SOBRES (la bóveda) registra aquí cómo estrenar su llave de sellado: se

package/vault/acta.js

@@ -358,6 +358,35 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
  * aceptando a un sellador que ya retiraste. Es el problema de siempre y hace falta un
  * oráculo, no más firmas.
  */
+/**
+ * ¿DE QUIÉN ES ESTO? La pregunta que se hacen geo, reputación y cualquiera que reciba algo
+ * firmado de un desconocido. Es lo único que necesitan llamar.
+ *
+ * Devuelve el `profileId` —la identidad— o por qué no.
+ *
+ * EL CERTIFICADO NO HACE FALTA AQUÍ, y conviene decirlo porque es lo que uno espera:
+ * el acta ya dice quién puede firmar por la identidad, y la cadena prueba el acta. El
+ * certificado es del protocolo aparato↔bóveda (autenticar peticiones), no de atribuir
+ * contenido. Mezclarlos obligaba a que cada post arrastrara un papel que no aporta nada.
+ *
+ * Lo que SÍ hay que entender: esto dice «esta identidad firmó esto», no «esto es
+ * reciente». Si la cadena que te llega es vieja, sigue verificando — para eso está el
+ * registro público, que es otra capa.
+ */
+export async function verifySignedBy ({ data, signature, publickey, chain, expectedProfileId = null } = {}) {
+  if (!data || typeof signature !== 'string' || typeof publickey !== 'string') {
+    return { ok: false, reason: 'shape' }
+  }
+  const c = await verifySealerChain(chain, { expectedProfileId })
+  if (!c.ok) return { ok: false, reason: 'cadena:' + c.reason }
+  const cabeza = chain[chain.length - 1]
+  // Quien firmó tiene que ser miembro CON `sign` en el acta vigente de esa cadena. Si le
+  // quitaste el permiso, sus firmas dejan de contar en cuanto se ve un acta más nueva.
+  if (!memberCanSign(cabeza, publickey)) return { ok: false, reason: 'firmante-no-autorizado' }
+  if (!(await verifyDeviceSig({ publickey, data, signature }))) return { ok: false, reason: 'firma-invalida' }
+  return { ok: true, profileId: c.profileId, seq: c.seq, signer: publickey }
+}
+
 export async function verifySealerChain (chain, { expectedProfileId = null } = {}) {
   if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
   const [raiz] = chain
@@ -909,7 +938,7 @@ export async function canAdopt ({ candidate, current }) {
 }
 
 export default {
-  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain,
+  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain, verifySignedBy,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,

package/vault/core.js

@@ -563,8 +563,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const sealerChain = () => {
     const cur = loadActa()
     if (!cur) return []
-    const eslabones = loadHistory().filter((a) => a.sealerChanged).sort((a, b) => a.seq - b.seq)
-    return cur.sealerChanged ? eslabones : [...eslabones, cur]
+    // La vigente cuenta como parte del material aunque todavía no esté en la historia
+    // (ahí entra al dejar de serlo). Sin esto, una cuenta recién creada devolvía [].
+    const porSeq = new Map([...loadHistory(), cur].map((a) => [a.seq, a]))
+    const eslabones = [...porSeq.values()].filter((a) => a.sealerChanged).sort((a, b) => a.seq - b.seq)
+    // Y la actual va al final si ella misma no es un eslabón: el verificador necesita ver
+    // la cabeza para saber en qué `seq` está y quién la selló.
+    return eslabones.length && eslabones[eslabones.length - 1].seq === cur.seq ? eslabones : [...eslabones, cur]
   }
 
   const loadRenounces = () => { try { return JSON.parse(kv.getItem(RENOUNCE_STORAGE) || '[]') || [] } catch (_) { return [] } }
@@ -627,7 +632,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const { generation } = await Content.makeGeneration({ members: base.members, gen: 1 })
       base.keyring = [generation]
     } catch (e) { console.warn('[identity] could not create the content key:', e.message) }
-    saveActa(await seal(base))
+    const genesis = await seal(base)
+    saveActa(genesis)
+    // EL GÉNESIS VA A LA HISTORIA DESDE EL PRIMER DÍA. Es el ancla de la cadena de
+    // selladores —el único eslabón autofirmado por la llave que da nombre al perfil— y
+    // sin él nadie de fuera puede verificar nada de esta cuenta, nunca. Antes solo se
+    // guardaba lo que DEJABA de ser vigente, así que una cuenta que nunca cambió su acta
+    // no tenía génesis guardado y su cadena salía vacía.
+    pushHistory(genesis)
     return loadActa()
   }
 
@@ -1144,7 +1156,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const LOCK_EXEMPT = new Set([
     'profileLockStatus', 'unlockProfile', 'listProfiles', 'currentProfile',
     'switchProfile', 'createProfile',
-    'profileActa', 'profileMembers', 'myMembership', 'isMaster'
+    'profileActa', 'profileMembers', 'myMembership', 'isMaster', 'sealerChain'
   ])
 
   const handlers = {
@@ -1345,7 +1357,22 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (data == null) throw new Error('data required')
       const local = async () => {
         const bytes = new TextEncoder().encode(canonicalStringify(data))
-        return { signature: await signBytes(keypair.privateKey, bytes), publickey: publickeyJwkStr }
+        const acta = loadActa()
+        return {
+          signature: await signBytes(keypair.privateKey, bytes),
+          publickey: publickeyJwkStr,
+          // A NOMBRE DE QUIÉN VA. `publickey` es la llave de ESTE aparato, y las apps la
+          // venían guardando como si fuera la identidad: publicar desde el teléfono y
+          // desde el PC quedaba a nombre de dos «personas» distintas, y la reputación se
+          // repartía entre ellas en vez de acumularse.
+          //
+          // La identidad es el `profileId` —la llave del génesis, que no cambia nunca— y
+          // la cadena es lo que prueba que este firmante le pertenece. Van juntos porque
+          // por separado no sirven: el `profileId` solo es una afirmación, y la cadena sin
+          // él no dice a quién atribuir.
+          profileId: acta?.profileId || publickeyJwkStr,
+          chain: sealerChain()
+        }
       }
       const acta = loadActa()
       const puedeFirmar = !acta || Acta.memberCan(acta, publickeyJwkStr, 'sign', loadRenounces())
@@ -1498,6 +1525,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { acta, isMaster: amMaster(), myCaps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()) }
     },
 
+    /**
+     * LA CADENA DE SELLADORES, para mandarla junto con una firma.
+     *
+     * Es lo que deja a un EXTRAÑO comprobar que quien firmó habla por esta identidad, sin
+     * preguntarle a nadie: `[génesis, …cambios de sellador…, acta actual]`. No son todas
+     * las actas —eso crecería con cada emparejamiento— sino solo los eslabones donde
+     * cambió quién sella, que casi nunca pasa. Lo normal es longitud 1: el génesis.
+     *
+     * Una cuenta de una sola bóveda devuelve SIEMPRE eso y nada más, y no puede quedarse
+     * obsoleta: su conjunto de selladores no puede cambiar, porque el único no puede
+     * quitarse a sí mismo y no hay otro que se lo quite.
+     */
+    async sealerChain () { return sealerChain() },
+
     /**
      * 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