@dotrino/identity 0.73.0 → 0.74.0

package/package.json

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

@@ -693,4 +693,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, makeDeviceEncKey, importDeviceEncKey, 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 } from '../vault/capabilities.js'

package/src/node.js

@@ -302,4 +302,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, makeDeviceEncKey, importDeviceEncKey, 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 } from '../vault/capabilities.js'

package/vault/capabilities.js

@@ -10,7 +10,7 @@
  *   - El vault firma un CERTIFICADO: «la clave D puede `scope` para la identidad P,
  *     mientras el ACTA lo diga», con un `nonce` que es el mango de revocación.
  *   - El dispositivo firma cada acción con `D` y adjunta el cert. Cualquiera
- *     verifica la CADENA `D ← P` + scope + expiración + revocación, offline.
+ *     verifica la CADENA `D ← P` + scope + lo que diga el ACTA + revocación, offline.
  *
  * Garantía: robar el dispositivo solo permite lo del `scope` (p.ej. publicar
  * ubicación) mientras el acta lo diga, y se puede revocar. La clave maestra queda intacta.
@@ -27,10 +27,27 @@ 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). */
-export const MAX_DELEGATION_MS = 30 * 24 * 60 * 60 * 1000   // 30 días
-/** Vida por defecto si no se especifica ttl/exp. */
-export const DEFAULT_DELEGATION_MS = 24 * 60 * 60 * 1000    // 24 h
+/**
+ * HASTA CUÁNDO SE ACEPTA UN PAPEL DEL MODELO VIEJO — **2026-10-01**, y se quita ese día.
+ *
+ * Los certificados de antes de 0.73 llevaban `exp` y no `seq`. Al pasar la bóveda al modelo
+ * del acta, TODOS los aparatos ya enrolados se quedaban fuera de golpe (`shape`) y sin forma
+ * de volver: el mostrador de renovación los rechazaba por lo mismo. Diez máquinas —los dos
+ * proxios, los nodes de contenido, el bot— habrían necesitado re-enrolarse a mano, con TTY
+ * en los dos lados.
+ *
+ * Así que se aceptan, con dos frenos y ninguna concesión de fondo:
+ *   · hasta su PROPIO vencimiento, que sigue valiendo (el más lejano es 2026-09-30);
+ *   · y en ningún caso pasado este tope.
+ * Además el mostrador los cruza con el acta igual que a los nuevos, así que un papel viejo
+ * no autoriza nada que el acta de hoy no autorice.
+ *
+ * Se apaga solo por partida doble: ninguna bóveda 0.73+ puede EMITIR uno de estos
+ * (`signDelegationWith` solo escribe `seq`), así que cuando el último caduque esta rama es
+ * inalcanzable. **Y aun así se borra en la fecha**, porque un repliegue sin fecha no es una
+ * migración: es un agujero (`CLAUDE.md`).
+ */
+export const LEGACY_CERTS_UNTIL = Date.parse('2026-10-01T00:00:00Z')
 
 const enc = (s) => new TextEncoder().encode(s)
 
@@ -118,6 +135,13 @@ export { avatarSvg, avatarDataUri } from './avatar.js'
  * ninguna renovación), y nadie tiene que abrir nada por calendario.
  */
 export function delegationBody (cert) {
+  // LA FORMA DEL CUERPO ES LA DEL PAPEL, no la del código que lo lee. Un papel del modelo
+  // viejo se firmó sobre `{ …, exp, nonce }`; recomponerlo con `seq: undefined` da otra
+  // string canónica y la firma no cuadra NUNCA — que es como el repliegue de migración no
+  // servía de nada hasta que una prueba lo dijo.
+  if (typeof cert.seq !== 'number' && typeof cert.exp === 'number') {
+    return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, exp: cert.exp, nonce: cert.nonce }
+  }
   return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, seq: cert.seq, nonce: cert.nonce }
 }
 
@@ -208,30 +232,15 @@ export async function signWithDevice ({ privateJwk, privateKey, publickey, data
  *   5) `nonce` no revocado (`revoked`: fn(nonce)→bool, Set o mapa).
  * @returns {{ok:boolean, reason?:string, iss?, sub?, scope?, iat?, seq?, nonce?}}
  */
-/**
- * MARGEN DE RELOJ ENTRE DOS APARATOS. Sin esto, emparejar es una lotería.
- *
- * La bóveda sella el certificado con SU reloj (`iat`) y el aparato lo valida con el suyo.
- * Con tolerancia cero, un aparato que vaya un pelo por detrás rechaza un certificado
- * perfectamente bueno con `not-yet-valid` — y el usuario no ve un problema de hora, ve un
- * emparejamiento que no funciona. Pasó de verdad (2026-08-31): un teléfono **850 ms** por
- * detrás, medido, no podía enrolarse en ninguna bóveda.
- *
- * Dos minutos es generoso para un reloj a la deriva y no significa nada frente a un
- * certificado que vale 30 días: aceptarlo dos minutos antes de tiempo no le abre la puerta
- * a nadie, porque lo que autoriza es la FIRMA, no la hora.
- *
- * Es para comparar aparatos DISTINTOS. Donde el mismo operador controla los dos relojes
- * —un servicio validando en la máquina que emite— el estricto sigue siendo lo correcto, y
- * por eso el default de `verifyDelegation` no cambia.
- */
-export const PEER_SKEW_MS = 120_000
 
 export async function verifyDelegation ({ cert, expectedScope, expectedSub, actaSeq = null, sealers = null, revoked } = {}) {
   if (!cert || typeof cert !== 'object') return { ok: false, reason: 'no-cert' }
   const { v, iss, sub, scope, iat, seq, nonce, sig } = cert
   if (v !== 1 || typeof iss !== 'string' || typeof sub !== 'string' || typeof sig !== 'string') return { ok: false, reason: 'shape' }
-  if (typeof iat !== 'number' || typeof seq !== 'number' || (typeof scope !== 'string' && !Array.isArray(scope))) return { ok: false, reason: 'shape' }
+  if (typeof iat !== 'number' || (typeof scope !== 'string' && !Array.isArray(scope))) return { ok: false, reason: 'shape' }
+  // ¿ES UN PAPEL DEL MODELO VIEJO? Llevaba `exp` y no `seq` (ver `LEGACY_CERTS_UNTIL`).
+  const legado = typeof seq !== 'number'
+  if (legado && typeof cert.exp !== 'number') return { ok: false, reason: 'shape' }
   if (!(await rawVerify(iss, enc(canonicalStringify(delegationBody(cert))), sig))) return { ok: false, reason: 'bad-signature' }
   // EL ACTA MANDA, Y NO HAY RELOJ (dueño, 2026-08-31). El papel no vence: dice «una
   // selladora de este perfil, mirando el acta nº `seq`, avaló esta llave». Lo que puede
@@ -257,7 +266,19 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
   // estaba apagado: vuelve, su papel ya no vale, y renovarlo exige una selladora ABIERTA.
   // O sea que un cambio de acta te obligaría a abrir la bóveda para que tus aparatos
   // volvieran — justo lo que se acaba de quitar de en medio.
-  if (seq > actaSeq) return { ok: false, reason: 'acta-vieja' }
+  if (!legado && seq > actaSeq) return { ok: false, reason: 'acta-vieja' }
+  // REPLIEGUE DE MIGRACIÓN, declarado y con fecha (ver `LEGACY_CERTS_UNTIL`). Un papel del
+  // modelo viejo se sigue aceptando, pero SOLO hasta su propio vencimiento: no se le regala
+  // ni un día. No hay nada que decidir sobre el acta que nombra, porque no nombra ninguna.
+  //
+  // Lo que NO se relaja, y es lo que hace que esto no sea un agujero: quien lo emitió tiene
+  // que poder sellar (abajo), y el mostrador cruza igual con el acta (`memberCanScope`). Un
+  // papel viejo no autoriza nada que el acta de hoy no autorice; lo único que compra es
+  // seguir hablando mientras su máquina se actualiza.
+  if (legado) {
+    if (Date.now() > cert.exp) return { ok: false, reason: 'expired' }
+    if (Date.now() > LEGACY_CERTS_UNTIL) return { ok: false, reason: 'legacy-cert-retirado' }
+  }
   // Y QUIEN LO EMITIÓ TIENE QUE PODER SELLAR. No se compara contra «la maestra»: cualquiera
   // que el acta nombre sellador emite papeles válidos — si no, la segunda bóveda podría
   // invalidar todos los certificados al sellar y luego no poder dar los nuevos.
@@ -269,7 +290,7 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
       : (revoked instanceof Set ? revoked.has(nonce) : !!revoked[nonce])
     if (isRev) return { ok: false, reason: 'revoked' }
   }
-  return { ok: true, iss, sub, scope, iat, seq, nonce }
+  return { ok: true, iss, sub, scope, iat, seq: legado ? null : seq, nonce, legacy: legado || undefined }
 }
 
 /**