@dotrino/identity 0.115.0 → 0.116.0

package/vault/vendor/vault/enroll.js

@@ -31,6 +31,7 @@
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
 import { verifyContinuity, canSeal, DEVICE_CAPS, VAULT_CN } from '@dotrino/identity/acta'
+import { cleanMachine } from '@dotrino/identity/machine'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -113,7 +114,7 @@ export async function deviceIdOf (pub) {
  * @param {(pub:string, obj:object)=>void} opts.sendByPubkey   dirigir por pubkey (cola offline 24 h).
  * @param {(op:string, info?:object)=>void} [opts.audit]
  * @param {(...a:any[])=>void} [opts.log]
- * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
+ * @param {(c:{deviceId:string, scope:any, label:string, machine?:any, mode?:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
  * @param {()=>void} [opts.onPendingChange]
  * @param {(sub:string)=>void} [opts.onDeviceRemoved]  se quitó un aparato (fuera del acta y sin papeles):
  *   para que quien guarde algo indexado por esa llave lo suelte. Se avisa desde AQUÍ y no desde
@@ -210,7 +211,7 @@ export function createEnrollDesk ({
   function listPending () {
     return [...pending.values()]
       .filter((p) => p.state === 'PENDING_CONFIRM')
-      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope }))
+      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope, machine: p.machine || null }))
   }
 
   function findPending (deviceId) {
@@ -314,12 +315,15 @@ export function createEnrollDesk ({
     // cuál era cuál. Si en `pair` le diste un nombre, ese es el nombre; el del aparato
     // sigue valiendo como propuesta cuando no dijiste nada.
     if (d.label && !pend.label) pend.label = String(d.label).slice(0, 60)
+    // DÓNDE CORRE (`@dotrino/identity/machine`): entra al acta con el aparato, para que la
+    // lista lo distinga de los demás aunque todos se llamen igual.
+    pend.machine = cleanMachine(d.machine)
     // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
     // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
     if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', machine: pend.machine || null, mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -396,7 +400,7 @@ export function createEnrollDesk ({
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     try {
-      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null, machine: pend.machine || null })
     } catch (e) {
       // El certificado ya está firmado y no se entrega: se revoca, para que no quede uno
       // válido suelto. Si ni eso sale, se dice también.

package/vault/vendor/vault/procContext.js

@@ -0,0 +1,97 @@
+/**
+ * LA PARTE PORTABLE DE `proc.js`: limpiar el contexto que declara quien pide, su huella y su
+ * línea. La usan el binario y la bóveda del navegador (que no tiene `/proc` y nunca mide,
+ * así que todo lo que le llega se queda como declarado). Leer `/proc` sigue en `proc.js`,
+ * que es solo de Node.
+ */
+import { sha256Hex } from './core/sha256.js'
+
+/** Topes. Un `argv` puede ser enorme y esto viaja en cada pedido y se pinta en un teléfono. */
+export const MAX_ARGV_BYTES = 4096
+export const MAX_PATH_BYTES = 1024
+/** Cuántos argumentos como mucho: más que esto no lo lee nadie. */
+export const MAX_ARGV_ITEMS = 64
+
+const enc = new TextEncoder()
+const byteLength = (s) => enc.encode(s).length
+export const clip = (s, max) => {
+  if (typeof s !== 'string') return ''
+  const b = enc.encode(s)
+  return b.length <= max ? s : new TextDecoder().decode(b.subarray(0, max))
+}
+
+/**
+ * Recorta el `argv` a lo que se puede enseñar y transportar. Devuelve también si sobró
+ * algo: un comando cortado que no dice que está cortado se lee como otro comando.
+ */
+export function trimArgv (argv) {
+  const list = (Array.isArray(argv) ? argv : []).map((a) => String(a))
+  let cut = list.length > MAX_ARGV_ITEMS
+  const kept = list.slice(0, MAX_ARGV_ITEMS)
+  let total = 0
+  const out = []
+  for (const a of kept) {
+    const b = byteLength(a)
+    if (total + b > MAX_ARGV_BYTES) { cut = true; break }
+    total += b
+    out.push(a)
+  }
+  return { argv: out, truncated: cut }
+}
+
+/**
+ * LO QUE LLEGA POR LA RED NO SE CREE NI EN LA FORMA. Este dato lo manda otro proceso, se
+ * guarda en memoria y se pinta en un teléfono: se recorta a lo que cabe y se tira lo que no
+ * tiene el tipo que debería. Devuelve `null` si no queda nada que enseñar — que no es lo
+ * mismo que un contexto vacío, y por eso no se devuelve un objeto a medias.
+ */
+export function sanitizeContext (raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const argvRaw = Array.isArray(raw.argv) ? raw.argv.filter((a) => typeof a === 'string') : []
+  const { argv, truncated } = trimArgv(argvRaw)
+  const exe = clip(typeof raw.exe === 'string' ? raw.exe : '', MAX_PATH_BYTES)
+  const cwd = clip(typeof raw.cwd === 'string' ? raw.cwd : '', MAX_PATH_BYTES)
+  if (!exe && !argv.length) return null
+  return {
+    pid: Number.isInteger(raw.pid) && raw.pid > 0 ? raw.pid : null,
+    uid: Number.isInteger(raw.uid) ? raw.uid : null,
+    exe,
+    cwd,
+    argv,
+    truncated: truncated || raw.truncated === true,
+    start: Number.isFinite(raw.start) ? raw.start : null,
+    user: clip(typeof raw.user === 'string' ? raw.user : '', 64),
+    host: clip(typeof raw.host === 'string' ? raw.host : '', 64)
+  }
+}
+
+/**
+ * LA HUELLA DEL COMANDO: qué binario, desde qué carpeta y con qué argumentos. Es la llave
+ * de la concesión por tiempo — aprobar `node server.js` en `/srv/app` no aprueba otra cosa
+ * ni la misma cosa en otro sitio.
+ *
+ * El pid NO entra: cambia en cada arranque y la gracia es justamente que el mismo comando
+ * se reconozca la próxima vez.
+ */
+export function commandFingerprint (ctx) {
+  if (!ctx || typeof ctx !== 'object') return null
+  const argv = Array.isArray(ctx.argv) ? ctx.argv : []
+  if (!ctx.exe && !argv.length) return null
+  const material = [ctx.exe || '', ctx.cwd || '', ...argv].join('\0')
+  return sha256Hex(material)
+}
+
+/** ¿Son el mismo comando? Mismo binario, misma carpeta, mismos argumentos. */
+export const sameCommand = (a, b) => {
+  const fa = commandFingerprint(a)
+  return !!fa && fa === commandFingerprint(b)
+}
+
+/** El comando en una línea, para un log o una pantalla estrecha. */
+export function commandLine (ctx, max = 160) {
+  const argv = Array.isArray(ctx?.argv) ? ctx.argv : []
+  const linea = argv.length ? argv.join(' ') : (ctx?.exe || '')
+  return linea.length > max ? linea.slice(0, max - 1) + '…' : linea
+}
+
+export default { sanitizeContext, commandFingerprint, sameCommand, commandLine, trimArgv }

package/vault/vendor/vault/revocation.js

@@ -0,0 +1,67 @@
+/**
+ * revocation.js — CUÁNDO se le dice a un aparato que ya no es de casa.
+ *
+ * Módulo PURO (sin red, sin disco, sin `node:*`), como `enroll.js` y `admin.js`: la regla
+ * vive en un solo sitio, se lee entera y se prueba sin levantar nada.
+ *
+ * EL PROBLEMA QUE RESUELVE. Un dispositivo al que quitaron del perfil no se entera por su
+ * cuenta: lo único que le borra la cuenta es un aviso FIRMADO por la maestra
+ * (`vault.revoked`). Un «unauthorized» suelto no vale y no debe valer — no va firmado, así
+ * que cualquiera podría destruir datos ajenos con un mensaje (el wipe-DoS de
+ * `docs/pairing-protocol.md §2.3`). Por eso la bóveda tiene que **atender** la conexión de
+ * un aparato que fue suyo, aunque su papel ya no sirva, precisamente para poder mandarlo a
+ * paseo. Si no lo hace, el aparato se queda enseñando una cuenta que ya no existe.
+ *
+ * LA REGLA, en una línea: papel nuestro + ya no está en el acta ⇒ se le avisa.
+ */
+
+/**
+ * Motivos de rechazo de `verifyChain` que significan «este papel ya no sirve».
+ *
+ * Los tres se producen DESPUÉS de que `verifyChain` haya comprobado la firma del propio
+ * aparato y la del certificado, así que quien llega hasta aquí demostró tener la llave que
+ * el certificado nombra. El resto de motivos (`shape`, `bad-signature`,
+ * `bad-action-signature`, `cert-device-mismatch`, `untrusted-issuer`…) son ruido o gente
+ * ajena: ahí no hay a quién avisar de nada.
+ */
+export const STALE_PAPER = Object.freeze(['revoked', 'expired', 'scope'])
+const STALE = new Set(STALE_PAPER)
+
+/** ¿El motivo del rechazo es «tu papel ya no sirve»? */
+export const isStalePaper = (reason) => STALE.has(reason)
+
+/**
+ * ¿Hay que mandarle el aviso firmado de expulsión?
+ *
+ * @param {Object} o
+ * @param {string} o.reason      por qué falló `verifyChain`.
+ * @param {string} o.pubkey      la llave del aparato que acaba de escribir.
+ * @param {string} o.master      la maestra de ESTA bóveda.
+ * @param {string|null} [o.certIss]  quién firmó el certificado que presentó.
+ * @param {Array<{pub:string}>|null} [o.members]  miembros del acta; `null` = no hay acta.
+ * @param {boolean} [o.knownRevoked]  consta explícitamente como revocado en las
+ *   delegaciones. Es el único criterio que queda cuando no hay acta.
+ * @returns {boolean}
+ */
+export function shouldNotifyRevoked ({ reason, pubkey, master, certIss = null, members = null, knownRevoked = false } = {}) {
+  if (typeof pubkey !== 'string' || !pubkey) return false
+  if (!isStalePaper(reason)) return false
+  // Que el papel sea NUESTRO. No hace falta que siga siendo válido —justo por eso estamos
+  // aquí— pero sí que lo haya firmado esta maestra: es lo que separa a un aparato que fue
+  // de casa de uno que pasaba por ahí.
+  if (certIss && master && certIss !== master) return false
+  // El aparato no puede echarse a sí mismo, y la maestra tampoco se echa.
+  if (master && pubkey === master) return false
+
+  // EL ACTA MANDA, y es lo único que manda. Un certificado retirado o vencido NO significa
+  // «estás fuera»: renovar retira el anterior y cambiar permisos obliga a renovar, así que
+  // un aparato de casa con un papel viejo solo tiene que renovar. Decirle «estás fuera»
+  // ahí lo borraba solo: dabas «administra» y el dispositivo desaparecía.
+  if (Array.isArray(members)) return !members.some((m) => m?.pub === pubkey)
+
+  // Sin acta (bóveda anterior al acta) no se puede saber quién es del perfil: solo se
+  // avisa a quien conste explícitamente como revocado.
+  return !!knownRevoked
+}
+
+export default { STALE_PAPER, isStalePaper, shouldNotifyRevoked }

package/vault/vendor/vault/sealed.js

@@ -0,0 +1,84 @@
+/**
+ * Sobres SELLADOS para respuestas del vault con contenido sensible (secretos).
+ *
+ * El proxy transporta pero NUNCA debe ver el contenido. Como la llave de
+ * dispositivo `D` es ECDSA (solo firma), el que PIDE genera una llave ECDH
+ * EFÍMERA por petición (`ek`) y la manda dentro del sobre firmado por `D`
+ * (→ ek queda autenticada por la cadena D←maestra). El vault sella la
+ * respuesta a esa ek: ECDH efímero propio + AES-256-GCM. Reproducir una
+ * respuesta vieja es inerte: cada petición usa una ek nueva y el replay no
+ * se puede descifrar.
+ *
+ * La AUTENTICIDAD de la respuesta no la da este módulo sino la firma de la
+ * maestra sobre el cuerpo (el dispositivo la verifica contra la `iss` pineada).
+ *
+ * WebCrypto puro (browser y Node ≥20). Cripto alineada al ecosistema:
+ * P-256 + AES-GCM, llaves como JWK string.
+ */
+
+const subtle = globalThis.crypto.subtle
+
+function b64 (buf) {
+  const bytes = new Uint8Array(buf)
+  let s = ''
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
+  return btoa(s)
+}
+
+function fromB64 (str) {
+  const bin = atob(str)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+async function deriveAesKey (privateKey, publicJwkStr) {
+  const pub = await subtle.importKey(
+    'jwk', JSON.parse(publicJwkStr),
+    { name: 'ECDH', namedCurve: 'P-256' }, false, []
+  )
+  const bits = await subtle.deriveBits({ name: 'ECDH', public: pub }, privateKey, 256)
+  return subtle.importKey('raw', bits, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt'])
+}
+
+/**
+ * Genera la llave ECDH EFÍMERA del solicitante (una por petición).
+ * `ek` (JWK string pública) viaja en el sobre firmado; `privateKey` se queda
+ * en memoria para abrir la respuesta.
+ */
+export async function makeEphemeralKey () {
+  const kp = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+  const jwk = await subtle.exportKey('jwk', kp.publicKey)
+  return { ek: JSON.stringify({ kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y }), privateKey: kp.privateKey }
+}
+
+/**
+ * Sella `payload` (cualquier JSON) hacia la ek del solicitante.
+ * @returns {Promise<{epk:string, iv:string, ct:string}>}
+ */
+export async function seal ({ ek, payload }) {
+  const eph = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+  const key = await deriveAesKey(eph.privateKey, ek)
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const pt = new TextEncoder().encode(JSON.stringify(payload))
+  const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, key, pt)
+  const epkJwk = await subtle.exportKey('jwk', eph.publicKey)
+  return {
+    epk: JSON.stringify({ kty: epkJwk.kty, crv: epkJwk.crv, x: epkJwk.x, y: epkJwk.y }),
+    iv: b64(iv),
+    ct: b64(ct)
+  }
+}
+
+/**
+ * Abre un sobre sellado con la privada efímera de `makeEphemeralKey()`.
+ * Lanza si el sobre no es para esa llave (AES-GCM autentica el contenido).
+ */
+export async function openSealed ({ privateKey, enc }) {
+  if (!enc || typeof enc.epk !== 'string' || typeof enc.iv !== 'string' || typeof enc.ct !== 'string') {
+    throw new Error('invalid sealed envelope')
+  }
+  const key = await deriveAesKey(privateKey, enc.epk)
+  const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(enc.iv) }, key, fromB64(enc.ct))
+  return JSON.parse(new TextDecoder().decode(pt))
+}