@dotrino/identity 0.37.0 → 0.38.0

package/vault/vendor/vault/index.js

@@ -27,16 +27,13 @@
  */
 import { verifyChain } 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.
+import { MSG, SCOPE } from './protocol.js'
 
-const SIGN_SCOPE = 'vault:sign'
+const SIGN_SCOPE = SCOPE.SIGN
 const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
-
-const MSG = {
-  ENROLL: 'vault.enroll',
-  DEVICES: 'vault.devices',
-  DEVICES_RESULT: 'vault.devices.result',
-  ERROR: 'vault.error'
-}
+const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
 
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
 export { deviceIdOf }
@@ -49,10 +46,11 @@ export { deviceIdOf }
  *   `me.publickey`, `signData`, `signDelegation`, `listDelegations`, `revokeDelegation`.
  * @param {object} [opts]
  * @param {string} [opts.proxyUrl='wss://proxy.dotrino.com']
- * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, approve, reject,
- *   listPending, listMachines, revoke, getSelfCert, onPendingChange, close }
+ * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, stopPairing,
+ *   approve, reject, listPending, listMachines, revoke, getSelfCert, onPendingChange,
+ *   onAdopted, close }
  */
-export async function startDeviceVault (identity, { proxyUrl } = {}) {
+export async function startDeviceVault (identity, { proxyUrl, client: injectedClient } = {}) {
   const iss = identity.me?.publickey
   if (!iss) throw new Error('sin identidad: crea/desbloquea tu identidad antes de usar el dispositivo como bóveda')
   const proxy = proxyUrl || 'wss://proxy.dotrino.com'
@@ -67,12 +65,17 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     return cert
   }
 
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({
-    url: proxy, enableWebRTC: false, autoReconnect: true,
-    maxReconnectAttempts: 100000, reconnectDelay: 4000
-  })
-  await client.connect()
+  // `client` inyectado: solo para las pruebas (transporte de mentira). En producción se
+  // levanta el del ecosistema — no hay otro transporte.
+  const client = injectedClient || await (async () => {
+    const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+    const c = new WebSocketProxyClient({
+      url: proxy, enableWebRTC: false, autoReconnect: true,
+      maxReconnectAttempts: 100000, reconnectDelay: 4000
+    })
+    await c.connect()
+    return c
+  })()
 
   const selfCert = await getSelfCert()
   const identify = async () => {
@@ -87,6 +90,7 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
   const send = (to, obj) => { try { client.send(to, obj) } catch (_) {} }
 
   let _onPendingChange = () => {}
+  let _onAdopted = () => {}
 
   // ENROLL / aprobación / revocación: núcleo COMPARTIDO con el daemon del PC y con la
   // copia vendorizada del iframe (`lib/src/enroll.js`). Un solo sitio donde vive el
@@ -99,9 +103,49 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     sendByPubkey: (pub, obj) => { try { client.sendByPubkey(pub, obj) } catch (_) {} },
     defaultScope: [SIGN_SCOPE],
     defaultTtlMs: DEVICE_TTL_MS,
+    // Camino A (la cuenta del aparato pasa a vivir aquí): sin la llave de cifrado, esta
+    // bóveda entraría mandando una cuenta cuyo contenido no puede abrir.
+    encPub: identity.me?.encryptionPubkey || null,
+    vaultLabel: 'bóveda',
+    // Cita del proxio para la invitación corta (QR). Si el proxio es viejo y no las
+    // conoce, el desk se cae solo a la invitación larga.
+    connToken: async () => {
+      try { return (await client.requestPairingCode())?.code || null }
+      catch (_) { return null }
+    },
+    onAdopted: (info) => { try { _onAdopted(info) } catch (_) {} },
     onPendingChange: () => _onPendingChange()
   })
 
+  /** Nonces revocados, para que un cert revocado no pase ningún `verifyChain`. */
+  async function revocationSet () {
+    const { revoked } = await identity.listDelegations()
+    return new Set((revoked || []).map((r) => r.nonce || r))
+  }
+
+  /**
+   * RENOVACIÓN automática (igual que `dotrino-vault#handleRenew`): un dispositivo con
+   * cert VIGENTE y no revocado pide uno fresco —misma sub-clave y scope— sin QR ni
+   * aprobación: sigue siendo el mismo dispositivo, solo extiende la ventana. Un cert
+   * vencido o revocado NO se renueva (ahí toca re-emparejar con aprobación).
+   *
+   * Sin esto, toda máquina enrolada contra un dispositivo-bóveda caduca a los 30 días.
+   */
+  async function handleRenew (from, p) {
+    const d = p?.data
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
+      return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
+    }
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss, revoked: await revocationSet() })
+    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+    // Reusar el label del cert original (si sigue registrado en delegations).
+    const { issued } = await identity.listDelegations()
+    const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
+    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
+    send(from, { type: MSG.RENEWED, cert })
+  }
+
   // Consulta de revocaciones (igual que `vault.devices` del daemon): responde la lista
   // de dispositivos enrolados + revocados para que el dispositivo refresque su set. Y si
   // QUIEN consulta es una máquina ya revocada (reapareció), le re-emite el REVOKED firmado.
@@ -124,7 +168,12 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
 
   client.on('message', (_from, p) => {
     if (!p || typeof p !== 'object') return
-    if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    // 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(() => {})
+    // 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(() => {})
   })
 
@@ -148,6 +197,7 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
   return {
     iss, proxy, client,
     startPairing: desk.startPairing,
+    stopPairing: desk.stopPairing,
     // Aprueba TIPEANDO el código que muestra la máquina: el núcleo compartido recompone
     // el compromiso `SHA-256(code‖dpub‖sn)` y solo firma el cert si coincide.
     approve: (deviceId, code) => desk.approve(code, { deviceId }),
@@ -159,6 +209,8 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },
+    /** Camino A: la cuenta del aparato quedó adoptada por esta bóveda. */
+    onAdopted (fn) { _onAdopted = fn || (() => {}) },
     close () { try { client.close() } catch (_) {} }
   }
 }

package/vault/vendor/vault/protocol.js

@@ -0,0 +1,93 @@
+/**
+ * Protocolo de mensajes entre un dispositivo y el vault (viajan por el proxy,
+ * direccionados por pubkey con `sendByPubkey`). El cuerpo va JSON-serializado en
+ * el campo `message` del sobre del proxy; el cliente lo entrega ya parseado.
+ *
+ * Emparejamiento ENDURECIDO (ver dotrino-vault/docs/pairing-protocol.md):
+ *   1. dispositivo → vault   ENROLL { data:{op,dpub,token,sn,label,ts}, signature }
+ *      (la firma es del dispositivo con su llave D = PRUEBA DE POSESION; un token
+ *       robado ya NO basta para enrolar).
+ *   2. vault → dispositivo   ENROLL_CHALLENGE { deviceId, sas }   (aun NO firma cert)
+ *   3. el dueño compara el SAS (pantalla del dispositivo ↔ del PC) y APRUEBA en el PC
+ *   4. vault → dispositivo   ENROLLED { cert, iss, sas }   (recien aqui firma el cert)
+ *   5. el dispositivo VALIDA la cadena: cert.iss === el iss que vio, cert.sub === D.
+ *
+ * Revocacion (robo): el vault envia REVOKED { body, signature } FIRMADO por la
+ * maestra → el dispositivo se autoborra SOLO si la firma valida contra la maestra
+ * pineada (cierra el wipe-DoS; un ERROR plano jamas borra).
+ */
+export const MSG = Object.freeze({
+  // La invitación corta no lleva la llave: el aparato la pide presentando el `sn` de
+  // la sesión. Una pública es pública — esto no la esconde, solo evita abrirle la
+  // puerta a quien acertó el token de conexión a ciegas.
+  HELLO: 'vault.hello',                       // dispositivo → vault: { sn }
+  HELLO_OK: 'vault.hello.ok',                 // vault → dispositivo: { iss, acct }
+  ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
+  ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
+  ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
+  REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
+  SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
+  SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }
+  GET: 'vault.get',                           // dispositivo → vault: { data, signature, cert }
+  DATA: 'vault.data',                         // vault → dispositivo: { id, node }
+  STORE: 'vault.store',                       // dispositivo → vault: { data:{method,args,publickey,ts}, signature, cert }
+  STORE_RESULT: 'vault.store.result',         // vault → dispositivo: { method, result }
+  DEVICES: 'vault.devices',                   // dispositivo → vault: { data:{publickey,ts}, signature, cert }
+  DEVICES_RESULT: 'vault.devices.result',     // vault → dispositivo: { devices, revoked }
+  RENEW: 'vault.renew',                       // dispositivo → vault: { data:{op,publickey,ts}, signature, cert }
+  RENEWED: 'vault.renewed',                   // vault → dispositivo: { cert }  (cert fresco, misma sub-clave/scope)
+  SECRETS: 'vault.secrets',                   // servicio → vault: { data:{op,ns,ek,publickey,ts}, signature, cert }
+  SECRETS_RESULT: 'vault.secrets.result',     // vault → servicio: { body:{op,ns,enc,ts}, signature } (enc SELLADO a ek; body firmado por la maestra)
+  // AVISO DE CAMBIO (no lleva valores): la bóveda dice «la configuración del ns
+  // cambió». El agente no la recarga en caliente — SALE limpio y su supervisor lo
+  // levanta. Dos razones, y la segunda es la de peso:
+  //   · Lee todo fresco. Recargar en caliente exige que cada sitio que leyó una
+  //     variable sepa releerla, y esa lista hay que mantenerla para siempre.
+  //   · BORRA DE MEMORIA EL VALOR VIEJO. En JavaScript un secreto no se puede
+  //     borrar: los strings son inmutables, no hay zeroize, y el valor queda en el
+  //     heap hasta que al recolector le apetezca — más lo que capturó cada closure
+  //     y cada caché derivada. Una llave se rota casi siempre PORQUE SE FILTRÓ, así
+  //     que dejarla viva en el proceso anula la razón de rotarla. Un proceso nuevo
+  //     empieza con el heap limpio.
+  // 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 }
+  // --- 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
+  // NO se exponen aquí, y no es un olvido — es el límite (§2 del diseño).
+  ADMIN: 'vault.admin',                       // admin → vault: { data:{op,…,ts,nonce}, signature, cert }
+  ADMIN_RESULT: 'vault.admin.result',         // vault → admin: { op, result }
+  // Aviso a TODOS los miembros de que el perfil cambió (alguien entró o salió). Es la
+  // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
+  // invisible para el resto de tus dispositivos.
+  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  ERROR: 'vault.error'                        // vault → dispositivo: { error }
+})
+
+/** Capacidades que puede llevar un `cert` (scope). Mínimo por defecto. */
+export const SCOPE = Object.freeze({
+  SIGN: 'vault:sign',   // pedir a la maestra que firme datos (identidad)
+  READ: 'vault:read',   // leer nodos del árbol de contenidos
+  STORE: 'vault:store', // leer/escribir el store de hilos + aperturas del usuario
+  // Consola remota (docs/consola-remota.md): admitir y expulsar miembros a distancia.
+  // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
+  // de master y sigue siendo local. No se empareja — se concede desde el PC.
+  ADMIN: 'vault:admin'
+})
+
+/**
+ * Scope de SECRETOS por namespace de servicio: un cert con `vault:secrets:proxy`
+ * solo puede leer los secretos del ns `proxy` — un VPS comprometido no puede
+ * pedir los de otro servicio. ns válido: [a-z0-9-]{1,32}.
+ */
+export const SECRETS_SCOPE_PREFIX = 'vault:secrets:'
+export const secretsScope = (ns) => SECRETS_SCOPE_PREFIX + ns
+export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,32}$/.test(ns)