@dotrino/identity 0.69.0 → 0.71.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.69.0",
+  "version": "0.71.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/vault/acta.js

@@ -62,6 +62,18 @@ const ACTA_LEIBLES = Object.freeze([1, 2, 3, 4])
 const V_CON_CADENA = 4
 /** ¿Esta acta lleva el eslabón? Las anteriores se leen igual; no pueden encadenar. */
 const conCadena = (acta) => Number(acta?.v) >= V_CON_CADENA
+/**
+ * Solo `https`, y sin excepción para localhost: esta dirección la va a abrir un TERCERO
+ * que no te conoce, y mandarlo por texto plano es dejar que cualquiera en el camino le
+ * conteste otra cosa. Que no lleve `#` ni credenciales: no es un enlace para una persona.
+ */
+const isChainUrl = (u) => {
+  if (typeof u !== 'string' || u.length > 300) return false
+  try {
+    const x = new URL(u)
+    return x.protocol === 'https:' && !x.hash && !x.username && !x.password
+  } catch (_) { return false }
+}
 /** Desde esta versión, sellar es solo un permiso y no hay campo `sealer`. */
 const V_SIN_CAMPO_SELLADOR = 3
 /** ¿Este acta es de las viejas, con el campo? */
@@ -221,12 +233,30 @@ export const canSeal = (acta, pub, renounces = []) =>
  * 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, sealPub = null, label = '', now = Date.now() }) {
+export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', chainUrl = null, now = Date.now() }) {
   if (!isPub(pub)) throw new Error('genesisActa: missing genesis pubkey')
+  if (chainUrl != null && !isChainUrl(chainUrl)) throw new Error('genesisActa: chainUrl must be https')
   return {
     v: ACTA_V,
     profileId: pub,
     sealedBy: pub,
+    /**
+     * DÓNDE PREGUNTAR SI ESTA CADENA SIGUE VIGENTE. Va en el GÉNESIS y en ningún otro
+     * sitio, y esa es toda la idea.
+     *
+     * La cadena que te llega prueba quién puede sellar, pero no que no haya algo más
+     * nuevo — si retiraste una bóveda, quien tenga la cadena vieja la sigue aceptando.
+     * Para enterarse hay que poder mirar a algún lado.
+     *
+     * Si la dirección viajara en la parte cambiable, el sellador expulsado la cambiaría
+     * a la suya y te mandaría a mirar su rama. En el génesis no puede: está autofirmada
+     * por la llave que da nombre al perfil, y cambiarla exige esa llave.
+     *
+     * `null` es lo normal y no es un defecto: una cuenta de una sola bóveda no tiene nada
+     * que pueda quedar obsoleto —su conjunto de selladores no puede cambiar— así que no
+     * hay a dónde preguntar ni falta que hace.
+     */
+    chainUrl: chainUrl || null,
     seq: 1,
     prev: null,
     // LA CADENA DE SELLADORES. El génesis es el ancla: está autofirmado por la llave que
@@ -258,6 +288,7 @@ export function checkShape (acta) {
   if (!acta || typeof acta !== 'object') return 'no-acta'
   if (!ACTA_LEIBLES.includes(acta.v)) return 'version'
   if (!isPub(acta.profileId) || !isPub(acta.sealedBy)) return 'shape'
+  if (acta.chainUrl != null && !isChainUrl(acta.chainUrl)) return 'chainurl'
   // El campo solo existe —y solo se exige— en las viejas.
   if (conCampoSellador(acta) && !isPub(acta.sealer)) return 'shape'
   if (!conCampoSellador(acta) && acta.sealer != null) return 'sealer-no-va-en-v3'
@@ -358,6 +389,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 +969,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

@@ -1357,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())