@dotrino/identity 0.112.0 → 0.114.0

package/README.md

@@ -179,6 +179,11 @@ const v = await verifySignedFor({ data: pin, signature, publickey, chain, audien
 `aud` es obligatorio igual que en la prueba; `exp` es opcional, porque la caducidad de lo
 publicado la lleva el servicio (el TTL del pin) y no el cuerpo.
 
+Si quien firma es un **servicio** de la cuenta (un miembro con `cn`), pásale `ns` con su
+cajón (0.114.0+): un servicio solo firma dentro del suyo, y sin `ns` no pasa nunca. Así el
+directorio de nombres acepta lo que firma su aparato `names` sin aceptar lo de cualquier
+otro servicio de la misma cuenta.
+
 ### Permiso por origen (0.86.0+)
 
 Una prueba dice **quién eres** sin preguntar nada: quien llega al iframe ya pasó el filtro

package/package.json

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

@@ -328,8 +328,9 @@ export async function verifySealerLink (link) {
  *
  * Es la hermana de `verifySealerChain`, que hace lo mismo con actas enteras para quien las
  * tiene. Lo que comprueba, y por qué basta:
- *   1. el primero es el GÉNESIS: `seq 1`, sin `prev`, y firmado por `profileId` — el ancla,
- *      que no se puede fabricar sin la llave que da nombre al perfil;
+ *   1. el primero está firmado por `profileId` — el ancla, que no se puede fabricar sin la
+ *      llave que da nombre al perfil. Normalmente es el génesis (`seq 1`, sin `prev`), pero
+ *      no tiene por qué: una cuenta que perdió su génesis ancla en un eslabón posterior;
  *   2. cada siguiente lo firmó alguien a quien el ANTERIOR autorizaba;
  *   3. y apunta al anterior por `seq` + hash, así que no se cuela uno de otra rama.
  *
@@ -339,7 +340,9 @@ export async function verifySealerLink (link) {
 export async function verifySealerLinkChain (chain, { expectedProfileId = null } = {}) {
   if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
   const [raiz] = chain
-  if (raiz?.seq !== 1 || raiz?.prev != null) return { ok: false, reason: 'no-empieza-en-genesis' }
+  // La misma regla que en `verifySealerChain`: la raíz la ancla la llave del perfil, no el
+  // número 1 (una cuenta puede haber perdido su génesis; ver allí).
+  if (!Number.isInteger(raiz?.seq) || raiz.seq < 1) return { ok: false, reason: 'no-empieza-en-genesis' }
   if (raiz.by !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
   if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
   const vr = await verifySealerLink(raiz)
@@ -619,7 +622,7 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
  * @param {{ data?: any, signature?: string, publickey?: string, chain?: any[], expectedProfileId?: string|null }} [args]
  */
 export async function verifySignedBy (args = {}) {
-  const { data, signature, publickey, chain, expectedProfileId = null } = args
+  const { data, signature, publickey, chain, expectedProfileId = null, ns = null } = args
   if (!data || typeof signature !== 'string' || typeof publickey !== 'string') {
     return { ok: false, reason: 'shape' }
   }
@@ -628,7 +631,10 @@ export async function verifySignedBy (args = {}) {
   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' }
+  // Un SERVICIO (miembro con `cn`) solo firma dentro de su cajón: quien verifica dice cuál
+  // con `ns` (el directorio de nombres acepta lo firmado por su aparato `names`, no por
+  // cualquier servicio de la cuenta). Sin `ns`, un servicio nunca pasa, como siempre.
+  if (!memberCanSign(cabeza, publickey, ns)) 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 }
 }
@@ -637,8 +643,15 @@ export async function verifySealerChain (chain, { expectedProfileId = null } = {
   if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
   const [raiz] = chain
 
-  if (raiz.seq !== 1 || raiz.sealerAnchor != null) return { ok: false, reason: 'no-empieza-en-genesis' }
-  // El ancla: el génesis se firma a sí mismo con la llave que da nombre al perfil.
+  // EL ANCLA ES LA LLAVE DEL PERFIL, NO EL NÚMERO 1 (dueño, 2026-10-14). La raíz vale si
+  // está firmada por la llave que da nombre al perfil, sea el génesis o un acta posterior.
+  // Antes se exigía `seq 1`, y eso dejaba sin cadena a toda cuenta anterior a las actas v5:
+  // su génesis no llevaba `sealerChanged`, la ventana de retención lo podó, y no hay de
+  // dónde recuperarlo. Exigir el génesis no protegía de nada: quien tenga la llave del
+  // perfil fabrica un génesis alterno igual que un acta posterior, y contra eso la capa es
+  // el registro público. Lo que sí sostiene la cadena —que cada eslabón lo firmó alguien a
+  // quien el anterior autorizaba— sigue intacto.
+  if (!Number.isInteger(raiz.seq) || raiz.seq < 1) return { ok: false, reason: 'no-empieza-en-genesis' }
   if (raiz.sealedBy !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
   if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
   const vr = await verifyActa({ acta: raiz })

package/vault/assertion.js

@@ -191,10 +191,13 @@ export async function verifyAssertion (assertion, opts = {}) {
  * quien la lleva es el servicio; si el cuerpo trae `exp`, se respeta.
  */
 /**
- * @param {{ data?: any, signature?: string, publickey?: string, chain?: any[], audience?: string, expectedProfileId?: string|null, now?: number, maxSkewMs?: number }} [args]
+ * `ns`: el cajón del servicio que firma (su `cn` en el acta). Solo hace falta cuando lo
+ * firmado viene de un SERVICIO de la cuenta y no de un aparato de la persona.
+ *
+ * @param {{ data?: any, signature?: string, publickey?: string, chain?: any[], audience?: string, expectedProfileId?: string|null, ns?: string|null, now?: number, maxSkewMs?: number }} [args]
  */
 export async function verifySignedFor (args = {}) {
-  const { data, signature, publickey, chain, audience, expectedProfileId = null, now = Date.now(), maxSkewMs = ASSERTION_MAX_SKEW_MS } = args
+  const { data, signature, publickey, chain, audience, expectedProfileId = null, ns = null, now = Date.now(), maxSkewMs = ASSERTION_MAX_SKEW_MS } = args
   if (typeof audience !== 'string' || !audience.trim()) return { ok: false, reason: 'no-audience' }
   if (!data || typeof data !== 'object') return { ok: false, reason: 'shape' }
   if (typeof data.aud !== 'string' || !data.aud) return { ok: false, reason: 'sin-destinatario' }
@@ -207,7 +210,7 @@ export async function verifySignedFor (args = {}) {
     if (!Number.isFinite(data.iat)) return { ok: false, reason: 'shape' }
     if (data.iat > now + maxSkewMs) return { ok: false, reason: 'del-futuro' }
   }
-  const v = await verifySignedBy({ data, signature, publickey, chain, expectedProfileId })
+  const v = await verifySignedBy({ data, signature, publickey, chain, expectedProfileId, ns })
   if (!v.ok) return { ok: false, reason: 'firma:' + v.reason }
   return { ok: true, profileId: v.profileId, signer: v.signer, seq: v.seq, aud: data.aud }
 }

package/vault/core.js

@@ -873,7 +873,9 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     h.sort((a, b) => a.seq - b.seq)
     const ventana = h.slice(-ACTA_WINDOW)
     const enVentana = new Set(ventana.map((a) => a.seq))
-    const eslabones = h.filter((a) => a.sealerChanged && !enVentana.has(a.seq))
+    // El génesis cuenta siempre como eslabón: las actas anteriores a v5 no llevaban la
+    // marca, y por eso la poda se llevó el génesis de las cuentas viejas.
+    const eslabones = h.filter((a) => (a.sealerChanged || a.seq === 1) && !enVentana.has(a.seq))
     kv.setItem(ACTA_HISTORY_STORAGE, JSON.stringify([...eslabones, ...ventana].sort((a, b) => a.seq - b.seq)))
   }
 
@@ -888,7 +890,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     // 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)
+    const eslabones = [...porSeq.values()].filter((a) => a.sealerChanged || a.seq === 1).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]
@@ -2506,6 +2508,10 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * 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.
+     *
+     * SIN GÉNESIS, la cadena es `[acta actual]` y vale igual mientras la actual esté firmada
+     * por la llave del perfil: la raíz la ancla esa llave, no el número 1 (`verifySealerChain`).
+     * Pasa en las cuentas anteriores a v5, cuyo génesis se podó sin la marca de eslabón.
      */
     async sealerChain () { return sealerChain() },