@dotrino/identity 0.28.0 → 0.30.0

package/package.json

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

@@ -32,10 +32,37 @@ import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
 export const ACTA_V = 1
 
-/** Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master. */
-export const CAPS = Object.freeze(['sign', 'store', 'read'])
+/**
+ * Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master.
+ *
+ * `secrets` es distinta de las otras tres: solo la pueden tener los miembros con **CN**
+ * (los servicios), y lo que abre es únicamente el cajón de SU nombre. Ver `cn` abajo.
+ */
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets'])
+
+/** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read'])
+
+/** Capacidades de un SERVICIO (con CN): solo su propio cajón de secretos. */
+export const SERVICE_CAPS = Object.freeze(['secrets'])
+
+/** Un CN válido: minúsculas, números y guiones (igual que el namespace de secretos). */
+export const isValidCn = (cn) => typeof cn === 'string' && /^[a-z0-9-]{1,32}$/.test(cn)
+
+/**
+ * Scope del cert que corresponde a cada capacidad. `secrets` necesita el CN para
+ * completarse: el miembro `proxy` obtiene `vault:secrets:proxy` y nada más — no existe un
+ * scope de secretos «de todos».
+ */
+export function capScope (cap, cn = null) {
+  if (cap === 'sign') return 'vault:sign'
+  if (cap === 'store') return 'vault:store'
+  if (cap === 'read') return 'vault:read'
+  if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
+  return null
+}
 
-/** Cada capacidad es uno de los scopes que ya existen en los certs (sin scopes nuevos). */
+/** Compat: el mapa directo, para las tres capacidades de dispositivo. */
 export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read' })
 
 const enc = (s) => new TextEncoder().encode(s)
@@ -77,7 +104,7 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     sealedBy: pub,
     seq: 1,
     prev: null,
-    members: [{ pub, encPub, label: String(label || '').slice(0, 60), caps: [...CAPS], addedAt: now, cert: null }],
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...DEVICE_CAPS], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
@@ -98,6 +125,15 @@ export function checkShape (acta) {
   for (const m of acta.members) {
     if (!isPub(m?.pub) || !Array.isArray(m?.caps)) return 'member'
     if (m.caps.some((c) => !CAPS.includes(c))) return 'cap-desconocida'
+    // El CN es la frontera: un SERVICIO solo puede abrir su propio cajón, y un
+    // DISPOSITIVO no tiene cajón que abrir. Que no se pueda escribir un acta que
+    // mezcle las dos cosas es lo que hace que el límite sea real y no una costumbre.
+    if (m.cn != null) {
+      if (!isValidCn(m.cn)) return 'cn-invalido'
+      if (m.caps.some((c) => !SERVICE_CAPS.includes(c))) return 'servicio-con-capacidades-de-dispositivo'
+    } else if (m.caps.includes('secrets')) {
+      return 'secretos-sin-cn'
+    }
   }
   if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
   if (!acta.members.some((m) => m.pub === acta.sealer)) return 'sealer-no-es-miembro'
@@ -166,11 +202,15 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         const m = ch.member
         if (!isPub(m?.pub)) throw new Error('admit: falta la pubkey del miembro')
         if (find(m.pub)) throw new Error('admit: ese miembro ya está en el acta')
+        const cn = m.cn != null ? String(m.cn) : null
+        if (cn !== null && !isValidCn(cn)) throw new Error('admit: CN inválido (minúsculas, números y guiones)')
         next.members.push({
           pub: m.pub,
           encPub: m.encPub || null,
           label: String(m.label || '').slice(0, 60),
-          caps: cleanCaps(m.caps),
+          cn,
+          // Un servicio (con CN) solo puede tener `secrets`; un dispositivo, las otras tres.
+          caps: cleanCaps(m.caps).filter((c) => (cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c)),
           addedAt: now,
           cert: m.cert || null,
           // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
@@ -181,7 +221,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       case 'caps': {
         const m = find(ch.pub)
         if (!m) throw new Error('caps: ese miembro no está en el acta')
-        m.caps = cleanCaps(ch.caps)
+        // No se puede ascender un servicio a dispositivo cambiándole las capacidades: para
+        // eso hay que sacarlo y volver a admitirlo, que es un gesto visible.
+        m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
         break
       }
       case 'remove': {
@@ -284,6 +326,26 @@ export function effectiveCaps (acta, pub, extraRenounces = []) {
   return m.caps.filter((c) => !quitadas.has(c))
 }
 
+/**
+ * ¿Puede este miembro leer el cajón de secretos `ns`? Solo si su CN es exactamente ése.
+ * Es la frontera que pediste: la llave del proxy no ve nada más que lo del proxy.
+ */
+export function memberCanReadSecrets (acta, pub, ns) {
+  const m = (acta?.members || []).find((x) => x.pub === pub)
+  if (!m || !m.cn) return false
+  return m.cn === ns && effectiveCaps(acta, pub).includes('secrets')
+}
+
+/** Los scopes de cert que le corresponden a un miembro según el acta. */
+export function memberScopes (acta, pub, extraRenounces = []) {
+  const m = (acta?.members || []).find((x) => x.pub === pub)
+  if (!m) return []
+  return effectiveCaps(acta, pub, extraRenounces).map((c) => capScope(c, m.cn)).filter(Boolean)
+}
+
+/** ¿Es un servicio (tiene CN) o un dispositivo del usuario? */
+export const isService = (acta, pub) => !!(acta?.members || []).find((x) => x.pub === pub)?.cn
+
 /** ¿Puede este miembro hacer `cap` según el acta? (con el cert se cruza aparte: cert ∩ acta). */
 export function memberCan (acta, pub, cap, extraRenounces = []) {
   return effectiveCaps(acta, pub, extraRenounces).includes(cap)
@@ -362,5 +424,5 @@ export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
-  effectiveCaps, memberCan, canAdopt
+  effectiveCaps, memberCan, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
 }

package/vault/core.js

@@ -32,6 +32,7 @@ export const REVOCATIONS_STORAGE = 'dotrino.identity.revocations'   // nonces re
 export const VAULT_DEVICE_STORAGE = 'dotrino.identity.vault.device' // sub-clave D de ESTE dispositivo (custodia en el iframe)
 export const VAULT_CERT_STORAGE = 'dotrino.identity.vault.cert'     // { cert, master, proxy, deviceId, pairedAt }
 export const ACTA_STORAGE = 'dotrino.identity.acta'                 // acta de perfil vigente (quién es del perfil y qué puede)
+export const ACTA_HISTORY_STORAGE = 'dotrino.identity.acta.history' // últimas actas selladas (§1.3)
 export const RENOUNCE_STORAGE = 'dotrino.identity.renounced'        // renuncias propias aún no absorbidas por el master
 // Multi-perfil por dispositivo: lista de perfiles + el activo. Cada perfil tiene su propio
 // namespace `dotrino.identity.p.<id>.<suffix>` para TODAS las claves de arriba (keypair, me, etc.).
@@ -345,6 +346,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // `acta.js`, que es puro y está probado aparte.
   const loadActa = () => { try { return JSON.parse(kv.getItem(ACTA_STORAGE) || 'null') } catch (_) { return null } }
   const saveActa = (a) => kv.setItem(ACTA_STORAGE, JSON.stringify(a))
+  // VENTANA DE RETENCIÓN (§1.3): el master conserva las últimas actas para que un miembro
+  // que estuvo apagado pueda comprobar el encadenamiento al volver. Un tercero no las
+  // necesita —le basta el snapshot actual—, pero entre miembros hay que poder verificar
+  // que la nueva desciende de la que uno tenía. Más viejo que la ventana ⇒ re-admitirse.
+  const ACTA_WINDOW = 50
+  const loadHistory = () => { try { return JSON.parse(kv.getItem(ACTA_HISTORY_STORAGE) || '[]') || [] } catch (_) { return [] } }
+  const pushHistory = (acta) => {
+    if (!acta) return
+    const h = loadHistory().filter((a) => a.seq !== acta.seq)
+    h.push(acta)
+    h.sort((a, b) => a.seq - b.seq)
+    kv.setItem(ACTA_HISTORY_STORAGE, JSON.stringify(h.slice(-ACTA_WINDOW)))
+  }
+
   const loadRenounces = () => { try { return JSON.parse(kv.getItem(RENOUNCE_STORAGE) || '[]') || [] } catch (_) { return [] } }
   const saveRenounces = (l) => kv.setItem(RENOUNCE_STORAGE, JSON.stringify(l))
 
@@ -363,6 +378,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     if (!acta) throw new Error('este perfil todavía no tiene acta')
     const next = await Acta.applyChanges(acta, changes, { by: publickeyJwkStr })
     const sealed = await seal(next)
+    pushHistory(acta) // la que deja de ser vigente entra en la ventana de retención
     saveActa(sealed)
     emitVault({ phase: 'acta', seq: sealed.seq, sealer: sealed.sealer })
     return sealed
@@ -447,6 +463,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    * Adopta un acta que llega de otro miembro, si gana según §2.4.1 (seq mayor que encadene,
    * o el traspaso a igual seq). Nunca retrocede.
    */
+  /**
+   * Adopta una CADENA de actas, una a una. Es lo que permite ponerse al día tras estar
+   * apagado sin bajar la guardia: cada eslabón se comprueba contra el anterior en vez de
+   * aceptar un salto a ciegas.
+   */
+  async function adoptChain (chain) {
+    let last = null
+    for (const a of [...(chain || [])].sort((x, y) => x.seq - y.seq)) {
+      const r = await adoptActa(a)
+      if (r.adopted) last = r
+    }
+    return last || { adopted: false, reason: 'nada-que-adoptar', seq: loadActa()?.seq ?? null }
+  }
+
   async function adoptActa (candidate) {
     const current = loadActa()
     const r = await Acta.canAdopt({ candidate, current })
@@ -1041,6 +1071,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         pub: m.pub,
         id: await Acta.memberId(m.pub),
         label: m.label || '',
+        cn: m.cn || null,
+        isService: !!m.cn,
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
         isMe: m.pub === publickeyJwkStr,
@@ -1069,8 +1101,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * Admite un miembro (solo el master). El cert lo emite quien llama, antes o después.
      * `continuity`: si esa identidad ya existía por su cuenta, su puente firmado (F3).
      */
-    async admitMember ({ pub, encPub = null, label = '', caps = ['store', 'read'], cert = null, continuity = null } = {}) {
-      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, caps, cert, continuity } }])
+    async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null } = {}) {
+      // `cn`: si viene, este miembro es un SERVICIO y su único permiso es abrir el cajón de
+      // secretos de ESE nombre — no ve nada más del usuario. Sin `cn` es un dispositivo.
+      const finales = caps || (cn ? ['secrets'] : ['store', 'read'])
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }])
       // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
       // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
       let wrapped = false
@@ -1162,9 +1197,23 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, ...r }
     },
 
+    /**
+     * Las actas que este master conserva desde `sinceSeq` (sin incluirla), para que un
+     * miembro que volvió pueda comprobar el encadenamiento. Vacío si se salió de la ventana.
+     */
+    async actaHistory ({ sinceSeq = 0 } = {}) {
+      const cur = loadActa()
+      const hist = loadHistory().filter((a) => a.seq > sinceSeq)
+      const all = cur && cur.seq > sinceSeq ? [...hist, cur] : hist
+      return { chain: all.sort((a, b) => a.seq - b.seq), window: ACTA_WINDOW }
+    },
+
     /** Adopta un acta que llega de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
     async adoptActa ({ acta } = {}) { return adoptActa(acta) },
 
+    /** Adopta una cadena completa (para ponerse al día tras estar apagado). */
+    async adoptActaChain ({ chain } = {}) { return adoptChain(chain) },
+
     /** Une este dispositivo al perfil de otra bóveda (solo si aquí no hay nada que perder). */
     async joinProfile ({ acta } = {}) { return joinProfile(acta) },
 
@@ -1253,9 +1302,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
       try {
-        const res = await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink })
+        const res = await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, sinceSeq: loadActa()?.seq ?? 0, onRevoked: wipeVaultLink })
         // El acta viaja con la lista: así los cambios de política llegan sin canal aparte.
-        if (res.acta) { try { await (res.acta.profileId === loadActa()?.profileId ? adoptActa(res.acta) : joinProfile(res.acta)) } catch (_) {} }
+        // Si estuve apagado, viene la CADENA y se adopta eslabón a eslabón (§1.3).
+        try {
+          if (res.chain?.length && res.chain[0].profileId === loadActa()?.profileId) await adoptChain(res.chain)
+          else if (res.acta) await (res.acta.profileId === loadActa()?.profileId ? adoptActa(res.acta) : joinProfile(res.acta))
+        } catch (_) {}
         return res
       } catch (e) { return handleVaultError(e) }
     },

package/vault/remote.js

@@ -166,9 +166,10 @@ export async function requestStore ({ master, proxy, device, cert, method, args,
 }
 
 /** Lista (solo lectura) los dispositivos enrolados en tu vault. */
-export async function requestDevices ({ master, proxy, device, cert, onRevoked } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
-  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null }
+export async function requestDevices ({ master, proxy, device, cert, sinceSeq, onRevoked } = {}) {
+  const data = typeof sinceSeq === 'number' ? { op: 'devices', sinceSeq } : { op: 'devices' }
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.devices', okType: 'vault.devices.result', data })
+  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null, chain: res.chain || null }
 }
 
 /**

package/vault/vendor/vault/enroll.js

@@ -50,6 +50,19 @@ const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 
+/**
+ * El CN de un servicio sale de su scope: `vault:secrets:proxy` ⇒ CN `proxy`. Con CN, el
+ * miembro entra al acta como SERVICIO —solo abre su propio cajón— en vez de como un
+ * dispositivo del usuario. Es la frontera, y vive en el acta para que se pueda comprobar.
+ */
+export function scopeToCn (scope) {
+  for (const s of (Array.isArray(scope) ? scope : [scope])) {
+    const m = /^vault:secrets:([a-z0-9-]{1,32})$/.exec(String(s || ''))
+    if (m) return m[1]
+  }
+  return null
+}
+
 /** Token aleatorio de 128 bits en hex. */
 export function randToken () {
   const b = crypto.getRandomValues(new Uint8Array(16))
@@ -215,8 +228,9 @@ export function createEnrollDesk ({
     let acta = null
     try {
       if (typeof identity.admitMember === 'function') {
-        const caps = scopeToCaps(pend.scope)
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', caps, cert, continuity: pend.continuity || null })
+        const cn = scopeToCn(pend.scope)
+        const caps = cn ? ['secrets'] : scopeToCaps(pend.scope)
+        if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
       }
       acta = (await identity.profileActa?.())?.acta || null
     } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }