@dotrino/identity 0.60.3 → 0.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.60.3",
+  "version": "0.62.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -55,12 +55,12 @@
     "type": "git",
     "url": "git+https://github.com/imdotrino/dotrino-identity.git"
   },
-  "dependencies": {
-    "@dotrino/proxy-client": "^0.11.0"
-  },
   "devDependencies": {
     "fake-indexeddb": "^6.2.5",
     "typescript": "5.9.3",
     "@types/node": "^22.0.0"
+  },
+  "peerDependencies": {
+    "@dotrino/proxy-client": ">=0.13.1"
   }
 }

package/vault/acta.js

@@ -53,15 +53,21 @@ const ACTA_LEIBLES = Object.freeze([1, 2])
  * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
  * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
  * `approve` es el aparato que APRUEBA: cuando un cajón exige aprobación por uso, el
  * vault le avisa y solo su firma libera los secretos (normalmente el teléfono). Como
  * `admin`, no viaja en un QR: se concede a mano (`dotrino-vault caps <ID> +approve`).
+ *
+ * `passwords` es el aparato que puede PEDIR CREDENCIALES de la bóveda de contraseñas
+ * (el gestor: la extensión del navegador, la app del teléfono). Pide de a una y por
+ * dominio; nunca lista la bóveda. Va aquí y no en una lista aparte porque quién puede
+ * pedirle algo a la bóveda es exactamente lo que decide el acta — tener dos registros
+ * de lo mismo obliga a acordarse de los dos al quitar un aparato.
  */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords'])
 
 /**
  * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se
@@ -93,12 +99,13 @@ export function capScope (cap, cn = null) {
   if (cap === 'read') return 'vault:read'
   if (cap === 'admin') return 'vault:admin'
   if (cap === 'approve') return 'vault:approve'
+  if (cap === 'passwords') return 'vault:passwords'
   if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
   return null
 }
 
 /** Compat: el mapa directo, para las capacidades de dispositivo. */
-export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve' })
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords' })
 
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')

package/vault/vault.js

@@ -105,6 +105,22 @@ import { pubkeyId } from './capabilities.js'
   // libera y otra pestaña visible lo toma. Así varias apps abiertas no compiten.
   const SELF_FLAG = 'dotrino.self-vault.enabled' // persistido en localStorage (kv)
   const SELF_LOCK = 'dotrino-self-vault'
+  /**
+   * Proxio del mostrador, SOLO en localhost (`?proxy=ws://…` en la URL de este iframe).
+   *
+   * En producción es el del ecosistema y no hay nada que elegir. Existe porque las
+   * pruebas de punta a punta levantan su propio proxio y prometen no tocar producción:
+   * sin esto, el mostrador de una bóveda-en-pestaña marcaba a `proxy.dotrino.com` desde
+   * el banco de pruebas. Es el mismo permiso que ya tiene `?vault=` en la consola.
+   */
+  const selfProxyUrl = (() => {
+    try {
+      const u = new URL(location.href)
+      if (!/^(localhost|127\.0\.0\.1|\[::1\])$/.test(u.hostname)) return null
+      const p = u.searchParams.get('proxy')
+      return /^wss?:\/\//.test(p || '') ? p : null
+    } catch (_) { return null }
+  })()
   let daemon = null           // handle de startDeviceVault cuando ESTE iframe es el activo
   let _lockResolver = null    // resolver del callback del lock (libera al resolverlo)
 
@@ -133,7 +149,7 @@ import { pubkeyId } from './capabilities.js'
       // Import dinámico: aísla fallos del vendor del arranque del vault (cargado por
       // todas las apps). El import map de index.html resuelve @dotrino/vault.
       const { startDeviceVault } = await import('@dotrino/vault')
-      daemon = await startDeviceVault(selfIdentity)
+      daemon = await startDeviceVault(selfIdentity, selfProxyUrl ? { proxyUrl: selfProxyUrl } : undefined)
       daemon.onPendingChange(() => broadcast('selfVault', { pending: daemon.listPending() }))
       broadcast('selfVault', { running: true })
     } catch (e) { daemon = null; broadcast('selfVault', { error: e?.message || String(e) }) }

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.24.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.34.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
 El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
 resuelve en el navegador sin bundler. index.js importa ./enroll.js y ./protocol.js
 (relativos, se vendorizan tambien) y @dotrino/identity/capabilities (=../../capabilities.js)

package/vault/vendor/vault/enroll.js

@@ -261,9 +261,15 @@ export function createEnrollDesk ({
     pend.dpub = d.dpub
     pend.deviceId = deviceId
     pend.commit = d.commit
-    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave de contenido del
-    // perfil al admitirlo. Sin ella entra, pero no podrá leer lo que haya guardado.
+    // Llave de CIFRADO del dispositivo: con ella se le envuelve la clave del cajón al
+    // admitirlo. Un SERVICIO sin ella entraría al acta y no podría leer NUNCA ninguna
+    // variable —las privadas van selladas a esta llave—, así que se corta aquí en vez
+    // de admitirlo y dejar que falle más tarde y en otro sitio. Un dispositivo de
+    // persona sí puede entrar sin ella: no lee variables de servicio.
     if (typeof d.encPub === 'string') pend.encPub = d.encPub
+    if (!pend.encPub && scopeToCn(pend.scope)) {
+      return reply(from, { type: MSG_ERROR, error: 'a service must send its encryption key (update @dotrino/vault on the service)' })
+    }
     // Certificado de continuidad (opcional): lo firma la identidad que se une, con su
     // propia llave. Se comprueba aquí y se guarda con el miembro al aprobar.
     if (d.continuity) {
@@ -335,8 +341,11 @@ export function createEnrollDesk ({
     let record = null
     try {
       if (typeof identity.admitMember === 'function') {
+        // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
+        // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
+        // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
         const cn = scopeToCn(pend.scope)
-        const caps = cn ? ['secrets'] : scopeToCaps(pend.scope)
+        const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
         if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
       }
       record = (await identity.profileActa?.())?.acta || null

package/vault/vendor/vault/index.js

@@ -25,10 +25,10 @@
  * (`identity.signDelegation`). Transporte: `@dotrino/proxy-client` (import perezoso).
  * No reimplementa nada del ecosistema.
  */
-import { verifyChain } from '@dotrino/identity/capabilities'
+import { verifyChain, verifyDeviceSig } from '@dotrino/identity/capabilities'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
-// local se queda corta, el dispositivo deja de atender mensajes sin que nadie lo note.
+// local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
@@ -168,15 +168,132 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (mine) desk.emitRevoke(chk.device, mine.nonce)
   }
 
+  /**
+   * Lo que el daemon comprueba antes de cualquier operación firmada, en un solo sitio:
+   * frescura (anti-replay), cadena de certs, scope esperado y revocaciones.
+   *
+   * Estaba repetido en `handleRenew` y `handleDevices` con matices distintos; al añadir
+   * el resto de operaciones eso habría sido cuatro copias divergiendo.
+   */
+  async function authorise (from, p, expectedScope) {
+    const d = p?.data
+    if (!d || !p.signature || !p.cert) {
+      send(from, { type: MSG.ERROR, error: 'invalid request' })
+      return null
+    }
+    if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
+      send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or a clock out of sync)' })
+      return null
+    }
+    const chk = await verifyChain({
+      data: d, signature: p.signature, cert: p.cert,
+      ...(expectedScope ? { expectedScope } : {}),
+      trustedIssuer: iss, revoked: await revocationSet(),
+    })
+    if (!chk.ok) {
+      send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+      return null
+    }
+    return chk
+  }
+
+  /**
+   * FIRMAR en name de la identidad. Es la razón de ser de una bóveda, y faltaba: un
+   * aparato enrolado contra este dispositivo podía renovar su cert y listar aparatos,
+   * pero no pedir la única cosa para la que se enroló.
+   */
+  async function handleSign (from, p) {
+    const chk = await authorise(from, p, SCOPE.SIGN)
+    if (!chk) return
+    const toSign = p.data?.payload
+    if (toSign == null) return send(from, { type: MSG.ERROR, error: 'data.payload required' })
+    const { signature, publickey } = await identity.signData(toSign)
+    send(from, { type: MSG.SIGNED, signature, publickey, device: chk.device })
+  }
+
+  /** Leer del almacén del perfil. Mismo scope que en el daemon: `read`. */
+  async function handleGet (from, p) {
+    const chk = await authorise(from, p, SCOPE.READ)
+    if (!chk) return
+    const id = p.data?.id || 'root'
+    try {
+      const node = await identity.getNode?.(id)
+      send(from, { type: MSG.DATA, id, node: node ?? null })
+    } catch (e) {
+      send(from, { type: MSG.ERROR, error: 'get: ' + e.message })
+    }
+  }
+
+  /**
+   * Escribir en el almacén. Se pasa por `vaultStore`, que es el mismo camino que usa
+   * un aparato contra el daemon — no se reimplementa el store aquí.
+   */
+  async function handleStore (from, p) {
+    const d = p?.data
+    if (!d || typeof d.method !== 'string') {
+      return send(from, { type: MSG.ERROR, error: 'store: invalid method' })
+    }
+    const chk = await authorise(from, p, SCOPE.STORE)
+    if (!chk) return
+    try {
+      const result = await identity.vaultStore?.(d.method, d.args || [])
+      send(from, { type: MSG.DATA, id: d.method, node: result ?? null })
+    } catch (e) {
+      send(from, { type: MSG.ERROR, error: 'store: ' + e.message })
+    }
+  }
+
+  /**
+   * ¿Sigue este aparato dentro del acta? Lo pregunta un aparato al arrancar, y por eso
+   * NO va firmado con cert: va firmado con su propia llave. Un aparato revocado tiene
+   * que poder enterarse de que lo está.
+   */
+  async function handleCheck (from, p) {
+    const d = p?.data
+    if (!d || typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
+    const pub = d.publickey
+    if (typeof pub !== 'string') return send(from, { type: MSG.ERROR, error: 'unauthorized: shape' })
+    if (!(await verifyDeviceSig({ publickey: pub, data: d, signature: p.signature }))) {
+      return send(from, { type: MSG.ERROR, error: 'unauthorized: bad-signature' })
+    }
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    const inside = (record?.members || []).some((m) => m?.pub === pub)
+    if (inside) return send(from, { type: MSG.CHECKED, in: true })
+
+    // Fuera del acta: se le dice, y además se le re-emite el aviso firmado si consta
+    // revocado — para que se apague solo en vez de quedarse creyendo que sigue dentro.
+    const { revokedCerts, issued } = await identity.listDelegations()
+    const mine = (revokedCerts || issued || []).find((x) => x.sub === pub && x.revokedAt)
+    if (mine) desk.emitRevoke(pub, mine.nonce)
+    send(from, { type: MSG.CHECKED, in: false })
+  }
+
+  /**
+   * Un fallo dentro de un handler NO se traga.
+   *
+   * El router llevaba `.catch(() => {})` en cada rama: si algo reventaba, el aparato del
+   * otro lado se quedaba esperando para siempre y aquí no quedaba rastro. Ahora se
+   * contesta el error — que es lo que permite depurarlo desde el lado que pregunta.
+   */
+  const handle = (name, promise, from) => Promise.resolve(promise).catch((e) => {
+    send(from, { type: MSG.ERROR, error: `${name}: ${e?.message || e}` })
+  })
+
   client.on('message', (_from, p) => {
     if (!p || typeof p !== 'object') return
     // El QR corto no lleva la llave: el aparato la pide con un HELLO presentando el `sn`.
-    if (p.type === MSG.HELLO) Promise.resolve(desk.handleHello(_from, p)).catch(() => {})
-    else if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    if (p.type === MSG.HELLO) handle('hello', desk.handleHello(_from, p), _from)
+    else if (p.type === MSG.ENROLL) handle('enroll', desk.handleEnroll(_from, p), _from)
     // Camino A: el aparato devuelve su acta sellada admitiendo a esta bóveda.
-    else if (p.type === MSG.ACTA_SEALED) Promise.resolve(desk.handleActaSealed(_from, p)).catch(() => {})
-    else if (p.type === MSG.RENEW) handleRenew(_from, p).catch(() => {})
-    else if (p.type === MSG.DEVICES) handleDevices(_from, p).catch(() => {})
+    else if (p.type === MSG.ACTA_SEALED) handle('acta', desk.handleActaSealed(_from, p), _from)
+    else if (p.type === MSG.RENEW) handle('renew', handleRenew(_from, p), _from)
+    else if (p.type === MSG.DEVICES) handle('devices', handleDevices(_from, p), _from)
+    // Lo que faltaba para que un aparato enrolado aquí pueda hacer lo mismo que contra
+    // el daemon del PC: firmar, leer, guardar y comprobar que sigue dentro.
+    else if (p.type === MSG.SIGN) handle('sign', handleSign(_from, p), _from)
+    else if (p.type === MSG.GET) handle('get', handleGet(_from, p), _from)
+    else if (p.type === MSG.STORE) handle('store', handleStore(_from, p), _from)
+    else if (p.type === MSG.CHECK) handle('check', handleCheck(_from, p), _from)
   })
 
   /**

package/vault/vendor/vault/protocol.js

@@ -66,6 +66,16 @@ export const MSG = Object.freeze({
   // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
   // aviso de reinicio sin autenticar ES un ataque de denegación.
   SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  // REPARTIR LA LLAVE DE UN CAJÓN A UN MIEMBRO NUEVO. Lo hace el SERVICIO y no la
+  // bóveda, porque la bóveda no puede abrir la llave sin la frase y el servicio ya la
+  // tiene: re-envolverla no le añade ningún poder. Ver `docs/secretos-sellados.md` §8.11.
+  //
+  // El servicio NO se fía de lo que le manden: comprueba la firma de la maestra, comprueba
+  // el ACTA que viene dentro (también firmada) y saca de ahí la llave pública del
+  // destinatario. Así, ni siquiera una bóveda comprometida puede hacerle envolver la
+  // llave para alguien que la maestra no haya metido en su propio cajón.
+  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, signature }
+  REWRAP_OK: 'vault.rewrap.ok',               // servicio → vault: { data:{op,owner,gen,target,wrap,ts}, signature, cert }
   // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
   // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
   // Admitir y expulsar, nada más: cambiar permisos, traspasar el mando y los secretos